Amazon DynamoDB

import json

def lambda_handler(event, context):
    for record in event['Records']:
        event_name = record['eventName']  # INSERT | MODIFY | REMOVE
        
        if event_name == 'INSERT':
            new_item = record['dynamodb']['NewImage']
            print(f"New item created: {json.dumps(new_item)}")
            # Gửi welcome email, sync to Elasticsearch, etc.
            
        elif event_name == 'MODIFY':
            old_item = record['dynamodb']['OldImage']
            new_item = record['dynamodb']['NewImage']
            print(f"Item updated from {old_item} to {new_item}")
            
        elif event_name == 'REMOVE':
            old_item = record['dynamodb']['OldImage']
            print(f"Item deleted: {json.dumps(old_item)}")
    
    return {'statusCode': 200}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:GetItem",
        "dynamodb:Query"
      ],
      "Resource": "arn:aws:dynamodb:ap-southeast-1:123456789012:table/Users",
      "Condition": {
        "ForAllValues:StringEquals": {
          "dynamodb:LeadingKeys": ["${www.amazon.com:user_id}"]
        },
        "StringEqualsIfExists": {
          "dynamodb:Select": "SPECIFIC_ATTRIBUTES"
        },
        "ForAllValues:StringEquals": {
          "dynamodb:Attributes": ["userId", "name", "email"]
        }
      }
    }
  ]
}

# Tạo VPC Gateway Endpoint cho DynamoDB
aws ec2 create-vpc-endpoint \
  --vpc-id vpc-0abc123def456 \
  --service-name com.amazonaws.ap-southeast-1.dynamodb \
  --route-table-ids rtb-0abc123def456

# Kiểm tra endpoint
aws ec2 describe-vpc-endpoints \
  --filters "Name=service-name,Values=com.amazonaws.ap-southeast-1.dynamodb"

import boto3

dynamodb = boto3.client('dynamodb')

def transfer_money(from_account, to_account, amount):
    """Chuyển tiền atomic: trừ account A, cộng account B"""
    try:
        dynamodb.transact_write_items(
            TransactItems=[
                {
                    'Update': {
                        'TableName': 'Accounts',
                        'Key': {'accountId': {'S': from_account}},
                        'UpdateExpression': 'SET balance = balance - :amount',
                        'ConditionExpression': 'balance >= :amount',
                        'ExpressionAttributeValues': {
                            ':amount': {'N': str(amount)}
                        }
                    }
                },
                {
                    'Update': {
                        'TableName': 'Accounts',
                        'Key': {'accountId': {'S': to_account}},
                        'UpdateExpression': 'SET balance = balance + :amount',
                        'ExpressionAttributeValues': {
                            ':amount': {'N': str(amount)}
                        }
                    }
                },
                {
                    'Put': {
                        'TableName': 'Transactions',
                        'Item': {
                            'txId': {'S': 'TX-2024-001'},
                            'fromAccount': {'S': from_account},
                            'toAccount': {'S': to_account},
                            'amount': {'N': str(amount)},
                            'status': {'S': 'completed'}
                        }
                    }
                }
            ]
        )
        print("Transfer successful!")
    except dynamodb.exceptions.TransactionCanceledException as e:
        print(f"Transfer failed: {e}")
        # Không có partial update — tất cả rollback

┌──────────────────┬─────────────────────┬──────────────────────────────┐
│ PK               │ SK                  │ Attributes                   │
├──────────────────┼─────────────────────┼──────────────────────────────┤
│ USER#001         │ PROFILE             │ name, email, phone           │
│ USER#001         │ ORDER#2024-001      │ total, status, createdAt     │
│ USER#001         │ ORDER#2024-002      │ total, status, createdAt     │
│ USER#001         │ ADDRESS#home        │ street, city, zipCode        │
│ USER#002         │ PROFILE             │ name, email, phone           │
│ USER#002         │ ORDER#2024-003      │ total, status, createdAt     │
│ PRODUCT#A100     │ METADATA            │ name, price, category        │
│ PRODUCT#A100     │ REVIEW#001          │ rating, comment, userId      │
│ PRODUCT#A100     │ REVIEW#002          │ rating, comment, userId      │
└──────────────────┴─────────────────────┴──────────────────────────────┘

Access Patterns:
  → Lấy profile user:     Query PK="USER#001", SK="PROFILE"
  → Lấy tất cả orders:    Query PK="USER#001", SK begins_with("ORDER#")
  → Lấy product + reviews: Query PK="PRODUCT#A100"

# Thay vì PK = "2024-01-15" (hot partition)
# Thêm random suffix: PK = "2024-01-15#3"

import random

def get_sharded_pk(date_str, num_shards=10):
    """Tạo sharded partition key"""
    shard = random.randint(0, num_shards - 1)
    return f"{date_str}#{shard}"

# Write: PK sẽ là "2024-01-15#0", "2024-01-15#1", ..., "2024-01-15#9"
# Read: Cần query tất cả 10 shards rồi merge kết quả
pk = get_sharded_pk("2024-01-15")

# Scatter-Gather pattern cho read
def query_all_shards(date_str, num_shards=10):
    results = []
    for shard in range(num_shards):
        pk = f"{date_str}#{shard}"
        items = dynamodb.query(
            TableName='Events',
            KeyConditionExpression='PK = :pk',
            ExpressionAttributeValues={':pk': {'S': pk}}
        )
        results.extend(items['Items'])
    return results

# Tạo table với Composite Primary Key (Provisioned mode)
aws dynamodb create-table \
  --table-name Users \
  --attribute-definitions \
    AttributeName=PK,AttributeType=S \
    AttributeName=SK,AttributeType=S \
  --key-schema \
    AttributeName=PK,KeyType=HASH \
    AttributeName=SK,KeyType=RANGE \
  --billing-mode PROVISIONED \
  --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5

# Tạo table On-Demand mode
aws dynamodb create-table \
  --table-name Events \
  --attribute-definitions AttributeName=eventId,AttributeType=S \
  --key-schema AttributeName=eventId,KeyType=HASH \
  --billing-mode PAY_PER_REQUEST

# Liệt kê tables
aws dynamodb list-tables

# Xem thông tin table
aws dynamodb describe-table --table-name Users

# Xóa table
aws dynamodb delete-table --table-name Users

# Chuyển đổi capacity mode
aws dynamodb update-table \
  --table-name Users \
  --billing-mode PAY_PER_REQUEST

# PutItem — Tạo/ghi đè item
aws dynamodb put-item \
  --table-name Users \
  --item '{
    "PK": {"S": "USER#001"},
    "SK": {"S": "PROFILE"},
    "name": {"S": "Nguyen Van Minh"},
    "email": {"S": "minh@example.com"},
    "age": {"N": "28"}
  }'

# GetItem — Đọc 1 item (Strongly Consistent)
aws dynamodb get-item \
  --table-name Users \
  --key '{"PK": {"S": "USER#001"}, "SK": {"S": "PROFILE"}}' \
  --consistent-read

# UpdateItem — Cập nhật attributes
aws dynamodb update-item \
  --table-name Users \
  --key '{"PK": {"S": "USER#001"}, "SK": {"S": "PROFILE"}}' \
  --update-expression "SET age = :newAge, updatedAt = :now" \
  --expression-attribute-values '{
    ":newAge": {"N": "29"},
    ":now": {"S": "2024-01-15T10:30:00Z"}
  }'

# DeleteItem — Xóa item
aws dynamodb delete-item \
  --table-name Users \
  --key '{"PK": {"S": "USER#001"}, "SK": {"S": "PROFILE"}}'

# Conditional Write — Chỉ ghi nếu điều kiện thỏa mãn
aws dynamodb put-item \
  --table-name Users \
  --item '{"PK": {"S": "USER#003"}, "SK": {"S": "PROFILE"}, "name": {"S": "Test"}}' \
  --condition-expression "attribute_not_exists(PK)"

# Query — Lấy tất cả items của 1 user
aws dynamodb query \
  --table-name Users \
  --key-condition-expression "PK = :pk" \
  --expression-attribute-values '{":pk": {"S": "USER#001"}}'

# Query — Lấy orders của user (SK begins_with)
aws dynamodb query \
  --table-name Users \
  --key-condition-expression "PK = :pk AND begins_with(SK, :sk)" \
  --expression-attribute-values '{
    ":pk": {"S": "USER#001"},
    ":sk": {"S": "ORDER#"}
  }'

# Query với filter (filter sau khi đọc, vẫn tốn RCU)
aws dynamodb query \
  --table-name Users \
  --key-condition-expression "PK = :pk AND begins_with(SK, :sk)" \
  --filter-expression "total > :minTotal" \
  --expression-attribute-values '{
    ":pk": {"S": "USER#001"},
    ":sk": {"S": "ORDER#"},
    ":minTotal": {"N": "100000"}
  }'

# Query trên GSI
aws dynamodb query \
  --table-name Users \
  --index-name email-index \
  --key-condition-expression "email = :email" \
  --expression-attribute-values '{":email": {"S": "minh@example.com"}}'

# Scan — Đọc toàn bộ table (TRÁNH dùng trong production!)
aws dynamodb scan --table-name Users --max-items 10

# Scan với filter
aws dynamodb scan \
  --table-name Users \
  --filter-expression "age > :minAge" \
  --expression-attribute-values '{":minAge": {"N": "25"}}'

# BatchWriteItem — Ghi nhiều items (tối đa 25 items, 16 MB)
aws dynamodb batch-write-item --request-items '{
  "Users": [
    {
      "PutRequest": {
        "Item": {
          "PK": {"S": "USER#010"},
          "SK": {"S": "PROFILE"},
          "name": {"S": "User 10"}
        }
      }
    },
    {
      "DeleteRequest": {
        "Key": {
          "PK": {"S": "USER#005"},
          "SK": {"S": "PROFILE"}
        }
      }
    }
  ]
}'

# BatchGetItem — Đọc nhiều items (tối đa 100 items, 16 MB)
aws dynamodb batch-get-item --request-items '{
  "Users": {
    "Keys": [
      {"PK": {"S": "USER#001"}, "SK": {"S": "PROFILE"}},
      {"PK": {"S": "USER#002"}, "SK": {"S": "PROFILE"}}
    ],
    "ProjectionExpression": "PK, #n, email",
    "ExpressionAttributeNames": {"#n": "name"}
  }
}'

# Bật Point-in-Time Recovery
aws dynamodb update-continuous-backups \
  --table-name Users \
  --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true

# Tạo On-Demand Backup
aws dynamodb create-backup \
  --table-name Users \
  --backup-name users-backup-2024-01-15

# Bật DynamoDB Streams
aws dynamodb update-table \
  --table-name Users \
  --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES

# Bật TTL
aws dynamodb update-time-to-live \
  --table-name Sessions \
  --time-to-live-specification Enabled=true,AttributeName=expiresAt

# Tạo GSI
aws dynamodb update-table \
  --table-name Users \
  --attribute-definitions AttributeName=email,AttributeType=S \
  --global-secondary-index-updates '[
    {
      "Create": {
        "IndexName": "email-index",
        "KeySchema": [{"AttributeName": "email", "KeyType": "HASH"}],
        "Projection": {"ProjectionType": "ALL"},
        "ProvisionedThroughput": {
          "ReadCapacityUnits": 5,
          "WriteCapacityUnits": 5
        }
      }
    }
  ]'

# Export table to S3
aws dynamodb export-table-to-point-in-time \
  --table-arn arn:aws:dynamodb:ap-southeast-1:123456789012:table/Users \
  --s3-bucket my-dynamodb-exports \
  --s3-prefix users/ \
  --export-format DYNAMODB_JSON

# SELECT (Query)
aws dynamodb execute-statement \
  --statement "SELECT * FROM Users WHERE PK='USER#001' AND begins_with(SK, 'ORDER#')"

# INSERT
aws dynamodb execute-statement \
  --statement "INSERT INTO Users VALUE {'PK': 'USER#099', 'SK': 'PROFILE', 'name': 'Test User'}"

# UPDATE
aws dynamodb execute-statement \
  --statement "UPDATE Users SET age=30 WHERE PK='USER#001' AND SK='PROFILE'"

# DELETE
aws dynamodb execute-statement \
  --statement "DELETE FROM Users WHERE PK='USER#099' AND SK='PROFILE'"