เส้นทางการเรียนรู้บน AWS:

การทำโมเดลข้อมูลผู้เล่นเกมด้วย Amazon DynamoDB

ข้อมูลเบื้องต้น

พื้นหลังและการตั้งค่า

วางแผนโมเดลข้อมูล

การใช้งานหลัก: โปรไฟล์ผู้ใช้และเกม

ออกแบบรูปแบบการเข้าสู่เกม

การล้างข้อมูลและขั้นตอนถัดไป

การใช้งานหลัก: โปรไฟล์ผู้ใช้และเกม

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

ระยะเวลาที่ใช้ในการศึกษาโมดูล: 20 นาที

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

  • เริ่มต้นจากเอนทิตีที่ต่างกันในตาราง หากคุณกำลังคืนค่าประเภทข้อมูลที่แตกต่างกันจำนวนมากในตารางเดียว เช่น พนักงาน แผนก ลูกค้า และใบสั่ง โปรดตรวจสอบให้แน่ใจว่าคีย์หลักของคุณสามารถระบุเอนทิตีแต่ละเอนทิตีได้อย่างชัดเจน และสามารถดำเนินการหลักๆ กับไอเท็มแต่ละไอเท็ม
  • ใช้คำนำหน้าเพื่อแยกความแตกต่างระหว่างประเภทของเอนทิตี การใช้คำนำหน้าเพื่อแยกความแตกต่างระหว่างประเภทของเอนทิตีนั้น จะสามารถป้องกันการขัดแย้งกันและช่วยในการสืบค้นข้อมูล ตัวอย่างเช่น หากคุณมีทั้งลูกค้าและพนักงานในตารางเดียวกัน คีย์หลักสำหรับลูกค้าอาจจะเป็น CUSTOMER#<CUSTOMERID> และคีย์หลักสำหรับพนักงานอาจจะเป็น EMPLOYEE#<EMPLOYEEID>
  • มุ่งเป้าไปที่การดำเนินการกับไอเท็มเดียวก่อน จากนั้น จึงเพิ่มการดำเนินการกับไอเท็มจำนวนมาก หากสามารถทำได้ สำหรับคีย์หลักนั้น สิ่งที่สำคัญก็คือ คุณต้องสามารถตอบสนองตัวเลือกในการอ่านและเขียนบนไอเท็มเดียวโดยใช้ API ไอเท็มเดียว: GetItem, PutItem, UpdateItem และ DeleteItem นอกจากนี้ คุณอาจต้องสามารถตอบสนองรูปแบบการอ่านไอเท็มจำนวนมากของคุณด้วยคีย์หลักโดยใช้ การสืบค้น หากทำไม่ได้ คุณสามารถเพิ่มดัชนีรองเพื่อจัดการกรณีการใช้ การสืบค้น

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

  • ขั้นตอนที่ 1 ออกแบบคีย์หลัก

    ขั้นตอนที่ 1 ออกแบบคีย์หลัก

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

    • User
    • Game
    • UserGameMapping

    UserGameMapping คือบันทึกข้อมูลที่บ่งชี้ผู้ใช้ที่เข้าร่วมเกม มีความสัมพันธ์แบบกลุ่มต่อกลุ่มระหว่าง User และ Game

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

    หากโมเดลข้อมูลมีเอนทิตีหลายเอนทิตีที่มีความสัมพันธ์ระหว่างกัน โดยทั่วไป คุณจะใช้คีย์หลักแบบรวม ที่มีทั้งค่า HASH และค่า RANGE คีย์หลักแบบรวมให้ความสามารถในการสืบค้นบนคีย์ HASH เพื่อตอบสนองรูปแบบการสืบค้นแบบใดแบบหนึ่งที่เราต้องการ ในเอกสารประกอบ DynamoDB นั้น คีย์การแบ่งแยกจะเรียกว่า HASH และคีย์การจัดเรียงจะเรียกว่า RANGE และในคู่มือนี้ เราสามารถใช้อภิธานศัพท์ API สลับกันได้ และโดยเฉพาะอย่างยิ่ง เมื่อเราพูดถึงโค้ดหรือรูปแบบโปรโตคอลแบบผ่านสาย JSON ใน DynamoDB

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

    เรามาใช้รูปแบบต่อไปนี้กับค่า HASH และค่า RANGE สำหรับเอนทิตีแต่ละประเภทโดยคำนึงถึงเรื่องนี้กันเถอะ

    เอนทิตี HASH RANGE
    User USER#<USERNAME> #METADATA#<USERNAME>
    Game GAME#<GAME_ID> #METADATA#<GAME_ID>
    UserGameMapping GAME#<GAME_ID> USER#<USERNAME>

    เรามาตรวจดูตารางก่อนหน้านี้กันเถอะ

    สำหรับเอนทิตี User ค่า HASH คือ USER#<USERNAME> โปรดสังเกตว่า เราใช้คำนำหน้าเพื่อระบุเอนทิตีและป้องกันการขัดแย้งกันที่อาจเกิดขึ้นได้กับเอนทิตีประเภทต่างๆ

    สำหรับค่า RANGE บนเอนทิตี User เราใช้คำนำหน้าคงที่ #METADATA# แล้วตามด้วยค่า USERNAME สำหรับค่า RANGE เป็นสิ่งสำคัญที่เราต้องมีค่าที่รู้จัก เช่น USERNAME ซึ่งอนุญาตให้กับการดำเนินการกับรายการเดียว เช่น GetItem, PutItem และ DeleteItem

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

    เอนทิตี Game มีการออกแบบคีย์หลักที่คล้ายคลึงกับการออกแบบเอนทิตี User โดยจะใช้คำนำหน้าที่แตกต่างกัน (GAME#) และใช้ GAME_ID แทน USERNAME แต่มีหลักการแบบเดียวกัน

    สุดท้าย UserGameMapping ใช้คีย์ HASH เดียวกันเป็นเอนทิตี Game ซึ่งไม่เพียงช่วยให้เราดึงเมตาดาต้าสำหรับ Game เท่านั้น แต่ยังช่วยให้เราดึงผู้ใช้ทั้งหมดใน Game จากการสืบค้นเพียงครั้งเดียวด้วย จากนั้น เราใช้เอนทิตี User สำหรับคีย์ RANGE บน UserGameMapping เพื่อระบุว่าผู้ใช้รายใดที่เข้าร่วมเกมใดเกมหนึ่งโดยเฉพาะ

    ในขั้นตอนถัดไป เราจะสร้างตารางด้วยการออกแบบคีย์หลักนี้ 

  • ขั้นที่ 2: สร้างตาราง

    ขั้นที่ 2: สร้างตาราง

    ตอนนี้ เราได้สร้างคีย์หลักขึ้นมาแล้ว เรามาสร้างตารางกันเถอะ

    โค้ดที่คุณดาวน์โหลดในขั้นที่ 3 ของโมดูล 1 มีสคริปต์ Python รวมอยู่ในไดเรกทอรี scripts/ ที่ชื่อว่า create_table.py เนื้อหาของสคริปต์ Python มีดังนี้

    import boto3

dynamodb = boto3.client('dynamodb')

try:
    dynamodb.create_table(
        TableName='battle-royale',
        AttributeDefinitions=[
            {
                "AttributeName": "PK",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SK",
                "AttributeType": "S"
            }
        ],
        KeySchema=[
            {
                "AttributeName": "PK",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SK",
                "KeyType": "RANGE"
            }
        ],
        ProvisionedThroughput={
            "ReadCapacityUnits": 1,
            "WriteCapacityUnits": 1
        }
    )
    print("Table created successfully.")
except Exception as e:
    print("Could not create table. Error:")
    print(e)

    สคริปต์ก่อนหน้าใช้การดำเนินการ CreateTable โดยใช้ Boto 3 ซึ่งเป็น AWS SDK for Python การดำเนินการดังกล่าวจะกำหนดคำจำกัดความของแอตทริบิวต์สองแอตทริบิวต์ ซึ่งเป็นประเภทแอตทริบิวต์ที่จะใช้ในคีย์หลัก ถึงแม้ว่า DynamoDB จะไม่มีโครงสร้าง แต่คุณต้องกำหนดชื่อและประเภทของแอตทริบิวต์ที่ใช้สำหรับคีย์หลัก แอตทริบิวต์ต้องรวมอยู่ในรายการทุกรายการที่เขียนลงในตาราง ดังนั้น จึงต้องมีการระบุแอตทริบิวต์ในขณะที่คุณกำลังสร้างตาราง

    เนื่องจากเราจัดเก็บเอนทิตีที่แตกต่างกันไว้ในตารางเดียว เราจึงใช้ชื่อแอตทริบิวต์ของคีย์หลัก เช่น UserId ไม่ได้ แอตทริบิวต์หมายถึงบางสิ่งที่แตกต่างกันไปตามประเภทของเอนทิตีที่จัดเก็บ ตัวอย่างเช่น คีย์หลักสำหรับผู้ใช้อาจจะเป็น USERNAME และคีย์หลักสำหรับเกมอาจจะเป็น GAMEID ดังนั้น เราจึงใช้ชื่อสามัญสำหรับแอตทริบิวต์ เช่น ใช้ PK (สำหรับคีย์การแบ่งแยก) และใช้ SK (สำหรับคีย์การจัดเรียง)

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

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

    เมื่อต้องการสร้างตาราง ให้รันสคริปต์ Python ด้วยคำสั่งต่อไปนี้

    python scripts/create_table.py

    สคริปต์ดังกล่าวควรส่งข้อความนี้ “Table created successfully.” กลับมา

    ในขั้นตอนถัดไป เราจะโหลดข้อมูลตัวอย่างที่มีจำนวนมากลงในตาราง 

  • ขั้นตอนที่ 3: การโหลดข้อมูลจำนวนมากลงในตาราง

    ขั้นตอนที่ 3: การโหลดข้อมูลจำนวนมากลงในตาราง

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

    ในไดเรกทอรี scripts/ คุณจะพบไฟล์ที่ชื่อว่า items.json ไฟล์นี้มีไอเท็มตัวอย่าง 835 ไอเท็มที่ถูกสร้างขึ้นแบบสุ่มสำหรับห้องแล็บนี้ ไอเท็มเหล่านี้ประกอบไปด้วยเอนทิตี User, Game และ UserGameMapping เปิดไฟล์ดังกล่าวหากคุณต้องการเห็นรายการตัวอย่างบางรายการ

    นอกจากนี้ ไดเรกทอรี scripts/ ยังมีไฟล์ชื่อว่า bulk_load_table.py ที่อ่านรายการต่างๆ ในไฟล์ items.json และเขียนรายการจำนวนมากลงในตาราง DynamoDB เนื้อหาของไฟล์ดังกล่าวมีดังนี้

    import json

import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('battle-royale')

items = []

with open('scripts/items.json', 'r') as f:
    for row in f:
        items.append(json.loads(row))

with table.batch_writer() as batch:
    for item in items:
        batch.put_item(Item=item)

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

    รันสคริปต์ bulk_load_table.py และโหลดข้อมูลลงในตารางของคุณโดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล

    python scripts/bulk_load_table.py

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

    aws dynamodb scan \
 --table-name battle-royale \
 --select COUNT

    ซึ่งควรจะแสดงผลลัพธ์ดังต่อไปนี้

    {
    "Count": 835, 
    "ScannedCount": 835, 
    "ConsumedCapacity": null
}

    คุณควรเห็นจำนวน 835 ซึ่งบ่งบอกว่าไอเท็มทั้งหมดของคุณได้รับการโหลดสำเร็จแล้ว

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

  • ขั้นที่ 4: เรียกดูประเภทเอนทิตีจำนวนมากในคำขอเดียว

    ขั้นที่ 4: เรียกดูประเภทเอนทิตีจำนวนมากในคำขอเดียว

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

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

    คำขอนี้ขยายประเภทเอนทิตีสองประเภท: เอนทิตี Game และเอนทิตี UserGameMapping แต่ไม่ได้หมายความว่าเราต้องสร้างคำขอจำนวนมาก

    ในโค้ดที่คุณดาวน์โหลด สคริปต์ fetch_game_and_players.py อยู่ในไดเรกทอรี application/ สคริปต์นี้จะแสดงวิธีการจัดโครงสร้างโค้ดของคุณเพื่อเรียกดูทั้งเอนทิตี Game และเอนทิตี UserGameMapping สำหรับเกมในคำขอเดียว

    โค้ดต่อไปนี้ประกอบด้วยสคริปต์ fetch_game_and_players.py

    import boto3

from entities import Game, UserGameMapping

dynamodb = boto3.client('dynamodb')

GAME_ID = "3d4285f0-e52b-401a-a59b-112b38c4a26b"


def fetch_game_and_users(game_id):
    resp = dynamodb.query(
        TableName='battle-royale',
        KeyConditionExpression="PK = :pk AND SK BETWEEN :metadata AND :users",
        ExpressionAttributeValues={
            ":pk": { "S": "GAME#{}".format(game_id) },
            ":metadata": { "S": "#METADATA#{}".format(game_id) },
            ":users": { "S": "USER$" },
        },
        ScanIndexForward=True
    )

    game = Game(resp['Items'][0])
    game.users = [UserGameMapping(item) for item in resp['Items'][1:]]

    return game


game = fetch_game_and_users(GAME_ID)

print(game)
for user in game.users:
    print(user)

    ตรงช่วงต้นของสคริปต์นี้ เรานำเข้าไลบรารี Boto 3 และคลาสธรรมดาบางคลาสเพื่อแทนอ็อบเจ็กต์ในโค้ดแอปพลิเคชันของเรา คุณสามารถดูคำจำกัดความสำหรับเอนทิตีเหล่านั้นได้ในไฟล์ application/entities.py

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

    ฟังก์ชัน fetch_game_and_users ทำหน้าที่สองสามอย่าง อย่างแรก สร้างคำขอการสืบค้นไปยัง DynamoDB การสืบค้นนี้ใช้ PK ของ GAME#<GameId> จากนั้น จะขอเอนทิตีใดๆ ที่มีคีย์การจัดเรียงอยู่ระหว่าง #METADATA#<GameId> และ USER$ ซึ่งจะจับเอนทิตี Game ที่มีคีย์การจัดเรียงเป็น #METADATA#<GameId> และ UserGameMappings ทั้งหมด เอนทิตีที่มีคีย์ที่ขึ้นต้นด้วย USER# คีย์การจัดเรียงของประเภทสตริงจะถูกจัดเรียงตามโค้ดอักขระ ASCII เครื่องหมายดอลลาร์ ($) จะใส่ไว้หลังเครื่องหมายปอนด์ (#) ใน ASCII เพื่อให้แน่ใจว่าเราจะได้รับการแมปทั้งหมดในเอนทิตี UserGameMapping

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

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

    python application/fetch_game_and_players.py

    สคริปต์ควรพิมพ์อ็อบเจ็กต์เกมและอ็อบเจ็กต์ UserGameMapping ทั้งหมดลงในคอนโซล

    Game<3d4285f0-e52b-401a-a59b-112b38c4a26b -- Green Grasslands>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- branchmichael>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- deanmcclure>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- emccoy>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- emma83>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- iherrera>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- jeremyjohnson>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- lisabaker>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- maryharris>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- mayrebecca>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- meghanhernandez>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- nruiz>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- pboyd>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- richardbowman>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- roberthill>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- robertwood>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- victoriapatrick>
UserGameMapping<3d4285f0-e52b-401a-a59b-112b38c4a26b -- waltervargas>

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

    สรุป

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

    ด้วยการออกแบบคีย์หลักในปัจจุบัน เราสามารถตอบสนองรูปแบบการเข้าถึงต่อไปนี้:

    • สร้างโปรไฟล์ผู้ใช้ (เขียน)
    • อัปเดตโปรไฟล์ผู้ใช้ (เขียน)
    • ดูโปรไฟล์ผู้ใช้ (อ่าน)
    • สร้างเกม (เขียน)
    • ดูเกม (อ่าน)
    • ร่วมเล่นเกมสำหรับผู้ใช้ (เขียน)
    • เริ่มเกม (เขียน)
    • อัปเดตเกมสำหรับผู้ใช้ (เขียน)
    • อัปเดตเกม (เขียน)

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

ถัดไป: การออกแบบรูปแบบการเข้าถึงเกม