DynamoDB BatchGetItem en Python (boto3)

batch_get_item récupère jusqu'à 100 éléments par clé primaire en une seule requête (16 Mo max). Avec le client bas niveau boto3 tu passes une carte RequestItems table → clés — et tu dois boucler sur UnprocessedKeys, car un lot peut légitimement ne renvoyer qu'une partie de ce que tu as demandé.

Code

import time

import boto3

client = boto3.client("dynamodb")

request_items = {
    "Music": {
        "Keys": [
            {"Artist": {"S": "Arturo Sandoval"}, "SongTitle": {"S": "Cubano Chant"}},
            {"Artist": {"S": "Arturo Sandoval"}, "SongTitle": {"S": "A Mis Abuelos"}},
            {"Artist": {"S": "Ella Fitzgerald"}, "SongTitle": {"S": "Misty"}},
        ]
    }
}

items = []
attempt = 0

while request_items:
    response = client.batch_get_item(RequestItems=request_items)
    items.extend(response["Responses"].get("Music", []))

    # A partial result is NOT an error: throttling, a >16 MB response, or an
    # internal failure returns the leftovers in UnprocessedKeys. Retry them
    # with exponential backoff.
    request_items = response["UnprocessedKeys"]
    if request_items:
        attempt += 1
        time.sleep(min(0.1 * 2**attempt, 5))

print(f"Fetched {len(items)} items")

Explication

RequestItems — une carte nom de table → {"Keys": [...]} ; une requête peut couvrir plusieurs tables. Chaque clé doit être la clé primaire complète (partition + tri pour une clé composite), en DynamoDB JSON ({"S": ...}, {"N": ...}). Plus de 100 clés, ou la même clé deux fois, lève une ValidationException.
Responses — une carte nom de table → les éléments trouvés. Les éléments reviennent dans aucun ordre particulier, et les clés qui n'existent pas n'apparaissent tout simplement pas — associe les résultats aux requêtes par leurs attributs de clé.
UnprocessedKeys — la boucle de relance ci-dessus n'est pas optionnelle. Si la réponse dépasse 16 Mo, que le débit est épuisé, ou qu'une lecture de partition dépasse 1 Mo, DynamoDB renvoie le reste ici au format RequestItems, prêt à être réinjecté directement (une carte vide signifie terminé — falsy en Python, ce qui met fin au while). AWS recommande fortement un backoff exponentiel entre les tentatives.
Cohérence — les lectures par lot sont à terme par défaut ; définis "ConsistentRead": True par table pour des lectures fortement cohérentes.
Par table tu peux aussi passer ProjectionExpression (avec ExpressionAttributeNames) pour ne récupérer que certains attributs.
Tu préfères des types Python natifs au DynamoDB JSON ? L'API resource offre dynamodb.batch_get_item(...) avec des valeurs simples, mais le contrat de relance est le même — UnprocessedKeys est à toi de vider dans les deux cas.

À faire visuellement

Tu préfères ne pas assembler à la main des cartes de clés en DynamoDB JSON ? Le DynamoDB Expression Builder construit des cartes clé/valeur typées et copie du code exécutable, et le calculateur de taille d'élément montre à quel point un lot s'approche du plafond de 16 Mo.

Pour récupérer et inspecter des éléments sur plusieurs tables dans une interface graphique — aucune boucle de relance à écrire — télécharge DynoTable.

Exemples liés

DynamoDB BatchGetItem en Node.js — la même lecture par lot avec l'AWS SDK v3.
DynamoDB BatchGetItem avec l'AWS CLI — la même lecture par lot depuis le shell.
DynamoDB GetItem en Python — la lecture d'un seul élément que ceci regroupe en lot.
Opérations par lot dans DynamoDB — limites, échec partiel, et quand le regroupement en lot est payant.
"Too many items requested for the BatchGetItem call" — plus de 100 clés dans une seule requête.
"Provided list of item keys contains duplicates" — la même clé deux fois dans un seul lot.

References

Dernière vérification le 2026-07-13 par rapport à la documentation officielle AWS liée ci-dessus.