DynamoDB - คู่มือฉบับย่อ

DynamoDB ช่วยให้ผู้ใช้สามารถสร้างฐานข้อมูลที่สามารถจัดเก็บและดึงข้อมูลจำนวนเท่าใดก็ได้และให้บริการปริมาณการใช้ข้อมูลเท่าใดก็ได้ โดยจะกระจายข้อมูลและทราฟฟิกผ่านเซิร์ฟเวอร์โดยอัตโนมัติเพื่อจัดการคำขอของลูกค้าแต่ละรายแบบไดนามิกและยังรักษาประสิทธิภาพที่รวดเร็ว

DynamoDB กับ RDBMS

DynamoDB ใช้แบบจำลอง NoSQL ซึ่งหมายความว่าใช้ระบบที่ไม่ใช่เชิงสัมพันธ์ ตารางต่อไปนี้เน้นความแตกต่างระหว่าง DynamoDB และ RDBMS -

งานทั่วไป	RDBMS	DynamoDB
Connect to the Source	ใช้การเชื่อมต่อแบบต่อเนื่องและคำสั่ง SQL	ใช้คำขอ HTTP และการดำเนินการ API
Create a Table	โครงสร้างพื้นฐานคือตารางและต้องกำหนด	ใช้คีย์หลักเท่านั้นและไม่มีสคีมาในการสร้าง ใช้แหล่งข้อมูลต่างๆ
Get Table Info	ข้อมูลตารางทั้งหมดยังคงสามารถเข้าถึงได้	เปิดเผยเฉพาะคีย์หลักเท่านั้น
Load Table Data	ใช้แถวที่สร้างจากคอลัมน์	ในตารางจะใช้รายการที่สร้างจากแอตทริบิวต์
Read Table Data	ใช้คำสั่ง SELECT และคำสั่งกรอง	ใช้ GetItem แบบสอบถามและสแกน
Manage Indexes	ใช้ดัชนีมาตรฐานที่สร้างขึ้นผ่านคำสั่ง SQL การแก้ไขจะเกิดขึ้นโดยอัตโนมัติในการเปลี่ยนแปลงตาราง	ใช้ดัชนีรองเพื่อให้ได้ฟังก์ชันเดียวกัน ต้องมีข้อมูลจำเพาะ (คีย์พาร์ติชันและคีย์การเรียงลำดับ)
Modify Table Data	ใช้คำสั่ง UPDATE	ใช้การดำเนินการ UpdateItem
Delete Table Data	ใช้คำสั่ง DELETE	มันใช้การดำเนินการ DeleteItem
Delete a Table	มันใช้คำสั่ง DROP TABLE	ใช้การดำเนินการ DeleteTable

ข้อดี

ข้อดีหลักสองประการของ DynamoDB คือความสามารถในการปรับขนาดและความยืดหยุ่น ไม่ได้บังคับให้ใช้แหล่งข้อมูลและโครงสร้างเฉพาะทำให้ผู้ใช้สามารถทำงานกับแทบทุกอย่าง แต่ในลักษณะเดียวกัน

การออกแบบยังรองรับการใช้งานที่หลากหลายตั้งแต่งานและการดำเนินงานที่มีน้ำหนักเบาไปจนถึงความต้องการการทำงานขององค์กร นอกจากนี้ยังช่วยให้ใช้หลายภาษาได้ง่าย: Ruby, Java, Python, C #, Erlang, PHP และ Perl

ข้อ จำกัด

DynamoDB ประสบกับข้อ จำกัด บางประการอย่างไรก็ตามข้อ จำกัด เหล่านี้ไม่จำเป็นต้องสร้างปัญหาใหญ่หลวงหรือขัดขวางการพัฒนาที่มั่นคง

คุณสามารถตรวจสอบได้จากประเด็นต่อไปนี้ -

Capacity Unit Sizes- หน่วยความจุในการอ่านคือการอ่านที่สม่ำเสมอเพียงครั้งเดียวต่อวินาทีสำหรับรายการที่มีขนาดไม่เกิน 4KB หน่วยความจุในการเขียนคือการเขียนครั้งเดียวต่อวินาทีสำหรับรายการที่มีขนาดไม่เกิน 1KB
Provisioned Throughput Min/Max- ตารางทั้งหมดและดัชนีทุติยภูมิทั่วโลกมีหน่วยความจุในการอ่านและการเขียนอย่างน้อยหนึ่งหน่วย สูงสุดขึ้นอยู่กับภูมิภาค ในสหรัฐอเมริกาการอ่านและเขียน 40K ยังคงเป็นขีด จำกัด ต่อตาราง (80K ต่อบัญชี) และภูมิภาคอื่น ๆ จะมีขีด จำกัด 10K ต่อตารางโดยมีขีด จำกัด บัญชี 20K
Provisioned Throughput Increase and Decrease - คุณสามารถเพิ่มได้บ่อยเท่าที่ต้องการ แต่การลดจะ จำกัด อยู่ที่ไม่เกินสี่ครั้งต่อวันต่อโต๊ะ
Table Size and Quantity Per Account - ขนาดโต๊ะไม่มีขีด จำกัด แต่บัญชีมีขีด จำกัด 256 ตารางเว้นแต่คุณจะขอขีด จำกัด ที่สูงขึ้น
Secondary Indexes Per Table - อนุญาตให้ใช้ในท้องถิ่นห้าแห่งและระดับโลกห้าแห่ง
Projected Secondary Index Attributes Per Table - DynamoDB อนุญาต 20 แอตทริบิวต์
Partition Key Length and Values - ความยาวต่ำสุดอยู่ที่ 1 ไบต์และสูงสุดที่ 2048 ไบต์อย่างไรก็ตาม DynamoDB ไม่ จำกัด ค่า
Sort Key Length and Values - ความยาวต่ำสุดคือ 1 ไบต์และสูงสุดที่ 1024 ไบต์โดยไม่ จำกัด ค่าเว้นแต่ว่าตารางจะใช้ดัชนีรองในเครื่อง
Table and Secondary Index Names - ชื่อต้องมีความยาวอย่างน้อย 3 อักขระและไม่เกิน 255 ตัวโดยใช้อักขระต่อไปนี้: AZ, az, 0-9,“ _”,“ -” และ“.”
Attribute Names - อักขระหนึ่งตัวยังคงเป็นค่าต่ำสุดและสูงสุด 64KB โดยมีข้อยกเว้นสำหรับคีย์และคุณลักษณะบางอย่าง
Reserved Words - DynamoDB ไม่ป้องกันการใช้คำสงวนเป็นชื่อ
Expression Length- สตริงนิพจน์มีขีด จำกัด 4KB นิพจน์แอตทริบิวต์มีขีด จำกัด 255 ไบต์ ตัวแปรการแทนที่ของนิพจน์มีขีด จำกัด 2MB

ก่อนใช้ DynamoDB คุณต้องทำความคุ้นเคยกับองค์ประกอบพื้นฐานและระบบนิเวศ ในระบบนิเวศ DynamoDB คุณทำงานกับตารางแอตทริบิวต์และรายการ ตารางมีชุดของรายการและรายการมีชุดแอตทริบิวต์ แอตทริบิวต์เป็นองค์ประกอบพื้นฐานของข้อมูลที่ไม่ต้องมีการย่อยสลายอีกต่อไปนั่นคือฟิลด์

คีย์หลัก

คีย์หลักทำหน้าที่เป็นวิธีการระบุเฉพาะสำหรับรายการตารางและดัชนีรองให้ความยืดหยุ่นในการสืบค้น สตรีม DynamoDB บันทึกเหตุการณ์โดยการแก้ไขข้อมูลตาราง

การสร้างตารางไม่เพียงต้องการตั้งชื่อ แต่ต้องใช้คีย์หลักด้วย ซึ่งระบุรายการตาราง ไม่มีสองรายการที่ใช้คีย์ร่วมกัน DynamoDB ใช้คีย์หลักสองประเภท -

Partition Key- คีย์หลักอย่างง่ายนี้ประกอบด้วยแอตทริบิวต์เดียวที่เรียกว่า "พาร์ติชันคีย์" ภายใน DynamoDB ใช้ค่าคีย์เป็นอินพุตสำหรับฟังก์ชันแฮชเพื่อกำหนดการจัดเก็บ
Partition Key and Sort Key - คีย์นี้เรียกว่า "คีย์หลักแบบผสม" ประกอบด้วยสองแอตทริบิวต์
- คีย์พาร์ติชันและ
- คีย์การจัดเรียง
DynamoDB ใช้แอ็ตทริบิวต์แรกกับฟังก์ชันแฮชและเก็บไอเท็มที่มีพาร์ติชันคีย์เดียวกันไว้ด้วยกัน ด้วยลำดับที่กำหนดโดยคีย์การจัดเรียง รายการสามารถแชร์คีย์พาร์ติชันได้ แต่ไม่สามารถจัดเรียงคีย์ได้

แอตทริบิวต์คีย์หลักอนุญาตเฉพาะค่าสเกลาร์ (เดี่ยว) และชนิดข้อมูลสตริงตัวเลขหรือไบนารี แอตทริบิวต์ที่ไม่ใช่คีย์ไม่มีข้อ จำกัด เหล่านี้

ดัชนีรอง

ดัชนีเหล่านี้ช่วยให้คุณสืบค้นข้อมูลตารางด้วยคีย์สำรอง แม้ว่า DynamoDB จะไม่บังคับให้ใช้ แต่ก็เพิ่มประสิทธิภาพการสืบค้น

DynamoDB ใช้ดัชนีรองสองประเภท -

Global Secondary Index - ดัชนีนี้มีพาร์ติชันและคีย์การเรียงลำดับซึ่งอาจแตกต่างจากคีย์ตาราง
Local Secondary Index - ดัชนีนี้มีคีย์พาร์ติชันเหมือนกับตารางอย่างไรก็ตามคีย์การจัดเรียงจะแตกต่างกัน

API

การดำเนินการ API ที่นำเสนอโดย DynamoDB รวมถึงระนาบควบคุมระนาบข้อมูล (เช่นการสร้างการอ่านการอัปเดตและการลบ) และสตรีม ในการควบคุมการทำงานของเครื่องบินคุณสร้างและจัดการตารางด้วยเครื่องมือต่อไปนี้ -

CreateTable
DescribeTable
ListTables
UpdateTable
DeleteTable

ในระนาบข้อมูลคุณดำเนินการ CRUD ด้วยเครื่องมือต่อไปนี้ -

สร้าง	อ่าน	อัปเดต	ลบ
PutItem BatchWriteItem	GetItem BatchGetItem แบบสอบถาม สแกน	UpdateItem	DeleteItem BatchWriteItem

สตรีมตารางควบคุมการดำเนินการสตรีม คุณสามารถตรวจสอบเครื่องมือสตรีมต่อไปนี้ -

ListStreams
DescribeStream
GetShardIterator
GetRecords

ปริมาณงานที่เตรียมไว้

ในการสร้างตารางคุณต้องระบุทรูพุตที่จัดเตรียมไว้ซึ่งสงวนทรัพยากรสำหรับการอ่านและเขียน คุณใช้หน่วยความจุเพื่อวัดและตั้งค่าปริมาณงาน

เมื่อแอปพลิเคชันเกินปริมาณงานที่ตั้งไว้คำขอจะล้มเหลว คอนโซล DynamoDB GUI ช่วยให้สามารถตรวจสอบการตั้งค่าและปริมาณงานที่ใช้เพื่อการจัดเตรียมที่ดีขึ้นและไดนามิก

อ่านความสม่ำเสมอ

DynamoDB ใช้ eventually consistent และ strongly consistentอ่านเพื่อรองรับความต้องการแอปพลิเคชันแบบไดนามิก การอ่านที่สอดคล้องกันในที่สุดไม่ได้ให้ข้อมูลปัจจุบันเสมอไป

การอ่านที่สอดคล้องกันอย่างมากจะส่งข้อมูลปัจจุบันเสมอ (ยกเว้นอุปกรณ์ล้มเหลวหรือปัญหาเครือข่าย) การอ่านที่สอดคล้องกันในที่สุดจะทำหน้าที่เป็นการตั้งค่าเริ่มต้นโดยต้องมีการตั้งค่า true ในไฟล์ConsistentRead พารามิเตอร์เพื่อเปลี่ยนแปลง

พาร์ทิชัน

DynamoDB ใช้พาร์ติชันสำหรับจัดเก็บข้อมูล การจัดสรรพื้นที่เก็บข้อมูลสำหรับตารางเหล่านี้มีการสำรอง SSD และจำลองแบบข้ามโซนโดยอัตโนมัติ DynamoDB จัดการงานพาร์ติชันทั้งหมดโดยไม่ต้องให้ผู้ใช้มีส่วนร่วม

ในการสร้างตารางตารางจะเข้าสู่สถานะ CREATING ซึ่งจัดสรรพาร์ติชัน เมื่อถึงสถานะ ACTIVE คุณสามารถดำเนินการได้ ระบบจะเปลี่ยนพาร์ติชันเมื่อความจุถึงสูงสุดหรือเมื่อคุณเปลี่ยนทรูพุต

สภาพแวดล้อม DynamoDB ประกอบด้วยการใช้บัญชี Amazon Web Services ของคุณเพื่อเข้าถึงคอนโซล DynamoDB GUI เท่านั้นอย่างไรก็ตามคุณยังสามารถทำการติดตั้งภายในเครื่องได้

ไปที่เว็บไซต์ต่อไปนี้ - https://aws.amazon.com/dynamodb/

คลิกปุ่ม "เริ่มต้นใช้งาน Amazon DynamoDB" หรือปุ่ม "สร้างบัญชี AWS" หากคุณไม่มีบัญชี Amazon Web Services ขั้นตอนง่ายๆที่มีคำแนะนำจะแจ้งให้คุณทราบถึงค่าธรรมเนียมและข้อกำหนดที่เกี่ยวข้องทั้งหมด

หลังจากดำเนินการตามขั้นตอนที่จำเป็นทั้งหมดแล้วคุณจะสามารถเข้าถึงได้ เพียงลงชื่อเข้าใช้คอนโซล AWS จากนั้นไปที่คอนโซล DynamoDB

อย่าลืมลบเนื้อหาที่ไม่ได้ใช้หรือไม่จำเป็นเพื่อหลีกเลี่ยงค่าธรรมเนียมที่เกี่ยวข้อง

ติดตั้งในเครื่อง

AWS (Amazon Web Service) มีเวอร์ชันของ DynamoDB สำหรับการติดตั้งภายในเครื่อง รองรับการสร้างแอปพลิเคชันโดยไม่ต้องใช้บริการเว็บหรือการเชื่อมต่อ นอกจากนี้ยังช่วยลดปริมาณงานที่จัดเตรียมการจัดเก็บข้อมูลและค่าธรรมเนียมการโอนโดยอนุญาตให้มีฐานข้อมูลในเครื่อง คู่มือนี้ถือว่าเป็นการติดตั้งภายในเครื่อง

เมื่อพร้อมสำหรับการปรับใช้คุณสามารถทำการปรับเปลี่ยนเล็กน้อยในแอปพลิเคชันของคุณเพื่อแปลงเป็นการใช้งาน AWS

ไฟล์ติดตั้งคือไฟล์ .jar executable. ทำงานใน Linux, Unix, Windows และระบบปฏิบัติการอื่น ๆ ที่รองรับ Java ดาวน์โหลดไฟล์โดยใช้หนึ่งในลิงค์ต่อไปนี้ -

Tarball - http://dynamodb-local.s3-website-us-west2.amazonaws.com/dynamodb_local_latest.tar.gz
Zip archive - http://dynamodb-local.s3-website-us-west2.amazonaws.com/dynamodb_local_latest.zip

Note- ที่เก็บอื่นเสนอไฟล์ แต่ไม่จำเป็นต้องเป็นเวอร์ชันล่าสุด ใช้ลิงก์ด้านบนเพื่ออัปเดตไฟล์ติดตั้ง นอกจากนี้ตรวจสอบให้แน่ใจว่าคุณมี Java Runtime Engine (JRE) เวอร์ชัน 6.x หรือเวอร์ชันที่ใหม่กว่า DynamoDB ไม่สามารถทำงานกับเวอร์ชันเก่าได้

หลังจากดาวน์โหลดไฟล์เก็บถาวรที่เหมาะสมแล้วให้แตกไดเร็กทอรี (DynamoDBLocal.jar) และวางไว้ในตำแหน่งที่ต้องการ

จากนั้นคุณสามารถเริ่ม DynamoDB ได้โดยเปิดพรอมต์คำสั่งไปที่ไดเร็กทอรีที่มี DynamoDBLocal.jar และป้อนคำสั่งต่อไปนี้ -

java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb

คุณยังสามารถหยุด DynamoDB ได้โดยปิดพรอมต์คำสั่งที่ใช้เริ่มต้น

สภาพแวดล้อมการทำงาน

คุณสามารถใช้เชลล์ JavaScript คอนโซล GUI และหลายภาษาเพื่อทำงานกับ DynamoDB ภาษาที่มีให้ ได้แก่ Ruby, Java, Python, C #, Erlang, PHP และ Perl

ในบทช่วยสอนนี้เราใช้ตัวอย่างคอนโซล Java และ GUI เพื่อความชัดเจนของแนวคิดและโค้ด ติดตั้ง Java IDE, AWS SDK สำหรับ Java และตั้งค่าข้อมูลรับรองความปลอดภัย AWS สำหรับ Java SDK เพื่อใช้ Java

การแปลงจาก Local เป็น Web Service Code

เมื่อพร้อมสำหรับการปรับใช้คุณจะต้องแก้ไขโค้ดของคุณ การปรับเปลี่ยนขึ้นอยู่กับภาษารหัสและปัจจัยอื่น ๆ การเปลี่ยนแปลงหลักประกอบด้วยการเปลี่ยนendpointจากจุดในพื้นที่ไปยังภูมิภาค AWS การเปลี่ยนแปลงอื่น ๆ จำเป็นต้องมีการวิเคราะห์แอปพลิเคชันของคุณอย่างลึกซึ้งยิ่งขึ้น

การติดตั้งในเครื่องแตกต่างจากบริการบนเว็บในหลาย ๆ ด้านรวมถึง แต่ไม่ จำกัด เฉพาะความแตกต่างที่สำคัญดังต่อไปนี้ -

การติดตั้งในเครื่องจะสร้างตารางทันที แต่บริการใช้เวลานานกว่ามาก
การติดตั้งโลคัลละเว้นทรูพุต
การลบจะเกิดขึ้นทันทีในการติดตั้งภายในเครื่อง
การอ่าน / เขียนเกิดขึ้นอย่างรวดเร็วในการติดตั้งภายในเครื่องเนื่องจากไม่มีเครือข่ายเหนือศีรษะ

DynamoDB มีสามตัวเลือกสำหรับการดำเนินการ: คอนโซล GUI บนเว็บเชลล์ JavaScript และภาษาโปรแกรมที่คุณเลือก

ในบทช่วยสอนนี้เราจะเน้นไปที่การใช้คอนโซล GUI และภาษา Java เพื่อความชัดเจนและความเข้าใจแนวคิด

GUI คอนโซล

คอนโซล GUI หรือ AWS Management Console สำหรับ Amazon DynamoDB สามารถพบได้ตามที่อยู่ต่อไปนี้ - https://console.aws.amazon.com/dynamodb/home

ช่วยให้คุณสามารถทำงานต่อไปนี้ -

CRUD
ดูรายการตาราง
ดำเนินการสืบค้นตาราง
ตั้งค่าสัญญาณเตือนสำหรับการตรวจสอบความจุของตาราง
ดูตารางเมตริกแบบเรียลไทม์
ดูสัญญาณเตือนบนโต๊ะ

หากบัญชี DynamoDB ของคุณไม่มีตารางในการเข้าถึงจะแนะนำคุณตลอดการสร้างตาราง หน้าจอหลักมีทางลัดสามทางสำหรับการดำเนินการทั่วไป -

สร้างตาราง
เพิ่มและสืบค้นตาราง
ตรวจสอบและจัดการตาราง

เชลล์ JavaScript

DynamoDB มีเชลล์ JavaScript แบบโต้ตอบ เชลล์ทำงานภายในเว็บเบราว์เซอร์และเบราว์เซอร์ที่แนะนำ ได้แก่ Firefox และ Chrome

Note - การใช้เบราว์เซอร์อื่นอาจทำให้เกิดข้อผิดพลาด

เข้าถึงเชลล์โดยเปิดเว็บเบราว์เซอร์และป้อนที่อยู่ต่อไปนี้ -http://localhost:8000/shell

ใช้เชลล์โดยป้อน JavaScript ในบานหน้าต่างด้านซ้ายและคลิกปุ่มไอคอน "เล่น" ที่มุมขวาบนของบานหน้าต่างด้านซ้ายซึ่งเรียกใช้โค้ด ผลลัพธ์ของโค้ดจะแสดงในบานหน้าต่างด้านขวา

DynamoDB และ Java

ใช้ Java กับ DynamoDB โดยใช้สภาพแวดล้อมการพัฒนา Java ของคุณ การดำเนินการยืนยันตามไวยากรณ์และโครงสร้าง Java ปกติ

ประเภทข้อมูลที่ DynamoDB รองรับ ได้แก่ ประเภทข้อมูลเฉพาะสำหรับแอตทริบิวต์การดำเนินการและภาษาการเข้ารหัสที่คุณเลือก

ประเภทข้อมูลแอตทริบิวต์

DynamoDB สนับสนุนชุดข้อมูลขนาดใหญ่สำหรับแอตทริบิวต์ของตาราง ข้อมูลแต่ละประเภทจัดอยู่ในหนึ่งในสามประเภทต่อไปนี้ -

Scalar - ประเภทเหล่านี้แสดงถึงค่าเดียวและรวมถึงตัวเลขสตริงไบนารีบูลีนและค่าว่าง
Document - ประเภทเหล่านี้แสดงถึงโครงสร้างที่ซับซ้อนซึ่งมีแอตทริบิวต์ซ้อนกันและรวมถึงรายการและแผนที่
Set - ประเภทเหล่านี้แสดงถึงสเกลาร์หลายชุดและรวมถึงชุดสตริงชุดตัวเลขและชุดไบนารี

จำ DynamoDB เป็นฐานข้อมูล NoSQL ที่ไม่มีสกีมาที่ไม่ต้องการแอตทริบิวต์หรือข้อกำหนดประเภทข้อมูลเมื่อสร้างตาราง ต้องใช้ประเภทข้อมูลแอตทริบิวต์คีย์หลักเท่านั้นซึ่งตรงกันข้ามกับ RDBMS ซึ่งต้องใช้ชนิดข้อมูลคอลัมน์ในการสร้างตาราง

สเกลาร์

Numbers - จำกัด ไว้ที่ 38 หลักและเป็นค่าบวกลบหรือศูนย์
String - เป็น Unicode ที่ใช้ UTF-8 โดยมีความยาวขั้นต่ำ> 0 และสูงสุด 400KB
Binary- จัดเก็บข้อมูลไบนารีใด ๆ เช่นข้อมูลที่เข้ารหัสรูปภาพและข้อความบีบอัด DynamoDB มองว่าไบต์ของมันไม่ได้ลงนาม
Boolean - จัดเก็บจริงหรือเท็จ
Null - เป็นตัวแทนของสถานะที่ไม่รู้จักหรือไม่ได้กำหนด

เอกสาร

List - จัดเก็บคอลเลกชันมูลค่าที่สั่งซื้อและใช้วงเล็บเหลี่ยม ([... ])
Map - จัดเก็บคอลเลคชันคู่ค่าชื่อ - ค่าที่ไม่เรียงลำดับและใช้วงเล็บปีกกา ({... })

ชุด

ชุดต้องมีองค์ประกอบประเภทเดียวกันไม่ว่าจะเป็นตัวเลขสตริงหรือไบนารี ขีด จำกัด เดียวที่วางไว้ในชุดประกอบด้วยขีด จำกัด ขนาดรายการ 400KB และแต่ละองค์ประกอบไม่ซ้ำกัน

ประเภทข้อมูลการดำเนินการ

DynamoDB API เก็บข้อมูลประเภทต่างๆที่ใช้โดยการดำเนินการ คุณสามารถตรวจสอบการเลือกประเภทคีย์ต่อไปนี้ -

AttributeDefinition - แสดงถึงตารางคีย์และสคีมาดัชนี
Capacity - แสดงถึงปริมาณทรูพุตที่ใช้โดยตารางหรือดัชนี
CreateGlobalSecondaryIndexAction - แสดงดัชนีทุติยภูมิสากลใหม่ที่เพิ่มลงในตาราง
LocalSecondaryIndex - แสดงถึงคุณสมบัติดัชนีรองในท้องถิ่น
ProvisionedThroughput - แสดงถึงทรูพุตที่จัดเตรียมไว้สำหรับดัชนีหรือตาราง
PutRequest - แสดงถึงคำขอของ PutItem
TableDescription - แสดงถึงคุณสมบัติของตาราง

Java Datatypes ที่รองรับ

DynamoDB ให้การสนับสนุนชนิดข้อมูลดั้งเดิมชุดคอลเลกชันและชนิดที่กำหนดเองสำหรับ Java

การสร้างตารางโดยทั่วไปประกอบด้วยการวางไข่ของตารางการตั้งชื่อการสร้างแอตทริบิวต์คีย์หลักและการตั้งค่าประเภทข้อมูลแอตทริบิวต์

ใช้ GUI Console, Java หรือตัวเลือกอื่นเพื่อทำงานเหล่านี้

สร้างตารางโดยใช้ GUI Console

สร้างตารางโดยเข้าถึงคอนโซลที่ https://console.aws.amazon.com/dynamodb. จากนั้นเลือกตัวเลือก "สร้างตาราง"

ตัวอย่างของเราสร้างตารางที่เต็มไปด้วยข้อมูลผลิตภัณฑ์โดยมีผลิตภัณฑ์ของแอตทริบิวต์เฉพาะที่ระบุด้วยหมายเลขรหัส (แอตทริบิวต์ตัวเลข) ในCreate Tableหน้าจอป้อนชื่อตารางภายในฟิลด์ชื่อตาราง ป้อนคีย์หลัก (ID) ภายในฟิลด์คีย์พาร์ติชัน และป้อน "ตัวเลข" สำหรับประเภทข้อมูล

หลังจากป้อนข้อมูลทั้งหมดแล้วให้เลือก Create.

สร้างตารางโดยใช้ Java

ใช้ Java เพื่อสร้างตารางเดียวกัน คีย์หลักประกอบด้วยสองคุณลักษณะต่อไปนี้ -

ID - ใช้คีย์พาร์ติชันและ ScalarAttributeType N, หมายถึงเลข.
Nomenclature - ใช้คีย์การจัดเรียงและ ScalarAttributeType Sหมายถึงสตริง

Java ใช้ไฟล์ createTable methodเพื่อสร้างตาราง และภายในการเรียกชื่อตารางแอตทริบิวต์คีย์หลักและชนิดข้อมูลแอตทริบิวต์จะถูกระบุ

คุณสามารถดูตัวอย่างต่อไปนี้ -

import java.util.Arrays;
 
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient; 
import com.amazonaws.services.dynamodbv2.document.DynamoDB; 
import com.amazonaws.services.dynamodbv2.document.Table; 

import com.amazonaws.services.dynamodbv2.model.AttributeDefinition; 
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement; 
import com.amazonaws.services.dynamodbv2.model.KeyType; 
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput; 
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
 
public class ProductsCreateTable {  
   public static void main(String[] args) throws Exception { 
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client); 
      String tableName = "Products";  
      try { 
         System.out.println("Creating the table, wait..."); 
         Table table = dynamoDB.createTable (tableName, 
            Arrays.asList ( 
               new KeySchemaElement("ID", KeyType.HASH), // the partition key 
                                                         // the sort key 
               new KeySchemaElement("Nomenclature", KeyType.RANGE)
            ),
            Arrays.asList ( 
               new AttributeDefinition("ID", ScalarAttributeType.N), 
               new AttributeDefinition("Nomenclature", ScalarAttributeType.S)
            ),
            new ProvisionedThroughput(10L, 10L)
         );
         table.waitForActive(); 
         System.out.println("Table created successfully.  Status: " + 
            table.getDescription().getTableStatus());
            
      } catch (Exception e) {
         System.err.println("Cannot create the table: "); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

ในตัวอย่างข้างต้นให้สังเกตจุดสิ้นสุด: .withEndpoint.

ระบุการใช้การติดตั้งภายในเครื่องโดยใช้ localhost นอกจากนี้โปรดทราบว่าจำเป็นProvisionedThroughput parameterซึ่งการติดตั้งภายในจะละเว้น

การโหลดตารางโดยทั่วไปประกอบด้วยการสร้างไฟล์ต้นฉบับการตรวจสอบว่าไฟล์ต้นทางสอดคล้องกับไวยากรณ์ที่เข้ากันได้กับ DynamoDB การส่งไฟล์ต้นทางไปยังปลายทางจากนั้นยืนยันการเติมข้อมูลที่สำเร็จ

ใช้คอนโซล GUI, Java หรือตัวเลือกอื่นในการทำงาน

โหลดตารางโดยใช้ GUI Console

โหลดข้อมูลโดยใช้การรวมกันของบรรทัดคำสั่งและคอนโซล คุณสามารถโหลดข้อมูลได้หลายวิธีซึ่งบางส่วนมีดังต่อไปนี้ -

คอนโซล
บรรทัดคำสั่ง
รหัสและ
Data Pipeline (คุณลักษณะที่กล่าวถึงในบทช่วยสอนในภายหลัง)

อย่างไรก็ตามเพื่อความรวดเร็วตัวอย่างนี้ใช้ทั้งเชลล์และคอนโซล ขั้นแรกให้โหลดข้อมูลต้นทางลงในปลายทางด้วยไวยากรณ์ต่อไปนี้ -

aws dynamodb batch-write-item -–request-items file://[filename]

ตัวอย่างเช่น -

aws dynamodb batch-write-item -–request-items file://MyProductData.json

ตรวจสอบความสำเร็จของการดำเนินการโดยเข้าถึงคอนโซลที่ -

https://console.aws.amazon.com/dynamodb

เลือก Tables จากบานหน้าต่างนำทางและเลือกตารางปลายทางจากรายการตาราง

เลือกไฟล์ Itemsเพื่อตรวจสอบข้อมูลที่คุณใช้ในการเติมข้อมูลในตาราง เลือกCancel เพื่อกลับไปที่รายการตาราง

โหลดตารางโดยใช้ Java

ใช้ Java โดยการสร้างไฟล์ต้นฉบับก่อน ไฟล์ต้นฉบับของเราใช้รูปแบบ JSON ผลิตภัณฑ์แต่ละชิ้นมีแอตทริบิวต์คีย์หลักสองรายการ (ID และระบบการตั้งชื่อ) และแผนที่ JSON (สถิติ) -

[ 
   { 
      "ID" : ... , 
      "Nomenclature" : ... , 
      "Stat" : { ... }
   }, 
   { 
      "ID" : ... , 
      "Nomenclature" : ... , 
      "Stat" : { ... } 
   }, 
    ... 
]

คุณสามารถดูตัวอย่างต่อไปนี้ -

{ 
   "ID" : 122, 
   "Nomenclature" : "Particle Blaster 5000", 
   "Stat" : { 
      "Manufacturer" : "XYZ Inc.", 
      "sales" : "1M+", 
      "quantity" : 500, 
      "img_src" : "http://www.xyz.com/manuals/particleblaster5000.jpg", 
      "description" : "A laser cutter used in plastic manufacturing." 
   } 
}

ขั้นตอนต่อไปคือการวางไฟล์ในไดเร็กทอรีที่แอปพลิเคชันของคุณใช้

Java ใช้ไฟล์ putItem และ path methods เพื่อดำเนินการโหลด

คุณสามารถตรวจสอบตัวอย่างโค้ดต่อไปนี้เพื่อประมวลผลไฟล์และโหลดได้ -

import java.io.File;
import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.databind.node.ObjectNode;

public class ProductsLoadData {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      JsonParser parser = new JsonFactory() 
         .createParser(new File("productinfo.json"));  
      
      JsonNode rootNode = new ObjectMapper().readTree(parser); 
      Iterator<JsonNode> iter = rootNode.iterator();  
      ObjectNode currentNode;  
      
      while (iter.hasNext()) { 
         currentNode = (ObjectNode) iter.next();  
         int ID = currentNode.path("ID").asInt(); 
         String Nomenclature = currentNode.path("Nomenclature").asText();  
         
         try { 
            table.putItem(new Item() 
               .withPrimaryKey("ID", ID, "Nomenclature", Nomenclature) 
               .withJSON("Stat", currentNode.path("Stat").toString()));
            System.out.println("Successful load: " + ID + " " + Nomenclature);  
         } catch (Exception e) {
            System.err.println("Cannot add product: " + ID + " " + Nomenclature);
            System.err.println(e.getMessage()); 
            break; 
         } 
      } 
      parser.close(); 
   } 
}

การสืบค้นตารางโดยหลักต้องเลือกตารางระบุคีย์พาร์ติชันและดำเนินการสืบค้น ด้วยตัวเลือกในการใช้ดัชนีทุติยภูมิและการกรองที่ลึกขึ้นผ่านการสแกน

ใช้ GUI Console, Java หรือตัวเลือกอื่นในการทำงาน

ตารางแบบสอบถามโดยใช้ GUI Console

ดำเนินการสืบค้นง่ายๆโดยใช้ตารางที่สร้างไว้ก่อนหน้านี้ ขั้นแรกให้เปิดคอนโซลที่https://console.aws.amazon.com/dynamodb

เลือก Tables จากบานหน้าต่างนำทางแล้วเลือก Replyจากรายการตาราง จากนั้นเลือกไฟล์Items เพื่อดูข้อมูลที่โหลด

เลือกลิงก์การกรองข้อมูล (“ Scan: [Table] Reply”) ที่อยู่ด้านล่าง Create Item ปุ่ม.

ในหน้าจอการกรองให้เลือกแบบสอบถามสำหรับการดำเนินการ ป้อนค่าคีย์พาร์ติชันที่เหมาะสมแล้วคลิกStart.

Reply จากนั้นส่งคืนรายการที่ตรงกัน

ตารางแบบสอบถามโดยใช้ Java

ใช้วิธีการสืบค้นใน Java เพื่อดำเนินการดึงข้อมูล ต้องระบุค่าคีย์พาร์ติชันโดยมีคีย์การเรียงลำดับเป็นทางเลือก

เขียนโค้ดคิวรี Java โดยสร้างไฟล์ querySpec objectอธิบายพารามิเตอร์ จากนั้นส่งผ่านวัตถุไปยังวิธีการสืบค้น เราใช้คีย์พาร์ติชันจากตัวอย่างก่อนหน้านี้

คุณสามารถดูตัวอย่างต่อไปนี้ -

import java.util.HashMap;
import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;

public class ProductsQuery {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      HashMap<String, String> nameMap = new HashMap<String, String>(); 
      nameMap.put("#ID", "ID");  
      HashMap<String, Object> valueMap = new HashMap<String, Object>(); 
      valueMap.put(":xxx", 122);
      QuerySpec querySpec = new QuerySpec() 
         .withKeyConditionExpression("#ID = :xxx") 
         .withNameMap(new NameMap().with("#ID", "ID")) 
         .withValueMap(valueMap);  
      
      ItemCollection<QueryOutcome> items = null; 
      Iterator<Item> iterator = null; 
      Item item = null;  
      try { 
         System.out.println("Product with the ID 122"); 
         items = table.query(querySpec);  
         iterator = items.iterator(); 
         
         while (iterator.hasNext()) { 
            item = iterator.next(); 
            System.out.println(item.getNumber("ID") + ": " 
               + item.getString("Nomenclature")); 
         } 
      } catch (Exception e) { 
         System.err.println("Cannot find products with the ID number 122"); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

โปรดทราบว่าแบบสอบถามใช้คีย์พาร์ติชันอย่างไรก็ตามดัชนีรองมีตัวเลือกอื่นสำหรับคิวรี ความยืดหยุ่นช่วยให้สามารถสืบค้นแอตทริบิวต์ที่ไม่ใช่คีย์ซึ่งเป็นหัวข้อที่จะกล่าวถึงในบทช่วยสอนนี้ในภายหลัง

วิธีการสแกนยังสนับสนุนการดำเนินการดึงข้อมูลโดยการรวบรวมข้อมูลตารางทั้งหมด optional .withFilterExpression ป้องกันไม่ให้รายการที่อยู่นอกเกณฑ์ที่ระบุปรากฏในผลลัพธ์

ต่อไปในบทช่วยสอนนี้เราจะพูดถึง scanningในรายละเอียด. ตอนนี้ดูตัวอย่างต่อไปนี้ -

import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.ScanSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;

public class ProductsScan {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000");  
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      ScanSpec scanSpec = new ScanSpec() 
         .withProjectionExpression("#ID, Nomenclature , stat.sales") 
         .withFilterExpression("#ID between :start_id and :end_id") 
         .withNameMap(new NameMap().with("#ID",  "ID")) 
         .withValueMap(new ValueMap().withNumber(":start_id", 120)
         .withNumber(":end_id", 129));  
      
      try { 
         ItemCollection<ScanOutcome> items = table.scan(scanSpec);  
         Iterator<Item> iter = items.iterator(); 
        
         while (iter.hasNext()) {
            Item item = iter.next(); 
            System.out.println(item.toString()); 
         } 
      } catch (Exception e) { 
         System.err.println("Cannot perform a table scan:"); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

ในบทนี้เราจะพูดถึงวิธีการลบตารางและวิธีต่างๆในการลบตาราง

การลบตารางเป็นการดำเนินการง่ายๆที่ต้องการมากกว่าชื่อตารางเล็กน้อย ใช้คอนโซล GUI, Java หรือตัวเลือกอื่น ๆ เพื่อทำงานนี้

ลบตารางโดยใช้ GUI Console

ดำเนินการลบโดยเข้าไปที่คอนโซลก่อนที่ -

https://console.aws.amazon.com/dynamodb.

เลือก Tables จากบานหน้าต่างนำทางและเลือกตารางที่ต้องการลบจากรายการตารางดังที่แสดงใน screeenshot ต่อไปนี้

สุดท้ายเลือก Delete Table. หลังจากเลือกลบตารางการยืนยันจะปรากฏขึ้น จากนั้นตารางของคุณจะถูกลบ

ลบตารางโดยใช้ Java

ใช้ deleteวิธีการลบตาราง ตัวอย่างจะได้รับด้านล่างเพื่ออธิบายแนวคิดได้ดีขึ้น

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient; 
import com.amazonaws.services.dynamodbv2.document.DynamoDB; 
import com.amazonaws.services.dynamodbv2.document.Table;  

public class ProductsDeleteTable {  
   public static void main(String[] args) throws Exception {  
      AmazonDynamoDBClient client = new AmazonDynamoDBClient() 
         .withEndpoint("http://localhost:8000"); 
      
      DynamoDB dynamoDB = new DynamoDB(client);  
      Table table = dynamoDB.getTable("Products");  
      try { 
         System.out.println("Performing table delete, wait..."); 
         table.delete(); 
         table.waitForDelete(); 
         System.out.print("Table successfully deleted.");  
      } catch (Exception e) { 
         System.err.println("Cannot perform table delete: "); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

DynamoDB นำเสนอชุดเครื่องมือ API ที่มีประสิทธิภาพมากมายสำหรับการจัดการตารางการอ่านข้อมูลและการแก้ไขข้อมูล

Amazon แนะนำให้ใช้ AWS SDKs(เช่น Java SDK) แทนที่จะเรียก API ระดับต่ำ ไลบรารีทำให้การโต้ตอบกับ API ระดับต่ำไม่จำเป็นโดยตรง ไลบรารีช่วยลดความซับซ้อนของงานทั่วไปเช่นการพิสูจน์ตัวตนการทำให้เป็นอนุกรมและการเชื่อมต่อ

จัดการตาราง

DynamoDB เสนอการดำเนินการระดับต่ำห้ารายการสำหรับการจัดการตาราง -

CreateTable- สิ่งนี้สร้างตารางและรวมถึงปริมาณงานที่กำหนดโดยผู้ใช้ คุณต้องตั้งค่าคีย์หลักไม่ว่าจะเป็นแบบคอมโพสิตหรือแบบธรรมดา นอกจากนี้ยังอนุญาตให้มีดัชนีรองหนึ่งหรือหลายดัชนี
ListTables - แสดงรายการตารางทั้งหมดในบัญชีผู้ใช้ AWS ปัจจุบันและเชื่อมโยงกับปลายทาง
UpdateTable - สิ่งนี้จะเปลี่ยนแปลงทรูพุตและทรูพุตของดัชนีรองทั่วโลก
DescribeTable- สิ่งนี้ให้ข้อมูลเมตาของตาราง ตัวอย่างเช่นรัฐขนาดและดัชนี
DeleteTable - เพียงแค่ลบตารางและดัชนี

อ่านข้อมูล

DynamoDB เสนอการดำเนินการระดับต่ำสี่รายการสำหรับการอ่านข้อมูล -

GetItem- ยอมรับคีย์หลักและส่งคืนแอตทริบิวต์ของรายการที่เกี่ยวข้อง อนุญาตให้เปลี่ยนแปลงค่าเริ่มต้นในการตั้งค่าการอ่านที่สอดคล้องกันในที่สุด
BatchGetItem- ดำเนินการตามคำขอ GetItem หลายรายการผ่านคีย์หลักโดยมีตัวเลือกตารางเดียวหรือหลายตาราง ส่งคืนสินค้าไม่เกิน 100 รายการและต้องมีขนาดต่ำกว่า 16MB อนุญาตให้อ่านได้อย่างสม่ำเสมอและสม่ำเสมอในที่สุด
Scan- อ่านรายการตารางทั้งหมดและสร้างชุดผลลัพธ์ที่สอดคล้องกันในที่สุด คุณสามารถกรองผลลัพธ์ตามเงื่อนไข หลีกเลี่ยงการใช้ดัชนีและสแกนทั้งตารางดังนั้นอย่าใช้สำหรับการค้นหาที่ต้องการความสามารถในการคาดเดา
Query- ส่งคืนรายการตารางเดียวหรือหลายรายการหรือรายการดัชนีรอง ใช้ค่าที่ระบุสำหรับพาร์ติชันคีย์และอนุญาตให้ใช้ตัวดำเนินการเปรียบเทียบเพื่อ จำกัด ขอบเขต รวมถึงการสนับสนุนสำหรับความสอดคล้องทั้งสองประเภทและการตอบสนองแต่ละครั้งจะมีขนาด จำกัด 1MB

แก้ไขข้อมูล

DynamoDB เสนอการดำเนินการระดับต่ำสี่รายการสำหรับการแก้ไขข้อมูล -

PutItem- สิ่งนี้จะสร้างไอเท็มใหม่หรือแทนที่ไอเท็มที่มีอยู่ ในการค้นพบคีย์หลักที่เหมือนกันโดยค่าเริ่มต้นจะแทนที่รายการ ตัวดำเนินการตามเงื่อนไขช่วยให้คุณสามารถหลีกเลี่ยงค่าเริ่มต้นและแทนที่รายการภายใต้เงื่อนไขบางประการเท่านั้น
BatchWriteItem- ดำเนินการทั้งคำขอ PutItem และ DeleteItem หลายรายการและในหลายตาราง หากคำขอหนึ่งรายการล้มเหลวจะไม่ส่งผลกระทบต่อการดำเนินการทั้งหมด ความจุสูงสุด 25 รายการและขนาด 16MB
UpdateItem - จะเปลี่ยนแอตทริบิวต์รายการที่มีอยู่และอนุญาตให้ใช้ตัวดำเนินการตามเงื่อนไขเพื่อดำเนินการอัปเดตภายใต้เงื่อนไขบางประการเท่านั้น
DeleteItem - ใช้คีย์หลักในการลบรายการและยังอนุญาตให้ใช้ตัวดำเนินการตามเงื่อนไขเพื่อระบุเงื่อนไขในการลบ

การสร้างไอเท็มใน DynamoDB ประกอบด้วยข้อมูลจำเพาะไอเท็มและแอ็ตทริบิวต์เป็นหลักและอ็อพชันของการระบุเงื่อนไข แต่ละรายการมีอยู่เป็นชุดของแอตทริบิวต์โดยแต่ละแอตทริบิวต์ตั้งชื่อและกำหนดค่าของประเภทหนึ่ง ๆ

ประเภทค่า ได้แก่ สเกลาร์เอกสารหรือชุด รายการมีขีด จำกัด ขนาด 400KB โดยมีจำนวนแอตทริบิวต์ที่สามารถปรับให้เหมาะสมได้ภายในขีด จำกัด นั้น ขนาดชื่อและค่า (ความยาวไบนารีและ UTF-8) กำหนดขนาดรายการ การใช้ชื่อแอตทริบิวต์แบบสั้นช่วยในการย่อขนาดรายการ

Note- คุณต้องระบุแอตทริบิวต์คีย์หลักทั้งหมดโดยคีย์หลักต้องใช้คีย์พาร์ติชันเท่านั้น และคีย์คอมโพสิตที่ต้องใช้ทั้งพาร์ติชันและคีย์การเรียงลำดับ

นอกจากนี้ตารางจำไม่มีสคีมาที่กำหนดไว้ล่วงหน้า คุณสามารถจัดเก็บชุดข้อมูลที่แตกต่างกันอย่างมากในตารางเดียว

ใช้คอนโซล GUI, Java หรือเครื่องมืออื่นเพื่อทำงานนี้

จะสร้างรายการโดยใช้ GUI Console ได้อย่างไร?

ไปที่คอนโซล ในบานหน้าต่างนำทางทางด้านซ้ายให้เลือกTables. เลือกชื่อตารางเพื่อใช้เป็นปลายทางจากนั้นเลือกไฟล์Items ตามที่แสดงในภาพหน้าจอต่อไปนี้

เลือก Create Item. หน้าจอ Create Item มีอินเทอร์เฟซสำหรับป้อนค่าแอ็ตทริบิวต์ที่ต้องการ ต้องป้อนดัชนีรองด้วย

หากคุณต้องการแอตทริบิวต์เพิ่มเติมให้เลือกเมนูการทำงานทางด้านซ้ายของไฟล์ Message. จากนั้นเลือกAppendและประเภทข้อมูลที่ต้องการ

หลังจากป้อนข้อมูลที่จำเป็นทั้งหมดแล้วให้เลือก Save เพื่อเพิ่มรายการ

วิธีใช้ Java ในการสร้างรายการ

การใช้ Java ในการดำเนินการสร้างไอเท็มประกอบด้วยการสร้างอินสแตนซ์คลาส DynamoDB อินสแตนซ์คลาสตารางอินสแตนซ์คลาสไอเท็มและการระบุคีย์หลักและแอ็ตทริบิวต์ของไอเท็มที่คุณจะสร้าง จากนั้นเพิ่มรายการใหม่ของคุณด้วยเมธอด putItem

ตัวอย่าง

DynamoDB dynamoDB = new DynamoDB (new AmazonDynamoDBClient(
   new ProfileCredentialsProvider()));
Table table = dynamoDB.getTable("ProductList");
   
// Spawn a related items list 
List<Number> RELItems = new ArrayList<Number>(); 
RELItems.add(123); 
RELItems.add(456); 
RELItems.add(789);  
   
//Spawn a product picture map  
Map<String, String> photos = new HashMap<String, String>(); 
photos.put("Anterior", "http://xyz.com/products/101_front.jpg"); 
photos.put("Posterior", "http://xyz.com/products/101_back.jpg"); 
photos.put("Lateral", "http://xyz.com/products/101_LFTside.jpg");  

//Spawn a product review map 
Map<String, List<String>> prodReviews = new HashMap<String, List<String>>();  
List<String> fiveStarRVW = new ArrayList<String>(); 
fiveStarRVW.add("Shocking high performance."); 
fiveStarRVW.add("Unparalleled in its market."); 
prodReviews.put("5 Star", fiveStarRVW);  
List<String> oneStarRVW = new ArrayList<String>(); 
oneStarRVW.add("The worst offering in its market."); 
prodReviews.put("1 Star", oneStarRVW);  

// Generate the item 
Item item = new Item()
   .withPrimaryKey("Id", 101) 
   .withString("Nomenclature", "PolyBlaster 101") 
   .withString("Description", "101 description") 
   .withString("Category", "Hybrid Power Polymer Cutter")  
   .withString("Make", "Brand – XYZ") 
   .withNumber("Price", 50000) 
   .withString("ProductCategory", "Laser Cutter") 
   .withBoolean("Availability", true) 
   .withNull("Qty") 
   .withList("ItemsRelated", RELItems) 
   .withMap("Images", photos) 
   .withMap("Reviews", prodReviews);

// Add item to the table  
PutItemOutcome outcome = table.putItem(item);

คุณยังสามารถดูตัวอย่างขนาดใหญ่ต่อไปนี้

Note- ตัวอย่างต่อไปนี้อาจถือว่าเป็นแหล่งข้อมูลที่สร้างขึ้นก่อนหน้านี้ ก่อนที่จะพยายามดำเนินการให้จัดหาไลบรารีที่สนับสนุนและสร้างแหล่งข้อมูลที่จำเป็น (ตารางที่มีคุณสมบัติที่ต้องการหรือแหล่งอ้างอิงอื่น ๆ )

ตัวอย่างต่อไปนี้ยังใช้ Eclipse IDE, ไฟล์หนังสือรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

package com.amazonaws.codesamples.document;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;

import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;

public class CreateItemOpSample { 
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
      new ProfileCredentialsProvider()));  
   static String tblName = "ProductList";  
      
   public static void main(String[] args) throws IOException {  
      createItems();  
      retrieveItem();  
         
      // Execute updates 
      updateMultipleAttributes(); 
      updateAddNewAttribute(); 
      updateExistingAttributeConditionally();  
         
      // Item deletion 
      deleteItem();  
   }
   private static void createItems() {  
      Table table = dynamoDB.getTable(tblName); 
      try {  
         Item item = new Item() 
            .withPrimaryKey("ID", 303)
            .withString("Nomenclature", "Polymer Blaster 4000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc.")))  
            .withNumber("Price", 50000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Laser Cutter"); 
         
         table.putItem(item);  
         item = new Item() 
            .withPrimaryKey("ID", 313) 
            .withString("Nomenclature", "Agitatatron 2000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc."))) 
            .withNumber("Price", 40000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Agitator"); 
         
         table.putItem(item);  
      } catch (Exception e) { 
         System.err.println("Cannot create items."); 
         System.err.println(e.getMessage()); 
      } 
   }   
}

การดึงข้อมูลใน DynamoDB จำเป็นต้องใช้ GetItem และระบุชื่อตารางและคีย์หลักของรายการ อย่าลืมใส่คีย์หลักที่สมบูรณ์แทนที่จะละเว้นบางส่วน

ตัวอย่างเช่นการละเว้นคีย์การจัดเรียงของคีย์ผสม

พฤติกรรม GetItem เป็นไปตามค่าเริ่มต้นสามค่า -

ดำเนินการเป็นการอ่านที่สอดคล้องกันในที่สุด
มีคุณสมบัติทั้งหมด
ไม่มีรายละเอียดการใช้หน่วยความจุ

พารามิเตอร์เหล่านี้ช่วยให้คุณสามารถแทนที่พฤติกรรม GetItem เริ่มต้นได้

ดึงข้อมูลรายการ

DynamoDB ช่วยให้มั่นใจได้ถึงความน่าเชื่อถือโดยการรักษาสำเนาหลายรายการในเซิร์ฟเวอร์หลายเครื่อง การเขียนที่ประสบความสำเร็จแต่ละครั้งจะสร้างสำเนาเหล่านี้ขึ้นมา แต่ต้องใช้เวลามากในการดำเนินการ ความหมายสอดคล้องกันในที่สุด ซึ่งหมายความว่าคุณไม่สามารถลองอ่านได้ทันทีหลังจากเขียนรายการ

คุณสามารถเปลี่ยนค่าเริ่มต้นในการอ่าน GetItem ที่สอดคล้องกันได้ในที่สุดอย่างไรก็ตามต้นทุนของข้อมูลปัจจุบันที่มากขึ้นยังคงใช้หน่วยความจุมากขึ้น โดยเฉพาะสองเท่า หมายเหตุโดยทั่วไป DynamoDB จะบรรลุความสอดคล้องกันในทุกสำเนาภายในหนึ่งวินาที

คุณสามารถใช้คอนโซล GUI, Java หรือเครื่องมืออื่นเพื่อทำงานนี้

การดึงข้อมูลโดยใช้ Java

การใช้ Java ในการดำเนินการดึงไอเท็มจำเป็นต้องสร้างอินสแตนซ์คลาส DynamoDB, อินสแตนซ์คลาสตารางและการเรียกใช้เมธอด getItem ของอินสแตนซ์ตาราง จากนั้นระบุคีย์หลักของรายการ

คุณสามารถดูตัวอย่างต่อไปนี้ -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));  
Table table = dynamoDB.getTable("ProductList");  
Item item = table.getItem("IDnum", 109);

ในบางกรณีคุณต้องระบุพารามิเตอร์สำหรับการดำเนินการนี้

ตัวอย่างต่อไปนี้ใช้ .withProjectionExpression และ GetItemSpec สำหรับข้อกำหนดการดึงข้อมูล -

GetItemSpec spec = new GetItemSpec() 
   .withPrimaryKey("IDnum", 122) 
   .withProjectionExpression("IDnum, EmployeeName, Department") 
   .withConsistentRead(true);

Item item = table.getItem(spec);
System.out.println(item.toJSONPretty());

คุณยังสามารถทบทวนตัวอย่างที่ใหญ่กว่าต่อไปนี้เพื่อความเข้าใจที่ดีขึ้น

ตัวอย่างนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

package com.amazonaws.codesamples.document;

import java.io.IOException
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;

import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;

public class GetItemOpSample {
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient(
      new ProfileCredentialsProvider()));
   
   static String tblName = "ProductList";
   public static void main(String[] args) throws IOException {
      createItems();
      retrieveItem();
      
      // Execute updates
      updateMultipleAttributes();
      updateAddNewAttribute();
      updateExistingAttributeConditionally();
      
      // Item deletion
      deleteItem();
   }
   private static void createItems() {
      Table table = dynamoDB.getTable(tblName);
      try {
         Item item = new Item()
            .withPrimaryKey("ID", 303)
            .withString("Nomenclature", "Polymer Blaster 4000")
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc.")))
            .withNumber("Price", 50000)
            .withBoolean("InProduction", true)
            .withString("Category", "Laser Cutter");
            table.putItem(item);
            
         item = new Item()
            .withPrimaryKey("ID", 313)
            .withString("Nomenclature", "Agitatatron 2000")
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc.")))
            .withNumber("Price", 40000)
            .withBoolean("InProduction", true)
            .withString("Category", "Agitator");
         
         table.putItem(item);
      } catch (Exception e) {
         System.err.println("Cannot create items.");
         System.err.println(e.getMessage());
      }
   }
   private static void retrieveItem() {
      Table table = dynamoDB.getTable(tableName);
      try {
         Item item = table.getItem("ID", 303, "ID, Nomenclature, Manufacturers", null);
         System.out.println("Displaying retrieved items...");
         System.out.println(item.toJSONPretty());
      } catch (Exception e) {
         System.err.println("Cannot retrieve items.");
         System.err.println(e.getMessage());
      }
   }
}

การอัปเดตรายการใน DynamoDB ส่วนใหญ่ประกอบด้วยการระบุคีย์หลักแบบเต็มและชื่อตารางสำหรับรายการ ต้องใช้ค่าใหม่สำหรับแต่ละแอตทริบิวต์ที่คุณแก้ไข การดำเนินการใช้UpdateItemซึ่งแก้ไขรายการที่มีอยู่หรือสร้างขึ้นจากการค้นพบรายการที่ขาดหายไป

ในการอัปเดตคุณอาจต้องการติดตามการเปลี่ยนแปลงโดยการแสดงค่าเดิมและค่าใหม่ก่อนและหลังการดำเนินการ UpdateItem ใช้ไฟล์ReturnValues พารามิเตอร์เพื่อให้บรรลุสิ่งนี้

Note - การดำเนินการไม่ได้รายงานการใช้หน่วยความจุ แต่คุณสามารถใช้ไฟล์ ReturnConsumedCapacity พารามิเตอร์.

ใช้คอนโซล GUI, Java หรือเครื่องมืออื่น ๆ เพื่อทำงานนี้

จะอัปเดตรายการโดยใช้เครื่องมือ GUI ได้อย่างไร

ไปที่คอนโซล ในบานหน้าต่างนำทางทางด้านซ้ายให้เลือกTables. เลือกตารางที่ต้องการจากนั้นเลือกItems แท็บ

เลือกรายการที่ต้องการสำหรับการอัปเดตและเลือก Actions | Edit.

แก้ไขแอตทริบิวต์หรือค่าที่จำเป็นในไฟล์ Edit Item หน้าต่าง.

อัปเดตรายการโดยใช้ Java

การใช้ Java ในการดำเนินการอัพเดตไอเท็มจำเป็นต้องสร้างอินสแตนซ์คลาส Table และเรียกใช้ updateItemวิธี. จากนั้นคุณระบุคีย์หลักของรายการและระบุไฟล์UpdateExpression รายละเอียดการปรับเปลี่ยนแอตทริบิวต์

ต่อไปนี้เป็นตัวอย่างของสิ่งเดียวกัน -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient(
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ProductList");

Map<String, String> expressionAttributeNames = new HashMap<String, String>();
expressionAttributeNames.put("#M", "Make");
expressionAttributeNames.put("#P", "Price
expressionAttributeNames.put("#N", "ID");

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();
expressionAttributeValues.put(":val1",
   new HashSet<String>(Arrays.asList("Make1","Make2")));
expressionAttributeValues.put(":val2", 1);       //Price

UpdateItemOutcome outcome =  table.updateItem(
   "internalID",                                 // key attribute name
   111,                                          // key attribute value
   "add #M :val1 set #P = #P - :val2 remove #N", // UpdateExpression
   expressionAttributeNames,
   expressionAttributeValues);

updateItem วิธีนี้ยังอนุญาตให้ระบุเงื่อนไขซึ่งสามารถดูได้ในตัวอย่างต่อไปนี้ -

Table table = dynamoDB.getTable("ProductList");
Map<String, String> expressionAttributeNames = new HashMap<String, String>();
expressionAttributeNames.put("#P", "Price");

Map<String, Object> expressionAttributeValues = new HashMap<String, Object>();
expressionAttributeValues.put(":val1", 44);  // change Price to 44
expressionAttributeValues.put(":val2", 15);  // only if currently 15

UpdateItemOutcome outcome = table.updateItem (new PrimaryKey("internalID",111),
   "set #P = :val1",                        // Update
   "#P = :val2",                            // Condition 
   expressionAttributeNames,
   expressionAttributeValues);

อัปเดตรายการโดยใช้ตัวนับ

DynamoDB อนุญาตให้ตัวนับอะตอมซึ่งหมายถึงการใช้ UpdateItem เพื่อเพิ่ม / ลดค่าแอตทริบิวต์โดยไม่ส่งผลกระทบต่อคำขออื่น ๆ นอกจากนี้ตัวนับจะอัปเดตอยู่เสมอ

ต่อไปนี้เป็นตัวอย่างที่อธิบายว่าสามารถทำได้อย่างไร

ตัวอย่างนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

package com.amazonaws.codesamples.document;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;

import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;

public class UpdateItemOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   static String tblName = "ProductList";  
   
   public static void main(String[] args) throws IOException {  
      createItems();  
      retrieveItem();  
      
      // Execute updates 
      updateMultipleAttributes(); 
      updateAddNewAttribute();
      updateExistingAttributeConditionally();  
      
      // Item deletion 
      deleteItem(); 
   }
   private static void createItems() {  
      Table table = dynamoDB.getTable(tblName); 
      try { 
         Item item = new Item() 
            .withPrimaryKey("ID", 303) 
            .withString("Nomenclature", "Polymer Blaster 4000") 
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc."))) 
            .withNumber("Price", 50000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Laser Cutter"); 
            table.putItem(item);  
         
         item = new Item() 
            .withPrimaryKey("ID", 313) 
            .withString("Nomenclature", "Agitatatron 2000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc."))) 
            .withNumber("Price", 40000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Agitator");  
            table.putItem(item);  
      } catch (Exception e) { 
         System.err.println("Cannot create items."); 
         System.err.println(e.getMessage()); 
      } 
   }
   private static void updateAddNewAttribute() { 
      Table table = dynamoDB.getTable(tableName);  
      try {  
         Map<String, String> expressionAttributeNames = new HashMap<String, String>(); 
         expressionAttributeNames.put("#na", "NewAttribute");  
         UpdateItemSpec updateItemSpec = new UpdateItemSpec() 
            .withPrimaryKey("ID", 303) 
            .withUpdateExpression("set #na = :val1") 
            .withNameMap(new NameMap() 
            .with("#na", "NewAttribute")) 
            .withValueMap(new ValueMap() 
            .withString(":val1", "A value")) 
            .withReturnValues(ReturnValue.ALL_NEW);  
            UpdateItemOutcome outcome =  table.updateItem(updateItemSpec);  
         
         // Confirm 
         System.out.println("Displaying updated item..."); 
         System.out.println(outcome.getItem().toJSONPretty());             
      } catch (Exception e) { 
         System.err.println("Cannot add an attribute in " + tableName); 
         System.err.println(e.getMessage()); 
      }         
   } 
}

การลบรายการใน DynamoDB จำเป็นต้องระบุชื่อตารางและคีย์รายการเท่านั้น ขอแนะนำอย่างยิ่งให้ใช้นิพจน์เงื่อนไขซึ่งจำเป็นเพื่อหลีกเลี่ยงการลบรายการที่ไม่ถูกต้อง

ตามปกติคุณสามารถใช้คอนโซล GUI, Java หรือเครื่องมือที่จำเป็นอื่น ๆ เพื่อทำงานนี้ได้

ลบรายการโดยใช้ GUI Console

ไปที่คอนโซล ในบานหน้าต่างนำทางทางด้านซ้ายให้เลือกTables. จากนั้นเลือกชื่อตารางและItems แท็บ

เลือกรายการที่ต้องการลบและเลือก Actions | Delete.

ก Delete Item(s)จะปรากฏขึ้นตามที่แสดงใน screeshot ต่อไปนี้ เลือก "ลบ" เพื่อยืนยัน

จะลบรายการโดยใช้ Java ได้อย่างไร?

การใช้ Java ในการดำเนินการลบไอเท็มเกี่ยวข้องกับการสร้างอินสแตนซ์ไคลเอ็นต์ DynamoDB และเรียกไฟล์ deleteItem วิธีการโดยใช้รหัสของรายการ

คุณสามารถดูตัวอย่างต่อไปนี้ซึ่งได้รับการอธิบายโดยละเอียด

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ProductList");
DeleteItemOutcome outcome = table.deleteItem("IDnum", 151);

คุณยังสามารถระบุพารามิเตอร์เพื่อป้องกันการลบที่ไม่ถูกต้อง เพียงใช้ไฟล์ConditionExpression.

ตัวอย่างเช่น -

Map<String,Object> expressionAttributeValues = new HashMap<String,Object>(); 
expressionAttributeValues.put(":val", false);
  
DeleteItemOutcome outcome = table.deleteItem("IDnum",151, 
   "Ship = :val",  
   null,                   // doesn't use ExpressionAttributeNames  
   expressionAttributeValues);

ต่อไปนี้เป็นตัวอย่างขนาดใหญ่เพื่อความเข้าใจที่ดีขึ้น

ตัวอย่างนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

package com.amazonaws.codesamples.document;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;

import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;

public class DeleteItemOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   
   static String tblName = "ProductList";  
   public static void main(String[] args) throws IOException { 
      createItems(); 
      retrieveItem();  
      
      // Execute updates 
      updateMultipleAttributes(); 
      updateAddNewAttribute(); 
      updateExistingAttributeConditionally();  
      
      // Item deletion 
      deleteItem();  
   }  
   private static void createItems() {  
      Table table = dynamoDB.getTable(tblName); 
      try {  
         Item item = new Item()  
            .withPrimaryKey("ID", 303) 
            .withString("Nomenclature", "Polymer Blaster 4000")
            .withStringSet( "Manufacturers",
            new HashSet<String>(Arrays.asList("XYZ Inc.", "LMNOP Inc."))) 
            .withNumber("Price", 50000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Laser Cutter"); 
            table.putItem(item);  
         
         item = new Item() 
            .withPrimaryKey("ID", 313) 
            .withString("Nomenclature", "Agitatatron 2000") 
            .withStringSet( "Manufacturers", 
            new HashSet<String>(Arrays.asList("XYZ Inc,", "CDE Inc."))) 
            .withNumber("Price", 40000) 
            .withBoolean("InProduction", true) 
            .withString("Category", "Agitator"); 
            table.putItem(item);  
      } catch (Exception e) { 
         System.err.println("Cannot create items."); 
         System.err.println(e.getMessage());  
      } 
   }  
   private static void deleteItem() {  
      Table table = dynamoDB.getTable(tableName);  
      try {  
         DeleteItemSpec deleteItemSpec = new DeleteItemSpec() 
            .withPrimaryKey("ID", 303)  
            .withConditionExpression("#ip = :val") 
            .withNameMap(new NameMap() 
            .with("#ip", "InProduction"))
            .withValueMap(new ValueMap() 
            .withBoolean(":val", false)) 
            .withReturnValues(ReturnValue.ALL_OLD);  
         DeleteItemOutcome outcome = table.deleteItem(deleteItemSpec);  
         
         // Confirm 
         System.out.println("Displaying deleted item..."); 
         System.out.println(outcome.getItem().toJSONPretty());  
      } catch (Exception e) { 
         System.err.println("Cannot delete item in " + tableName); 
         System.err.println(e.getMessage()); 
      } 
   } 
}

การเขียนแบทช์ทำงานกับหลายรายการโดยการสร้างหรือลบหลายรายการ การดำเนินการเหล่านี้ใช้BatchWriteItemซึ่งมีข้อ จำกัด ไม่เกิน 16MB เขียนและ 25 คำขอ แต่ละรายการมีขนาด จำกัด 400KB การเขียนแบทช์ยังไม่สามารถทำการอัพเดตไอเท็มได้

Batch Writing คืออะไร?

การเขียนแบทช์สามารถจัดการกับรายการในหลาย ๆ ตาราง การเรียกใช้การดำเนินการเกิดขึ้นสำหรับแต่ละคำขอซึ่งหมายความว่าการดำเนินการจะไม่ส่งผลกระทบต่อกันและอนุญาตให้มีการผสมที่แตกต่างกัน ตัวอย่างเช่นหนึ่งPutItem และสาม DeleteItemคำขอเป็นชุดโดยที่คำขอ PutItem ล้มเหลวจะไม่ส่งผลกระทบต่อผู้อื่น คำขอที่ล้มเหลวส่งผลให้การดำเนินการส่งคืนข้อมูล (คีย์และข้อมูล) ที่เกี่ยวข้องกับแต่ละคำขอที่ล้มเหลว

Note- หาก DynamoDB ส่งคืนรายการใด ๆ โดยไม่ได้ประมวลผลให้ลองอีกครั้ง อย่างไรก็ตามให้ใช้วิธีการสำรองเพื่อหลีกเลี่ยงความล้มเหลวของคำขออื่นเนื่องจากการบรรทุกเกินพิกัด

DynamoDB ปฏิเสธการดำเนินการเขียนแบบแบตช์เมื่อหนึ่งหรือหลายข้อความต่อไปนี้พิสูจน์ว่าเป็นจริง -

คำขอเกินปริมาณงานที่จัดเตรียมไว้
คำขอพยายามใช้ BatchWriteItems เพื่ออัปเดตรายการ
คำขอดำเนินการหลายอย่างในรายการเดียว
ไม่มีตารางคำขอ
แอตทริบิวต์รายการในคำขอไม่ตรงกับเป้าหมาย
คำขอมีขนาดเกินขีด จำกัด

การเขียนแบบกลุ่มต้องมีบางอย่าง RequestItem พารามิเตอร์ -

จำเป็นต้องดำเนินการลบ DeleteRequest สำคัญ subelements หมายถึงชื่อแอตทริบิวต์และค่า
PutRequest รายการที่ต้องการ Item subelement หมายถึงแผนผังแอตทริบิวต์และแอตทริบิวต์

Response - การดำเนินการที่ประสบความสำเร็จส่งผลให้ได้รับการตอบสนอง HTTP 200 ซึ่งระบุลักษณะเช่นหน่วยความจุที่ใช้เมตริกการประมวลผลตารางและรายการที่ยังไม่ได้ประมวลผล

Batch เขียนด้วย Java

ดำเนินการเขียนแบตช์โดยสร้างอินสแตนซ์คลาส DynamoDB, a TableWriteItems อินสแตนซ์คลาสที่อธิบายการดำเนินการทั้งหมดและการเรียกใช้ batchWriteItem วิธีการใช้วัตถุ TableWriteItems

Note- คุณต้องสร้างอินสแตนซ์ TableWriteItems สำหรับทุกตารางในชุดงานที่เขียนลงในหลายตาราง ตรวจสอบการตอบกลับคำขอของคุณสำหรับคำขอที่ยังไม่ได้ดำเนินการ

คุณสามารถตรวจสอบตัวอย่างการเขียนแบทช์ต่อไปนี้ -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));  

TableWriteItems forumTableWriteItems = new TableWriteItems("Forum") 
   .withItemsToPut( 
   new Item() 
   .withPrimaryKey("Title", "XYZ CRM") 
   .withNumber("Threads", 0));  

TableWriteItems threadTableWriteItems = new TableWriteItems(Thread) 
   .withItemsToPut( 
   new Item() 
   .withPrimaryKey("ForumTitle","XYZ CRM","Topic","Updates") 
   .withHashAndRangeKeysToDelete("ForumTitle","A partition key value", 
   "Product Line 1", "A sort key value"));

BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem (
   forumTableWriteItems, threadTableWriteItems);

โปรแกรมต่อไปนี้เป็นอีกตัวอย่างที่ใหญ่กว่าเพื่อให้เข้าใจวิธีที่แบตช์เขียนด้วย Java ได้ดียิ่งขึ้น

ตัวอย่างนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

package com.amazonaws.codesamples.document;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.BatchWriteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableWriteItems;
import com.amazonaws.services.dynamodbv2.model.WriteRequest;

public class BatchWriteOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   static String forumTableName = "Forum"; 
   static String threadTableName = "Thread";  
      
   public static void main(String[] args) throws IOException { 
      batchWriteMultiItems();   
   }
   private static void batchWriteMultiItems() { 
      try {
         // Place new item in Forum 
         TableWriteItems forumTableWriteItems = new TableWriteItems(forumTableName) 
                                                                       //Forum 
            .withItemsToPut(new Item() 
            .withPrimaryKey("Name", "Amazon RDS") 
            .withNumber("Threads", 0));  
            
         // Place one item, delete another in Thread 
         // Specify partition key and range key 
         TableWriteItems threadTableWriteItems = new TableWriteItems(threadTableName) 
            .withItemsToPut(new Item() 
            .withPrimaryKey("ForumName","Product  
            Support","Subject","Support Thread 1") 
            .withString("Message", "New OS Thread 1 message")
            .withHashAndRangeKeysToDelete("ForumName","Subject", "Polymer Blaster", 
            "Support Thread 100"));  
            
         System.out.println("Processing request..."); 
         BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem (
               forumTableWriteItems, threadTableWriteItems);
         do {  
            // Confirm no unprocessed items 
            Map<String, List<WriteRequest>> unprocessedItems 
               = outcome.getUnprocessedItems();  
                  
            if (outcome.getUnprocessedItems().size() == 0) { 
               System.out.println("All items processed."); 
            } else { 
               System.out.println("Gathering unprocessed items..."); 
               outcome = dynamoDB.batchWriteItemUnprocessed(unprocessedItems); 
            }  
         } while (outcome.getUnprocessedItems().size() > 0);  
      } catch (Exception e) { 
         System.err.println("Could not get items: "); 
         e.printStackTrace(System.err); 
      }   
   } 
}

Batch Retrieve การดำเนินการส่งคืนแอ็ตทริบิวต์ของรายการเดียวหรือหลายรายการ โดยทั่วไปการดำเนินการเหล่านี้ประกอบด้วยการใช้คีย์หลักเพื่อระบุรายการที่ต้องการ BatchGetItem การดำเนินการอยู่ภายใต้ข้อ จำกัด ของการดำเนินการส่วนบุคคลรวมทั้งข้อ จำกัด เฉพาะของตนเอง

คำขอต่อไปนี้ในการดำเนินการดึงข้อมูลเป็นกลุ่มส่งผลให้เกิดการปฏิเสธ -

ขอมากกว่า 100 รายการ
ส่งคำขอเกินปริมาณงาน

การดำเนินการดึงข้อมูลแบบกลุ่มดำเนินการประมวลผลคำขอบางส่วนที่มีศักยภาพเกินขีด จำกัด

For example- การร้องขอเพื่อดึงข้อมูลหลายรายการที่มีขนาดใหญ่พอที่จะเกินขีด จำกัด ส่งผลให้เป็นส่วนหนึ่งของการประมวลผลคำขอและข้อความแสดงข้อผิดพลาดที่ระบุส่วนที่ยังไม่ได้ประมวลผล ในการส่งคืนรายการที่ยังไม่ได้ประมวลผลให้สร้างโซลูชันอัลกอริธึมแบ็คออฟเพื่อจัดการสิ่งนี้แทนการควบคุมตาราง

BatchGetในที่สุดการดำเนินการจะดำเนินการด้วยการอ่านที่สอดคล้องกันโดยต้องมีการปรับเปลี่ยนเพื่อให้สอดคล้องกัน พวกเขายังทำการดึงข้อมูลแบบขนาน

Note- ลำดับของสินค้าที่ส่งคืน DynamoDB ไม่เรียงลำดับรายการ นอกจากนี้ยังไม่ได้ระบุว่าไม่มีรายการที่ร้องขอ นอกจากนี้คำขอเหล่านั้นใช้หน่วยความจุ

การดำเนินการ BatchGet ทั้งหมดต้องการ RequestItems พารามิเตอร์เช่นความสอดคล้องในการอ่านชื่อแอ็ตทริบิวต์และคีย์หลัก

Batch Retrievals ด้วย Java

การใช้ Java ในการดำเนินการ BatchGet จำเป็นต้องสร้างอินสแตนซ์คลาส DynamoDB TableKeysAndAttributes อินสแตนซ์คลาสที่อธิบายรายการค่าคีย์หลักสำหรับรายการและส่งผ่านวัตถุ TableKeysAndAttributes ไปยัง BatchGetItem วิธี.

ต่อไปนี้เป็นตัวอย่างของการดำเนินการ BatchGet -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));  

TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes 
   (forumTableName);
   
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys (
   "Title",
   "Updates",  
   "Product Line 1"
); 
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes (
   threadTableName);
      
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys (
   "ForumTitle",
   "Topic",  
   "Product Line 1",
   "P1 Thread 1", 
   "Product Line 1",
   "P1 Thread 2", 
   "Product Line 2",
   "P2 Thread 1"
); 
BatchGetItemOutcome outcome = dynamoDB.batchGetItem ( 
   forumTableKeysAndAttributes, threadTableKeysAndAttributes);
      
for (String tableName : outcome.getTableItems().keySet()) { 
   System.out.println("Table items " + tableName); 
   List<Item> items = outcome.getTableItems().get(tableName); 
   for (Item item : items) { 
      System.out.println(item); 
   } 
}

คุณสามารถดูตัวอย่างขนาดใหญ่ต่อไปนี้

Note- โปรแกรมต่อไปนี้อาจถือว่าเป็นแหล่งข้อมูลที่สร้างขึ้นก่อนหน้านี้ ก่อนที่จะพยายามดำเนินการให้จัดหาไลบรารีที่สนับสนุนและสร้างแหล่งข้อมูลที่จำเป็น (ตารางที่มีคุณสมบัติที่ต้องการหรือแหล่งอ้างอิงอื่น ๆ )

โปรแกรมนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

package com.amazonaws.codesamples.document;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.BatchGetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableKeysAndAttributes;
import com.amazonaws.services.dynamodbv2.model.KeysAndAttributes;

public class BatchGetOpSample { 
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
      new ProfileCredentialsProvider())); 
      
   static String forumTableName = "Forum"; 
   static String threadTableName = "Thread"; 
     
   public static void main(String[] args) throws IOException { 
      retrieveMultipleItemsBatchGet(); 
   }
   private static void retrieveMultipleItemsBatchGet() {         
      try { 
         TableKeysAndAttributes forumTableKeysAndAttributes = 
            new TableKeysAndAttributes(forumTableName); 
         
         //Create partition key 
         forumTableKeysAndAttributes.addHashOnlyPrimaryKeys (
            "Name", 
            "XYZ Melt-O-tron", 
            "High-Performance Processing"
         ); 
         TableKeysAndAttributes threadTableKeysAndAttributes = 
            new TableKeysAndAttributes(threadTableName); 
         
         //Create partition key and sort key 
         threadTableKeysAndAttributes.addHashAndRangePrimaryKeys (
            "ForumName",
            "Subject",  
            "High-Performance Processing",
            "HP Processing Thread One", 
            "High-Performance Processing",
            "HP Processing Thread Two", 
            "Melt-O-Tron",
            "MeltO Thread One"
         );
         System.out.println("Processing..."); 
         BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes,
            threadTableKeysAndAttributes); 
              
         Map<String, KeysAndAttributes> unprocessed = null;    
         do { 
            for (String tableName : outcome.getTableItems().keySet()) { 
               System.out.println("Table items for " + tableName); 
               List<Item> items = outcome.getTableItems().get(tableName); 
               
               for (Item item : items) { 
                  System.out.println(item.toJSONPretty()); 
               } 
            } 
            // Confirm no unprocessed items 
            unprocessed = outcome.getUnprocessedKeys(); 
                 
            if (unprocessed.isEmpty()) { 
               System.out.println("All items processed."); 
            } else { 
               System.out.println("Gathering unprocessed items..."); 
               outcome = dynamoDB.batchGetItemUnprocessed(unprocessed); 
            } 
         } while (!unprocessed.isEmpty()); 
      } catch (Exception e) { 
         System.err.println("Could not get items."); 
         System.err.println(e.getMessage()); 
      }   
   } 
}

แบบสอบถามค้นหารายการหรือดัชนีรองผ่านคีย์หลัก การดำเนินการค้นหาต้องใช้คีย์พาร์ติชันและค่าเฉพาะหรือคีย์การจัดเรียงและค่า พร้อมตัวเลือกในการกรองด้วยการเปรียบเทียบ ลักษณะการทำงานเริ่มต้นของแบบสอบถามประกอบด้วยการส่งคืนทุกแอตทริบิวต์สำหรับรายการที่เกี่ยวข้องกับคีย์หลักที่ให้มา อย่างไรก็ตามคุณสามารถระบุแอตทริบิวต์ที่ต้องการด้วยไฟล์ProjectionExpression พารามิเตอร์.

แบบสอบถามใช้ไฟล์ KeyConditionExpressionพารามิเตอร์เพื่อเลือกไอเท็มซึ่งต้องระบุชื่อคีย์พาร์ติชันและค่าในรูปแบบของเงื่อนไขความเท่าเทียมกัน คุณยังมีตัวเลือกในการระบุเงื่อนไขเพิ่มเติมสำหรับคีย์การเรียงลำดับที่มีอยู่

ตัวอย่างเงื่อนไขคีย์การจัดเรียงมีดังนี้ -

ซีเนียร์ No	เงื่อนไขและคำอธิบาย
1	x = y จะประเมินว่าเป็นจริงถ้าแอตทริบิวต์ x เท่ากับ y
2	x < y จะประเมินเป็นจริงถ้า x น้อยกว่า y
3	x <= y จะประเมินเป็นจริงถ้า x น้อยกว่าหรือเท่ากับ y
4	x > y จะประเมินเป็นจริงถ้า x มากกว่า y
5	x >= y มันจะประเมินเป็นจริงถ้า x มากกว่าหรือเท่ากับ y
6	x BETWEEN y AND z จะประเมินเป็นจริงถ้า x เป็นทั้ง> = y และ <= z

DynamoDB ยังรองรับฟังก์ชันต่อไปนี้: begins_with (x, substr)

จะประเมินเป็น true หากแอตทริบิวต์ x เริ่มต้นด้วยสตริงที่ระบุ

เงื่อนไขต่อไปนี้ต้องเป็นไปตามข้อกำหนดบางประการ -

ชื่อแอตทริบิวต์ต้องขึ้นต้นด้วยอักขระภายในชุด az หรือ AZ
อักขระตัวที่สองของชื่อแอตทริบิวต์ต้องอยู่ในชุด az, AZ หรือ 0-9
ชื่อแอตทริบิวต์ไม่สามารถใช้คำสงวน

ชื่อแอตทริบิวต์ที่ไม่เป็นไปตามข้อ จำกัด ข้างต้นสามารถกำหนดตัวยึดได้

คิวรีประมวลผลโดยดำเนินการดึงข้อมูลตามลำดับคีย์การจัดเรียงและใช้เงื่อนไขและนิพจน์ตัวกรองที่มีอยู่ การค้นหาจะส่งคืนชุดผลลัพธ์เสมอและเมื่อไม่มีการจับคู่จะส่งกลับค่าว่าง

ผลลัพธ์จะส่งคืนตามลำดับคีย์การจัดเรียงและลำดับตามประเภทข้อมูลโดยมีค่าเริ่มต้นที่แก้ไขได้เป็นลำดับจากน้อยไปมาก

การสืบค้นด้วย Java

คิวรีใน Java ช่วยให้คุณสามารถสอบถามตารางและดัชนีรองได้ พวกเขาต้องการข้อกำหนดของคีย์พาร์ติชันและเงื่อนไขความเท่าเทียมกันโดยมีตัวเลือกในการระบุคีย์การเรียงลำดับและเงื่อนไข

ขั้นตอนที่จำเป็นทั่วไปสำหรับแบบสอบถามใน Java ได้แก่ การสร้างอินสแตนซ์คลาส DynamoDB อินสแตนซ์คลาสของตารางสำหรับตารางเป้าหมายและการเรียกใช้วิธีการสอบถามของอินสแตนซ์ Table เพื่อรับวัตถุคิวรี

การตอบสนองต่อแบบสอบถามประกอบด้วยไฟล์ ItemCollection วัตถุที่ให้รายการที่ส่งคืนทั้งหมด

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการสืบค้นโดยละเอียด -

DynamoDB dynamoDB = new DynamoDB (
   new AmazonDynamoDBClient(new ProfileCredentialsProvider()));

Table table = dynamoDB.getTable("Response");  
   QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("ID = :nn") 
.withValueMap(new ValueMap() 
   .withString(":nn", "Product Line 1#P1 Thread 1"));
   
ItemCollection<QueryOutcome> items = table.query(spec);  
Iterator<Item> iterator = items.iterator(); 
Item item = null; 

while (iterator.hasNext()) { 
   item = iterator.next(); 
   System.out.println(item.toJSONPretty());
}

วิธีการสืบค้นสนับสนุนพารามิเตอร์ทางเลือกที่หลากหลาย ตัวอย่างต่อไปนี้สาธิตวิธีใช้พารามิเตอร์เหล่านี้ -

Table table = dynamoDB.getTable("Response");  
QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("ID = :nn and ResponseTM > :nn_responseTM")  
   .withFilterExpression("Author = :nn_author") 
   .withValueMap(new ValueMap()
   .withString(":nn", "Product Line 1#P1 Thread 1") 
   .withString(":nn_responseTM", twoWeeksAgoStr) 
   .withString(":nn_author", "Member 123"))
   .withConsistentRead(true);
   
ItemCollection<QueryOutcome> items = table.query(spec);  
Iterator<Item> iterator = items.iterator(); 

while (iterator.hasNext()) { 
   System.out.println(iterator.next().toJSONPretty()); 
}

คุณยังสามารถดูตัวอย่างขนาดใหญ่ต่อไปนี้

ตัวอย่างนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

package com.amazonaws.codesamples.document;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;

import com.amazonaws.services.dynamodbv2.document.Page;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;

public class QueryOpSample {
   static DynamoDB dynamoDB = new DynamoDB(
      new AmazonDynamoDBClient(new ProfileCredentialsProvider()));
   static String tableName = "Reply";  
   
   public static void main(String[] args) throws Exception { 
      String forumName = "PolyBlaster"; 
      String threadSubject = "PolyBlaster Thread 1";  
      getThreadReplies(forumName, threadSubject); 
   } 
   private static void getThreadReplies(String forumName, String threadSubject) {  
      Table table = dynamoDB.getTable(tableName);  
      String replyId = forumName + "#" + threadSubject; 
      QuerySpec spec = new QuerySpec() 
         .withKeyConditionExpression("Id = :v_id") 
         .withValueMap(new ValueMap() 
         .withString(":v_id", replyId)); 
         
      ItemCollection<QueryOutcome> items = table.query(spec); 
      System.out.println("\ngetThreadReplies results:"); 
      Iterator<Item> iterator = items.iterator(); 
      
      while (iterator.hasNext()) { 
         System.out.println(iterator.next().toJSONPretty()); 
      } 
   } 
}

Scan Operations อ่านรายการตารางหรือดัชนีรองทั้งหมด ฟังก์ชันเริ่มต้นส่งคืนแอตทริบิวต์ข้อมูลทั้งหมดของรายการทั้งหมดภายในดัชนีหรือตาราง จ้างProjectionExpression พารามิเตอร์ในการกรองแอตทริบิวต์

การสแกนทุกครั้งจะส่งคืนชุดผลลัพธ์แม้ว่าจะไม่พบรายการที่ตรงกันก็ตามซึ่งส่งผลให้ชุดว่างเปล่า สแกนดึงข้อมูลไม่เกิน 1MB พร้อมตัวเลือกในการกรองข้อมูล

Note - พารามิเตอร์และการกรองการสแกนยังใช้กับการสืบค้น

ประเภทของการสแกน

Filtering- การดำเนินการสแกนเสนอการกรองที่ดีผ่านนิพจน์ตัวกรองซึ่งจะแก้ไขข้อมูลหลังจากการสแกนหรือการสืบค้น ก่อนส่งคืนผลลัพธ์ นิพจน์ใช้ตัวดำเนินการเปรียบเทียบ ไวยากรณ์ของพวกเขาคล้ายกับนิพจน์เงื่อนไขยกเว้นคีย์แอ็ตทริบิวต์ซึ่งนิพจน์ตัวกรองไม่อนุญาต คุณไม่สามารถใช้พาร์ติชันหรือคีย์การเรียงลำดับในนิพจน์ตัวกรอง

Note - ขีด จำกัด 1MB ใช้ก่อนการใช้งานการกรองใด ๆ

Throughput Specifications- การสแกนใช้ปริมาณงานอย่างไรก็ตามการบริโภคจะเน้นที่ขนาดรายการมากกว่าข้อมูลที่ส่งคืน ปริมาณการใช้ยังคงเหมือนเดิมไม่ว่าคุณจะร้องขอทุกแอตทริบิวต์หรือเพียงไม่กี่รายการและการใช้หรือไม่ใช้นิพจน์ตัวกรองก็ไม่ส่งผลต่อการบริโภคเช่นกัน

Pagination- DynamoDB จะแบ่งหน้าผลลัพธ์ที่ทำให้เกิดการแบ่งผลลัพธ์ออกเป็นหน้าเฉพาะ ขีด จำกัด 1MB ใช้กับผลลัพธ์ที่ส่งคืนและเมื่อคุณทำเกินการสแกนอีกครั้งจะมีความจำเป็นเพื่อรวบรวมข้อมูลที่เหลือ LastEvaluatedKeyค่าช่วยให้คุณทำการสแกนในภายหลังนี้ เพียงใช้ค่ากับไฟล์ExclusiveStartkey. เมื่อLastEvaluatedKeyค่ากลายเป็นโมฆะการดำเนินการเสร็จสิ้นทุกหน้าของข้อมูล อย่างไรก็ตามค่าที่ไม่ใช่ค่าว่างไม่ได้หมายความว่าจะมีข้อมูลเหลืออยู่โดยอัตโนมัติ เฉพาะค่า null เท่านั้นที่ระบุสถานะ

The Limit Parameter- พารามิเตอร์ขีด จำกัด จัดการขนาดผลลัพธ์ DynamoDB ใช้เพื่อสร้างจำนวนรายการที่จะประมวลผลก่อนส่งคืนข้อมูลและไม่ทำงานนอกขอบเขต หากคุณตั้งค่าเป็น x DynamoDB จะส่งคืนค่า x รายการแรกที่ตรงกัน

ค่า LastEvaluatedKey ยังใช้ในกรณีของพารามิเตอร์ จำกัด ที่ให้ผลลัพธ์บางส่วน ใช้เพื่อทำการสแกนให้เสร็จสมบูรณ์

Result Count - การตอบคำถามและการสแกนรวมถึงข้อมูลที่เกี่ยวข้องด้วย ScannedCountและนับซึ่งจะหาจำนวนรายการที่สแกน / สอบถามและหาจำนวนรายการที่ส่งคืน หากคุณไม่กรองค่าจะเหมือนกัน เมื่อคุณเกิน 1MB จำนวนนับจะแสดงเฉพาะส่วนที่ประมวลผล

Consistency- ผลลัพธ์การค้นหาและผลการสแกนจะเป็นการอ่านที่สอดคล้องกันในที่สุดอย่างไรก็ตามคุณสามารถตั้งค่าการอ่านที่สอดคล้องกันอย่างมากได้เช่นกัน ใช้ConsistentRead พารามิเตอร์เพื่อเปลี่ยนการตั้งค่านี้

Note - การตั้งค่าการอ่านที่สม่ำเสมอส่งผลกระทบต่อการบริโภคโดยใช้หน่วยความจุสองเท่าเมื่อตั้งค่าให้สอดคล้องกันอย่างมาก

Performance- ข้อความค้นหาให้ประสิทธิภาพที่ดีกว่าการสแกนเนื่องจากการสแกนรวบรวมข้อมูลตารางแบบเต็มหรือดัชนีรองส่งผลให้การตอบสนองช้าและปริมาณการใช้งานที่หนักหน่วง การสแกนจะทำงานได้ดีที่สุดสำหรับตารางขนาดเล็กและการค้นหาที่มีตัวกรองน้อยอย่างไรก็ตามคุณสามารถออกแบบการสแกนแบบลีนได้โดยปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดบางประการเช่นหลีกเลี่ยงกิจกรรมการอ่านแบบเร่งด่วนและการใช้ประโยชน์จากการสแกนคู่ขนาน

การสืบค้นจะพบช่วงของคีย์ที่ตรงตามเงื่อนไขที่กำหนดโดยมีประสิทธิภาพที่กำหนดโดยจำนวนข้อมูลที่ดึงมาแทนที่จะเป็นระดับเสียงของคีย์ พารามิเตอร์ของการดำเนินการและจำนวนการจับคู่ส่งผลต่อประสิทธิภาพโดยเฉพาะ

การสแกนแบบขนาน

การสแกนดำเนินการประมวลผลตามลำดับโดยค่าเริ่มต้น จากนั้นจะส่งคืนข้อมูลในส่วน 1MB ซึ่งจะแจ้งให้แอปพลิเคชันดึงข้อมูลส่วนถัดไป ส่งผลให้มีการสแกนตารางและดัชนีขนาดใหญ่เป็นเวลานาน

คุณลักษณะนี้ยังหมายความว่าการสแกนอาจไม่ได้ใช้ประโยชน์จากปริมาณงานที่มีอยู่อย่างเต็มที่ DynamoDB กระจายข้อมูลตารางในหลายพาร์ติชัน และปริมาณงานสแกนยังคง จำกัด อยู่ที่พาร์ติชันเดียวเนื่องจากการทำงานของพาร์ติชันเดียว

วิธีแก้ปัญหานี้มาจากการแบ่งตารางหรือดัชนีออกเป็นกลุ่มอย่างมีเหตุผล จากนั้น "คนงาน" แบบขนาน (พร้อมกัน) จะสแกนส่วนต่างๆ ใช้พารามิเตอร์ของกลุ่มและTotalSegments เพื่อระบุเซ็กเมนต์ที่สแกนโดยคนงานบางคนและระบุจำนวนเซ็กเมนต์ทั้งหมดที่ประมวลผล

หมายเลขผู้ปฏิบัติงาน

คุณต้องทดสอบกับค่าผู้ปฏิบัติงาน (พารามิเตอร์กลุ่ม) เพื่อให้ได้ประสิทธิภาพของแอปพลิเคชันที่ดีที่สุด

Note- การสแกนแบบขนานกับคนงานจำนวนมากส่งผลต่อปริมาณงานโดยอาจใช้ปริมาณงานทั้งหมด จัดการปัญหานี้ด้วยพารามิเตอร์ Limit ซึ่งคุณสามารถใช้เพื่อหยุดผู้ปฏิบัติงานคนเดียวไม่ให้ใช้ปริมาณงานทั้งหมด

ต่อไปนี้เป็นตัวอย่างการสแกนแบบเจาะลึก

ตัวอย่างนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;

public class ScanOpSample {  
   static DynamoDB dynamoDB = new DynamoDB(
      new AmazonDynamoDBClient(new ProfileCredentialsProvider())); 
   static String tableName = "ProductList";  
   
   public static void main(String[] args) throws Exception { 
      findProductsUnderOneHun();                       //finds products under 100 dollars
   }  
   private static void findProductsUnderOneHun() { 
      Table table = dynamoDB.getTable(tableName);
      Map<String, Object> expressionAttributeValues = new HashMap<String, Object>(); 
      expressionAttributeValues.put(":pr", 100); 
         
      ItemCollection<ScanOutcome> items = table.scan ( 
         "Price < :pr",                                  //FilterExpression 
         "ID, Nomenclature, ProductCategory, Price",     //ProjectionExpression 
         null,                                           //No ExpressionAttributeNames  
         expressionAttributeValues);
         
      System.out.println("Scanned " + tableName + " to find items under $100."); 
      Iterator<Item> iterator = items.iterator(); 
         
      while (iterator.hasNext()) { 
         System.out.println(iterator.next().toJSONPretty()); 
      }     
   } 
}

DynamoDB ใช้ดัชนีสำหรับแอตทริบิวต์คีย์หลักเพื่อปรับปรุงการเข้าถึง ช่วยเร่งการเข้าถึงแอปพลิเคชันและการดึงข้อมูลและสนับสนุนประสิทธิภาพที่ดีขึ้นโดยการลดความล่าช้าของแอปพลิเคชัน

ดัชนีทุติยภูมิ

ดัชนีรองมีชุดย่อยของแอตทริบิวต์และคีย์สำรอง คุณใช้ผ่านการสืบค้นหรือการสแกนซึ่งกำหนดเป้าหมายดัชนี

เนื้อหารวมถึงคุณลักษณะที่คุณโครงการหรือคัดลอก ในการสร้างคุณกำหนดคีย์สำรองสำหรับดัชนีและแอตทริบิวต์ใด ๆ ที่คุณต้องการฉายในดัชนี จากนั้น DynamoDB จะคัดลอกแอตทริบิวต์ลงในดัชนีรวมถึงแอตทริบิวต์คีย์หลักที่มาจากตาราง หลังจากดำเนินการเหล่านี้แล้วคุณเพียงแค่ใช้แบบสอบถาม / สแกนเหมือนกับการทำงานบนโต๊ะ

DynamoDB จะรักษาดัชนีรองทั้งหมดโดยอัตโนมัติ ในการดำเนินการรายการเช่นการเพิ่มหรือลบจะอัปเดตดัชนีใด ๆ บนตารางเป้าหมาย

DynamoDB เสนอดัชนีรองสองประเภท -

Global Secondary Index- ดัชนีนี้ประกอบด้วยคีย์พาร์ติชันและคีย์การจัดเรียงซึ่งอาจแตกต่างจากตารางต้นทาง ใช้ป้ายกำกับ "global" เนื่องจากความสามารถในการสืบค้น / สแกนบนดัชนีเพื่อขยายข้อมูลตารางทั้งหมดและทั่วทุกพาร์ติชัน
Local Secondary Index- ดัชนีนี้แชร์คีย์พาร์ติชันกับตาราง แต่ใช้คีย์การจัดเรียงอื่น ลักษณะ "โลคัล" เป็นผลมาจากพาร์ติชันทั้งหมดที่กำหนดขอบเขตไปยังพาร์ติชันตารางที่มีค่าคีย์พาร์ติชันเหมือนกัน

ประเภทของดัชนีที่ดีที่สุดที่จะใช้ขึ้นอยู่กับความต้องการของแอปพลิเคชัน พิจารณาความแตกต่างระหว่างทั้งสองที่นำเสนอในตารางต่อไปนี้ -

คุณภาพ	ดัชนีทุติยภูมิทั่วโลก	ดัชนีทุติยภูมิในท้องถิ่น
คีย์สคีมา	ใช้คีย์หลักแบบง่ายหรือแบบผสม	จะใช้คีย์หลักแบบผสมเสมอ
คุณสมบัติที่สำคัญ	คีย์พาร์ติชันดัชนีและคีย์การจัดเรียงสามารถประกอบด้วยสตริงตัวเลขหรือแอตทริบิวต์ตารางไบนารี	คีย์พาร์ติชันของดัชนีคือแอ็ตทริบิวต์ที่แชร์กับคีย์พาร์ติชันตาราง คีย์การจัดเรียงสามารถเป็นแอตทริบิวต์สตริงตัวเลขหรือตารางไบนารี
ขนาด จำกัด ต่อค่าคีย์พาร์ติชัน	ไม่ จำกัด ขนาด	มันกำหนดขีด จำกัด สูงสุด 10GB สำหรับขนาดรวมของรายการที่จัดทำดัชนีที่เกี่ยวข้องกับค่าคีย์พาร์ติชัน
การดำเนินการดัชนีออนไลน์	คุณสามารถวางไข่ในการสร้างตารางเพิ่มในตารางที่มีอยู่หรือลบที่มีอยู่	คุณต้องสร้างเมื่อสร้างตาราง แต่ไม่สามารถลบหรือเพิ่มลงในตารางที่มีอยู่ได้
แบบสอบถาม	ช่วยให้การสืบค้นครอบคลุมทั้งตารางและทุกพาร์ติชัน	พวกเขากล่าวถึงพาร์ติชันเดียวผ่านค่าคีย์พาร์ติชันที่ให้ไว้ในแบบสอบถาม
ความสม่ำเสมอ	แบบสอบถามของดัชนีเหล่านี้เสนอตัวเลือกที่สอดคล้องกันในที่สุดเท่านั้น	ข้อความค้นหาเหล่านี้มีตัวเลือกที่สอดคล้องหรือสอดคล้องกันอย่างมากในที่สุด
ต้นทุนปริมาณงาน	รวมถึงการตั้งค่าปริมาณงานสำหรับการอ่านและเขียน คิวรี / สแกนใช้ความจุจากดัชนีไม่ใช่ตารางซึ่งใช้กับการอัปเดตการเขียนตารางด้วย	การสืบค้น / การสแกนใช้ความสามารถในการอ่านตาราง ตารางเขียนอัพเดตดัชนีภายในเครื่องและใช้หน่วยความจุของตาราง
การฉายภาพ	การสืบค้น / การสแกนสามารถร้องขอแอตทริบิวต์ที่คาดการณ์ไว้ในดัชนีเท่านั้นโดยจะไม่มีการเรียกคืนแอตทริบิวต์ของตาราง	การสืบค้น / การสแกนสามารถขอแอตทริบิวต์ที่ไม่ได้คาดการณ์ไว้ ยิ่งไปกว่านั้นการดึงข้อมูลโดยอัตโนมัติเกิดขึ้น

เมื่อสร้างหลายตารางด้วยดัชนีรองให้ทำตามลำดับ หมายถึงสร้างตารางและรอให้ถึงสถานะ ACTIVE ก่อนสร้างใหม่และรออีกครั้ง DynamoDB ไม่อนุญาตให้สร้างพร้อมกัน

ดัชนีทุติยภูมิแต่ละรายการต้องการข้อกำหนดบางประการ -

Type - ระบุท้องถิ่นหรือทั่วโลก
Name - ใช้กฎการตั้งชื่อเหมือนกับตาราง
Key Schema - อนุญาตเฉพาะสตริงระดับบนสุดตัวเลขหรือประเภทไบนารีเท่านั้นโดยประเภทดัชนีจะเป็นตัวกำหนดข้อกำหนดอื่น ๆ
Attributes for Projection - DynamoDB จะฉายภาพโดยอัตโนมัติและอนุญาตให้ใช้ข้อมูลประเภทใดก็ได้
Throughput - ระบุความสามารถในการอ่าน / เขียนสำหรับดัชนีทุติยภูมิทั่วโลก

ขีด จำกัด สำหรับดัชนียังคงอยู่ที่ 5 global และ 5 local ต่อตาราง

คุณสามารถเข้าถึงข้อมูลโดยละเอียดเกี่ยวกับดัชนีด้วย DescribeTable. ส่งคืนชื่อขนาดและจำนวนรายการ

Note - ค่าเหล่านี้จะอัปเดตทุกๆ 6 ชั่วโมง

ในแบบสอบถามหรือการสแกนที่ใช้เพื่อเข้าถึงข้อมูลดัชนีให้ระบุชื่อตารางและดัชนีแอตทริบิวต์ที่ต้องการสำหรับผลลัพธ์และคำสั่งเงื่อนไขใด ๆ DynamoDB เสนอตัวเลือกในการส่งคืนผลลัพธ์ในลำดับจากน้อยไปมากหรือจากมากไปหาน้อย

Note - การลบตารางจะลบดัชนีทั้งหมดด้วย

แอปพลิเคชันที่ต้องการแบบสอบถามประเภทต่างๆที่มีแอตทริบิวต์ต่างกันสามารถใช้ดัชนีรองส่วนกลางเดียวหรือหลายดัชนีในการดำเนินการสืบค้นโดยละเอียดเหล่านี้

For example - ระบบติดตามผู้ใช้สถานะการเข้าสู่ระบบและเวลาในการเข้าสู่ระบบการเติบโตของตัวอย่างก่อนหน้านี้ทำให้การสืบค้นข้อมูลช้าลง

ดัชนีทุติยภูมิสากลเร่งการสืบค้นโดยจัดการการเลือกแอตทริบิวต์จากตาราง ใช้คีย์หลักในการจัดเรียงข้อมูลและไม่จำเป็นต้องมีแอตทริบิวต์ตารางคีย์หรือสคีมาคีย์ที่เหมือนกับตาราง

ดัชนีรองส่วนกลางทั้งหมดต้องมีคีย์พาร์ติชันพร้อมตัวเลือกของคีย์การเรียงลำดับ สคีมาคีย์ดัชนีอาจแตกต่างจากตารางและแอตทริบิวต์คีย์ดัชนีสามารถใช้แอตทริบิวต์สตริงระดับบนสุดตัวเลขหรือตารางไบนารี

ในการฉายภาพคุณสามารถใช้แอตทริบิวต์ตารางอื่น ๆ ได้อย่างไรก็ตามคิวรีจะไม่ดึงข้อมูลจากตารางหลัก

การคาดการณ์คุณสมบัติ

การคาดการณ์ประกอบด้วยชุดแอตทริบิวต์ที่คัดลอกจากตารางไปยังดัชนีรอง การฉายภาพจะเกิดขึ้นกับคีย์พาร์ติชันตารางและคีย์การเรียงลำดับเสมอ ในแบบสอบถามการคาดการณ์อนุญาตให้ DynamoDB เข้าถึงแอตทริบิวต์ใด ๆ ของการฉายภาพ โดยพื้นฐานแล้วมีอยู่เป็นโต๊ะของตัวเอง

ในการสร้างดัชนีรองคุณต้องระบุแอตทริบิวต์สำหรับการฉายภาพ DynamoDB เสนอสามวิธีในการทำงานนี้ -

KEYS_ONLY- รายการดัชนีทั้งหมดประกอบด้วยพาร์ติชันตารางและจัดเรียงค่าคีย์และค่าคีย์ดัชนี สิ่งนี้สร้างดัชนีที่เล็กที่สุด
INCLUDE - ประกอบด้วยแอตทริบิวต์ KEYS_ONLY และแอตทริบิวต์ที่ไม่ใช่คีย์ที่ระบุ
ALL - ประกอบด้วยแอตทริบิวต์ของตารางแหล่งที่มาทั้งหมดสร้างดัชนีที่ใหญ่ที่สุดเท่าที่จะเป็นไปได้

สังเกตข้อแลกเปลี่ยนในการคาดคะเนแอตทริบิวต์ในดัชนีทุติยภูมิสากลซึ่งเกี่ยวข้องกับปริมาณงานและต้นทุนการจัดเก็บ

พิจารณาประเด็นต่อไปนี้ -

หากคุณต้องการเข้าถึงเพียงไม่กี่แอตทริบิวต์ที่มีเวลาแฝงต่ำให้ฉายเฉพาะที่คุณต้องการ ซึ่งจะช่วยลดต้นทุนการจัดเก็บและการเขียน
หากแอปพลิเคชันเข้าถึงแอตทริบิวต์ที่ไม่ใช่คีย์บางรายการบ่อยครั้งให้คาดการณ์เนื่องจากค่าใช้จ่ายในการจัดเก็บข้อมูลซีดเมื่อเทียบกับปริมาณการสแกน
คุณสามารถฉายชุดแอตทริบิวต์จำนวนมากที่เข้าถึงบ่อยได้อย่างไรก็ตามมีค่าใช้จ่ายในการจัดเก็บที่สูง
ใช้ KEYS_ONLY สำหรับการสืบค้นตารางที่ไม่บ่อยนักและการเขียน / อัปเดตบ่อยๆ สิ่งนี้ควบคุมขนาด แต่ยังคงให้ประสิทธิภาพที่ดีในการสืบค้น

แบบสอบถามและการสแกนดัชนีทุติยภูมิสากล

คุณสามารถใช้แบบสอบถามเพื่อเข้าถึงรายการเดียวหรือหลายรายการในดัชนี คุณต้องระบุดัชนีและชื่อตารางคุณลักษณะที่ต้องการและเงื่อนไข พร้อมตัวเลือกในการส่งคืนผลลัพธ์ในลำดับจากน้อยไปมากหรือมากไปหาน้อย

คุณยังสามารถใช้การสแกนเพื่อรับข้อมูลดัชนีทั้งหมด ต้องใช้ชื่อตารางและดัชนี คุณใช้นิพจน์ตัวกรองเพื่อดึงข้อมูลเฉพาะ

การซิงโครไนซ์ข้อมูลตารางและดัชนี

DynamoDB ทำการซิงโครไนซ์ดัชนีกับตารางพาเรนต์โดยอัตโนมัติ การดำเนินการแก้ไขแต่ละรายการทำให้เกิดการอัปเดตแบบอะซิงโครนัสอย่างไรก็ตามแอปพลิเคชันไม่ได้เขียนลงในดัชนีโดยตรง

คุณต้องเข้าใจผลกระทบของการบำรุงรักษา DynamoDB ต่อดัชนี ในการสร้างดัชนีคุณต้องระบุแอตทริบิวต์หลักและประเภทข้อมูลซึ่งหมายความว่าในการเขียนประเภทข้อมูลเหล่านั้นต้องตรงกับประเภทข้อมูลสคีมาหลัก

ในการสร้างหรือลบไอเท็มดัชนีอัพเดตในลักษณะที่สอดคล้องกันในที่สุดอย่างไรก็ตามการอัพเดตข้อมูลจะแพร่กระจายในเสี้ยววินาที (เว้นแต่ว่าระบบจะล้มเหลวในบางประเภท) คุณต้องคำนึงถึงความล่าช้าในการใช้งานนี้

Throughput Considerations in Global Secondary Indexes- ดัชนีทุติยภูมิทั่วโลกหลายรายการส่งผลต่อปริมาณงาน การสร้างดัชนีต้องใช้ข้อกำหนดหน่วยความจุซึ่งมีอยู่แยกต่างหากจากตารางส่งผลให้การดำเนินงานใช้หน่วยความจุดัชนีมากกว่าหน่วยตาราง

ซึ่งอาจส่งผลให้มีการควบคุมปริมาณหากข้อความค้นหาหรือการเขียนเกินปริมาณงานที่จัดเตรียมไว้ ดูการตั้งค่าปริมาณงานโดยใช้DescribeTable.

Read Capacity- ดัชนีทุติยภูมิทั่วโลกให้ความสอดคล้องในที่สุด ในแบบสอบถาม DynamoDB จะทำการคำนวณการจัดเตรียมที่เหมือนกับที่ใช้สำหรับตารางโดยมีความแตกต่างเพียงอย่างเดียวในการใช้ขนาดรายการดัชนีแทนที่จะเป็นขนาดรายการ ขีด จำกัด ของการส่งคืนแบบสอบถามยังคงอยู่ที่ 1MB ซึ่งรวมถึงขนาดชื่อแอตทริบิวต์และค่าในทุกรายการที่ส่งคืน

เขียนความจุ

เมื่อการดำเนินการเขียนเกิดขึ้นดัชนีที่ได้รับผลกระทบจะใช้หน่วยการเขียน ต้นทุนการเขียนข้อมูลคือผลรวมของหน่วยความสามารถในการเขียนที่ใช้ในการเขียนตารางและหน่วยที่ใช้ในการปรับปรุงดัชนี การดำเนินการเขียนที่ประสบความสำเร็จต้องใช้ความสามารถเพียงพอหรือส่งผลให้เกิดการควบคุมปริมาณ

ต้นทุนการเขียนยังคงขึ้นอยู่กับปัจจัยบางประการซึ่งมีดังนี้ -

รายการใหม่ที่กำหนดแอตทริบิวต์ที่จัดทำดัชนีหรือการอัปเดตรายการที่กำหนดแอตทริบิวต์ที่จัดทำดัชนีที่ไม่ได้กำหนดใช้การดำเนินการเขียนเพียงครั้งเดียวเพื่อเพิ่มรายการลงในดัชนี
การอัพเดตการเปลี่ยนค่าแอตทริบิวต์ของคีย์ที่จัดทำดัชนีใช้การเขียนสองรายการเพื่อลบรายการและเขียนรายการใหม่
การเขียนตารางที่ทริกเกอร์การลบแอตทริบิวต์ที่จัดทำดัชนีจะใช้การเขียนเพียงครั้งเดียวเพื่อลบการคาดการณ์รายการเก่าในดัชนี
รายการที่ไม่มีอยู่ในดัชนีก่อนและหลังการดำเนินการอัพเดตไม่ใช้การเขียน
การอัปเดตที่เปลี่ยนเฉพาะค่าแอ็ตทริบิวต์ที่คาดการณ์ไว้ในสคีมาคีย์ดัชนีและไม่ได้จัดทำดัชนีค่าแอตทริบิวต์ของคีย์ให้ใช้การเขียนเพื่ออัปเดตค่าของแอ็ตทริบิวต์ที่คาดการณ์ไว้ในดัชนี

ปัจจัยทั้งหมดนี้ถือว่าขนาดรายการน้อยกว่าหรือเท่ากับ 1KB

การจัดเก็บดัชนีทุติยภูมิทั่วโลก

ในการเขียนรายการ DynamoDB จะคัดลอกชุดแอตทริบิวต์ที่ถูกต้องโดยอัตโนมัติไปยังดัชนีใด ๆ ที่ต้องมีแอตทริบิวต์ สิ่งนี้ส่งผลกระทบต่อบัญชีของคุณโดยการเรียกเก็บเงินจากการจัดเก็บรายการตารางและการจัดเก็บแอตทริบิวต์ ช่องว่างที่ใช้เป็นผลมาจากผลรวมของปริมาณเหล่านี้ -

ขนาดไบต์ของคีย์หลักของตาราง
ขนาดไบต์ของแอตทริบิวต์คีย์ดัชนี
ขนาดไบต์ของแอตทริบิวต์ที่คาดการณ์ไว้
ค่าโสหุ้ย 100 ไบต์ต่อรายการดัชนี

คุณสามารถประมาณความต้องการพื้นที่จัดเก็บได้โดยการประมาณขนาดรายการโดยเฉลี่ยและคูณด้วยปริมาณของรายการในตารางที่มีแอตทริบิวต์คีย์ดัชนีรองส่วนกลาง

DynamoDB ไม่เขียนข้อมูลรายการสำหรับรายการตารางที่มีแอตทริบิวต์ที่ไม่ได้กำหนดซึ่งกำหนดเป็นพาร์ติชันดัชนีหรือคีย์การเรียงลำดับ

Crud ดัชนีทุติยภูมิทั่วโลก

สร้างตารางที่มีดัชนีรองส่วนกลางโดยใช้ CreateTable การทำงานที่จับคู่กับ GlobalSecondaryIndexesพารามิเตอร์. คุณต้องระบุแอ็ตทริบิวต์เพื่อใช้เป็นคีย์พาร์ติชันดัชนีหรือใช้อื่นสำหรับคีย์การเรียงลำดับดัชนี แอตทริบิวต์คีย์ดัชนีทั้งหมดต้องเป็นสตริงตัวเลขหรือสเกลาร์ไบนารี คุณต้องระบุการตั้งค่าปริมาณงานซึ่งประกอบด้วยReadCapacityUnits และ WriteCapacityUnits.

ใช้ UpdateTable เพื่อเพิ่มดัชนีรองส่วนกลางลงในตารางที่มีอยู่โดยใช้พารามิเตอร์ GlobalSecondaryIndexes อีกครั้ง

ในการดำเนินการนี้คุณต้องระบุอินพุตต่อไปนี้ -

ชื่อดัชนี
คีย์สคีมา
แอตทริบิวต์ที่คาดการณ์ไว้
การตั้งค่าปริมาณงาน

การเพิ่มดัชนีทุติยภูมิสากลอาจใช้เวลานานพอสมควรกับตารางขนาดใหญ่เนื่องจากปริมาณสินค้าปริมาณแอตทริบิวต์ที่คาดการณ์ความจุในการเขียนและกิจกรรมการเขียน ใช้CloudWatch เมตริกเพื่อตรวจสอบกระบวนการ

ใช้ DescribeTableเพื่อดึงข้อมูลสถานะสำหรับดัชนีรองส่วนกลาง จะส่งกลับหนึ่งในสี่IndexStatus สำหรับ GlobalSecondaryIndexes -

CREATING - ระบุขั้นตอนการสร้างของดัชนีและความไม่พร้อมใช้งาน
ACTIVE - แสดงถึงความพร้อมของดัชนีในการใช้งาน
UPDATING - ระบุสถานะการอัปเดตของการตั้งค่าปริมาณงาน
DELETING - ระบุสถานะการลบของดัชนีและความไม่พร้อมใช้งานถาวรสำหรับการใช้งาน

อัปเดตการตั้งค่าทรูพุตที่จัดเตรียมดัชนีรองส่วนกลางระหว่างขั้นตอนการโหลด / การเติมย้อนกลับ (แอตทริบิวต์การเขียน DynamoDB ไปยังดัชนีและการติดตามรายการที่เพิ่ม / ลบ / อัปเดต) ใช้UpdateTable เพื่อดำเนินการนี้

คุณควรจำไว้ว่าคุณไม่สามารถเพิ่ม / ลบดัชนีอื่น ๆ ในระหว่างขั้นตอนการเติม

ใช้ UpdateTable เพื่อลบดัชนีรองส่วนกลาง อนุญาตให้ลบเพียงดัชนีเดียวต่อการดำเนินการอย่างไรก็ตามคุณสามารถรันการดำเนินการหลายรายการพร้อมกันได้สูงสุดห้ารายการ กระบวนการลบไม่มีผลต่อกิจกรรมการอ่าน / เขียนของตารางพาเรนต์ แต่คุณไม่สามารถเพิ่ม / ลบดัชนีอื่น ๆ ได้จนกว่าการดำเนินการจะเสร็จสิ้น

การใช้ Java เพื่อทำงานกับ Global Secondary Indexes

สร้างตารางด้วยดัชนีผ่าน CreateTable เพียงสร้างอินสแตนซ์คลาส DynamoDB aCreateTableRequest อินสแตนซ์คลาสสำหรับการร้องขอข้อมูลและส่งอ็อบเจ็กต์คำร้องขอไปยังเมธอด CreateTable

โปรแกรมต่อไปนี้เป็นตัวอย่างสั้น ๆ -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));
   
// Attributes 
ArrayList<AttributeDefinition> attributeDefinitions = new 
   ArrayList<AttributeDefinition>();  
attributeDefinitions.add(new AttributeDefinition() 
   .withAttributeName("City") 
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition() 
   .withAttributeName("Date") 
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition() 
   .withAttributeName("Wind") 
   .withAttributeType("N"));
   
// Key schema of the table 
ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>(); 
tableKeySchema.add(new KeySchemaElement()
   .withAttributeName("City") 
   .withKeyType(KeyType.HASH));              //Partition key
   
tableKeySchema.add(new KeySchemaElement() 
   .withAttributeName("Date") 
   .withKeyType(KeyType.RANGE));             //Sort key
   
// Wind index 
GlobalSecondaryIndex windIndex = new GlobalSecondaryIndex() 
   .withIndexName("WindIndex") 
   .withProvisionedThroughput(new ProvisionedThroughput() 
   .withReadCapacityUnits((long) 10) 
   .withWriteCapacityUnits((long) 1)) 
   .withProjection(new Projection().withProjectionType(ProjectionType.ALL));
   
ArrayList<KeySchemaElement> indexKeySchema = new ArrayList<KeySchemaElement>(); 
indexKeySchema.add(new KeySchemaElement() 
   .withAttributeName("Date") 
   .withKeyType(KeyType.HASH));              //Partition key
   
indexKeySchema.add(new KeySchemaElement() 
   .withAttributeName("Wind") 
   .withKeyType(KeyType.RANGE));             //Sort key
   
windIndex.setKeySchema(indexKeySchema);  
CreateTableRequest createTableRequest = new CreateTableRequest() 
   .withTableName("ClimateInfo") 
   .withProvisionedThroughput(new ProvisionedThroughput() 
   .withReadCapacityUnits((long) 5) 
   .withWriteCapacityUnits((long) 1))
   .withAttributeDefinitions(attributeDefinitions) 
   .withKeySchema(tableKeySchema) 
   .withGlobalSecondaryIndexes(windIndex); 
Table table = dynamoDB.createTable(createTableRequest); 
System.out.println(table.getDescription());

ดึงข้อมูลดัชนีด้วย DescribeTable. ขั้นแรกสร้างอินสแตนซ์คลาส DynamoDB จากนั้นสร้างอินสแตนซ์คลาส Table เพื่อกำหนดเป้าหมายดัชนี สุดท้ายส่งตารางไปยังวิธีการอธิบาย

นี่คือตัวอย่างสั้น ๆ -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ClimateInfo"); 
TableDescription tableDesc = table.describe();  
Iterator<GlobalSecondaryIndexDescription> gsiIter = 
   tableDesc.getGlobalSecondaryIndexes().iterator(); 

while (gsiIter.hasNext()) { 
   GlobalSecondaryIndexDescription gsiDesc = gsiIter.next(); 
   System.out.println("Index data " + gsiDesc.getIndexName() + ":");  
   Iterator<KeySchemaElement> kse7Iter = gsiDesc.getKeySchema().iterator(); 
   
   while (kseIter.hasNext()) { 
      KeySchemaElement kse = kseIter.next(); 
      System.out.printf("\t%s: %s\n", kse.getAttributeName(), kse.getKeyType()); 
   }
   Projection projection = gsiDesc.getProjection(); 
   System.out.println("\tProjection type: " + projection.getProjectionType()); 
   
   if (projection.getProjectionType().toString().equals("INCLUDE")) { 
      System.out.println("\t\tNon-key projected attributes: " 
         + projection.getNonKeyAttributes()); 
   } 
}

ใช้แบบสอบถามเพื่อดำเนินการแบบสอบถามดัชนีเช่นเดียวกับแบบสอบถามตาราง เพียงสร้างอินสแตนซ์คลาส DynamoDB อินสแตนซ์คลาสตารางสำหรับดัชนีเป้าหมายอินสแตนซ์คลาสดัชนีสำหรับดัชนีเฉพาะและส่งดัชนีและวัตถุเคียวรีไปยังเมธอดคิวรี

ดูรหัสต่อไปนี้เพื่อทำความเข้าใจให้ดีขึ้น -

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
   new ProfileCredentialsProvider()));
   
Table table = dynamoDB.getTable("ClimateInfo"); 
Index index = table.getIndex("WindIndex");  
QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("#d = :v_date and Wind = :v_wind") 
   .withNameMap(new NameMap() 
   .with("#d", "Date"))
   .withValueMap(new ValueMap() 
   .withString(":v_date","2016-05-15") 
   .withNumber(":v_wind",0));
   
ItemCollection<QueryOutcome> items = index.query(spec);
Iterator<Item> iter = items.iterator();

while (iter.hasNext()) {
   System.out.println(iter.next().toJSONPretty()); 
}

โปรแกรมต่อไปนี้เป็นตัวอย่างที่ใหญ่กว่าเพื่อความเข้าใจที่ดีขึ้น -

ตัวอย่างนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

import java.util.ArrayList;
import java.util.Iterator;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Index;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;

import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.GlobalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.Projection;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;

public class GlobalSecondaryIndexSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient ( 
      new ProfileCredentialsProvider()));  
   public static String tableName = "Bugs";   
   public static void main(String[] args) throws Exception {  
      createTable(); 
      queryIndex("CreationDateIndex"); 
      queryIndex("NameIndex"); 
      queryIndex("DueDateIndex"); 
   }
   public static void createTable() {  
      // Attributes 
      ArrayList<AttributeDefinition> attributeDefinitions = new 
         ArrayList<AttributeDefinition>();  
      attributeDefinitions.add(new AttributeDefinition()
         .withAttributeName("BugID") 
         .withAttributeType("S")); 
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("Name")
         .withAttributeType("S"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("CreationDate")
         .withAttributeType("S"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("DueDate") 
         .withAttributeType("S"));
         
      // Table Key schema
      ArrayList<KeySchemaElement> tableKeySchema = new ArrayList<KeySchemaElement>(); 
      tableKeySchema.add (new KeySchemaElement() 
         .withAttributeName("BugID") 
         .withKeyType(KeyType.HASH));              //Partition key 
      
      tableKeySchema.add (new KeySchemaElement() 
         .withAttributeName("Name") 
         .withKeyType(KeyType.RANGE));             //Sort key
         
      // Indexes' initial provisioned throughput
      ProvisionedThroughput ptIndex = new ProvisionedThroughput()
         .withReadCapacityUnits(1L)
         .withWriteCapacityUnits(1L);
         
      // CreationDateIndex 
      GlobalSecondaryIndex creationDateIndex = new GlobalSecondaryIndex() 
         .withIndexName("CreationDateIndex") 
         .withProvisionedThroughput(ptIndex) 
         .withKeySchema(new KeySchemaElement() 
         .withAttributeName("CreationDate") 
         .withKeyType(KeyType.HASH),               //Partition key 
         new KeySchemaElement()
         .withAttributeName("BugID") 
         .withKeyType(KeyType.RANGE))              //Sort key 
         .withProjection(new Projection() 
         .withProjectionType("INCLUDE") 
         .withNonKeyAttributes("Description", "Status"));
         
      // NameIndex 
      GlobalSecondaryIndex nameIndex = new GlobalSecondaryIndex() 
         .withIndexName("NameIndex") 
         .withProvisionedThroughput(ptIndex) 
         .withKeySchema(new KeySchemaElement()  
         .withAttributeName("Name")  
         .withKeyType(KeyType.HASH),                  //Partition key 
         new KeySchemaElement()  
         .withAttributeName("BugID")  
         .withKeyType(KeyType.RANGE))                 //Sort key 
         .withProjection(new Projection() 
         .withProjectionType("KEYS_ONLY"));
         
      // DueDateIndex 
      GlobalSecondaryIndex dueDateIndex = new GlobalSecondaryIndex() 
         .withIndexName("DueDateIndex") 
         .withProvisionedThroughput(ptIndex) 
         .withKeySchema(new KeySchemaElement() 
         .withAttributeName("DueDate") 
         .withKeyType(KeyType.HASH))               //Partition key 
         .withProjection(new Projection() 
         .withProjectionType("ALL"));
         
      CreateTableRequest createTableRequest = new CreateTableRequest() 
         .withTableName(tableName) 
         .withProvisionedThroughput( new ProvisionedThroughput() 
         .withReadCapacityUnits( (long) 1) 
         .withWriteCapacityUnits( (long) 1)) 
         .withAttributeDefinitions(attributeDefinitions)
         .withKeySchema(tableKeySchema)
         .withGlobalSecondaryIndexes(creationDateIndex, nameIndex, dueDateIndex);  
         System.out.println("Creating " + tableName + "..."); 
         dynamoDB.createTable(createTableRequest);  
      
      // Pause for active table state 
      System.out.println("Waiting for ACTIVE state of " + tableName); 
      try { 
         Table table = dynamoDB.getTable(tableName); 
         table.waitForActive(); 
      } catch (InterruptedException e) { 
         e.printStackTrace(); 
      } 
   }
   public static void queryIndex(String indexName) { 
      Table table = dynamoDB.getTable(tableName);  
      System.out.println 
      ("\n*****************************************************\n"); 
      System.out.print("Querying index " + indexName + "...");  
      Index index = table.getIndex(indexName);  
      ItemCollection<QueryOutcome> items = null; 
      QuerySpec querySpec = new QuerySpec();  
      
      if (indexName == "CreationDateIndex") { 
         System.out.println("Issues filed on 2016-05-22"); 
         querySpec.withKeyConditionExpression("CreationDate = :v_date and begins_with
            (BugID, :v_bug)") 
            .withValueMap(new ValueMap() 
            .withString(":v_date","2016-05-22")
            .withString(":v_bug","A-")); 
         items = index.query(querySpec); 
      } else if (indexName == "NameIndex") { 
         System.out.println("Compile error"); 
         querySpec.withKeyConditionExpression("Name = :v_name and begins_with
            (BugID, :v_bug)") 
            .withValueMap(new ValueMap() 
            .withString(":v_name","Compile error") 
            .withString(":v_bug","A-")); 
         items = index.query(querySpec); 
      } else if (indexName == "DueDateIndex") { 
         System.out.println("Items due on 2016-10-15"); 
         querySpec.withKeyConditionExpression("DueDate = :v_date") 
         .withValueMap(new ValueMap() 
         .withString(":v_date","2016-10-15")); 
         items = index.query(querySpec); 
      } else { 
         System.out.println("\nInvalid index name"); 
         return; 
      }  
      Iterator<Item> iterator = items.iterator(); 
      System.out.println("Query: getting result..."); 
      
      while (iterator.hasNext()) { 
         System.out.println(iterator.next().toJSONPretty()); 
      } 
   } 
}

แอปพลิเคชันบางตัวดำเนินการสืบค้นด้วยคีย์หลักเท่านั้น แต่บางสถานการณ์จะได้รับประโยชน์จากคีย์การเรียงลำดับสำรอง อนุญาตให้แอปพลิเคชันของคุณมีทางเลือกโดยการสร้างดัชนีรองในเครื่องเดียวหรือหลายดัชนี

ข้อกำหนดในการเข้าถึงข้อมูลที่ซับซ้อนเช่นการรวมรายการนับล้านทำให้จำเป็นต้องดำเนินการสืบค้น / สแกนที่มีประสิทธิภาพมากขึ้น ดัชนีรองในเครื่องมีคีย์การเรียงลำดับสำรองสำหรับค่าคีย์พาร์ติชัน นอกจากนี้ยังมีสำเนาแอตทริบิวต์ของตารางทั้งหมดหรือบางส่วน พวกเขาจัดระเบียบข้อมูลด้วยคีย์พาร์ติชันตาราง แต่ใช้คีย์การจัดเรียงอื่น

การใช้ดัชนีทุติยภูมิในเครื่องจะช่วยขจัดความจำเป็นในการสแกนตารางทั้งหมดและช่วยให้สามารถสืบค้นข้อมูลได้ง่ายและรวดเร็วโดยใช้คีย์การจัดเรียง

ดัชนีทุติยภูมิในพื้นที่ทั้งหมดต้องเป็นไปตามเงื่อนไขบางประการ -

คีย์พาร์ติชันที่เหมือนกันและคีย์พาร์ติชันตารางต้นทาง
คีย์การจัดเรียงของแอตทริบิวต์สเกลาร์เดียวเท่านั้น
การฉายภาพของคีย์การจัดเรียงตารางต้นทางที่ทำหน้าที่เป็นแอตทริบิวต์ที่ไม่ใช่คีย์

ดัชนีรองในเครื่องทั้งหมดจะเก็บพาร์ติชันและคีย์เรียงลำดับจากตารางหลักโดยอัตโนมัติ ในแบบสอบถามหมายถึงการรวบรวมแอตทริบิวต์ที่คาดการณ์ไว้อย่างมีประสิทธิภาพและการดึงแอตทริบิวต์ที่ไม่ได้คาดการณ์ไว้ด้วย

ขีด จำกัด การจัดเก็บสำหรับดัชนีรองภายในเครื่องจะยังคงอยู่ที่ 10GB ต่อค่าคีย์พาร์ติชันซึ่งรวมถึงรายการตารางทั้งหมดและรายการดัชนีที่แชร์ค่าคีย์พาร์ติชัน

การฉายแอททริบิวต์

การดำเนินการบางอย่างต้องการการอ่าน / ดึงข้อมูลส่วนเกินเนื่องจากความซับซ้อน การดำเนินการเหล่านี้สามารถใช้ปริมาณงานได้มาก การฉายภาพช่วยให้คุณหลีกเลี่ยงการดึงข้อมูลที่มีราคาแพงและดำเนินการสืบค้นข้อมูลที่หลากหลายโดยการแยกแอตทริบิวต์เหล่านี้ โปรดจำไว้ว่าการคาดการณ์ประกอบด้วยแอตทริบิวต์ที่คัดลอกไปยังดัชนีรอง

เมื่อสร้างดัชนีรองคุณต้องระบุแอตทริบิวต์ที่คาดการณ์ไว้ เรียกคืนตัวเลือกสามตัวที่มีให้โดย DynamoDB:KEYS_ONLY, INCLUDE, and ALL.

เมื่อเลือกแอตทริบิวต์บางอย่างในการประมาณการให้พิจารณาการแลกเปลี่ยนต้นทุนที่เกี่ยวข้อง -

หากคุณคาดการณ์แอตทริบิวต์ที่จำเป็นเพียงเล็กน้อยคุณจะลดต้นทุนการจัดเก็บได้อย่างมาก
หากคุณคาดการณ์แอตทริบิวต์ที่ไม่ใช่คีย์ที่เข้าถึงบ่อยคุณจะชดเชยต้นทุนการสแกนด้วยต้นทุนการจัดเก็บ
หากคุณฉายแอตทริบิวต์ที่ไม่ใช่คีย์ส่วนใหญ่หรือทั้งหมดสิ่งนี้จะเพิ่มความยืดหยุ่นสูงสุดและลดปริมาณงาน (ไม่มีการดึงข้อมูล) อย่างไรก็ตามต้นทุนการจัดเก็บเพิ่มขึ้น
หากคุณคาดการณ์ KEYS_ONLY สำหรับการเขียน / อัปเดตบ่อยครั้งและการสืบค้นที่ไม่บ่อยนักระบบจะย่อขนาดให้เล็กที่สุด แต่ยังคงเตรียมการสืบค้นไว้

การสร้างดัชนีทุติยภูมิในท้องถิ่น

ใช้ LocalSecondaryIndexพารามิเตอร์ของ CreateTable เพื่อสร้างดัชนีรองภายในเครื่องเดียวหรือหลายตัว คุณต้องระบุแอตทริบิวต์ที่ไม่ใช่คีย์หนึ่งรายการสำหรับคีย์การเรียงลำดับ ในการสร้างตารางคุณจะสร้างดัชนีรองในเครื่อง ในการลบคุณจะลบดัชนีเหล่านี้

ตารางที่มีดัชนีรองในเครื่องต้องเป็นไปตามขีด จำกัด ของขนาด 10GB ต่อค่าคีย์พาร์ติชัน แต่สามารถจัดเก็บรายการจำนวนเท่าใดก็ได้

การสืบค้นและการสแกนดัชนีทุติยภูมิในพื้นที่

การดำเนินการเคียวรีบนดัชนีรองภายในจะส่งคืนรายการทั้งหมดที่มีค่าคีย์พาร์ติชันที่ตรงกันเมื่อหลายรายการในดัชนีแบ่งค่าคีย์การเรียงลำดับ รายการที่ตรงกันจะไม่ส่งคืนตามลำดับที่แน่นอน การค้นหาสำหรับดัชนีทุติยภูมิในเครื่องจะใช้ความสอดคล้องกันในท้ายที่สุดหรืออย่างใดอย่างหนึ่งโดยการอ่านที่สอดคล้องกันอย่างมากจะแสดงค่าล่าสุด

การสแกนจะส่งคืนข้อมูลดัชนีทุติยภูมิในเครื่องทั้งหมด การสแกนกำหนดให้คุณระบุชื่อตารางและดัชนีและอนุญาตให้ใช้นิพจน์ตัวกรองเพื่อทิ้งข้อมูล

การเขียนรายการ

ในการสร้างดัชนีรองในเครื่องคุณต้องระบุแอตทริบิวต์คีย์การเรียงลำดับและประเภทข้อมูล เมื่อคุณเขียนรายการประเภทของรายการจะต้องตรงกับประเภทข้อมูลของคีย์สคีมาหากรายการนั้นกำหนดแอตทริบิวต์ของคีย์ดัชนี

DynamoDB ไม่ได้กำหนดข้อกำหนดความสัมพันธ์แบบหนึ่งต่อหนึ่งบนรายการตารางและรายการดัชนีรองในเครื่อง ตารางที่มีดัชนีทุติยภูมิในเครื่องหลายตัวมีต้นทุนการเขียนสูงกว่าตารางที่มีดัชนีรองในเครื่องน้อยกว่า

การพิจารณาปริมาณงานในดัชนีทุติยภูมิในพื้นที่

การใช้ความจุในการอ่านของแบบสอบถามขึ้นอยู่กับลักษณะของการเข้าถึงข้อมูล ข้อความค้นหาใช้ความสอดคล้องในท้ายที่สุดหรืออย่างใดอย่างหนึ่งโดยมีการอ่านที่สอดคล้องกันอย่างมากโดยใช้หน่วยเดียวเทียบกับครึ่งหน่วยในการอ่านที่สอดคล้องกันในที่สุด

ข้อ จำกัด ของผลลัพธ์ ได้แก่ ขนาดสูงสุด 1MB ขนาดผลลัพธ์มาจากผลรวมของขนาดรายการดัชนีที่ตรงกันปัดเศษขึ้นเป็น 4KB ที่ใกล้ที่สุดและขนาดรายการตารางที่ตรงกันจะปัดเศษเป็น 4KB ที่ใกล้ที่สุด

ปริมาณการใช้ความจุในการเขียนยังคงอยู่ในหน่วยที่จัดเตรียมไว้ คำนวณต้นทุนทั้งหมดที่จัดเตรียมโดยการหาผลรวมของหน่วยบริโภคในการเขียนตารางและหน่วยบริโภคในการอัปเดตดัชนี

คุณยังสามารถพิจารณาปัจจัยสำคัญที่มีผลต่อต้นทุนซึ่งบางส่วน ได้แก่ -

เมื่อคุณเขียนรายการที่กำหนดแอตทริบิวต์ที่จัดทำดัชนีหรืออัปเดตรายการเพื่อกำหนดแอตทริบิวต์ที่จัดทำดัชนีที่ไม่ได้กำหนดการดำเนินการเขียนเดียวจะเกิดขึ้น
เมื่อการอัปเดตตารางเปลี่ยนค่าแอตทริบิวต์ของคีย์ที่จัดทำดัชนีการเขียนสองครั้งจะเกิดขึ้นเพื่อลบแล้วเพิ่มรายการ
เมื่อการเขียนทำให้เกิดการลบแอตทริบิวต์ที่จัดทำดัชนีการเขียนหนึ่งรายการจะเกิดขึ้นเพื่อลบการคาดการณ์รายการเก่า
เมื่อไม่มีรายการอยู่ในดัชนีก่อนหรือหลังการอัพเดตจะไม่มีการเขียนเกิดขึ้น

การจัดเก็บดัชนีทุติยภูมิในเครื่อง

ในการเขียนรายการตาราง DynamoDB จะคัดลอกแอตทริบิวต์ที่เหมาะสมโดยอัตโนมัติไปยังดัชนีรองภายในที่ต้องการ สิ่งนี้เรียกเก็บเงินจากบัญชีของคุณ ช่องว่างที่ใช้เป็นผลมาจากผลรวมของขนาดไบต์ของคีย์หลักของตารางขนาดไบต์แอ็ตทริบิวต์คีย์ดัชนีขนาดไบต์ของแอ็ตทริบิวต์ที่คาดการณ์ไว้และ 100 ไบต์ในค่าโสหุ้ยสำหรับแต่ละรายการดัชนี

การจัดเก็บโดยประมาณได้จากการประมาณขนาดรายการดัชนีโดยเฉลี่ยและคูณด้วยปริมาณรายการในตาราง

การใช้ Java เพื่อทำงานกับ Local Secondary Indexes

สร้างดัชนีรองในเครื่องโดยสร้างอินสแตนซ์คลาส DynamoDB ก่อน จากนั้นสร้างอินสแตนซ์คลาส CreateTableRequest พร้อมข้อมูลการร้องขอที่จำเป็น สุดท้ายใช้เมธอด createTable

ตัวอย่าง

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
String tableName = "Tools";  
CreateTableRequest createTableRequest = new 
   CreateTableRequest().withTableName(tableName);
   
//Provisioned Throughput
createTableRequest.setProvisionedThroughput (
   new ProvisionedThroughput()
   .withReadCapacityUnits((long)5)
   .withWriteCapacityUnits(( long)5));
   
//Attributes 
ArrayList<AttributeDefinition> attributeDefinitions = 
   new ArrayList<AttributeDefinition>();
   attributeDefinitions.add(new AttributeDefinition()
   .withAttributeName("Make")
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition()
   .withAttributeName("Model")
   .withAttributeType("S"));
   
attributeDefinitions.add(new AttributeDefinition()
   .withAttributeName("Line")
   .withAttributeType("S"));
   
createTableRequest.setAttributeDefinitions(attributeDefinitions);

//Key Schema 
ArrayList<KeySchemaElement> tableKeySchema = new 
   ArrayList<KeySchemaElement>();
   
tableKeySchema.add(new KeySchemaElement()
   .withAttributeName("Make")
   .withKeyType(KeyType.HASH));                    //Partition key
   
tableKeySchema.add(new KeySchemaElement()
   .withAttributeName("Model")
   .withKeyType(KeyType.RANGE));                   //Sort key
   
createTableRequest.setKeySchema(tableKeySchema);
ArrayList<KeySchemaElement> indexKeySchema = new 
   ArrayList<KeySchemaElement>();
   
indexKeySchema.add(new KeySchemaElement()
   .withAttributeName("Make")
   .withKeyType(KeyType.HASH));                   //Partition key
   
indexKeySchema.add(new KeySchemaElement()
   .withAttributeName("Line")
   .withKeyType(KeyType.RANGE));                   //Sort key
   
Projection projection = new Projection()
   .withProjectionType(ProjectionType.INCLUDE);

ArrayList<String> nonKeyAttributes = new ArrayList<String>(); 
nonKeyAttributes.add("Type"); 
nonKeyAttributes.add("Year"); 
projection.setNonKeyAttributes(nonKeyAttributes);  

LocalSecondaryIndex localSecondaryIndex = new LocalSecondaryIndex() 
   .withIndexName("ModelIndex")
   .withKeySchema(indexKeySchema)
   .withProjection(p rojection);  

ArrayList<LocalSecondaryIndex> localSecondaryIndexes = new 
   ArrayList<LocalSecondaryIndex>(); 

localSecondaryIndexes.add(localSecondaryIndex); 
createTableRequest.setLocalSecondaryIndexes(localSecondaryIndexes);  
Table table = dynamoDB.createTable(createTableRequest); 
System.out.println(table.getDescription());

ดึงข้อมูลเกี่ยวกับดัชนีรองในเครื่องด้วยวิธีการอธิบาย เพียงสร้างอินสแตนซ์คลาส DynamoDB สร้างอินสแตนซ์คลาส Table และส่งตารางไปยังเมธอดอธิบาย

ตัวอย่าง

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
   
String tableName = "Tools";
Table table = dynamoDB.getTable(tableName);
TableDescription tableDescription = table.describe();

List<LocalSecondaryIndexDescription> localSecondaryIndexes = 
   tableDescription.getLocalSecondaryIndexes();
   
Iterator<LocalSecondaryIndexDescription> lsiIter = 
   localSecondaryIndexes.iterator();
   
while (lsiIter.hasNext()) {  
   LocalSecondaryIndexDescription lsiDescription = lsiIter.next(); 
   System.out.println("Index info " + lsiDescription.getIndexName() + ":"); 
   Iterator<KeySchemaElement> kseIter = lsiDescription.getKeySchema().iterator(); 
   
   while (kseIter.hasNext()) { 
      KeySchemaElement kse = kseIter.next(); 
      System.out.printf("\t%s: %s\n", kse.getAttributeName(), kse.getKeyType()); 
   }
   
   Projection projection = lsiDescription.getProjection(); 
   System.out.println("\tProjection type: " + projection.getProjectionType()); 
   
   if (projection.getProjectionType().toString().equals("INCLUDE")) { 
      System.out.println("\t\tNon-key projected attributes: " + 
         projection.getNonKeyAttributes()); 
   } 
}

ดำเนินการสืบค้นโดยใช้ขั้นตอนเดียวกับแบบสอบถามตาราง เพียงแค่สร้างอินสแตนซ์คลาส DynamoDB, อินสแตนซ์คลาสตาราง, อินสแตนซ์คลาสดัชนี, อ็อบเจ็กต์เคียวรีและใช้วิธีเคียวรี

ตัวอย่าง

DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
   new ProfileCredentialsProvider()));
   
String tableName = "Tools";  
Table table = dynamoDB.getTable(tableName); 
Index index = table.getIndex("LineIndex");  
QuerySpec spec = new QuerySpec() 
   .withKeyConditionExpression("Make = :v_make and Line = :v_line") 
   .withValueMap(new ValueMap() 
   .withString(":v_make", "Depault") 
   .withString(":v_line", "SuperSawz"));
      
ItemCollection<QueryOutcome> items = index.query(spec);
Iterator<Item> itemsIter = items.iterator();

while (itemsIter.hasNext()) { 
   Item item = itemsIter.next(); 
   System.out.println(item.toJSONPretty()); 
}

คุณยังสามารถดูตัวอย่างต่อไปนี้

ตัวอย่างต่อไปนี้ยังใช้ Eclipse IDE, ไฟล์ข้อมูลรับรอง AWS และ AWS Toolkit ภายใน Eclipse AWS Java Project

ตัวอย่าง

import java.util.ArrayList;
import java.util.Iterator;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;

import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Index;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.PutItemOutcome;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;

import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.LocalSecondaryIndex;
import com.amazonaws.services.dynamodbv2.model.Projection;
import com.amazonaws.services.dynamodbv2.model.ProjectionType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ReturnConsumedCapacity;
import com.amazonaws.services.dynamodbv2.model.Select;

public class LocalSecondaryIndexSample {  
   static DynamoDB dynamoDB = new DynamoDB(new AmazonDynamoDBClient( 
      new ProfileCredentialsProvider()));  
   public static String tableName = "ProductOrders";  
   
   public static void main(String[] args) throws Exception {  
      createTable();
      query(null); 
      query("IsOpenIndex"); 
      query("OrderCreationDateIndex"); 
   }
   public static void createTable() { 
      CreateTableRequest createTableRequest = new CreateTableRequest() 
         .withTableName(tableName) 
         .withProvisionedThroughput(new ProvisionedThroughput() 
         .withReadCapacityUnits((long) 1) 
         .withWriteCapacityUnits((long) 1));
         
      // Table partition and sort keys attributes 
      ArrayList<AttributeDefinition> attributeDefinitions = new 
         ArrayList<AttributeDefinition>(); 
      
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("CustomerID") 
         .withAttributeType("S"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("OrderID") 
         .withAttributeType("N"));
         
      // Index primary key attributes 
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("OrderDate") 
         .withAttributeType("N"));
         
      attributeDefinitions.add(new AttributeDefinition() 
         .withAttributeName("OpenStatus") 
         .withAttributeType("N"));  
      createTableRequest.setAttributeDefinitions(attributeDefinitions);
      
      // Table key schema 
      ArrayList<KeySchemaElement> tableKeySchema = new
         ArrayList<KeySchemaElement>(); 
      tableKeySchema.add(new KeySchemaElement()  
         .withAttributeName("CustomerID") 
         .withKeyType(KeyType.HASH));                    //Partition key
         
      tableKeySchema.add(new KeySchemaElement() 
         .withAttributeName("OrderID") 
         .withKeyType(KeyType.RANGE));                   //Sort key
         
      createTableRequest.setKeySchema(tableKeySchema);  
      ArrayList<LocalSecondaryIndex> localSecondaryIndexes = new 
         ArrayList<LocalSecondaryIndex>();  
      
      // OrderDateIndex 
      LocalSecondaryIndex orderDateIndex = new LocalSecondaryIndex() 
         .withIndexName("OrderDateIndex");
         
      // OrderDateIndex key schema 
      ArrayList<KeySchemaElement> indexKeySchema = new 
         ArrayList<KeySchemaElement>(); 
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("CustomerID") 
         .withKeyType(KeyType.HASH));                   //Partition key
         
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("OrderDate") 
         .withKeyType(KeyType.RANGE));                   //Sort key
      orderDateIndex.setKeySchema(indexKeySchema);
      
      // OrderCreationDateIndex projection w/attributes list 
      Projection projection = new Projection() 
         .withProjectionType(ProjectionType.INCLUDE); 
      
      ArrayList<String> nonKeyAttributes = new ArrayList<String>(); 
      nonKeyAttributes.add("ProdCat"); 
      nonKeyAttributes.add("ProdNomenclature"); 
      projection.setNonKeyAttributes(nonKeyAttributes);
      orderCreationDateIndex.setProjection(projection);  
      localSecondaryIndexes.add(orderDateIndex);  
      
      // IsOpenIndex 
      LocalSecondaryIndex isOpenIndex = new LocalSecondaryIndex() 
         .withIndexName("IsOpenIndex");  
      
      // OpenStatusIndex key schema 
      indexKeySchema = new ArrayList<KeySchemaElement>(); 
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("CustomerID") 
         .withKeyType(KeyType.HASH));                   //Partition key
         
      indexKeySchema.add(new KeySchemaElement() 
         .withAttributeName("OpenStatus") 
         .withKeyType(KeyType.RANGE));                   //Sort key
         
      // OpenStatusIndex projection 
      projection = new Projection() .withProjectionType(ProjectionType.ALL);  
      OpenStatusIndex.setKeySchema(indexKeySchema); 
      OpenStatusIndex.setProjection(projection);  
      localSecondaryIndexes.add(OpenStatusIndex);  
      
      // Put definitions in CreateTable request 
      createTableRequest.setLocalSecondaryIndexes(localSecondaryIndexes);  
      System.out.println("Spawning table " + tableName + "..."); 
      System.out.println(dynamoDB.createTable(createTableRequest));  
      
      // Pause for ACTIVE status 
      System.out.println("Waiting for ACTIVE table:" + tableName); 
      try { 
         Table table = dynamoDB.getTable(tableName);
         table.waitForActive(); 
      } catch (InterruptedException e) { 
         e.printStackTrace(); 
      } 
   }
   public static void query(String indexName) {  
      Table table = dynamoDB.getTable(tableName);  
      System.out.println("\n*************************************************\n"); 
      System.out.println("Executing query on" + tableName);  
      QuerySpec querySpec = new QuerySpec() 
         .withConsistentRead(true) 
         .withScanIndexForward(true) 
         .withReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);
      
      if (indexName == "OpenStatusIndex") {  
         System.out.println("\nEmploying index: '" + indexName 
            + "' open orders for this customer.");
            
         System.out.println( 
            "Returns only user-specified attribute list\n"); 
         Index index = table.getIndex(indexName); 
             
         querySpec.withKeyConditionExpression("CustomerID = :v_custmid and 
            OpenStatus = :v_openstat") 
            .withValueMap(new ValueMap() 
            .withString(":v_custmid", "[email protected]") 
            .withNumber(":v_openstat", 1));  
         
         querySpec.withProjectionExpression( 
            "OrderDate, ProdCat, ProdNomenclature, OrderStatus"); 
            ItemCollection<QueryOutcome> items = index.query(querySpec); 
            Iterator<Item> iterator = items.iterator();  
            System.out.println("Printing query results...");  
            
         while (iterator.hasNext()) { 
            System.out.println(iterator.next().toJSONPretty()); 
         }  
      } else if (indexName == "OrderDateIndex") { 
         System.out.println("\nUsing index: '" + indexName 
            + "': this customer's orders placed after 05/22/2016."); 
         System.out.println("Projected attributes are returned\n"); 
         Index index = table.getIndex(indexName); 
             
         querySpec.withKeyConditionExpression("CustomerID = :v_custmid and OrderDate 
            >= :v_ordrdate") 
            .withValueMap(new ValueMap() 
            .withString(":v_custmid", "[email protected]") 
            .withNumber(":v_ordrdate", 20160522));
               
         querySpec.withSelect(Select.ALL_PROJECTED_ATTRIBUTES);  
         ItemCollection<QueryOutcome> items = index.query(querySpec); 
         Iterator<Item> iterator = items.iterator();  
         System.out.println("Printing query results...");  
            
         while (iterator.hasNext()) { 
            System.out.println(iterator.next().toJSONPretty()); 
         }  
      } else { 
         System.out.println("\nNo index: All Jane's orders by OrderID:\n"); 
         querySpec.withKeyConditionExpression("CustomerID = :v_custmid") 
            .withValueMap(new ValueMap()
            .withString(":v_custmid", "[email protected]"));  
         
         ItemCollection<QueryOutcome> items = table.query(querySpec); 
         Iterator<Item> iterator = items.iterator();  
         System.out.println("Printing query results...");  
         
         while (iterator.hasNext()) { 
            System.out.println(iterator.next().toJSONPretty()); 
         } 
      } 
   } 
}

DynamoDB ไม่มีฟังก์ชันการรวม คุณต้องใช้การสืบค้นการสแกนดัชนีและเครื่องมือต่างๆอย่างสร้างสรรค์เพื่อทำงานเหล่านี้ ด้วยเหตุนี้ค่าใช้จ่ายในการรับส่งข้อมูลของการสืบค้น / การสแกนในการดำเนินการเหล่านี้อาจมีมาก

คุณยังมีตัวเลือกในการใช้ไลบรารีและเครื่องมืออื่น ๆ สำหรับภาษาการเข้ารหัส DynamoDB ที่คุณต้องการ ตรวจสอบความเข้ากันได้กับ DynamoDB ก่อนใช้งาน

คำนวณสูงสุดหรือต่ำสุด

ใช้ลำดับการจัดเก็บผลลัพธ์จากน้อยไปหามากพารามิเตอร์ Limit และพารามิเตอร์ใด ๆ ที่กำหนดลำดับเพื่อค้นหาค่าสูงสุดและต่ำสุด

ตัวอย่างเช่น -

Map<String, AttributeValue> eaval = new HashMap<>(); 
eaval.put(":v1", new AttributeValue().withS("hashval")); 
queryExpression = new DynamoDBQueryExpression<Table>() 
   .withIndexName("yourindexname") 
   .withKeyConditionExpression("HK = :v1") 
   .withExpressionAttributeValues(values) 
   .withScanIndexForward(false);                //descending order 

queryExpression.setLimit(1); 
QueryResultPage<Lookup> res = 
   dynamoDBMapper.queryPage(Table.class, queryExpression);

คำนวณจำนวน

ใช้ DescribeTableอย่างไรก็ตามหากต้องการรับจำนวนรายการในตารางโปรดทราบว่ามีข้อมูลเก่า ใช้ JavagetScannedCount method.

ใช้ประโยชน์ LastEvaluatedKey เพื่อให้แน่ใจว่าจะให้ผลลัพธ์ทั้งหมด

ตัวอย่างเช่น -

ScanRequest scanRequest = new ScanRequest().withTableName(yourtblName); 
ScanResult yourresult = client.scan(scanRequest); 
System.out.println("#items:" + yourresult.getScannedCount());

การคำนวณค่าเฉลี่ยและผลรวม

ใช้ดัชนีและแบบสอบถาม / สแกนเพื่อดึงและกรองค่าก่อนประมวลผล จากนั้นก็ดำเนินการกับค่าเหล่านั้นผ่านวัตถุ

DynamoDB ใช้หนังสือรับรองที่คุณระบุเพื่อพิสูจน์ตัวตนคำขอ ข้อมูลรับรองเหล่านี้จำเป็นและต้องมีสิทธิ์สำหรับการเข้าถึงทรัพยากร AWS สิทธิ์เหล่านี้ครอบคลุมแทบทุกด้านของ DynamoDB ไปจนถึงคุณสมบัติย่อย ๆ ของการทำงานหรือฟังก์ชันการทำงาน

ประเภทของสิทธิ์

ในส่วนนี้เราจะพูดคุยเกี่ยวกับสิทธิ์ต่างๆและการเข้าถึงทรัพยากรใน DynamoDB

การพิสูจน์ตัวตนผู้ใช้

ในการสมัครใช้งานคุณได้ระบุรหัสผ่านและอีเมลซึ่งใช้เป็นข้อมูลรับรองรูท DynamoDB เชื่อมโยงข้อมูลนี้กับบัญชี AWS ของคุณและใช้ข้อมูลนี้เพื่อให้สามารถเข้าถึงทรัพยากรทั้งหมดได้อย่างสมบูรณ์

AWS ขอแนะนำให้คุณใช้ข้อมูลรับรองระดับรากของคุณสำหรับการสร้างบัญชีการดูแลระบบเท่านั้น สิ่งนี้ช่วยให้คุณสร้างบัญชี IAM / ผู้ใช้ที่มีสิทธิ์น้อยกว่า ผู้ใช้ IAM เป็นบัญชีอื่น ๆ ที่สร้างขึ้นด้วยบริการ IAM สิทธิ์การเข้าถึง / สิทธิ์ของพวกเขารวมถึงการเข้าถึงเพจที่ปลอดภัยและสิทธิ์ที่กำหนดเองบางอย่างเช่นการปรับเปลี่ยนตาราง

คีย์การเข้าถึงเป็นตัวเลือกอื่นสำหรับบัญชีเพิ่มเติมและการเข้าถึง ใช้เพื่อให้สิทธิ์การเข้าถึงและเพื่อหลีกเลี่ยงการให้สิทธิ์เข้าถึงด้วยตนเองในบางสถานการณ์ ผู้ใช้รวมเป็นอีกทางเลือกหนึ่งโดยอนุญาตให้เข้าถึงผ่านผู้ให้บริการข้อมูลประจำตัว

ธุรการ

ทรัพยากร AWS ยังคงอยู่ภายใต้การเป็นเจ้าของบัญชี นโยบายสิทธิ์ควบคุมสิทธิ์ที่มอบให้เพื่อวางไข่หรือเข้าถึงทรัพยากร ผู้ดูแลระบบเชื่อมโยงนโยบายสิทธิ์กับข้อมูลประจำตัว IAM ซึ่งหมายถึงบทบาทกลุ่มผู้ใช้และบริการ พวกเขายังแนบสิทธิ์ในทรัพยากร

สิทธิ์ระบุผู้ใช้ทรัพยากรและการดำเนินการ หมายเหตุผู้ดูแลระบบเป็นเพียงบัญชีที่มีสิทธิ์ของผู้ดูแลระบบ

การดำเนินงานและทรัพยากร

ตารางยังคงเป็นทรัพยากรหลักใน DynamoDB แหล่งข้อมูลย่อยทำหน้าที่เป็นทรัพยากรเพิ่มเติมเช่นสตรีมและดัชนี ทรัพยากรเหล่านี้ใช้ชื่อที่ไม่ซ้ำกันซึ่งบางส่วนได้กล่าวถึงในตารางต่อไปนี้ -

ประเภท	ARN (ชื่อทรัพยากร Amazon)
กระแส	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
ดัชนี	arn: aws: dynamodb: region: account-id: table / table-name / index / index-name
ตาราง	arn: aws: dynamodb: region: account-id: table / table-name

ความเป็นเจ้าของ

เจ้าของทรัพยากรถูกกำหนดให้เป็นบัญชี AWS ซึ่งสร้างทรัพยากรหรือบัญชีเอนทิตีหลักที่รับผิดชอบในการตรวจสอบคำขอในการสร้างทรัพยากร พิจารณาว่าฟังก์ชันนี้ภายในสภาพแวดล้อม DynamoDB เป็นอย่างไร -

ในการใช้ข้อมูลรับรองรูทเพื่อสร้างตารางบัญชีของคุณยังคงเป็นเจ้าของทรัพยากร
ในการสร้างผู้ใช้ IAM และให้สิทธิ์ผู้ใช้ในการสร้างตารางบัญชีของคุณยังคงเป็นเจ้าของทรัพยากร
ในการสร้างผู้ใช้ IAM และการให้สิทธิ์ผู้ใช้และทุกคนที่สามารถสมมติบทบาทได้รับอนุญาตในการสร้างตารางบัญชีของคุณจะยังคงเป็นเจ้าของทรัพยากร

จัดการการเข้าถึงทรัพยากร

การจัดการการเข้าถึงส่วนใหญ่ต้องให้ความสำคัญกับนโยบายสิทธิ์ที่อธิบายถึงผู้ใช้และการเข้าถึงทรัพยากร คุณเชื่อมโยงนโยบายกับข้อมูลประจำตัวหรือทรัพยากรของ IAM อย่างไรก็ตาม DynamoDB สนับสนุนนโยบาย IAM / identity เท่านั้น

นโยบายตามข้อมูลประจำตัว (IAM) ช่วยให้คุณสามารถให้สิทธิ์ได้ด้วยวิธีต่อไปนี้ -

แนบสิทธิ์ให้กับผู้ใช้หรือกลุ่ม
แนบสิทธิ์กับบทบาทสำหรับสิทธิ์ข้ามบัญชี

AWS อื่น ๆ อนุญาตให้ใช้นโยบายตามทรัพยากร นโยบายเหล่านี้อนุญาตให้เข้าถึงสิ่งต่างๆเช่นที่เก็บข้อมูล S3

องค์ประกอบนโยบาย

นโยบายกำหนดการกระทำผลกระทบทรัพยากรและหลักการ และให้สิทธิ์ในการดำเนินการเหล่านี้

Note - การดำเนินการ API อาจต้องการการอนุญาตสำหรับการดำเนินการหลายอย่าง

ดูองค์ประกอบนโยบายต่อไปนี้อย่างละเอียดยิ่งขึ้น -

Resource - ARN ระบุสิ่งนี้
Action - คำหลักระบุการดำเนินการทรัพยากรเหล่านี้และว่าจะอนุญาตหรือปฏิเสธ
Effect - ระบุเอฟเฟกต์สำหรับคำขอของผู้ใช้สำหรับการดำเนินการหมายถึงอนุญาตหรือปฏิเสธโดยมีการปฏิเสธเป็นค่าเริ่มต้น
Principal - เป็นการระบุผู้ใช้ที่แนบมากับนโยบาย

เงื่อนไข

ในการให้สิทธิ์คุณสามารถระบุเงื่อนไขเมื่อนโยบายเริ่มใช้งานได้เช่นในวันใดวันหนึ่ง แสดงเงื่อนไขด้วยคีย์เงื่อนไขซึ่งรวมถึงคีย์ AWS ทั้งระบบและคีย์ DynamoDB คีย์เหล่านี้จะกล่าวถึงโดยละเอียดในบทช่วยสอนในภายหลัง

สิทธิ์คอนโซล

ผู้ใช้ต้องการสิทธิ์พื้นฐานบางอย่างเพื่อใช้คอนโซล นอกจากนี้ยังต้องการสิทธิ์สำหรับคอนโซลในบริการมาตรฐานอื่น ๆ -

CloudWatch
ท่อส่งข้อมูล
การจัดการข้อมูลประจำตัวและการเข้าถึง
บริการแจ้งเตือน
Lambda

หากนโยบาย IAM พิสูจน์ได้ว่า จำกัด เกินไปผู้ใช้จะไม่สามารถใช้คอนโซลได้อย่างมีประสิทธิภาพ นอกจากนี้คุณไม่จำเป็นต้องกังวลเกี่ยวกับสิทธิ์ของผู้ใช้สำหรับผู้ที่เรียกใช้ CLI หรือ API เท่านั้น

นโยบาย Iam สำหรับการใช้งานทั่วไป

AWS ครอบคลุมการดำเนินการทั่วไปในสิทธิ์ด้วยนโยบายที่จัดการ IAM แบบสแตนด์อโลน พวกเขาให้การอนุญาตที่สำคัญซึ่งช่วยให้คุณหลีกเลี่ยงการตรวจสอบอย่างละเอียดเกี่ยวกับสิ่งที่คุณต้องให้

บางส่วนมีดังนี้ -

AmazonDynamoDBReadOnlyAccess - ให้การเข้าถึงแบบอ่านอย่างเดียวผ่านคอนโซล
AmazonDynamoDBFullAccess - ให้การเข้าถึงเต็มรูปแบบผ่านคอนโซล
AmazonDynamoDBFullAccesswithDataPipeline - ให้การเข้าถึงเต็มรูปแบบผ่านคอนโซลและอนุญาตให้ส่งออก / นำเข้าด้วย Data Pipeline

คุณยังสามารถสร้างนโยบายที่กำหนดเองได้

การให้สิทธิพิเศษ: การใช้เชลล์

คุณสามารถให้สิทธิ์โดยใช้เชลล์ Javascript โปรแกรมต่อไปนี้แสดงนโยบายการอนุญาตโดยทั่วไป -

{ 
   "Version": "2016-05-22", 
   "Statement": [ 
      { 
         "Sid": "DescribeQueryScanToolsTable", 
         "Effect": "Deny", 
         
         "Action": [ 
            "dynamodb:DescribeTable", 
            "dynamodb:Query", 
            "dynamodb:Scan" 
         ], 
         "Resource": "arn:aws:dynamodb:us-west-2:account-id:table/Tools" 
      } 
   ] 
}

คุณสามารถตรวจสอบสามตัวอย่างดังต่อไปนี้ -

Block the user from executing any table action.

{ 
   "Version": "2016-05-23", 
   "Statement": [ 
      { 
         "Sid": "AllAPIActionsOnTools", 
         "Effect": "Deny", 
         "Action": "dynamodb:*", 
         "Resource": "arn:aws:dynamodb:us-west-2:155556789012:table/Tools" 
      } 
   ] 
}

Block access to a table and its indices.

{ 
   "Version": "2016-05-23", 
   "Statement": [ 
      { 
         "Sid": "AccessAllIndexesOnTools", 
         "Effect": "Deny", 
         "Action": [
            "dynamodb:*" 
         ], 
         "Resource": [ 
            "arn:aws:dynamodb:us-west-2:155556789012:table/Tools", 
            "arn:aws:dynamodb:us-west-2:155556789012:table/Tools/index/*" 
         ] 
      } 
   ] 
}

Block a user from making a reserved capacity offering purchase.

{ 
   "Version": "2016-05-23", 
   "Statement": [ 
      { 
         "Sid": "BlockReservedCapacityPurchases", 
         "Effect": "Deny", 
         "Action": "dynamodb:PurchaseReservedCapacityOfferings", 
         "Resource": "arn:aws:dynamodb:us-west-2:155556789012:*" 
      } 
   ] 
}

การให้สิทธิพิเศษ: การใช้ GUI Console

คุณยังสามารถใช้คอนโซล GUI เพื่อสร้างนโยบาย IAM เริ่มต้นด้วยการเลือกTablesจากบานหน้าต่างนำทาง ในรายการตารางให้เลือกตารางเป้าหมายและทำตามขั้นตอนเหล่านี้

Step 1 - เลือกไฟล์ Access control แท็บ

Step 2- เลือกผู้ให้บริการข้อมูลประจำตัวการกระทำและคุณลักษณะนโยบาย เลือกCreate policy หลังจากเข้าสู่การตั้งค่าทั้งหมด

Step 3 - เลือก Attach policy instructionsและทำตามขั้นตอนที่จำเป็นแต่ละขั้นตอนเพื่อเชื่อมโยงนโยบายกับบทบาท IAM ที่เหมาะสม

DynamoDB API นำเสนอชุดการดำเนินการจำนวนมากซึ่งต้องใช้สิทธิ์ ในการตั้งค่าสิทธิ์คุณต้องสร้างการดำเนินการที่อนุญาตทรัพยากรที่อนุญาตและเงื่อนไขของแต่ละรายการ

คุณสามารถระบุการดำเนินการภายในฟิลด์การดำเนินการของนโยบาย ระบุมูลค่าทรัพยากรภายในฟิลด์ทรัพยากรของนโยบาย แต่ตรวจสอบให้แน่ใจว่าคุณใช้ไวยากรณ์ที่ถูกต้องซึ่งมีคำนำหน้า Dynamodb: กับการดำเนินการ API

ตัวอย่างเช่น - dynamodb:CreateTable

คุณยังสามารถใช้คีย์เงื่อนไขเพื่อกรองสิทธิ์

สิทธิ์และการดำเนินการ API

ดูการทำงานของ API และการอนุญาตที่เกี่ยวข้องที่ให้ไว้ในตารางต่อไปนี้ -

การทำงานของ API	การอนุญาตที่จำเป็น
BatchGetItem	dynamodb: BatchGetItem
BatchWriteItem	dynamodb: BatchWriteItem
CreateTable	dynamodb: CreateTable
DeleteItem	dynamodb: DeleteItem
DeleteTable	dynamodb: DeleteTable
อธิบายขีด จำกัด	dynamodb: DescribeLimits
DescribeReservedCapacity	dynamodb: DescribeReservedCapacity
DescribeReservedCapacityOfferings	dynamodb: DescribeReservedCapacityOfferings
อธิบายสตรีม	dynamodb: DescribeStream
DescribeTable	dynamodb: DescribeTable
GetItem	dynamodb: GetItem
GetRecords	dynamodb: GetRecords
GetShardIterator	dynamodb: GetShardIterator
ListStreams	dynamodb: ListStreams
ListTables	dynamodb: ListTables
PurchaseReservedCapacityOfferings	dynamodb: PurchaseReservedCapacityOfferings
PutItem	dynamodb: PutItem
แบบสอบถาม	dynamodb: แบบสอบถาม
สแกน	dynamodb: สแกน
UpdateItem	dynamodb: UpdateItem
UpdateTable	dynamodb: UpdateTable

ทรัพยากร

ในตารางต่อไปนี้คุณสามารถตรวจสอบทรัพยากรที่เกี่ยวข้องกับแต่ละการกระทำของ API ที่อนุญาต -

การทำงานของ API	ทรัพยากร
BatchGetItem	arn: aws: dynamodb: region: account-id: table / table-name
BatchWriteItem	arn: aws: dynamodb: region: account-id: table / table-name
CreateTable	arn: aws: dynamodb: region: account-id: table / table-name
DeleteItem	arn: aws: dynamodb: region: account-id: table / table-name
DeleteTable	arn: aws: dynamodb: region: account-id: table / table-name
อธิบายขีด จำกัด	arn: aws: dynamodb: region: account-id: *
DescribeReservedCapacity	arn: aws: dynamodb: region: account-id: *
DescribeReservedCapacityOfferings	arn: aws: dynamodb: region: account-id: *
อธิบายสตรีม	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
DescribeTable	arn: aws: dynamodb: region: account-id: table / table-name
GetItem	arn: aws: dynamodb: region: account-id: table / table-name
GetRecords	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
GetShardIterator	arn: aws: dynamodb: region: account-id: table / table-name / stream / stream-label
ListStreams	arn: aws: dynamodb: region: account-id: table / table-name / stream / *
ListTables	*
PurchaseReservedCapacityOfferings	arn: aws: dynamodb: region: account-id: *
PutItem	arn: aws: dynamodb: region: account-id: table / table-name
แบบสอบถาม	arn: aws: dynamodb: region: account-id: table / table-name หรือ arn: aws: dynamodb: region: account-id: table / table-name / index / index-name
สแกน	arn: aws: dynamodb: region: account-id: table / table-name หรือ arn: aws: dynamodb: region: account-id: table / table-name / index / index-name
UpdateItem	arn: aws: dynamodb: region: account-id: table / table-name
UpdateTable	arn: aws: dynamodb: region: account-id: table / table-name

ในการให้สิทธิ์ DynamoDB อนุญาตให้ระบุเงื่อนไขสำหรับเงื่อนไขเหล่านี้ผ่านนโยบาย IAM โดยละเอียดพร้อมด้วยคีย์เงื่อนไข รองรับการตั้งค่าเช่นการเข้าถึงรายการและแอตทริบิวต์เฉพาะ

Note - DynamoDB ไม่รองรับแท็กใด ๆ

การควบคุมโดยละเอียด

เงื่อนไขหลายประการอนุญาตให้มีความเฉพาะเจาะจงลงไปที่รายการและแอตทริบิวต์เช่นการอนุญาตให้เข้าถึงรายการเฉพาะตามบัญชีผู้ใช้ ใช้การควบคุมระดับนี้ด้วยนโยบาย IAM ที่มีเงื่อนไขซึ่งจะจัดการข้อมูลรับรองความปลอดภัย จากนั้นใช้นโยบายกับผู้ใช้กลุ่มและบทบาทที่ต้องการ Web Identity Federation ซึ่งเป็นหัวข้อที่จะกล่าวถึงในภายหลังยังมีวิธีควบคุมการเข้าถึงของผู้ใช้ผ่านการเข้าสู่ระบบของ Amazon, Facebook และ Google

องค์ประกอบเงื่อนไขของนโยบาย IAM ใช้การควบคุมการเข้าถึง คุณเพียงแค่เพิ่มลงในนโยบาย ตัวอย่างการใช้งานประกอบด้วยการปฏิเสธหรืออนุญาตให้เข้าถึงรายการตารางและแอตทริบิวต์ องค์ประกอบเงื่อนไขยังสามารถใช้คีย์เงื่อนไขเพื่อ จำกัด สิทธิ์

คุณสามารถตรวจสอบสองตัวอย่างต่อไปนี้ของคีย์เงื่อนไข -

dynamodb:LeadingKeys - ป้องกันการเข้าถึงรายการโดยผู้ใช้ที่ไม่มี ID ที่ตรงกับค่าคีย์พาร์ติชัน
dynamodb:Attributes - ป้องกันไม่ให้ผู้ใช้เข้าถึงหรือดำเนินการกับแอตทริบิวต์ภายนอกที่ระบุไว้

ในการประเมินผลนโยบาย IAM จะให้ผลลัพธ์เป็นค่าจริงหรือเท็จ หากส่วนใดประเมินว่าเป็นเท็จนโยบายทั้งหมดจะประเมินเป็นเท็จซึ่งส่งผลให้เกิดการปฏิเสธการเข้าถึง อย่าลืมระบุข้อมูลที่จำเป็นทั้งหมดในคีย์เงื่อนไขเพื่อให้แน่ใจว่าผู้ใช้สามารถเข้าถึงได้อย่างเหมาะสม

คีย์เงื่อนไขที่กำหนดไว้ล่วงหน้า

AWS มีชุดคีย์เงื่อนไขที่กำหนดไว้ล่วงหน้าซึ่งใช้กับบริการทั้งหมด รองรับการใช้งานที่หลากหลายและมีรายละเอียดในการตรวจสอบผู้ใช้และการเข้าถึง

Note - มีความไวของตัวพิมพ์เล็กและใหญ่ในปุ่มเงื่อนไข

คุณตรวจสอบการเลือกคีย์เฉพาะบริการต่อไปนี้ได้ -

dynamodb:LeadingKey- แสดงถึงคุณลักษณะหลักแรกของตาราง คีย์พาร์ติชัน ใช้ตัวปรับแต่ง ForAllValues ในเงื่อนไข
dynamodb:Select- แสดงถึงพารามิเตอร์การร้องขอการค้นหา / สแกนเลือก ต้องมีค่า ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES หรือ COUNT
dynamodb:Attributes- แสดงถึงรายการชื่อแอตทริบิวต์ภายในคำขอหรือแอตทริบิวต์ที่ส่งคืนจากคำขอ ค่าและฟังก์ชันคล้ายกับพารามิเตอร์การดำเนินการของ API เช่น BatchGetItem ใช้ AttributesToGet
dynamodb:ReturnValues - แสดงถึงพารามิเตอร์ ReturnValues ของคำขอและสามารถใช้ค่าเหล่านี้: ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW และ NONE
dynamodb:ReturnConsumedCapacity - แสดงถึงพารามิเตอร์ ReturnConsumedCapacity ของคำขอและสามารถใช้ค่าเหล่านี้: TOTAL และ NONE

Web Identity Federation ช่วยให้คุณลดความซับซ้อนในการพิสูจน์ตัวตนและการอนุญาตสำหรับกลุ่มผู้ใช้ขนาดใหญ่ คุณสามารถข้ามการสร้างบัญชีแต่ละบัญชีและกำหนดให้ผู้ใช้ต้องเข้าสู่ระบบผู้ให้บริการข้อมูลประจำตัวเพื่อรับข้อมูลรับรองหรือโทเค็นชั่วคราว ใช้ AWS Security Token Service (STS) เพื่อจัดการข้อมูลรับรอง แอปพลิเคชันใช้โทเค็นเหล่านี้เพื่อโต้ตอบกับบริการ

Web Identity Federation ยังสนับสนุนผู้ให้บริการข้อมูลประจำตัวอื่น ๆ เช่น - Amazon, Google และ Facebook

Function- ในการใช้งาน Web Identity Federation จะเรียกผู้ให้บริการข้อมูลประจำตัวสำหรับการตรวจสอบผู้ใช้และแอปก่อนและผู้ให้บริการจะส่งคืนโทเค็น ส่งผลให้แอปเรียก AWS STS และส่งโทเค็นเพื่อป้อนข้อมูล STS อนุญาตแอปและให้ข้อมูลรับรองการเข้าถึงชั่วคราวซึ่งอนุญาตให้แอปใช้บทบาท IAM และเข้าถึงทรัพยากรตามนโยบาย

การติดตั้ง Web Identity Federation

คุณต้องดำเนินการสามขั้นตอนต่อไปนี้ก่อนใช้งาน -

ใช้ผู้ให้บริการข้อมูลประจำตัวบุคคลที่สามที่รองรับเพื่อลงทะเบียนเป็นนักพัฒนา
ลงทะเบียนแอปพลิเคชันของคุณกับผู้ให้บริการเพื่อรับรหัสแอป
สร้างบทบาท IAM เดียวหรือหลายบทบาทรวมทั้งเอกสารแนบของนโยบาย คุณต้องใช้บทบาทต่อผู้ให้บริการต่อแอป

สมมติว่าหนึ่งในบทบาท IAM ของคุณเพื่อใช้ Web Identity Federation จากนั้นแอปของคุณจะต้องดำเนินการสามขั้นตอน -

Authentication
การได้มาซึ่งข้อมูลรับรอง
การเข้าถึงทรัพยากร

ในขั้นตอนแรกแอปของคุณจะใช้อินเทอร์เฟซของตัวเองเพื่อโทรหาผู้ให้บริการจากนั้นจัดการกระบวนการโทเค็น

จากนั้นขั้นตอนที่สองจัดการโทเค็นและกำหนดให้แอปของคุณส่งไฟล์ AssumeRoleWithWebIdentityร้องขอไปยัง AWS STS คำขอมีโทเค็นแรกรหัสแอปผู้ให้บริการและ ARN ของบทบาท IAM STS ให้ข้อมูลรับรองที่กำหนดให้หมดอายุหลังจากช่วงเวลาหนึ่ง

ในขั้นตอนสุดท้ายแอปของคุณจะได้รับการตอบกลับจาก STS ซึ่งมีข้อมูลการเข้าถึงทรัพยากร DynamoDB ประกอบด้วยข้อมูลรับรองการเข้าถึงเวลาหมดอายุบทบาทและ ID บทบาท

Data Pipeline อนุญาตให้ส่งออกและนำเข้าข้อมูลไปยัง / จากตารางไฟล์หรือที่เก็บข้อมูล S3 แน่นอนว่าสิ่งนี้มีประโยชน์ในการสำรองข้อมูลการทดสอบและสำหรับความต้องการหรือสถานการณ์ที่คล้ายคลึงกัน

ในการส่งออกคุณใช้คอนโซล Data Pipeline ซึ่งสร้างไปป์ไลน์ใหม่และเปิดใช้คลัสเตอร์ Amazon EMR (Elastic MapReduce) เพื่อทำการส่งออก EMR อ่านข้อมูลจาก DynamoDB และเขียนไปยังเป้าหมาย เราจะพูดถึง EMR โดยละเอียดในบทช่วยสอนนี้

ในการดำเนินการนำเข้าคุณใช้คอนโซล Data Pipeline ซึ่งสร้างไปป์ไลน์และเรียกใช้ EMR เพื่อดำเนินการนำเข้า มันอ่านข้อมูลจากต้นทางและเขียนไปยังปลายทาง

Note - การดำเนินการส่งออก / นำเข้ามีค่าใช้จ่ายตามบริการที่ใช้โดยเฉพาะ EMR และ S3

การใช้ Data Pipeline

คุณต้องระบุการดำเนินการและการอนุญาตทรัพยากรเมื่อใช้ Data Pipeline คุณสามารถใช้บทบาทหรือนโยบาย IAM เพื่อกำหนดได้ ผู้ใช้ที่กำลังดำเนินการนำเข้า / ส่งออกควรจดบันทึกว่าพวกเขาต้องการรหัสคีย์การเข้าถึงที่ใช้งานอยู่และรหัสลับ

บทบาท IAM สำหรับท่อส่งข้อมูล

คุณต้องมีบทบาท IAM สองบทบาทเพื่อใช้ Data Pipeline -

DataPipelineDefaultRole - นี่คือการกระทำทั้งหมดที่คุณอนุญาตให้ไปป์ไลน์ดำเนินการให้คุณ
DataPipelineDefaultResourceRole - มีทรัพยากรที่คุณอนุญาตให้ไปป์ไลน์จัดเตรียมให้คุณ

หากคุณยังใหม่กับ Data Pipeline คุณต้องวางบทบาทแต่ละบทบาท ผู้ใช้ก่อนหน้านี้ทั้งหมดมีบทบาทเหล่านี้เนื่องจากบทบาทที่มีอยู่

ใช้คอนโซล IAM เพื่อสร้างบทบาท IAM สำหรับ Data Pipeline และดำเนินการสี่ขั้นตอนต่อไปนี้ -

Step 1 - เข้าสู่ระบบคอนโซล IAM ที่อยู่ที่ https://console.aws.amazon.com/iam/

Step 2 - เลือก Roles จากแดชบอร์ด

Step 3 - เลือก Create New Role. จากนั้นป้อน DataPipelineDefaultRole ในไฟล์Role Name และเลือก Next Step. ในAWS Service Roles รายการใน Role Type พาเนลไปที่ Data Pipelineและเลือก Select. เลือกCreate Role ใน Review แผงหน้าปัด.

Step 4 - เลือก Create New Role.

ใช้ฟังก์ชันการนำเข้า / ส่งออกของ Data Pipeline เพื่อทำการสำรองข้อมูล วิธีดำเนินการสำรองข้อมูลขึ้นอยู่กับว่าคุณใช้คอนโซล GUI หรือใช้ Data Pipeline โดยตรง (API) สร้างไปป์ไลน์แยกกันสำหรับแต่ละตารางเมื่อใช้คอนโซลหรืออิมพอร์ต / เอ็กซ์พอร์ตหลายตารางในท่อเดียวหากใช้อ็อพชันโดยตรง

การส่งออกและนำเข้าข้อมูล

คุณต้องสร้างที่เก็บข้อมูล Amazon S3 ก่อนดำเนินการส่งออก คุณสามารถส่งออกจากตารางอย่างน้อยหนึ่งตาราง

ดำเนินกระบวนการสี่ขั้นตอนต่อไปนี้เพื่อดำเนินการส่งออก -

Step 1 - เข้าสู่ระบบ AWS Management Console และเปิดคอนโซล Data Pipeline ซึ่งอยู่ที่ https://console.aws.amazon.com/datapipeline/

Step 2 - หากคุณไม่มีไปป์ไลน์ในภูมิภาค AWS ให้เลือก Get started now. หากคุณมีอย่างน้อยหนึ่งรายการให้เลือกCreate new pipeline.

Step 3- ในหน้าการสร้างให้ป้อนชื่อไปป์ไลน์ของคุณ เลือกBuild using a templateสำหรับพารามิเตอร์ Source เลือกExport DynamoDB table to S3จากรายการ ป้อนตารางต้นทางในไฟล์Source DynamoDB table name ฟิลด์

ป้อนที่เก็บ S3 ปลายทางในไฟล์ Output S3 Folderกล่องข้อความโดยใช้รูปแบบต่อไปนี้: s3: // nameOfBucket / region / nameOfFolder ป้อนปลายทาง S3 สำหรับล็อกไฟล์S3 location for logs กล่องข้อความ.

Step 4 - เลือก Activate หลังจากเข้าสู่การตั้งค่าทั้งหมด

ไปป์ไลน์อาจใช้เวลาหลายนาทีกว่าจะเสร็จสิ้นกระบวนการสร้าง ใช้คอนโซลเพื่อตรวจสอบสถานะ ยืนยันการประมวลผลสำเร็จด้วยคอนโซล S3 โดยดูไฟล์ที่ส่งออก

การนำเข้าข้อมูล

การนำเข้าที่ประสบความสำเร็จจะเกิดขึ้นได้ก็ต่อเมื่อเงื่อนไขต่อไปนี้เป็นจริง: คุณสร้างตารางปลายทางปลายทางและต้นทางใช้ชื่อที่เหมือนกันและปลายทางและต้นทางใช้คีย์สคีมาที่เหมือนกัน

คุณสามารถใช้ตารางปลายทางที่เติมข้อมูลอย่างไรก็ตามการนำเข้าจะแทนที่รายการข้อมูลที่แชร์คีย์กับรายการต้นทางและยังเพิ่มรายการส่วนเกินลงในตาราง ปลายทางยังสามารถใช้ภูมิภาคอื่นได้

แม้ว่าคุณจะสามารถส่งออกแหล่งที่มาได้หลายแหล่ง แต่คุณสามารถนำเข้าได้เพียงรายการเดียวต่อการดำเนินการ คุณสามารถดำเนินการนำเข้าได้โดยปฏิบัติตามขั้นตอนต่อไปนี้ -

Step 1 - เข้าสู่ระบบ AWS Management Console จากนั้นเปิดคอนโซล Data Pipeline

Step 2 - หากคุณต้องการดำเนินการนำเข้าข้ามภูมิภาคคุณควรเลือกภูมิภาคปลายทาง

Step 3 - เลือก Create new pipeline.

Step 4 - ป้อนชื่อไปป์ไลน์ในไฟล์ Nameฟิลด์ เลือกBuild using a template สำหรับพารามิเตอร์ Source และในรายการเทมเพลตให้เลือก Import DynamoDB backup data from S3.

ป้อนตำแหน่งของไฟล์ต้นฉบับในไฟล์ Input S3 Folderกล่องข้อความ. ป้อนชื่อตารางปลายทางในไฟล์Target DynamoDB table nameฟิลด์ จากนั้นป้อนตำแหน่งของไฟล์บันทึกในไฟล์S3 location for logs กล่องข้อความ.

Step 5 - เลือก Activate หลังจากเข้าสู่การตั้งค่าทั้งหมด

การนำเข้าเริ่มต้นทันทีหลังจากการสร้างไปป์ไลน์ ไปป์ไลน์อาจใช้เวลาหลายนาทีเพื่อให้กระบวนการสร้างเสร็จสมบูรณ์

ข้อผิดพลาด

เมื่อเกิดข้อผิดพลาดคอนโซล Data Pipeline จะแสดง ERROR เป็นสถานะไปป์ไลน์ การคลิกไปป์ไลน์ที่มีข้อผิดพลาดจะนำคุณไปยังหน้ารายละเอียดซึ่งจะแสดงทุกขั้นตอนของกระบวนการและจุดที่เกิดความล้มเหลว ไฟล์บันทึกภายในยังให้ข้อมูลเชิงลึก

คุณสามารถตรวจสอบสาเหตุทั่วไปของข้อผิดพลาดได้ดังนี้ -

ไม่มีตารางปลายทางสำหรับการนำเข้าหรือไม่ได้ใช้คีย์สคีมาที่เหมือนกันกับต้นทาง
ไม่มีที่เก็บข้อมูล S3 หรือคุณไม่มีสิทธิ์ในการอ่าน / เขียน
ไปป์ไลน์หมดเวลา
คุณไม่มีสิทธิ์ในการส่งออก / นำเข้าที่จำเป็น
บัญชี AWS ของคุณถึงขีด จำกัด ทรัพยากรแล้ว

Amazon เสนอ CloudWatch สำหรับการรวมและวิเคราะห์ประสิทธิภาพผ่านคอนโซล CloudWatch บรรทัดคำสั่งหรือ CloudWatch API คุณยังสามารถใช้เพื่อตั้งปลุกและทำงานต่างๆ ดำเนินการตามที่ระบุในเหตุการณ์บางอย่าง

คอนโซล Cloudwatch

ใช้ประโยชน์จาก CloudWatch โดยเข้าถึงคอนโซลการจัดการจากนั้นเปิดคอนโซล CloudWatch ที่ https://console.aws.amazon.com/cloudwatch/.

จากนั้นคุณสามารถทำตามขั้นตอนต่อไปนี้ -

เลือก Metrics จากบานหน้าต่างนำทาง
ภายใต้เมตริก DynamoDB ภายใน CloudWatch Metrics by Category บานหน้าต่างเลือก Table Metrics.
ใช้บานหน้าต่างด้านบนเพื่อเลื่อนไปด้านล่างและตรวจสอบรายการเมตริกตารางทั้งหมด Viewing รายการมีตัวเลือกเมตริก

ในอินเทอร์เฟซผลลัพธ์คุณสามารถเลือก / ยกเลิกการเลือกแต่ละเมตริกได้โดยเลือกช่องทำเครื่องหมายข้างชื่อทรัพยากรและเมตริก จากนั้นคุณจะสามารถดูกราฟของแต่ละรายการได้

การรวม API

คุณสามารถเข้าถึง CloudWatch ได้ด้วยแบบสอบถาม ใช้ค่าเมตริกเพื่อดำเนินการกับ CloudWatch หมายเหตุ DynamoDB ไม่ส่งเมทริกที่มีค่าเป็นศูนย์ เพียงข้ามเมตริกสำหรับช่วงเวลาที่เมตริกเหล่านั้นยังคงอยู่ที่ค่านั้น

ต่อไปนี้เป็นเมตริกที่ใช้บ่อยที่สุด -

ConditionalCheckFailedRequests- ติดตามปริมาณความพยายามที่ล้มเหลวในการเขียนแบบมีเงื่อนไขเช่นการเขียน PutItem แบบมีเงื่อนไข ความล้มเหลวเขียนเพิ่มเมตริกนี้ทีละรายการเมื่อประเมินเป็นเท็จ นอกจากนี้ยังแสดงข้อผิดพลาด HTTP 400
ConsumedReadCapacityUnits- จะวัดปริมาณหน่วยความจุที่ใช้ในช่วงเวลาหนึ่ง คุณสามารถใช้สิ่งนี้เพื่อตรวจสอบปริมาณการใช้ตารางและดัชนีแต่ละรายการ
ConsumedWriteCapacityUnits- จะวัดปริมาณหน่วยความจุที่ใช้ในช่วงเวลาหนึ่ง คุณสามารถใช้สิ่งนี้เพื่อตรวจสอบปริมาณการใช้ตารางและดัชนีแต่ละรายการ
ReadThrottleEvents- เป็นการระบุปริมาณคำขอที่เกินหน่วยความจุที่จัดเตรียมไว้ในตาราง / ดัชนีที่อ่านได้ มันจะเพิ่มขึ้นในแต่ละเค้นรวมถึงการดำเนินการแบทช์ที่มีหลายเค้น
ReturnedBytes - จะวัดปริมาณไบต์ที่ส่งคืนในการดำเนินการดึงข้อมูลภายในช่วงเวลาหนึ่ง
ReturnedItemCount- จะวัดปริมาณรายการที่ส่งคืนในการดำเนินการ Query and Scan ในช่วงเวลาหนึ่ง ระบุเฉพาะรายการที่ส่งคืนไม่ใช่รายการที่ประเมินซึ่งโดยทั่วไปแล้วจะเป็นตัวเลขที่แตกต่างกันโดยสิ้นเชิง

Note - มีเมตริกอื่น ๆ อีกมากมายที่มีอยู่และส่วนใหญ่ช่วยให้คุณสามารถคำนวณค่าเฉลี่ยผลรวมสูงสุดต่ำสุดและจำนวนได้

DynamoDB มีการรวม CloudTrail รวบรวมคำขอ API ระดับต่ำจากหรือสำหรับ DynamoDB ในบัญชีและส่งไฟล์บันทึกไปยังที่เก็บข้อมูล S3 ที่ระบุ กำหนดเป้าหมายการโทรจากคอนโซลหรือ API คุณสามารถใช้ข้อมูลนี้เพื่อกำหนดคำขอที่สร้างขึ้นและแหล่งที่มาผู้ใช้การประทับเวลาและอื่น ๆ

เมื่อเปิดใช้งานจะติดตามการดำเนินการในไฟล์บันทึกซึ่งรวมถึงบันทึกบริการอื่น ๆ รองรับแปดการกระทำและสองสตรีม -

การกระทำทั้งแปดมีดังต่อไปนี้ -

CreateTable
DeleteTable
DescribeTable
ListTables
UpdateTable
DescribeReservedCapacity
DescribeReservedCapacityOfferings
PurchaseReservedCapacityOfferings

ในขณะที่สองกระแสคือ -

DescribeStream
ListStreams

บันทึกทั้งหมดมีข้อมูลเกี่ยวกับบัญชีที่ส่งคำขอ คุณสามารถกำหนดข้อมูลโดยละเอียดเช่นว่าผู้ใช้ root หรือ IAM เป็นผู้ร้องขอหรือไม่หรือใช้ข้อมูลประจำตัวชั่วคราวหรือ federated

ไฟล์บันทึกจะยังคงอยู่ในที่จัดเก็บเป็นเวลานานเท่าที่คุณระบุพร้อมการตั้งค่าสำหรับการเก็บถาวรและการลบ ค่าเริ่มต้นจะสร้างบันทึกที่เข้ารหัส คุณสามารถตั้งค่าการแจ้งเตือนสำหรับบันทึกใหม่ได้ คุณยังสามารถจัดระเบียบบันทึกหลายรายการตามภูมิภาคและบัญชีให้เป็นที่เก็บข้อมูลเดียว

การตีความไฟล์บันทึก

แต่ละไฟล์มีรายการเดียวหรือหลายรายการ แต่ละรายการประกอบด้วยเหตุการณ์รูปแบบ JSON หลายรายการ รายการแสดงถึงคำขอและรวมถึงข้อมูลที่เกี่ยวข้อง โดยไม่รับประกันการสั่งซื้อ

คุณสามารถตรวจสอบไฟล์บันทึกตัวอย่างต่อไปนี้ -

{"Records": [ 
   { 
      "eventVersion": "5.05",  
      "userIdentity": {
         "type": "AssumedRole", 
         "principalId": "AKTTIOSZODNN8SAMPLE:jane", 
         "arn": "arn:aws:sts::155522255533:assumed-role/users/jane", 
         "accountId": "155522255533", 
         "accessKeyId": "AKTTIOSZODNN8SAMPLE", 
         
         "sessionContext": { 
            "attributes": { 
               "mfaAuthenticated": "false", 
               "creationDate": "2016-05-11T19:01:01Z" 
            },
            
            "sessionIssuer": { 
               "type": "Role", 
               "principalId": "AKTTI44ZZ6DHBSAMPLE", 
               "arn": "arn:aws:iam::499955777666:role/admin-role", 
               "accountId": "499955777666", 
               "userName": "jill" 
            } 
         } 
      },
      
      "eventTime": "2016-05-11T14:33:20Z", 
      "eventSource": "dynamodb.amazonaws.com", 
      "eventName": "DeleteTable", 
      "awsRegion": "us-west-2", 
      "sourceIPAddress": "192.0.2.0", 
      "userAgent": "console.aws.amazon.com", 
      "requestParameters": {"tableName": "Tools"}, 
      
      "responseElements": {"tableDescription": { 
         "tableName": "Tools", 
         "itemCount": 0, 
         
         "provisionedThroughput": { 
            "writeCapacityUnits": 25, 
            "numberOfDecreasesToday": 0, 
            "readCapacityUnits": 25 
         },
         "tableStatus": "DELETING", 
         "tableSizeBytes": 0
      }},
      "requestID": "4D89G7D98GF7G8A7DF78FG89AS7GFSO5AEMVJF66Q9ASUAAJG", 
      "eventID": "a954451c-c2fc-4561-8aea-7a30ba1fdf52", 
      "eventType": "AwsApiCall", 
      "apiVersion": "2013-04-22", 
      "recipientAccountId": "155522255533" 
   } 
]}

Elastic MapReduce (EMR) ของ Amazon ช่วยให้คุณประมวลผลข้อมูลขนาดใหญ่ได้อย่างรวดเร็วและมีประสิทธิภาพ EMR เรียกใช้ Apache Hadoop บนอินสแตนซ์ EC2 แต่ทำให้กระบวนการง่ายขึ้น คุณใช้ Apache Hiveเพื่อค้นหาแผนที่เพื่อลดการไหลของงานผ่านHiveQLซึ่งเป็นภาษาแบบสอบถามที่คล้ายกับ SQL Apache Hive ทำหน้าที่เป็นวิธีเพิ่มประสิทธิภาพการสืบค้นและแอปพลิเคชันของคุณ

คุณสามารถใช้แท็บ EMR ของคอนโซลการจัดการ, EMR CLI, API หรือ SDK เพื่อเปิดใช้งานโฟลว์งาน คุณยังมีตัวเลือกในการเรียกใช้ Hive แบบโต้ตอบหรือใช้สคริปต์

การดำเนินการอ่าน / เขียน EMR ส่งผลกระทบต่อปริมาณการใช้งานอย่างไรก็ตามในคำขอขนาดใหญ่จะดำเนินการอีกครั้งด้วยการป้องกันอัลกอริทึมแบ็คออฟ นอกจากนี้การเรียกใช้ EMR ควบคู่ไปกับการดำเนินการและงานอื่น ๆ อาจส่งผลให้เกิดการควบคุมปริมาณ

การรวม DynamoDB / EMR ไม่สนับสนุนแอตทริบิวต์ชุดไบนารีและชุดไบนารี

ข้อกำหนดเบื้องต้นในการรวม DynamoDB / EMR

ตรวจสอบรายการตรวจสอบที่จำเป็นก่อนใช้ EMR -

บัญชี AWS
ตารางที่เติมข้อมูลภายใต้บัญชีเดียวกันที่ใช้ในการดำเนินการ EMR
เวอร์ชัน Hive ที่กำหนดเองพร้อมการเชื่อมต่อ DynamoDB
รองรับการเชื่อมต่อ DynamoDB
ถัง S3 (ทางเลือก)
ไคลเอนต์ SSH (ทางเลือก)
คู่คีย์ EC2 (อุปกรณ์เสริม)

การตั้งค่าไฮฟ์

ก่อนใช้ EMR ให้สร้างคู่คีย์เพื่อเรียกใช้ Hive ในโหมดโต้ตอบ คู่คีย์อนุญาตให้เชื่อมต่อกับอินสแตนซ์ EC2 และโหนดหลักของโฟลว์งาน

คุณสามารถทำได้โดยทำตามขั้นตอนต่อไป -

ล็อกอินเข้าสู่คอนโซลการจัดการและเปิดคอนโซล EC2 ที่อยู่ที่ https://console.aws.amazon.com/ec2/
เลือกภูมิภาคในส่วนบนขวามือของคอนโซล ตรวจสอบว่าภูมิภาคนั้นตรงกับภูมิภาค DynamoDB
ในบานหน้าต่างนำทางเลือก Key Pairs.
เลือก Create Key Pair.
ใน Key Pair Name ป้อนชื่อและเลือก Create.
ดาวน์โหลดไฟล์คีย์ส่วนตัวที่เป็นผลลัพธ์ซึ่งใช้รูปแบบต่อไปนี้: filename.pem

Note - คุณไม่สามารถเชื่อมต่อกับอินสแตนซ์ EC2 หากไม่มีคู่คีย์

กลุ่มไฮฟ์

สร้างคลัสเตอร์ที่เปิดใช้งานกลุ่มเพื่อเรียกใช้ Hive สร้างสภาพแวดล้อมที่จำเป็นของแอปพลิเคชันและโครงสร้างพื้นฐานสำหรับการเชื่อมต่อ Hive-to-DynamoDB

คุณสามารถทำงานนี้ได้โดยใช้ขั้นตอนต่อไปนี้ -

เข้าถึงคอนโซล EMR
เลือก Create Cluster.
ในหน้าจอการสร้างตั้งค่าการกำหนดค่าคลัสเตอร์ด้วยชื่อที่สื่อความหมายสำหรับคลัสเตอร์เลือก Yes สำหรับการป้องกันการยกเลิกและตรวจสอบ Enabled สำหรับการบันทึกปลายทาง S3 สำหรับ log folder S3 locationและ Enabled สำหรับการดีบัก
ในหน้าจอการกำหนดค่าซอฟต์แวร์ตรวจสอบให้แน่ใจว่ามีฟิลด์ค้างไว้ Amazon สำหรับการแจกจ่าย Hadoop เวอร์ชันล่าสุดสำหรับเวอร์ชัน AMI เวอร์ชัน Hive เริ่มต้นสำหรับแอปพลิเคชันที่จะติดตั้ง -Hive และเวอร์ชัน Pig เริ่มต้นสำหรับแอปพลิเคชันที่จะติดตั้ง -PG
ในหน้าจอการกำหนดค่าฮาร์ดแวร์ตรวจสอบให้แน่ใจว่ามีฟิลด์ค้างไว้ Launch into EC2-Classic สำหรับเครือข่าย No Preference สำหรับ EC2 Availability Zone ค่าเริ่มต้นสำหรับ Master-Amazon EC2 Instance Type ไม่มีการตรวจสอบ Request Spot Instance ค่าเริ่มต้นสำหรับ Core-Amazon EC2 Instance Type 2 สำหรับ Count ไม่ต้องตรวจสอบอินสแตนซ์ Request Spot ซึ่งเป็นค่าเริ่มต้นสำหรับประเภทอินสแตนซ์ Task-Amazon EC2 0 สำหรับ Count และไม่ตรวจสอบอินสแตนซ์ Request Spot

อย่าลืมกำหนดขีด จำกัด ที่ให้ความจุเพียงพอเพื่อป้องกันความล้มเหลวของคลัสเตอร์

ในหน้าจอความปลอดภัยและการเข้าถึงตรวจสอบให้แน่ใจว่าช่องมีคู่คีย์ของคุณในคู่คีย์ EC2 No other IAM users ในการเข้าถึงของผู้ใช้ IAM และ Proceed without roles ในบทบาท IAM
ตรวจสอบหน้าจอ Bootstrap Actions แต่อย่าแก้ไข
ตรวจสอบการตั้งค่าและเลือก Create Cluster เมื่อเสร็จแล้ว.

ก Summary บานหน้าต่างปรากฏขึ้นที่จุดเริ่มต้นของคลัสเตอร์

เปิดใช้งาน SSH Session

คุณต้องมีเซสชัน SSH ที่ใช้งานอยู่เพื่อเชื่อมต่อกับโหนดหลักและดำเนินการ CLI ค้นหาโหนดหลักโดยเลือกคลัสเตอร์ในคอนโซล EMR มันแสดงรายการโหนดหลักเป็นMaster Public DNS Name.

ติดตั้ง PuTTY หากคุณไม่มี จากนั้นเปิด PuTTYgen และเลือกLoad. เลือกไฟล์ PEM ของคุณแล้วเปิดขึ้นมา PuTTYgen จะแจ้งให้คุณทราบถึงการนำเข้าที่ประสบความสำเร็จ เลือกSave private key เพื่อบันทึกในรูปแบบคีย์ส่วนตัว PuTTY (PPK) แล้วเลือก Yesสำหรับการบันทึกโดยไม่มีวลีรหัสผ่าน จากนั้นป้อนชื่อสำหรับปุ่ม PuTTY กดSaveและปิด PuTTYgen

ใช้ PuTTY เพื่อเชื่อมต่อกับโหนดหลักโดยเริ่ม PuTTY ก่อน เลือกSessionจากรายการหมวดหมู่ ป้อน hadoop @ DNS ภายในช่องชื่อโฮสต์ ขยายConnection > SSH ในรายการประเภทและเลือก Auth. ในหน้าจอตัวเลือกการควบคุมเลือกBrowseสำหรับไฟล์คีย์ส่วนตัวสำหรับการพิสูจน์ตัวตน จากนั้นเลือกไฟล์คีย์ส่วนตัวของคุณและเปิด เลือกYes สำหรับป๊อปอัปการแจ้งเตือนความปลอดภัย

เมื่อเชื่อมต่อกับโหนดหลักพรอมต์คำสั่ง Hadoop จะปรากฏขึ้นซึ่งหมายความว่าคุณสามารถเริ่มเซสชัน Hive แบบโต้ตอบได้

ตารางไฮฟ์

Hive ทำหน้าที่เป็นเครื่องมือที่ช่วยให้คลังข้อมูลแบบสอบถามในกลุ่ม EMR ใช้HiveQL การตั้งค่าก่อนหน้านี้ทำให้คุณมีพร้อมท์ในการทำงาน เรียกใช้คำสั่ง Hive แบบโต้ตอบโดยเพียงแค่ป้อน“ hive” จากนั้นคำสั่งใด ๆ ที่คุณต้องการ ดูกวดวิชาไฮฟ์ของเราสำหรับข้อมูลเพิ่มเติมเกี่ยวกับไฮฟ์

สตรีม DynamoDB ช่วยให้คุณติดตามและตอบสนองต่อการเปลี่ยนแปลงรายการตาราง ใช้ฟังก์ชันนี้เพื่อสร้างแอปพลิเคชันที่ตอบสนองต่อการเปลี่ยนแปลงโดยการอัปเดตข้อมูลจากแหล่งต่างๆ ซิงโครไนซ์ข้อมูลสำหรับผู้ใช้หลายพันคนในระบบผู้ใช้ขนาดใหญ่หลายคน ใช้เพื่อส่งการแจ้งเตือนไปยังผู้ใช้เกี่ยวกับการอัปเดต การใช้งานพิสูจน์ได้ว่ามีความหลากหลายและมีสาระสำคัญ สตรีม DynamoDB ทำหน้าที่เป็นเครื่องมือหลักที่ใช้ในการทำงานนี้

สตรีมรวบรวมลำดับเวลาที่มีการปรับเปลี่ยนรายการภายในตาราง พวกเขาเก็บข้อมูลนี้ไว้สูงสุด 24 ชั่วโมง แอปพลิเคชั่นใช้เพื่อดูรายการต้นฉบับและรายการที่แก้ไขเกือบแบบเรียลไทม์

สตรีมที่เปิดใช้งานบนตารางจะจับการแก้ไขทั้งหมด ในการดำเนินการ CRUD ใด ๆ DynamoDB จะสร้างสตรีมเร็กคอร์ดที่มีแอ็ตทริบิวต์คีย์หลักของไอเท็มที่แก้ไข คุณสามารถกำหนดค่าสตรีมสำหรับข้อมูลเพิ่มเติมเช่นภาพก่อนและหลัง

สตรีมมีการค้ำประกันสองครั้ง -

แต่ละระเบียนจะปรากฏหนึ่งครั้งในสตรีมและ
การปรับเปลี่ยนแต่ละรายการจะส่งผลให้สตรีมเร็กคอร์ดมีลำดับเดียวกันกับการปรับเปลี่ยน

สตรีมทั้งหมดประมวลผลแบบเรียลไทม์เพื่อให้คุณใช้งานได้สำหรับฟังก์ชันที่เกี่ยวข้องในแอปพลิเคชัน

การจัดการสตรีม

ในการสร้างตารางคุณสามารถเปิดใช้งานสตรีมได้ ตารางที่มีอยู่อนุญาตให้ปิดสตรีมหรือเปลี่ยนแปลงการตั้งค่า สตรีมมีคุณลักษณะของการทำงานแบบอะซิงโครนัสซึ่งหมายความว่าไม่มีผลกระทบต่อประสิทธิภาพของตาราง

ใช้คอนโซล AWS Management สำหรับการจัดการสตรีมอย่างง่าย ขั้นแรกไปที่คอนโซลและเลือกTables. ในแท็บภาพรวมให้เลือกManage Stream. ภายในหน้าต่างเลือกข้อมูลที่เพิ่มลงในสตรีมเกี่ยวกับการแก้ไขข้อมูลตาราง หลังจากเข้าสู่การตั้งค่าทั้งหมดแล้วให้เลือกEnable.

หากคุณต้องการปิดใช้งานสตรีมที่มีอยู่ให้เลือก Manage Streamและจากนั้น Disable.

คุณยังสามารถใช้ APIs CreateTable และ UpdateTable เพื่อเปิดใช้งานหรือเปลี่ยนสตรีม ใช้พารามิเตอร์ StreamSpecification เพื่อกำหนดค่าสตรีม StreamEnabled ระบุสถานะซึ่งหมายถึงจริงสำหรับเปิดใช้งานและเท็จสำหรับปิดใช้งาน

StreamViewType ระบุข้อมูลที่เพิ่มในสตรีม: KEYS_ONLY, NEW_IMAGE, OLD_IMAGE และ NEW_AND_OLD_IMAGES

การอ่านสตรีม

อ่านและประมวลผลสตรีมโดยเชื่อมต่อกับปลายทางและสร้างคำขอ API แต่ละสตรีมประกอบด้วยสตรีมเร็กคอร์ดและทุกเร็กคอร์ดจะมีการปรับเปลี่ยนเพียงครั้งเดียวซึ่งเป็นเจ้าของสตรีม ระเบียนสตรีมประกอบด้วยหมายเลขลำดับที่เปิดเผยลำดับการเผยแพร่ ระเบียนอยู่ในกลุ่มหรือที่เรียกว่าเศษ Shards ทำหน้าที่เป็นภาชนะบรรจุสำหรับบันทึกหลายรายการและยังเก็บข้อมูลที่จำเป็นสำหรับการเข้าถึงและการสำรวจบันทึก หลังจาก 24 ชั่วโมงบันทึกจะถูกลบโดยอัตโนมัติ

Shards เหล่านี้สร้างและลบได้ตามต้องการและใช้เวลาไม่นาน นอกจากนี้ยังแบ่งออกเป็นเศษใหม่หลาย ๆ ชิ้นโดยอัตโนมัติโดยทั่วไปจะตอบสนองต่อการเขียนกิจกรรมที่เพิ่มขึ้นอย่างรวดเร็ว เมื่อปิดการสตรีมให้เปิดชาร์ดปิด ความสัมพันธ์ตามลำดับชั้นระหว่างชาร์ดหมายถึงแอปพลิเคชันต้องจัดลำดับความสำคัญของชาร์ดหลักเพื่อให้ลำดับการประมวลผลถูกต้อง คุณสามารถใช้ Kinesis Adapter เพื่อดำเนินการนี้โดยอัตโนมัติ

Note - การดำเนินการที่ไม่มีการเปลี่ยนแปลงอย่าเขียนบันทึกสตรีม

การเข้าถึงและการประมวลผลบันทึกจำเป็นต้องปฏิบัติงานต่อไปนี้ -

กำหนด ARN ของสตรีมเป้าหมาย
กำหนดชาร์ดของสตรีมที่เก็บบันทึกเป้าหมาย
เข้าถึงชาร์ดเพื่อดึงข้อมูลที่ต้องการ

Note- ควรมีสูงสุด 2 กระบวนการอ่านชาร์ดในครั้งเดียว หากเกิน 2 กระบวนการก็สามารถเค้นแหล่งที่มาได้

การดำเนินการสตรีม API ที่มีให้ ได้แก่

ListStreams
DescribeStream
GetShardIterator
GetRecords

คุณสามารถดูตัวอย่างการอ่านสตรีมต่อไปนี้ -

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBStreamsClient;

import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;

import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeStreamRequest;
import com.amazonaws.services.dynamodbv2.model.DescribeStreamResult;
import com.amazonaws.services.dynamodbv2.model.DescribeTableResult;

import com.amazonaws.services.dynamodbv2.model.GetRecordsRequest;
import com.amazonaws.services.dynamodbv2.model.GetRecordsResult;
import com.amazonaws.services.dynamodbv2.model.GetShardIteratorRequest;
import com.amazonaws.services.dynamodbv2.model.GetShardIteratorResult;

import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.Record;

import com.amazonaws.services.dynamodbv2.model.Shard;
import com.amazonaws.services.dynamodbv2.model.ShardIteratorType;
import com.amazonaws.services.dynamodbv2.model.StreamSpecification;
import com.amazonaws.services.dynamodbv2.model.StreamViewType;
import com.amazonaws.services.dynamodbv2.util.Tables;

public class StreamsExample {
   private static AmazonDynamoDBClient dynamoDBClient =  
      new AmazonDynamoDBClient(new ProfileCredentialsProvider());  
   private static AmazonDynamoDBStreamsClient streamsClient =  
      new AmazonDynamoDBStreamsClient(new ProfileCredentialsProvider());  

   public static void main(String args[]) {  
      dynamoDBClient.setEndpoint("InsertDbEndpointHere");   
      streamsClient.setEndpoint("InsertStreamEndpointHere");    
      
      // table creation 
      String tableName = "MyTestingTable";  
      ArrayList<AttributeDefinition> attributeDefinitions =  
         new ArrayList<AttributeDefinition>();  
      
      attributeDefinitions.add(new AttributeDefinition()
         .withAttributeName("ID") 
         .withAttributeType("N"));
         
      ArrayList<KeySchemaElement> keySchema = new 
         ArrayList<KeySchemaElement>(); 
      
      keySchema.add(new KeySchemaElement() 
         .withAttributeName("ID") 
         .withKeyType(KeyType.HASH));                       //Partition key

      StreamSpecification streamSpecification = new StreamSpecification(); 
      streamSpecification.setStreamEnabled(true); 
      streamSpecification.setStreamViewType(StreamViewType.NEW_AND_OLD_IMAGES);  
      CreateTableRequest createTableRequest = new CreateTableRequest() 
         .withTableName(tableName) 
         .withKeySchema(keySchema) 
         .withAttributeDefinitions(attributeDefinitions) 
         .withProvisionedThroughput(new ProvisionedThroughput() 
         .withReadCapacityUnits(1L) 
         .withWriteCapacityUnits(1L))
         .withStreamSpecification(streamSpecification);  
      
      System.out.println("Executing CreateTable for " + tableName); 
      dynamoDBClient.createTable(createTableRequest);  
      System.out.println("Creating " + tableName); 
      
      try { 
         Tables.awaitTableToBecomeActive(dynamoDBClient, tableName); 
      } catch (InterruptedException e) { 
         e.printStackTrace(); 
      } 
         
      // Get the table's stream settings 
      DescribeTableResult describeTableResult =
         dynamoDBClient.describeTable(tableName);  
      
      String myStreamArn = describeTableResult.getTable().getLatestStreamArn(); 
      StreamSpecification myStreamSpec =  
         describeTableResult.getTable().getStreamSpecification();  
      
      System.out.println("Current stream ARN for " + tableName + ": "+ myStreamArn);
      System.out.println("Stream enabled: "+ myStreamSpec.getStreamEnabled()); 
      System.out.println("Update view type: "+ myStreamSpec.getStreamViewType());  
      
      // Add an item 
      int numChanges = 0; 
      System.out.println("Making some changes to table data"); 
      Map<String, AttributeValue> item = new HashMap<String, AttributeValue>(); 
      item.put("ID", new AttributeValue().withN("222")); 
      item.put("Alert", new AttributeValue().withS("item!")); 
      dynamoDBClient.putItem(tableName, item); 
      numChanges++;  
      
      // Update the item         
      Map<String, AttributeValue> key = new HashMap<String, AttributeValue>(); 
      key.put("ID", new AttributeValue().withN("222")); 
      Map<String, AttributeValueUpdate> attributeUpdates =  
      new HashMap<String, AttributeValueUpdate>(); 
      
      attributeUpdates.put("Alert", new AttributeValueUpdate() 
         .withAction(AttributeAction.PUT) 
         .withValue(new AttributeValue().withS("modified item"))); 
      
      dynamoDBClient.updateItem(tableName, key, attributeUpdates); 
      numChanges++;   
      
      // Delete the item         
      dynamoDBClient.deleteItem(tableName, key);  
      numChanges++;
      
      // Get stream shards         
      DescribeStreamResult describeStreamResult =  
      streamsClient.describeStream(new DescribeStreamRequest() 
         .withStreamArn(myStreamArn)); 
      String streamArn =  
         describeStreamResult.getStreamDescription().getStreamArn(); 
      List<Shard> shards =  
         describeStreamResult.getStreamDescription().getShards();  
      
      // Process shards 
      for (Shard shard : shards) { 
         String shardId = shard.getShardId(); 
         System.out.println("Processing " + shardId + " in "+ streamArn);  
         
         // Get shard iterator 
         GetShardIteratorRequest getShardIteratorRequest = new 
            GetShardIteratorRequest() 
            .withStreamArn(myStreamArn) 
            .withShardId(shardId) 
            .withShardIteratorType(ShardIteratorType.TRIM_HORIZON); 
         
         GetShardIteratorResult getShardIteratorResult =  
            streamsClient.getShardIterator(getShardIteratorRequest); 
         String nextItr = getShardIteratorResult.getShardIterator();  
         
         while (nextItr != null && numChanges > 0) { 
            // Read data records with iterator                 
            GetRecordsResult getRecordsResult =  
               streamsClient.getRecords(new GetRecordsRequest(). 
               withShardIterator(nextItr));
               
            List<Record> records = getRecordsResult.getRecords(); 
            System.out.println("Pulling records...");  
               
            for (Record record : records) { 
               System.out.println(record); 
               numChanges--;
            } 
            nextItr = getRecordsResult.getNextShardIterator(); 
         } 
      } 
   } 
}

ในการประมวลผลคำขอไม่สำเร็จ DynamoDB จะแสดงข้อผิดพลาด ข้อผิดพลาดแต่ละข้อประกอบด้วยส่วนประกอบต่อไปนี้: รหัสสถานะ HTTP ชื่อข้อยกเว้นและข้อความ การจัดการข้อผิดพลาดขึ้นอยู่กับ SDK ของคุณซึ่งเผยแพร่ข้อผิดพลาดหรือรหัสของคุณเอง

รหัสและข้อความ

ข้อยกเว้นอยู่ในรหัสสถานะส่วนหัว HTTP ที่แตกต่างกัน 4xx และ 5xx ถือข้อผิดพลาดที่เกี่ยวข้องกับปัญหาการร้องขอและ AWS

การเลือกข้อยกเว้นในประเภท HTTP 4xx มีดังนี้ -

AccessDeniedException - ลูกค้าลงนามในคำขอไม่ถูกต้อง
ConditionalCheckFailedException - เงื่อนไขที่ประเมินเป็นเท็จ
IncompleteSignatureException - คำขอมีลายเซ็นที่ไม่สมบูรณ์

ข้อยกเว้นในประเภท HTTP 5xx มีดังนี้ -

ข้อผิดพลาดภายในเซิร์ฟเวอร์
ไม่สามารถให้บริการได้

Retries และ Backoff Algorithms

ข้อผิดพลาดมาจากหลายแหล่งเช่นเซิร์ฟเวอร์สวิตช์ตัวโหลดบาลานเซอร์และโครงสร้างและระบบอื่น ๆ โซลูชันทั่วไปประกอบด้วยการลองใหม่อย่างง่ายซึ่งรองรับความน่าเชื่อถือ SDK ทั้งหมดรวมตรรกะนี้โดยอัตโนมัติและคุณสามารถตั้งค่าพารามิเตอร์การลองใหม่เพื่อให้เหมาะกับความต้องการของแอปพลิเคชันของคุณ

For example - Java เสนอค่า maxErrorRetry เพื่อหยุดการลองใหม่

Amazon แนะนำให้ใช้โซลูชันแบ็คออฟนอกเหนือจากการลองใหม่เพื่อควบคุมโฟลว์ ซึ่งประกอบด้วยระยะเวลารอที่เพิ่มขึ้นเรื่อย ๆ ระหว่างการลองใหม่และหยุดลงในที่สุดหลังจากช่วงเวลาสั้น ๆ หมายเหตุ SDK ทำการลองใหม่โดยอัตโนมัติ แต่ไม่ใช่การย้อนกลับแบบเอ็กซ์โปเนนเชียล

โปรแกรมต่อไปนี้เป็นตัวอย่างของการย้อนกลับของการลองอีกครั้ง -

public enum Results { 
   SUCCESS,  
   NOT_READY,  
   THROTTLED,  
   SERVER_ERROR 
}
public static void DoAndWaitExample() {  
   try {
      // asynchronous operation. 
      long token = asyncOperation();  
      int retries = 0; 
      boolean retry = false;  
      
      do { 
         long waitTime = Math.min(getWaitTime(retries), MAX_WAIT_INTERVAL);  
         System.out.print(waitTime + "\n");  
         
         // Pause for result 
         Thread.sleep(waitTime);  
         
         // Get result 
         Results result = getAsyncOperationResult(token);  
         
         if (Results.SUCCESS == result) { 
            retry = false; 
         } else if (Results.NOT_READY == result) { 
            retry = true; 
         } else if (Results.THROTTLED == result) { 
            retry = true; 
         } else if (Results.SERVER_ERROR == result) { 
            retry = true; 
         } else { 
            
            // stop on other error 
            retry = false; 
         }  
      } while (retry && (retries++ < MAX_RETRIES)); 
   }
   catch (Exception ex) { 
   } 
}
public static long getWaitTime(int retryCount) {  
   long waitTime = ((long) Math.pow(3, retryCount) * 100L);  
   return waitTime; 
}

แนวทางปฏิบัติบางประการเพิ่มประสิทธิภาพโค้ดป้องกันข้อผิดพลาดและลดต้นทุนปริมาณงานเมื่อทำงานกับแหล่งข้อมูลและองค์ประกอบต่างๆ

ต่อไปนี้เป็นแนวทางปฏิบัติที่ดีที่สุดที่สำคัญที่สุดและใช้กันทั่วไปใน DynamoDB

ตาราง

การกระจายตารางหมายถึงแนวทางที่ดีที่สุดที่จะกระจายกิจกรรมการอ่าน / เขียนอย่างเท่าเทียมกันในทุกรายการในตาราง

มุ่งเป้าไปที่การเข้าถึงข้อมูลที่สม่ำเสมอบนรายการตาราง การใช้งานทรูพุตที่เหมาะสมขึ้นอยู่กับการเลือกคีย์หลักและรูปแบบปริมาณงานรายการ กระจายภาระงานอย่างเท่าเทียมกันในค่าคีย์พาร์ติชัน หลีกเลี่ยงสิ่งต่างๆเช่นค่าคีย์พาร์ติชันที่ใช้งานหนักจำนวนเล็กน้อย เลือกตัวเลือกที่ดีกว่าเช่นค่าคีย์พาร์ติชันที่แตกต่างกันจำนวนมาก

ทำความเข้าใจเกี่ยวกับลักษณะการทำงานของพาร์ติชัน ประมาณพาร์ติชันที่จัดสรรโดยอัตโนมัติโดย DynamoDB

DynamoDB นำเสนอการใช้งานแบบต่อเนื่องซึ่งจะสงวนปริมาณงานที่ไม่ได้ใช้สำหรับการ "ระเบิด" ของพลังงาน หลีกเลี่ยงการใช้ตัวเลือกนี้ในปริมาณมากเนื่องจากการระเบิดจะใช้ปริมาณงานจำนวนมากอย่างรวดเร็ว นอกจากนี้ยังไม่ได้พิสูจน์ทรัพยากรที่เชื่อถือได้

ในการอัปโหลดให้แจกจ่ายข้อมูลเพื่อให้ได้ประสิทธิภาพที่ดีขึ้น ดำเนินการนี้โดยการอัปโหลดไปยังเซิร์ฟเวอร์ที่จัดสรรทั้งหมดพร้อมกัน

แคชรายการที่ใช้บ่อยเพื่อยกเลิกการอ่านกิจกรรมไปยังแคชแทนที่จะเป็นฐานข้อมูล

รายการ

การควบคุมปริมาณประสิทธิภาพขนาดและต้นทุนการเข้าถึงยังคงเป็นปัญหาที่ใหญ่ที่สุดสำหรับสินค้า เลือกใช้โต๊ะแบบตัวต่อตัว ลบแอตทริบิวต์และแบ่งตารางเพื่อให้ตรงกับรูปแบบการเข้าถึง คุณสามารถปรับปรุงประสิทธิภาพได้อย่างมากด้วยวิธีง่ายๆนี้

บีบอัดค่าขนาดใหญ่ก่อนจัดเก็บ ใช้เครื่องมือบีบอัดมาตรฐาน ใช้ที่เก็บข้อมูลสำรองสำหรับค่าแอ็ตทริบิวต์ขนาดใหญ่เช่น S3 คุณสามารถจัดเก็บออบเจ็กต์ใน S3 และตัวระบุในรายการ

แจกจ่ายแอตทริบิวต์ขนาดใหญ่ในหลายรายการผ่านชิ้นส่วนรายการเสมือน สิ่งนี้เป็นวิธีแก้ปัญหาสำหรับข้อ จำกัด ของขนาดรายการ

แบบสอบถามและการสแกน

การสืบค้นและการสแกนส่วนใหญ่ประสบปัญหาในการบริโภคปริมาณงาน หลีกเลี่ยงการระเบิดซึ่งมักเกิดจากสิ่งต่างๆเช่นการเปลี่ยนไปใช้การอ่านที่สอดคล้องกันอย่างมาก ใช้การสแกนแบบขนานในลักษณะทรัพยากรต่ำ (เช่นฟังก์ชันพื้นหลังที่ไม่มีการควบคุมปริมาณ) นอกจากนี้ใช้เฉพาะกับตารางขนาดใหญ่และสถานการณ์ที่คุณไม่ได้ใช้งานการประมวลผลหรือการสแกนอย่างเต็มที่ทำให้มีประสิทธิภาพต่ำ

ดัชนีรองในท้องถิ่น

ดัชนีนำเสนอปัญหาในด้านปริมาณงานและต้นทุนการจัดเก็บและประสิทธิภาพของการสืบค้น หลีกเลี่ยงการสร้างดัชนีเว้นแต่คุณจะสอบถามแอตทริบิวต์บ่อยๆ ในการคาดการณ์ให้เลือกอย่างชาญฉลาดเพราะดัชนีขยายตัว เลือกเฉพาะที่ใช้งานหนัก

ใช้ดัชนีแบบกระจัดกระจายหมายถึงดัชนีที่คีย์การเรียงลำดับไม่ปรากฏในรายการตารางทั้งหมด ซึ่งเป็นประโยชน์ต่อการสืบค้นเกี่ยวกับแอตทริบิวต์ที่ไม่มีอยู่ในรายการตารางส่วนใหญ่

ให้ความสนใจกับการขยายการรวบรวมรายการ (รายการตารางทั้งหมดและดัชนี) การดำเนินการเพิ่ม / อัปเดตทำให้ทั้งตารางและดัชนีเพิ่มขึ้นและ 10GB ยังคงเป็นขีด จำกัด สำหรับคอลเลกชัน

ดัชนีรองทั่วโลก

ดัชนีนำเสนอปัญหาในด้านปริมาณงานและต้นทุนการจัดเก็บและประสิทธิภาพของการสืบค้น เลือกใช้คีย์แอ็ตทริบิวต์การแพร่กระจายซึ่งเช่นการอ่าน / เขียนการแพร่กระจายในตารางจะให้ความสม่ำเสมอของภาระงาน เลือกแอตทริบิวต์ที่กระจายข้อมูลอย่างเท่าเทียมกัน นอกจากนี้ใช้ดัชนีเบาบาง

ใช้ประโยชน์จากดัชนีทุติยภูมิทั่วโลกสำหรับการค้นหาอย่างรวดเร็วในแบบสอบถามที่ขอข้อมูลจำนวนพอประมาณ