การสร้างแบบจำลองข้อมูลใน AWS DynamoDB

วิธีสร้างโมเดลข้อมูลของคุณให้ทำงานกับ DynamoDB ที่ใช้ NoSQL ของ Amazon Web Services

ทำไมต้อง NoSQL?

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

ทำไมต้อง DynamoDB?

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

การทำความเข้าใจพื้นฐาน

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

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

รหัสพาร์ติชัน

ตาราง DynamoDB แบ่งออกเป็นพาร์ติชัน DynamoDB ใช้คีย์พาร์ติชันเป็นอินพุตไปยังฟังก์ชันแฮชภายใน ซึ่งผลลัพธ์จะกำหนดว่ารายการจะถูกจัดเก็บในพาร์ติชันใด

พาร์ทิชันร้อน

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

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

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

คีย์การเรียงลำดับ

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

ตัวอย่างของการสร้างแบบจำลองข้อมูล

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

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

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

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

{
  "TableName": "tournaments",
  "KeyConditionExpression": "partitionKey = :tournamentId",
  "ExpressionAttributeValues": {
    ":tournamentId": "983d39a3-bdd6-4b61-88d5-58595d555b81"
  }
}

จะเป็นอย่างไรถ้าคุณต้องการเฉพาะทีมตามรหัสทัวร์นาเมนต์ที่กำหนด?

นี่คือจุดที่คำนำหน้า team- มีประโยชน์ เนื่องจากเรานำหน้าคีย์การเรียงลำดับรายการของทีมทั้งหมดด้วย team- เราจึงสามารถดำเนินการฟังก์ชันพิเศษใน KeyConditionExpression ของเราได้ — begins_with การเรียกแบบสอบถามนี้จะดึงข้อมูลทีมทั้งหมดสำหรับรหัสการแข่งขันที่กำหนด (คีย์พาร์ติชัน)

{
  "TableName": "tournaments",
  "KeyConditionExpression": "partitionKey = :tournamentId and begins_with(sortKey, :teamPrefix)",
  "ExpressionAttributeValues": {
    ":teamPrefix": "team-",
    ":tournamentId": "983d39a3-bdd6-4b61-88d5-58595d555b81"
  }
}

จะทำอย่างไรถ้าคุณต้องการเพียงรายละเอียดพื้นฐาน?

เราดำเนินการเรียกรับรายการ DynamoDB ได้เนื่องจากเราทราบทั้งคีย์พาร์ติชันและคีย์การเรียงลำดับ

{
  "TableName": "tournaments",
  "Key": {
    "partitionKey": "983d39a3-bdd6-4b61-88d5-58595d555b81",
    "sortKey": "tournament-details"
  }
}

ห่อ

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

หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับบริการของ AWS

ขอขอบคุณที่อ่านและขอให้โชคดีกับโครงการของคุณ! แสดงความคิดเห็นหรือส่งข้อความถึงฉันหากคุณมีคำถามใด ๆ