Skip to main content Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/ComeOnOliver/skillshub --skill dynamodbDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... Mehr aus diesem Repository
Verwandte Berufe SOC
Basierend auf der SOC-Berufsklassifikation
name dynamodb description AWS DynamoDB NoSQL database for scalable data storage. Use when designing table schemas, writing queries, configuring indexes, managing capacity, implementing single-table design, or troubleshooting performance issues. last_updated 2026-01-07 doc_source https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/
AWS DynamoDB
Amazon DynamoDB is a fully managed NoSQL database service providing fast, predictable performance at any scale. It supports key-value and document data structures.
Table of Contents
Core Concepts
Keys
Key Type Description Partition Key (PK) Required. Determines data distribution Sort Key (SK) Optional. Enables range queries within partition Composite Key PK + SK combination
Secondary Indexes
Index Type Description GSI (Global Secondary Index) Different PK/SK, separate throughput, eventually consistent LSI (Local Secondary Index) Same PK, different SK, shares table throughput, strongly consistent option
Capacity Modes Mode Use Case On-Demand Unpredictable traffic, pay-per-request Provisioned Predictable traffic, lower cost, can use auto-scaling
Common Patterns
Create a Table 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 PAY_PER_REQUEST
import boto3
dynamodb = boto3.resource('dynamodb' )
table = dynamodb.create_table(
TableName='Users' ,
KeySchema=[
{'AttributeName' : 'PK' , 'KeyType' : 'HASH' },
{'AttributeName' : 'SK' , 'KeyType' : 'RANGE' }
],
AttributeDefinitions=[
{'AttributeName' : 'PK' , 'AttributeType' : 'S' },
{'AttributeName' : 'SK' , 'AttributeType' : 'S' }
],
BillingMode='PAY_PER_REQUEST'
)
table.wait_until_exists()
Basic CRUD Operations import boto3
from boto3.dynamodb.conditions import Key, Attr
dynamodb = boto3.resource('dynamodb' )
table = dynamodb.Table('Users' )
table.put_item(
Item={
'PK' : 'USER#123' ,
'SK' : 'PROFILE' ,
'name' : 'John Doe' ,
'email' : 'john@example.com' ,
'created_at' : '2024-01-15T10:30:00Z'
}
)
response = table.get_item(
Key={'PK' : 'USER#123' , 'SK' : 'PROFILE' }
)
item = response.get('Item' )
table.update_item(
Key={'PK' : 'USER#123' , 'SK' : 'PROFILE' },
UpdateExpression='SET #name = :name, updated_at = :updated' ,
ExpressionAttributeNames={'#name' : 'name' },
ExpressionAttributeValues={
':name' : 'John Smith' ,
':updated' : '2024-01-16T10:30:00Z'
}
)
table.delete_item(
Key={'PK' : 'USER#123' , 'SK' : 'PROFILE' }
)
Query Operations
response = table.query(
KeyConditionExpression=Key('PK' ).eq('USER#123' )
)
response = table.query(
KeyConditionExpression=Key('PK' ).eq('USER#123' ) & Key('SK' ).begins_with('ORDER#' )
)
response = table.query(
KeyConditionExpression=Key('PK' ).eq('USER#123' ),
FilterExpression=Attr('status' ).eq('active' )
)
response = table.query(
KeyConditionExpression=Key('PK' ).eq('USER#123' ),
ProjectionExpression='PK, SK, #name, email' ,
ExpressionAttributeNames={'#name' : 'name' }
)
paginator = dynamodb.meta.client.get_paginator('query' )
for page in paginator.paginate(
TableName='Users' ,
KeyConditionExpression='PK = :pk' ,
ExpressionAttributeValues={':pk' : {'S' : 'USER#123' }}
):
for item in page['Items' ]:
print (item)
Batch Operations
with table.batch_writer() as batch:
for i in range (100 ):
batch.put_item(Item={
'PK' : f'USER#{i} ' ,
'SK' : 'PROFILE' ,
'name' : f'User {i} '
})
dynamodb = boto3.resource('dynamodb' )
response = dynamodb.batch_get_item(
RequestItems={
'Users' : {
'Keys' : [
{'PK' : 'USER#1' , 'SK' : 'PROFILE' },
{'PK' : 'USER#2' , 'SK' : 'PROFILE' }
]
}
}
)
Create 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"}
}
}
]'
Conditional Writes from botocore.exceptions import ClientError
try :
table.put_item(
Item={'PK' : 'USER#123' , 'SK' : 'PROFILE' , 'name' : 'John' },
ConditionExpression='attribute_not_exists(PK)'
)
except ClientError as e:
if e.response['Error' ]['Code' ] == 'ConditionalCheckFailedException' :
print ("Item already exists" )
table.update_item(
Key={'PK' : 'USER#123' , 'SK' : 'PROFILE' },
UpdateExpression='SET #name = :name, version = version + :inc' ,
ConditionExpression='version = :current_version' ,
ExpressionAttributeNames={'#name' : 'name' },
ExpressionAttributeValues={
':name' : 'New Name' ,
':inc' : 1 ,
':current_version' : 5
}
)
CLI Reference
Table Operations Command Description aws dynamodb create-tableCreate table aws dynamodb describe-tableGet table info aws dynamodb update-tableModify table/indexes aws dynamodb delete-tableDelete table aws dynamodb list-tablesList all tables
Item Operations Command Description aws dynamodb put-itemCreate/replace item aws dynamodb get-itemRead single item aws dynamodb update-itemUpdate item attributes aws dynamodb delete-itemDelete item aws dynamodb queryQuery by key aws dynamodb scanFull table scan
Batch Operations Command Description aws dynamodb batch-write-itemBatch write (25 max) aws dynamodb batch-get-itemBatch read (100 max) aws dynamodb transact-write-itemsTransaction write aws dynamodb transact-get-itemsTransaction read
Best Practices
Data Modeling
Design for access patterns — know your queries before designingUse composite keys — PK for grouping, SK for sorting/filteringPrefer query over scan — scans are expensiveUse sparse indexes — only items with index attributes are indexedConsider single-table design for related entities
Performance
Distribute partition keys evenly — avoid hot partitionsUse batch operations to reduce API callsEnable DAX for read-heavy workloadsUse projections to reduce data transfer
Cost Optimization
Use on-demand for variable workloadsUse provisioned + auto-scaling for predictable workloadsSet TTL for expiring dataArchive to S3 for cold data
Troubleshooting
Throttling Symptom: ProvisionedThroughputExceededException
Hot partition (uneven key distribution)
Burst traffic exceeding capacity
GSI throttling affecting base table
import time
from botocore.config import Config
config = Config(
retries={
'max_attempts' : 10 ,
'mode' : 'adaptive'
}
)
dynamodb = boto3.resource('dynamodb' , config=config)
Hot Partitions
aws cloudwatch get-metric-statistics \
--namespace AWS/DynamoDB \
--metric-name ConsumedReadCapacityUnits \
--dimensions Name=TableName,Value=Users \
--start-time $(date -d '1 hour ago' -u +%Y-%m-%dT%H:%M:%SZ) \
--end-time $(date -u +%Y-%m-%dT%H:%M:%SZ) \
--period 60 \
--statistics Sum
Add randomness to partition keys
Use write sharding
Distribute access across partitions
Query Returns No Items
Verify key values exactly match (case-sensitive)
Check key types (S, N, B)
Confirm table/index name
Review filter expressions (they apply AFTER read)
Scan Performance Issue: Scans are slow and expensive
Use parallel scan for large tables
Create GSI for the access pattern
Use filter expressions to reduce returned data
import concurrent.futures
def scan_segment (segment, total_segments ):
return table.scan(
Segment=segment,
TotalSegments=total_segments
)
with concurrent.futures.ThreadPoolExecutor() as executor:
results = list (executor.map (
lambda s: scan_segment(s, 4 ),
range (4 )
))
References 