亚马逊DynamoDB入门指南

需积分: 10 201 浏览量更新于2024-07-22 收藏 6.62MB PDF 举报

"AWS DynamoDB Start Guide - AWS DynomoDB No SQL Quick Start Guide (English Version)" 本文将为你提供关于AWS DynamoDB的基础知识，帮助你快速入门这个高性能、完全托管的NoSQL数据库服务。DynamoDB是Amazon Web Services (AWS) 提供的一种关键组件，它能够以极高的吞吐量和低延迟存储和检索数据。适用于需要高可扩展性和一致性的在线交易应用。首先，了解DynamoDB的基本概念是非常重要的。DynamoDB基于键值对存储，其中每个记录都由一个主键（Partition Key）和一个可选的排序键（Sort Key）组成。主键用于区分不同的记录，而排序键则用于在同一个分区键内进行排序。此外，DynamoDB支持多种数据类型，包括字符串、数字、布尔值、二进制数据以及列表和映射等复杂数据结构。在DynamoDB中，表是数据的容器，你可以根据需要创建任意数量的表，并在这些表中存储数据。表的容量单位（Capacity Units）决定了读取和写入操作的速率，分为读容量单位和写容量单位。AWS会自动管理这些容量单位，以确保服务的可用性和性能。你可以根据需求动态调整容量，以应对流量的变化。 DynamoDB提供API版本2012-08-10，允许开发者通过简单的HTTP请求进行数据操作。这些操作包括创建、查询、更新和删除记录，以及执行批量操作。此外，DynamoDB还支持使用表达式进行条件更新，以确保数据的一致性。为了提高数据访问效率，DynamoDB提供了全局二级索引和本地二级索引。全局二级索引允许你在不改变主键的情况下创建额外的索引，从而以不同的键进行查询。而本地二级索引则与主键位于同一分区内，适合用于提高特定查询性能。 AWS还提供了DynamoDB Streams，这是一个记录表中所有更改的实时数据流。开发者可以利用这些流来实现事件驱动的应用，例如触发Lambda函数进行数据处理或同步到其他系统。安全性方面，DynamoDB支持IAM（Identity and Access Management）策略，允许精细控制对数据库的访问权限。同时，所有的数据传输都使用SSL加密，确保数据在传输过程中的安全。 DynamoDB与其他AWS服务无缝集成，如Lambda、S3和CloudWatch等。例如，你可以使用Lambda函数来响应DynamoDB Stream中的事件，或者通过CloudWatch监控表的性能指标。 AWS DynamoDB是一个强大的NoSQL数据库解决方案，尤其适合需要高并发、低延迟和灵活扩展性的应用场景。理解其核心特性和用法，将有助于你构建可靠且高效的云上应用。

true

Null

Null represents an attribute with an unknown or undefined state.

Example

NULL

Multi-Valued Data Types

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

attributes 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}

}

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Data Types

]

}

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. 91).

Supported Operations in DynamoDB

To work with tables and items, Amazon DynamoDB offers the following set of 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 communicate

with DynamoDB. For more information, see Working with Tables in DynamoDB (p. 52).

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 in DynamoDB (p. 83).

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 in DynamoDB (p. 183).

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,

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Supported Operations

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. 473).

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 successful

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

updates 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

incrementing or decrementing existing attribute values.

For more information, see Working with Items in DynamoDB (p. 83).

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.

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Conditional Updates and Concurrency Control

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

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

requests 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. 53).

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. 306)

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

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) × 1 (3 KB / 4 KB = 0.75, rounded up to the next whole number) = 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 or an index 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. 55).

API Version 2012-08-10

Amazon DynamoDB Developer Guide

Read Capacity Units

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

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. 361).

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. 361) and Using the AWS SDK for .NET (p.364).

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. 473).

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

Write Capacity Units

剩余737页未读，继续阅读

gsun5

粉丝: 0
资源: 3

亚马逊DynamoDB入门指南

AWS构架师 PPT(Architecting on AWS Student Guide)

berlin emodb

AWS CSAA Study Guide 2nd Edition.pdf

aws-start-instance

AWS-Lambda-Quick-Start-Guide:Packt发布的《 AWS Lambda快速入门指南》

AWS Certified SAA Exam guide

aws developer认证study guide

AWS Lambda 开发者User Guide

AWS ADMINISTRATION THE DEFINITIVE GUIDE

aws-robomaker Developer Guide

最新资源