Mappages de source d'événements et traitement de flux

Applications serverless avec AWS Lambda

Claudio Canales

Senior DevOps Engineer

Où s'insèrent les mappages de source

Les files et flux sont souvent interrogés par lots.
Les mappages de source gèrent l'interrogation et le batching.

Position du mappage de source d'événements

Qu'est-ce qu'un mappage de source d'événements ?

Ressource qui connecte une source à votre fonction.
Lambda interroge la source pour des enregistrements.
Lambda invoque votre handler avec un lot.

Flux du mappage de source d'événements

Push vs poll (pourquoi c'est important)

Modèle push

Les sources push envoient les événements immédiatement.
Exemple : un upload vers Amazon S3.

Modèle poll

Les sources poll sont interrogées par Lambda.
Lambda regroupe en lot et invoque votre handler.
Cela impacte la latence et la gestion des reprises.

Modèles push vs poll

File vs flux

File d'attente (Amazon SQS)

File de messages managée, comme une boîte de réception.

Flux (DynamoDB Streams)

Journal des changements d'une table DynamoDB.
Les deux arrivent comme Records, mais leur sens diffère.

Comparaison file vs flux

Structure d'un événement par lot (simplifiée)

{
  "Records": [{
    "messageId": "abc-123",
    "body": "{\"order_id\": \"A-42\"}"
  }]
}

La plupart des événements de mappage commencent par Records.
Chaque enregistrement a un messageId et une chaîne body.
Analysez body pour obtenir votre charge utile.

Démo : traiter chaque enregistrement

def lambda_handler(event, context):
    records = event.get("Records", [])
    for record in records:
        body = record.get("body", "")
        print("BODY:", body)
    return {"statusCode": 200}

Lisez Records avec une liste par défaut.
Parcourez chaque enregistrement et lisez body en sécurité.
Journalisez l'essentiel, puis retournez la réponse.

Démo : analyser le corps JSON

import json

def lambda_handler(event, context):
    record = event.get("Records", [])[0]
    payload = json.loads(record.get("body", "{}"))
    order_id = payload.get("order_id")
    print("ORDER_ID:", order_id)
    return {"statusCode": 200}

Importez json et lisez body avec une valeur sûre.
Parsez avec json.loads pour obtenir un dict.
Extrayez les champs utiles ; validez toujours avant.

Batching : taille et fenêtre de lot

Taille de lot : nombre d'enregistrements par invocation.
Fenêtre de lot : temps d'attente de Lambda pour remplir un lot.
Des lots plus grands améliorent le débit mais ajoutent du travail par exécution.
Pour SQS, surveillez ApproximateAgeOfOldestMessage pour l'arriéré.

Diagramme compromis taille de lot

Compromis de la taille de lot

Les grands lots sont efficaces mais augmentent la latence.
Les petits lots réduisent le temps de premier traitement mais augmentent les invocations.
Choisissez selon votre charge.

Taille de lot vs latence

Mise à l'échelle par concurrence

Plusieurs lots sont traités en parallèle.
Une plus forte concurrence augmente le débit.
Mais elle accroît aussi la charge en aval.

Traitement simultané de lots

Protéger les systèmes en aval

Trop de concurrence peut saturer une base ou une API.
Utilisez des limites pour contrôler la charge.
Préférez de petites unités de travail sûres.

Protection de la charge en aval

Échecs partiels de lot

Un lot peut contenir de bons et de mauvais enregistrements.
Sans échecs partiels, un mauvais enregistrement relance tout le lot.
Les échecs partiels permettent de relancer seulement les éléments en erreur.

Flux d'échec partiel de lot

Démo : signaler des échecs partiels (SQS)

def lambda_handler(event, context):
    failures = []
    for record in event.get("Records", []):
        try:
            process(record)
        except Exception:
            failures.append({"itemIdentifier": record["messageId"]})
    return {"batchItemFailures": failures}

Collectez les messageId des enregistrements en échec dans batchItemFailures.
Lambda ne relance que ces éléments.
Les enregistrements réussis ne sont pas renvoyés.

Points clés

Les mappages de source interrogent files et flux.
Ils livrent des Records en lots à votre handler.
Taille et fenêtre de lot échangent latence et débit.
Les échecs partiels évitent de retraiter les succès.

Schéma récapitulatif du mappage

Passons à la pratique !

Applications serverless avec AWS Lambda