AWS DynamoDB CLI操作与SDK编程

已于 2022-08-10 16:24:24 修改
阅读量875 收藏 1
点赞数
分类专栏： Web微服务开发 文章标签： java
于 2022-08-08 18:24:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35720385/article/details/126233429
版权

文章目录

访问 DynamoDB

您可以使用 AWS Management Console、AWS Command Line Interface (AWS CLI) 或 DynamoDB API 访问 Amazon DynamoDB。
本文着重说一下，AWS CLI终端命令行操作DynamoDB。
参考：AWS CLI
以MAC OS举例说明：

安装或更新 AWS CLI

如果您有sudo权限，您可以为计算机上的所有用户安装 AWS CLI。我们在一个易于复制和粘贴的组中提供了这些步骤。请参阅以下步骤中每行的说明。

curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
sudo installer -pkg AWSCLIV2.pkg -target /
curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
sudo installer -pkg ./AWSCLIV2.pkg -target /
which aws
aws --version

输出显示：

aws-cli/2.4.5 Python/3.8.8 Darwin/18.7.0 botocore/2.4.5

AWS CLI快速设置

配置本机和AWS

aws configure
# 按照配置填写自己AK和SK以及region
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json

创建表&CRUD操作

以下 AWS CLI 示例使用 create-table 创建一个新的 Music 表。

aws dynamodb create-table \
    --table-name Music \
    --attribute-definitions \
        AttributeName=Artist,AttributeType=S \
        AttributeName=SongTitle,AttributeType=S \
    --key-schema \
        AttributeName=Artist,KeyType=HASH \
        AttributeName=SongTitle,KeyType=RANGE \
    --provisioned-throughput \
        ReadCapacityUnits=5,WriteCapacityUnits=5 \
    --table-class STANDARD

使用 create-table 返回以下示例结果。

{

    "TableDescription": {
        "TableArn": "arn:aws:dynamodb:us-west-2:522194210714:table/Music",
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        },
        "TableClassSummary": {
            "LastUpdateDateTime": 1558028402.69,
            "TableClass": "STANDARD"
        },
        "TableSizeBytes": 0,
        "TableName": "Music",
        "TableStatus": "CREATING", 
        "TableId": "d04c7240-0e46-435d-b231-d54091fe1017",
        "KeySchema": [
            {
                "KeyType": "HASH",
                "AttributeName": "Artist"
            },
            {
                "KeyType": "RANGE",
                "AttributeName": "SongTitle"
            }
        ],
        "ItemCount": 0,
        "CreationDateTime": 1558028402.69
    }
}

请注意，TableStatus 字段的值设置为 CREATING。

要验证 DynamoDB 是否已完成创建 Music 表，请使用 describe-table 命令。

aws dynamodb describe-table --table-name Music | grep TableStatus

此命令将返回以下结果。在 DynamoDB 创建完表后，TableStatus 字段的值将设置为 ACTIVE。

DynamoDB API 写入数据

aws dynamodb put-item \
    --table-name Music  \
    --item \
        '{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Call Me Today"}, "AlbumTitle": {"S": "Somewhat Famous"}, "Awards": {"N": "1"}}'

aws dynamodb put-item \
    --table-name Music  \
    --item \
        '{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Howdy"}, "AlbumTitle": {"S": "Somewhat Famous"}, "Awards": {"N": "2"}}'

PartiQL for DynamoDB 写入数据

aws dynamodb execute-statement --statement "INSERT INTO Music  \
                VALUE  \
                {'Artist':'No One You Know','SongTitle':'Call Me Today', 'AlbumTitle':'Somewhat Famous', 'Awards':'1'}"

aws dynamodb execute-statement --statement "INSERT INTO Music  \
                VALUE  \
                {'Artist':'No One You Know','SongTitle':'Howdy', 'AlbumTitle':'Somewhat Famous', 'Awards':'2'}"

读取数据

DynamoDB API方式读取数据
注意

DynamoDB 的默认行为是最终一致性读取。下面用 consistent-read 参数演示较强的一致性读取。

aws dynamodb get-item --consistent-read \
    --table-name Music \
    --key '{ "Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"}}'

使用 get-item 返回以下示例结果。

{
    "Item": {
        "AlbumTitle": {
            "S": "Songs About Life"
        },
        "Awards": {
            "N": "10"
        },
        "SongTitle": {
            "S": "Happy Day"
        },
        "Artist": {
            "S": "Acme Band"
        }
    }
}

PartiQL for DynamoDB

aws dynamodb execute-statement --statement "SELECT * FROM Music   \
                                            WHERE Artist='Acme Band' AND SongTitle='Happy Day'"

使用 PartiQL Select 语句返回以下示例结果。

{
    "Items": [
        {
            "AlbumTitle": {
                "S": "Songs About Life"
            },
            "Awards": {
                "S": "10"
            },
            "Artist": {
                "S": "Acme Band"
            },
            "SongTitle": {
                "S": "Happy Day"
            }
        }
    ]
}
}

删除表

下面的 AWS CLI 示例使用 delete-table 删除 Music 表。

aws dynamodb delete-table --table-name Music

AWS SDK使用

AWS DynamoDB SDK pom依赖如下

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>2.17.230</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>dynamodb-enhanced</artifactId>
            <version>2.17.123</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.13.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.1</version>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>kms</artifactId>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>dynamodb</artifactId>
        </dependency>
       </dependencies>

使用 AWS SDK 创建 DynamoDB 表。

    public static String createTable(DynamoDbClient ddb, String tableName, String key) {

        DynamoDbWaiter dbWaiter = ddb.waiter();
        CreateTableRequest request = CreateTableRequest.builder()
                .attributeDefinitions(AttributeDefinition.builder()
                        .attributeName(key)
                        .attributeType(ScalarAttributeType.S)
                        .build())
                .keySchema(KeySchemaElement.builder()
                        .attributeName(key)
                        .keyType(KeyType.HASH)
                        .build())
                .provisionedThroughput(ProvisionedThroughput.builder()
                        .readCapacityUnits(new Long(10))
                        .writeCapacityUnits(new Long(10))
                        .build())
                .tableName(tableName)
                .build();

        String newTable ="";
        try {
            CreateTableResponse response = ddb.createTable(request);
            DescribeTableRequest tableRequest = DescribeTableRequest.builder()
                    .tableName(tableName)
                    .build();

            // Wait until the Amazon DynamoDB table is created.
            WaiterResponse<DescribeTableResponse> waiterResponse = dbWaiter.waitUntilTableExists(tableRequest);
            waiterResponse.matched().response().ifPresent(System.out::println);
            newTable = response.tableDescription().tableName();
            return newTable;

        } catch (DynamoDbException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
       return "";
    }

调用如下：

public static void main1(String[] args) {
        String tableName = "Customer";
        String key = "id";
        System.out.println("Creating an Amazon DynamoDB table "+tableName +" with a simple primary key: " +key );

        ProfileCredentialsProvider credentialsProvider = ProfileCredentialsProvider.create();

        Region region = Region.US_WEST_2;
        DynamoDbClient ddb = DynamoDbClient.builder()
                .credentialsProvider(credentialsProvider)
                .region(region)
                .build();

        String result = createTable(ddb, tableName, key);
        System.out.println("New table is "+result);
        ddb.close();
    }

使用 AWS SDK 向 DynamoDB 表中写入项目

使用增强型客户端将项目放入表中。

    public static void putRecord(DynamoDbEnhancedClient enhancedClient) {

        try {
            DynamoDbTable<Customer> custTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));

            // Create an Instant value.
            LocalDate localDate = LocalDate.parse("2020-04-07");
            LocalDateTime localDateTime = localDate.atStartOfDay();
            Instant instant = localDateTime.toInstant(ZoneOffset.UTC);

            // Populate the Table.
            Customer custRecord = new Customer();
            custRecord.setCustName("Tom red");
            custRecord.setId("id119");
            custRecord.setEmail("tred@noserver.com");
            custRecord.setRegistrationDate(instant) ;

            // Put the customer data into an Amazon DynamoDB table.
            custTable.putItem(custRecord);

        } catch (DynamoDbException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
        System.out.println("Customer data added to the table.");
    }

测试如下：

public static void main2(String[] args) {
    ProfileCredentialsProvider credentialsProvider = ProfileCredentialsProvider.create();
    Region region = Region.US_WEST_2;
    DynamoDbClient ddb = DynamoDbClient.builder()
            .credentialsProvider(credentialsProvider)
            .region(region)
            .build();

    DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
            .dynamoDbClient(ddb)
            .build();
    putRecord(enhancedClient) ;
    ddb.close();
}

使用 AWS SDK 从 DynamoDB 表中读取项目

public static int queryTable(DynamoDbClient ddb,
                             String tableName,
                             String partitionKeyName,
                             String partitionKeyVal,
                             String partitionAlias) {

    // Set up an alias for the partition key name in case it's a reserved word.
    HashMap<String,String> attrNameAlias = new HashMap<String,String>();
    attrNameAlias.put(partitionAlias, partitionKeyName);

    // Set up mapping of the partition name with the value.
    HashMap<String, AttributeValue> attrValues = new HashMap<>();

    attrValues.put(":"+partitionKeyName, AttributeValue.builder()
            .s(partitionKeyVal)
            .build());

    QueryRequest queryReq = QueryRequest.builder()
            .tableName(tableName)
            .keyConditionExpression(partitionAlias + " = :" + partitionKeyName)
            .expressionAttributeNames(attrNameAlias)
            .expressionAttributeValues(attrValues)
            .build();

    try {
        QueryResponse response = ddb.query(queryReq);
        return response.count();
    } catch (DynamoDbException e) {
        System.err.println(e.getMessage());
        System.exit(1);
    }
    return -1;
}

测试如下：

public static void main(String[] args) {
        String tableName = "Music";
        String partitionKeyName = "Artist";
        String partitionKeyVal = "No One You Know";

        // For more information about an alias, see:
        // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html
        String partitionAlias = "#a";

        System.out.format("Querying %s", tableName);
        System.out.println("");

        ProfileCredentialsProvider credentialsProvider = ProfileCredentialsProvider.create();
        Region region = Region.US_WEST_2;
        DynamoDbClient ddb = DynamoDbClient.builder()
                .credentialsProvider(credentialsProvider)
                .region(region)
                .build();

        int count = queryTable(ddb, tableName, partitionKeyName, partitionKeyVal,partitionAlias ) ;
        System.out.println("There were "+count + "  record(s) returned");
        ddb.close();

    }

使用 AWS SDK 更新 DynamoDB 表中的项目

public static String modifyItem(DynamoDbEnhancedClient enhancedClient, String keyVal, String email) {

    try {

        DynamoDbTable<Customer> mappedTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
        Key key = Key.builder()
                .partitionValue(keyVal)
                .build();

        // Get the item by using the key and update the email value.
        Customer customerRec = mappedTable.getItem(r->r.key(key));
        customerRec.setEmail(email);
        mappedTable.updateItem(customerRec);
        return customerRec.getEmail();

    } catch (DynamoDbException e) {
        System.err.println(e.getMessage());
        System.exit(1);
    }
    return "";
}

测试如下：

 public static void main3(String[] args) {
        String key = "id119";
        String email = "liyang19900109@gmail.com";
        ProfileCredentialsProvider credentialsProvider = ProfileCredentialsProvider.create();
        Region region = Region.US_WEST_2;
        DynamoDbClient ddb = DynamoDbClient.builder()
                .credentialsProvider(credentialsProvider)
                .region(region)
                .build();

        DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
                .dynamoDbClient(ddb)
                .build();

        String updatedValue = modifyItem(enhancedClient,key,email);
        System.out.println("The updated name value is "+updatedValue);
        ddb.close();
    }

使用 AWS SDK 删除 DynamoDB 表中的项目

  public static void deleteDymamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {

        HashMap<String,AttributeValue> keyToGet = new HashMap<>();
        keyToGet.put(key, AttributeValue.builder()
                .s(keyVal)
                .build());

        DeleteItemRequest deleteReq = DeleteItemRequest.builder()
                .tableName(tableName)
                .key(keyToGet)
                .build();

        try {
            ddb.deleteItem(deleteReq);
        } catch (DynamoDbException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
    }

测试：

public static void main4(String[] args) {
        String tableName = "Customer";
        String key = "id";
        String keyVal = "id119";

        System.out.format("Deleting item \"%s\" from %s\n", keyVal, tableName);
        ProfileCredentialsProvider credentialsProvider = ProfileCredentialsProvider.create();
        Region region = Region.US_WEST_2;
        DynamoDbClient ddb = DynamoDbClient.builder()
                .credentialsProvider(credentialsProvider)
                .region(region)
                .build();

        deleteDymamoDBItem(ddb, tableName, key, keyVal);
        ddb.close();
    }

使用 DynamoDB 和 AWS SDK 编程

概述了使用 AWS SDK 编程 Amazon DynamoDB 应用程序。
在这里插入图片描述

编程接口

在这里插入图片描述
每个 AWS SDK 提供了一个或多个用于使用 Amazon DynamoDB 的编程接口。这些接口范围从简单的低级 DynamoDB 包装到面向对象的持久层。可用接口因您使用的 AWS SDK 和编程语言而不同。
Low-Level-Interface 类似于 jdbc
High-Level-Interface 类似于mybatis

Low-Level-Interface低级别接口

每个语言特定 AWS SDK 为 Amazon DynamoDB 提供了一个低级别接口，其方法与低级别 DynamoDB API 请求非常相似。

在某些情况下，您需要使用 数据类型描述符 识别数据类型，例如 S 对于字符串，N 对于数字。

package com.amazonaws.codesamples;

import java.util.HashMap;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import com.amazonaws.services.dynamodbv2.model.GetItemResult;

public class MusicLowLevelDemo {

    public static void main(String[] args) {

        AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

        HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
        key.put("Artist", new AttributeValue().withS("No One You Know"));
        key.put("SongTitle", new AttributeValue().withS("Call Me Today"));

        GetItemRequest request = new GetItemRequest()
            .withTableName("Music")
            .withKey(key);

        try {
            GetItemResult result = client.getItem(request);
            if (result && result.getItem() != null) {
                AttributeValue year = result.getItem().get("Year");
                System.out.println("The song was released in " + year.getN());
            } else {
                System.out.println("No matching song was found");
            }
        } catch (Exception e) {
            System.err.println("Unable to retrieve data: ");
            System.err.println(e.getMessage());
        }
    }
}

document interface文档接口

许多 AWS SDK 提供文档接口，允许您对表和索引执行数据层面操作（创建、读取、更新、删除）。对于文档接口，无需指定 数据类型描述符。数据类型由数据本身的语义隐含。这些 AWS SDK 还提供了一些方法，可以在 JSON 文档转换为 Amazon DynamoDB 本机数据类型之间轻松转换。

以下 Java 程序使用 AWS SDK for Java 的文档接口。程序创建一个 Table 对象，表示 Music 表，然后要求该对象使用 GetItem 检索歌曲。然后程序打印该歌曲的发行年份。
com.amazonaws.services.dynamodbv2.document.DynamoDB 类实施 DynamoDB 文档接口。
注意DynamoDB充当一个围绕低级别客户端的包装程序 (AmazonDynamoDB)。

package com.amazonaws.codesamples.gsg;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.GetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;

public class MusicDocumentDemo {

    public static void main(String[] args) {

        AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
        DynamoDB docClient = new DynamoDB(client);

        Table table = docClient.getTable("Music");
        GetItemOutcome outcome = table.getItemOutcome(
                "Artist", "No One You Know",
                "SongTitle", "Call Me Today");

        int year = outcome.getItem().getInt("Year");
        System.out.println("The song was released in " + year);

    }
}

High-Level-Interface对象持久化接口

如果不直接执行数据层面操作，一些 AWS SDK 提供对象持久化接口。相反，您可以创建表示 Amazon DynamoDB 表和索引中项目的对象，并且仅与这些对象进行交互。这允许您编写以对象为中心的代码，而不是以数据库为中心的代码。
以下 Java 程序使用 DynamoDBMapper，AWS SDK for Java 的对象持久化接口。MusicItem 类表示 Music 表的项目。

package com.amazonaws.codesamples;

import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBRangeKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTable;

@DynamoDBTable(tableName="Music")
public class MusicItem {
    private String artist;
    private String songTitle;
    private String albumTitle;
    private int year;

    @DynamoDBHashKey(attributeName="Artist")
    public String getArtist() { return artist;}
    public void setArtist(String artist) {this.artist = artist;}

    @DynamoDBRangeKey(attributeName="SongTitle")
    public String getSongTitle() { return songTitle;}
    public void setSongTitle(String songTitle) {this.songTitle = songTitle;}

    @DynamoDBAttribute(attributeName = "AlbumTitle")
    public String getAlbumTitle() { return albumTitle;}
    public void setAlbumTitle(String albumTitle) {this.albumTitle = albumTitle;}

    @DynamoDBAttribute(attributeName = "Year")
    public int getYear() { return year; }
    public void setYear(int year) { this.year = year; }
}

然后，您可以实例化 MusicItem 对象，然后使用 DynamoDBMapper 的 load() 方法。然后，该程序打印该歌曲的发行年份。

com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper 类实施 DynamoDB 对象持久化接口。注意DynamoDBMapper充当一个围绕低级别客户端的包装程序 (AmazonDynamoDB)。

package com.amazonaws.codesamples;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;


public class MusicMapperDemo {

    public static void main(String[] args) {

        AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

        DynamoDBMapper mapper = new DynamoDBMapper(client);

        MusicItem keySchema = new MusicItem();
        keySchema.setArtist("No One You Know");
        keySchema.setSongTitle("Call Me Today");

        try {
            MusicItem result = mapper.load(keySchema);
            if (result != null) {
                System.out.println(
                "The song was released in "+ result.getYear());
            } else {
                System.out.println("No matching song was found");
            }
        } catch (Exception e) {
            System.err.println("Unable to retrieve data: ");
            System.err.println(e.getMessage());
        }

    }

}

DynamoDB 低级 API

在这里插入图片描述
Amazon DynamoDB 低级别 API 是 DynamoDB 的协议级接口。在此级别，每个 HTTP(S) 请求的格式必须正确并带有有效的数字签名。

AWS SDK 代表您构建低级 DynamoDB API 请求并处理来自 DynamoDB 的响应。这可让您专注于应用程序逻辑而不是低级详细信息。不过，您仍可通过大致了解低级 DynamoDB API 的工作方式获益。
注意：

DynamoDB Streams 具有自己的低级别 API，此 API 独立于 DynamoDB 的低级别 API 且完全受 AWS SDK
支持。

这里不对DynamoDB 低级 API做过多介绍，知道他就是个http接口就可以了，通过http请求实现和数据库交互。

DynamoDB 错误处理

错误组成部分：
程序发送请求后，DynamoDB 会尝试处理该请求。如果请求成功，DynamoDB 将返回一个 HTTP 成功状态代码 (200 OK)，以及所请求操作的结果。

如果请求失败，DynamoDB 会返回一个错误。每个错误包含三个部分：

  • HTTP 状态代码（如 400）。
  • 异常名称（如 ResourceNotFoundException）。
  • 错误消息（如 Requested resource not found: Table: tablename not found）。

AWS SDK 负责将错误传播到应用程序，以便您能执行适当操作。例如，在 Java 程序中，您可以编写 try-catch 逻辑以处理 ResourceNotFoundException。

参考错误响应处理

DynamoDB 项目大小和格式

DynamoDB 表是无架构的（主键除外），因此，表中的项目可具有不同的属性、大小和数据类型。

项目的总大小是其属性名称和值的长度总和，加上任何适用的开销，如下所述。您可以使用以下准则来估算属性大小：

  • 字符串是使用 UTF-8 二进制编码的 Unicode。字符串大小为 （属性名长度）+（UTF-8 编码的字节数）。
  • 数字的长度是可变的，最多 38 个有效位。系统会删减开头和结尾的 0。数字大小约为 （属性名长度）+（每 2 个有效位对应 1
    个字节）+（1 个字节）。
  • 必须先采用 base64 格式对二进制值进行编码，然后才能将其发送到
    DynamoDB，不过使用值的原始字节长度来计算大小。二进制属性的大小为 （属性名长度）+（原始字节数）。
  • 空属性或布尔属性的大小为 （属性名长度）+（1 字节）。
  • 对于类型为 List 或 Map 的属性，不论其内容如何，都需要 3 个字节的开销。List 或 Map 的大小为（属性名长度）+
    总和（嵌套元素大小）+（3 字节）。空 List 或 Map 的大小为 （属性名长度）+（3 字节）。
  • DynamoDB 中的所有项目都需要 100 字节的存储开销才能进行索引。
  • 某些 DynamoDB 功能（全局表、事务、使用 DynamoDB 的 Kinesis Data Streams
    更改数据捕获    ）需要额外的存储开销，才能考虑因启用这些功能而产生的系统创建属性。例如，全局表需要额外 48 字节的存储开销。

工作原理：DynamoDB 生存时间 (TTL)

通过 Amazon DynamoDB 生存时间 (TTL)，您可以定义每个项目的时间戳，以确定何时不再需要某个项目。在指定时间戳的日期和时间之后，DynamoDB 会立即从表中删除相应项目，而不会消耗任何写入吞吐量。提供 TTL 无需任何额外成本，它通过仅保留符合工作负载需求的项目来减少存储的数据量。

如果存储的项目在特定时间后不再相关，TTL 将非常有用。以下是 TTL 使用案例：

  • 在应用程序处于不活动状态一年后删除用户或传感器数据。
  • 通过 Amazon DynamoDB Streams 和 AWS Lambda 将过期项目存档到 Amazon S3 数据湖中。
  • 根据合同或法规义务，将敏感数据保留一定的时间。

TTL工作方式

在 DynamoDB 表上启用 TTL 时，必须标识此服务在确定项目是否符合过期条件时将查找的特定属性名称。在表上启用 TTL 后，每个分区扫描程序后台进程都会自动持续评估表中项目的过期状态。

1、扫描程序后台进程将 Unix纪元时间格式（单位秒）的当前时间与项目的用户定义的 属性中存储的时间进行比较。
如果属性是 Number数据类型时，属性的值是 Unix 历元时间格式，并以秒为单位，并且时间戳值比当前时间早，但不超过五年或更长（为了避免由于格式错误的 TTL值而导致可能意外删除），则该项目设置为过期。有关设置 TL 属性格式的详细信息，请参阅 设置项目的 TTL 属性的格式。
2、第二个后台进程将扫描过期项目并将其删除。这两个进程都在后台自动进行，不会影响表的读取或写入流量，也不会产生费用成本。

从表中删除项目时，会同时执行两项后台操作：

  • 按照与 DeleteItem 操作相同的方式，从任何本地二级索引和全局二级索引中删除项目。此操作没有任何额外成本。
  • 每个项目的删除操作都会进入 DynamoDB
    Streams    ，但会被标记为系统删除，而不是常规删除。有关如何使用此系统删除的更多信息，请参阅 DynamoDB Streams
    和生存时间。
    在这里插入图片描述

使用 DynamoDB 生存时间 (TTTTL)

使用 TTL 时，大部分艰巨的工作都是由 DynamoDB 代表您在幕后完成的。但是，您应该知道一些注意事项，以帮助您顺利地进行实施。

设置项目的 TTL 属性的格式

在表上启用 TTL 时，DynamoDB 要求您标识此服务在确定项目是否符合过期条件时将查找的特定属性名称。此外，进一步的要求可确保后台 TTL 进程使用 TTL 属性的值。要让项目符合通过 TTL 过期的资格：

  • 项目必须包含在表上启用 TTL 时指定的属性。例如，如果您为表指定将属性名称用作 expdate TTL
    属性，但项目没有具有该名称的属性，则 TTL 进程将忽略该项目。
  • TTL 属性的值必须是 Number 数据类型。例如，如果为表指定使用属性名称 expdate 作为 TTL 属性，但项目的属性是
    String 数据类型，则 TTL 进程将忽略该项目。
  • TL 属性的值必须是 Unix 时代时间格式，并以秒为单位。如果您使用任何其他格式，TTL进程将忽略该项目。
    例如，如果您将此属性的值设置为 1645119622，即，2022 年 2 月 17 日星期四17:40:22（格林威治标准时间），则该项目将在此时间之后过期。如需有关设置纪元时间戳格式的帮助，您可以使用纪元转换器之类的第三方工具来获取可视Web 表单。
  • TTL 属性值必须是过期时间不超过过去五年的日期时间戳。
TTL使用说明
  • 考虑是否需要通过 Amazon DynamoDB Streams 对已删除项目执行任何后期处理，
    例如，将项目存档到 Amazon S3数据湖。TTL 删除的流记录标记为系统删除而非正常删除，您可以使用 AWS Lambda函数筛选系统删除。有关添加到流记录的更多信息，请参阅 Amazon DynamoDB Streams 和生存时间。

启用生存时间 (TTL)

参考链接：启用生存时间

右耳听风
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AWS SDK for iOS
zhuxincheng_1218的专栏
09-04 1638
文章目录AWS SDK for iOSFeatures / APIsVisit our [Web Site](https://aws-amplify.github.io) to learn more about Amplify Framework.SetupInclude the SDK for iOS in an Existing ApplicationCocoaPodsCarthageFram...
AWS开发SDK
01-31
aws Java开发SDK说明文档，包含所有aws提供的云服务模块。
aws-sdk
ycclydy的博客
11-02 787
aws sdk之nodejs s3_莫冲的专栏-CSDN博客 nodejs 实现 AWS S3 上传、下载、删除_小妖666个人笔记-CSDN博客
推荐使用 AWS SDK for Go v2：新一代的云服务开发体验
最新发布
gitblog_00020的博客
05-12 485
推荐使用 AWS SDK for Go v2：新一代的云服务开发体验 项目地址:https://gitcode.com/aws/aws-sdk-go-v2 在当今的云计算时代，高效和稳定的SDK是开发者与AWS服务交互的关键桥梁。AWS SDK for Go v2，这个全新的Go语言版本SDK，为开发者带来了优化的性能、简洁的API设计以及强大的功能集。让我们一起探索它的魅力，并了解如何利用它来提...
[ 后端篇 ] 05 - AWS DynamoDB 入门教程
程序手艺人 - 嵌入式音频技术之旅
03-11 1099
DynamoDB 属于AWS 专有的 NoSQL 数据库服务。其实和Mongod类似。 由于DynamoDB 属于AWS的，需要下载专有的工具操作。 在 DynamoDB 中，表、项目和属性是您使用的核心组件。表 是项目 的集合，而每个项目是属性 的集合。DynamoDB 使用主键来唯一标识表中的每个项目，并且使用二级索引来提供更大的查询灵活性。您可以使用 DynamoDB 流 捕获 Dynamo...
aws-sdk-java, 面向Java的官方 AWS SDK.zip
10-11
aws-sdk-java, 面向Java的官方 AWS SDK 面向 Java 的 AWS ibm 提供的自动AWS支持Java开发人员轻松使用 Amazon Web Services 插件，并与 Amazon S3 。亚马逊 DynamoDB 。亚马逊冰川以及其他更多的解决方案建立可以伸缩解决方
PyPI 官网下载 | aws_cdk.aws_dynamodb-1.118.0-py3-none-any.whl
02-15
通过使用`aws_cdk.aws_dynamodb`库，开发者可以利用Python直接在AWS CDK中创建、配置和管理DynamoDB表，而无需直接操作AWS SDK或AWS CLI。 `aws_cdk.aws_dynamodb`库提供了丰富的功能，包括但不限于： 1. **创建...
Python库 | awscli-1.11.53.tar.gz
03-01
awscli是AWS官方提供的一个全面、统一的命令行工具，它覆盖了AWS的大多数服务，包括EC2（Elastic Compute Cloud）、S3（Simple Storage Service）、RDS（Relational Database Service）、DynamoDB、Lambda等。...
AWS DVA-C02样题
06-21
3. **无服务器架构**：熟悉Lambda函数的使用，包括事件驱动编程、函数触发器、处理异步任务以及与其它AWS服务的集成，如API Gateway和DynamoDB。 4. **数据持久化**：掌握不同类型的AWS数据库服务，如关系型数据库...
Python库 | awscli-1.11.83.tar.gz
03-03
这个库，awscli-1.11.83.tar.gz，是一个针对Python开发者的工具，它允许用户通过命令行执行多种操作，如管理EC2实例、S3存储桶、DynamoDB表等，极大地简化了对AWS基础设施的管理。 **Python在后端开发中的角色** ...
MoviesApp：React Native Movies App：AWS Amplify，AWS AppSync，AWS Cognito，GraphQL，DynamoDB
01-30
电影应用React Native，AWS AppSync，AWS Amplify，AWS Cognito，GraphQL，DynamoDB 请注意：这项工作仍在进行中，许多功能尚未完全开发。 7月24日更新： 可以对AWS Amplify库进行模块化： : 还有一些新的帮助程序...
AWSSDK.dll
12-23
aws服务的库包，可以通过这个库包提供的接口使用aws提供的服务。
AWS SDK 访问阿里云 OSS
李兵的专栏
03-23 7173
S3 已经成为云对象存储领域的规范，主流的对象存储都有对它的支持。阿里云 OSS 也支持 S3 协议，我们可以使用AWS的SDK对其进行操作，当然由于OSS与S3在功能和实现上的差别，OSS 不可能支持所有的AWS S3操作，但是，对于日常大部分操作，它都是支持的。 AWS CLI aws configure --p aliyun aws configure set s3.addre...
1、aws-sdk-go快速使用（minio和oss）
Salted fish in hand, I have the world.
07-22 2190
只要会话没有被修改，会话就可以安全地并发使用。创建会话后，SDK不会修改会话。从共享会话同时创建服务客户端是安全的。
【AWS学习笔记】aws cli 与 aws sdk简介
qq_41643167的博客
06-03 1263
aws cli 与 aws sdk简介 学习笔记
1. AWS DynamoDB实战之表的创建
JessicaWin
09-03 1245
DynamoDB是Amazon提供的一种完全托管的 NoSQL 数据库服务，数据库的软硬件的管理和维护都由Amazon负责，相比传统数据库，免除了用户操作和扩展分布式数据库的管理工作负担，因而无需担心硬件预置、设置和配置、复制、软件修补或集群扩展等问题。
AWSS3 iOS SDK使用教程
leleyuan1130的博客
01-17 2681
iOS AWSS3 SDK使用教程
亚马逊云AWSSDK 和工具参考指南！！！
TG_kinglki的博客
08-20 800
本AWS SDK 和工具参考指南旨在成为适用于多个 SDK 和工具的信息基础。除了此处提供的任何信息外，还应使用您正在使用的 SDK 或工具的特定的 SDK 或工具指南。AWSSDK 和工具维护政策涵盖AWS软件开发套件 (SDK) 和工具（包括移动和物联网 (IoT) SDK）的维护策略和版本控制及其底层依赖关系。AWS常用运行时 (CRT) 库— 概述几乎所有 SDK 都可用的AWS通用运行时 (CRT) 库。AWS SDK for Java 开发人员指南。
windows环境下编译aws-sdk-cpp踩坑记
Bruce Che 的专栏
06-02 1892
在做图片、视频片段存储技术调研时，从查阅的大量资料中，了解到很多人推荐的开源MinIO，其优点简单来说易于部署和调用，支持高可靠性等，但是官方却没提供C++版本的API接口，这点对C++开发人员不友好。好在它是遵循亚马逊S3协议的，所以可以通过调用aws-sdk-cpp对MinIO访问。下边记录了笔者编译aws-sdk-cpp碰到的一些坑以及解决办法，供有需要的朋友参考，以少走弯路。
AWS CLI用户指南：安装与配置详解
AWS CLI 是亚马逊提供的一个命令行工具，允许用户通过命令行与 AWS 服务进行交互，执行多种操作，如管理资源、部署应用程序等。这份用户指南旨在帮助用户熟练掌握 AWS CLI 的使用。 文档中展示了 AWS CLI 的使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值