亚马逊DynamoDB开发指南

需积分: 9 53 浏览量更新于2024-07-21 1 收藏 6.7MB PDF 举报

"亚马逊DynamoDB开发者指南，涵盖了API版本2012-08-10的内容。" 亚马逊DynamoDB是一款由AWS（Amazon Web Services）提供的高性能、完全托管的NoSQL数据库服务，它是对Cassandra等其他数据库系统的另一种选择。DynamoDB设计为可扩展、低延迟的数据存储解决方案，特别适合需要处理大量实时读写操作的应用场景，如电子商务、游戏和移动应用。本开发文档是为开发者提供关于如何设计、操作和优化DynamoDB的详细指南。文档内容可能包括以下几个主要部分： 1. **基础概念**：介绍DynamoDB的基本元素，如表、键、属性和数据类型。其中，键值对是DynamoDB的核心，每个表都有一个主键，可以由一个或两个属性组成，如哈希键和范围键。 2. **操作与API**：详述如何使用API进行数据操作，包括创建、更新和删除表，以及PutItem、GetItem、UpdateItem和DeleteItem等基本CRUD操作。同时，也会介绍Scan和Query操作，用于检索数据。 3. **性能管理**：讨论Provisioned Throughput的概念，这是DynamoDB中预置的读写容量单位，用户需要根据预期的工作负载来设置。同时，会涵盖如何监控和调整读写容量，以确保性能和成本效益。 4. **全球表与全局二级索引**：全球表允许用户在多个AWS区域间复制数据，实现低延迟的全球访问。全局二级索引则提供了额外的索引结构，以便从不同角度查询数据。 5. **索引与查询优化**：介绍本地二级索引和全局二级索引的使用，以及如何编写高效的查询语句，以最大程度地减少扫描和提高查询效率。 6. **数据备份与恢复**：讲解如何使用DynamoDB的自动备份功能，以及如何进行数据恢复，确保业务连续性。 7. **安全性与权限管理**：通过IAM（Identity and Access Management）控制对DynamoDB资源的访问，包括身份验证、授权和加密。 8. **流与事件驱动架构**：DynamoDB Streams允许跟踪表中的更改，并将这些更改作为事件推送到其他AWS服务，如Lambda，构建事件驱动的应用。 9. **最佳实践与设计模式**：提供在实际项目中使用DynamoDB时的经验法则，帮助开发者避免常见的设计陷阱。 10. **成本控制**：讲解如何理解和优化DynamoDB的计费模型，包括读写容量单位、数据存储费用和数据传输费用。这个文档还会包含一个详细的表格目录，方便开发者快速查找特定主题。通过深入阅读和理解这份开发者指南，开发者能够熟练地利用DynamoDB来构建高可用、高性能的应用程序。

Multi-Valued Data Types

DynamoDB also supports types that represent number sets, string sets and binary sets. Multi-valued at-

tributes such as an Authors attribute in a book item and a Color attribute of a product item are examples

of String Set type attributes. Because each of these types is a set, the values in each must be unique.

Attribute sets are not ordered; the order of the values returned in a set is not preserved. DynamoDB does

not support empty sets.

Examples

["Black", "Green" ,"Red"]

["42.2", "-19", "7.5", "3.14"]

["U3Vubnk=", "UmFpbnk=", "U25vd3k="]

Document Data Types

DynamoDB supports List and Map data types, which can be nested to represent complex data structures.

• A List type contains an ordered collection of values.

• A Map type contains an unordered collection of name-value pairs.

Lists and maps are ideal for storing JSON documents. The List data type is similar to a JSON array, and

the Map data type is similar to a JSON object. There are no restrictions on the data types that can be

stored in List or Map elements, and the elements do not have to be of the same type.

The following example shows a Map that contains a String, a Number, and a nested List (which itself

contains another Map).

Example

{

Day: "Monday",

UnreadEmails: 42,

ItemsOnMyDesk: [

"Coffee Cup",

"Telephone",

{

Pens: { Quantity : 3},

Pencils: { Quantity : 2},

Erasers: { Quantity : 1}

}

]

}

Note

DynamoDB lets you access individual elements within lists and arrays, even if those elements

are deeply nested. For more information, see Document Paths (p. 96).

Supported Operations in DynamoDB

To work with tables and items, Amazon DynamoDB offers the following set of operations:

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Supported Operations

Table Operations

DynamoDB provides operations to create, update and delete tables. After the table is created, you can

use the UpdateTable operation to increase or decrease a table's provisioned throughput. DynamoDB

also supports an operation to retrieve table information (the DescribeTable operation) including the

current status of the table, the primary key, and when the table was created.The ListTables operation

enables you to get a list of tables in your account in the region of the endpoint you are using to commu-

nicate with DynamoDB. For more information, see Working with Tables (p. 57).

Item Operations

Item operations enable you to add, update and delete items from a table. The UpdateItem operation

allows you to update existing attribute values, add new attributes, and delete existing attributes from an

item.You can also perform conditional updates. For example, if you are updating a price value, you can

set a condition so the update happens only if the current price is $20.

DynamoDB provides an operation to retrieve a single item (GetItem) or multiple items (BatchGetItem).

You can use the BatchGetItem operation to retrieve items from multiple tables. For more information,

see Working with Items (p. 89).

Query and Scan

The Query operation enables you to query a table using the hash attribute and an optional range filter.

If the table has a secondary index, you can also Query the index using its key.You can query only tables

whose primary key is of hash-and-range type; you can also query any secondary index on such tables.

Query is the most efficient way to retrieve items from a table or a secondary index.

DynamoDB also supports a Scan operation, which you can use on a table or a secondary index. The

Scan operation reads every item in the table or secondary index. For large tables and secondary indexes,

a Scan can consume a large amount of resources; for this reason, we recommend that you design your

applications so that you can use the Query operation mostly, and use Scan only where appropriate. For

more information, see Query and Scan Operations (p. 185).

You can use conditional expressions in both the Query and Scan operations to control which items are

returned.

Data Read and Consistency Considerations

DynamoDB maintains multiple copies of each item to ensure durability. When you receive an "operation

successful" response to your write request, DynamoDB ensures that the write is durable on multiple

servers. However, it takes time for the update to propagate to all copies.The data is eventually consistent,

meaning that a read request immediately after a write operation might not show the latest change. However,

DynamoDB offers you the option to request the most up-to-date version of the data. To support varied

application requirements, DynamoDB supports both eventually consistent and strongly consistent read

options.

Eventually Consistent Reads

When you read data (GetItem, BatchGetItem, Query or Scan operations), the response might not

reflect the results of a recently completed write operation (PutItem, UpdateItem or DeleteItem).The

response might include some stale data. Consistency across all copies of the data is usually reached

within a second; so if you repeat your read request after a short time, the response returns the latest data.

By default, the Query and GetItem operations perform eventually consistent reads, but you can optionally

request strongly consistent reads. BatchGetItem operations are eventually consistent by default, but

you can specify strongly consistent on a per-table basis.Scan operations are always eventually consistent.

For more information about operations in DynamoDB, see Using the DynamoDB API (p. 466).

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Table Operations

Strongly Consistent Reads

When you issue a strongly consistent read request, DynamoDB returns a response with the most up-to-

date data that reflects updates by all prior related write operations to which DynamoDB returned a suc-

cessful response. A strongly consistent read might be less available in the case of a network delay or

outage. For the query or get item operations, you can request a strongly consistent read result by specifying

optional parameters in your request.

Conditional Updates and Concurrency Control

In a multiuser environment, it is important to ensure data updates made by one client don't overwrite up-

dates made by another client.This "lost update" problem is a classic database concurrency issue. Suppose

two clients read the same item. Both clients get a copy of that item from DynamoDB. Client 1 then sends

a request to update the item. Client 2 is not aware of any update. Later, Client 2 sends its own request

to update the item, overwriting the update made by Client 1. Thus, the update made by Client 1 is lost.

DynamoDB supports a "conditional write" feature that lets you specify a condition when updating an item.

DynamoDB writes the item only if the specified condition is met; otherwise it returns an error. In the "lost

update" example, client 2 can add a condition to verify item values on the server-side are same as the

item copy on the client-side. If the item on the server is updated, client 2 can choose to get an updated

copy before applying its own updates.

DynamoDB also supports an "atomic counter" feature where you can send a request to add or subtract

from an existing attribute value without interfering with another simultaneous write request. For example,

a web application might want to maintain a counter per visitor to its site. In this case, the client only wants

to increment a value regardless of what the previous value was. DynamoDB write operations support in-

crementing or decrementing existing attribute values.

For more information, see Working with Items (p. 89).

Provisioned Throughput in Amazon DynamoDB

When you create or update a table, you specify how much provisioned throughput capacity you want to

reserve for reads and writes. DynamoDB will reserve the necessary machine resources to meet your

throughput needs while ensuring consistent, low-latency performance.

A unit of read capacity represents one strongly consistent read per second (or two eventually consistent

reads per second) for items as large as 4 KB. A unit of write capacity represents one write per second

for items as large as 1 KB.

Items larger than 4 KB will require more than one read operation. The total number of read operations

necessary is the item size, rounded up to the next multiple of 4 KB, divided by 4 KB. For example, to

calculate the number of read operations for an item of 10 KB, you would round up to the next multiple of

4 KB (12 KB) and then divide by 4 KB, for 3 read operations.

The following table explains how to calculate the provisioned throughput capacity that you need.

How to CalculateCapacity Units Required For

Number of item reads per second × 4 KB item size

(If you use eventually consistent reads, you'll get twice

as many reads per second.)

Reads

Number of item writes per second × 1 KB item sizeWrites

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Conditional Updates and Concurrency Control

If your application's read or write requests exceed the provisioned throughput for a table, then those re-

quests might be throttled.You can use the AWS Management Console to monitor your provisioned and

actual throughput and to change your provisioned capacity in anticipation of traffic changes.

For more information about specifying the provisioned throughput requirements for a table, see Specifying

Read and Write Requirements for Tables (p. 58).

For tables with secondary indexes, DynamoDB consumes additional capacity units. For example, if you

wanted to add a single 1 KB item to a table, and that item contained an indexed attribute, then you would

need two write capacity units—one for writing to the table, and another for writing to the index. For more

information, see:

• Provisioned Throughput Considerations for Local Secondary Indexes (p. 257)

• Provisioned Throughput Considerations for Global Secondary Indexes (p. 304)

Read Capacity Units

If your items are smaller than 4 KB in size, each read capacity unit will give you one strongly consistent

read per second, or two eventually consistent reads per second.You cannot group multiple items in a

single read operation, even if the items together are 4 KB or smaller. For example, if your items are 3 KB

and you want to read 80 items per second from your table, then you need to provision 80 (reads per

second) × 4 KB (rounded up to the next 4 KB boundary) = 80 read capacity units for strong consistency.

For eventual consistency, you need to provision only 40 read capacity units.

If your items are larger than 4 KB, you will need to round up the item size to the next 4 KB boundary. For

example, if your items are 6 KB and you want to do 100 strongly consistent reads per second, you need

to provision 100 (reads per second) × 2 (6 KB / 4 KB = 1.5, rounded up to the next whole number) = 200

read capacity units.

You can use the Query and Scan operations in DynamoDB to retrieve multiple consecutive items from

a table in a single request.With these operations, DynamoDB uses the cumulative size of the processed

items to calculate provisioned throughput. For example, if a Query operation retrieves 100 items that are

1 KB each, the read capacity calculation is not (100 × 4 KB) = 100 read capacity units, as if those items

were retrieved individually using GetItem or BatchGetItem. Instead, the total would be only 25 read

capacity units ((100 * 1024 bytes) = 100 KB, which is then divided by 4 KB). For more information see

Item Size Calculations (p. 60).

Write Capacity Units

If your items are smaller than 1 KB in size, then each write capacity unit will give you 1 write per second.

You cannot group multiple items in a single write operation, even if the items together are 1 KB or smaller.

For example, if your items are 512 bytes and you want to write 100 items per second to your table, then

you would need to provision 100 write capacity units.

If your items are larger than 1 KB in size, you will need to round the item size up to the next 1 KB

boundary. For example, if your items are 1.5 KB and you want to do 10 writes per second, then you would

need to provision 10 (writes per second) × 2 (1.5 KB rounded up to the next whole number) = 20 write

capacity units.

Accessing DynamoDB

Amazon DynamoDB is a web service that uses HTTP and HTTPS as a transport and JavaScript Object

Notation (JSON) as a message serialization format.Your application code can make requests directly to

the DynamoDB web service API. Instead of making the requests to the DynamoDB API directly from your

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Read Capacity Units

application, we recommend that you use the AWS Software Development Kits (SDKs). The easy-to-use

libraries in the AWS SDKs make it unnecessary to call the DynamoDB API directly from your application.

The libraries take care of request authentication, serialization, and connection management. For more

information about using the AWS SDKs, see Using the AWS SDKs with DynamoDB (p. 354).

The AWS SDKs provide low-level APIs that closely match the underlying DynamoDB API. To further

simplify application development, the SDKs also provide the following additional APIs:

• The Java and .NET SDKs provide APIs with higher levels of abstraction. These higher-level interfaces

let you define the relationships between objects in your program and the database tables that store

those objects' data. After you define this mapping, you call simple object methods. This allows you to

write object-centric code, rather than database-centric code.

• The .NET SDK provides a document model that wraps some of the low-level API functionality to further

simplify your coding.

For more information, see Using the AWS SDK for Java (p. 354) and Using the AWS SDK for .NET (p.356).

If you decide not to use the AWS SDKs, then your application will need to construct individual service

requests. Each request must contain a valid JSON payload and correct HTTP headers, including a valid

AWS signature. For more information on constructing your own service requests, see Using the DynamoDB

API (p. 466).

DynamoDB also provides a management console that enables you to work with tables and items.You

can create, update, and delete tables without writing any code.You can view all the existing items in a

table or use a query to filter the items in the table.You can add new items or delete items.You can also

use the management console to monitor the performance of your tables. Using CloudWatch metrics in

the console, you can monitor table throughput and other performance metrics. For more information, go

to DynamoDB console.

Regions and Endpoints for DynamoDB

By default, the AWS SDKs and console for DynamoDB reference the US-West (Oregon) Region. As

DynamoDB expands availability to new regions, new endpoints for these regions are also available to

use in your own HTTP requests, the AWS SDKs, and the console. For a current list of supported regions

and endpoints, see Regions and Endpoints.

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Regions and Endpoints for DynamoDB

剩余722页未读，继续阅读

jcdel

粉丝: 3
资源: 27

亚马逊DynamoDB开发指南

Dynamo开发手册

SpringDataDynamoDB.zip

Dynamo论文整理的PPT与中文PPT

DynamoDB开发人员指南

dynamodb-document-js-sdk：DynamoDB文档SDK（使用Javascript）

Amazon DynamoDB开发全攻略：构建高可用NoSQL数据库

dynamodb:用于开发的本地dynamodb服务器

Go的DynamoDB客户端-Golang开发

Laravel开发-dynamodb .zip.zip

AWS官方文档：DynamoDB ElasticCache RDS RedShift SimpleDB

最新资源