Händelsekällmappningar och strömbearbetning

Serverlösa applikationer med AWS Lambda

Claudio Canales

Senior DevOps Engineer

Händelsekällmappningens roll

Köer och strömmar avsöks ofta i batchar.
Händelsekällmappningar hanterar avsökning och batchbeteende.

Position för händelsekällmappning

Vad är en händelsekällmappning?

En resurs som kopplar en källa till din funktion.
Lambda avsöker källan efter poster.
Lambda anropar din handler med en batch.

Flöde för händelsekällmappning

Push vs. poll – varför det spelar roll

Push-modell

Push-källor skickar händelser omedelbart.
Exempel: en uppladdning till Amazon S3.

Poll-modell

Poll-källor avsöks av Lambda.
Lambda bygger en batch och anropar din handler.
Det påverkar latens och beteende vid omförsök.

Push- och poll-modeller

Kö vs. ström

Kö (Amazon SQS)

En hanterad meddelandekö, likt en inkorg.

Ström (DynamoDB Streams)

En ändringslogg för en DynamoDB-tabell.
Båda levereras som Records, men innebörden skiljer sig.

Jämförelse kö vs. ström

Batchhändelsens struktur (förenklad)

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

De flesta mappningshändelser börjar med Records.
Varje post har ett messageId och en body-sträng.
Parsa body till din egen nyttolast.

Genomgång: bearbeta varje post

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

Läs Records med en standardlista.
Iterera över posterna och läs body på ett säkert sätt.
Logga det du behöver och returnera sedan.

Genomgång: parsa JSON-kroppen

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}

Importera json och läs body med ett säkert standardvärde.
Parsa med json.loads för att få en dict.
Extrahera de fält du behöver och validera alltid först.

Batchning: batchstorlek och batchfönster

Batchstorlek: antal poster per anrop.
Batchfönster: hur länge Lambda väntar för att fylla en batch.
Större batchar ökar genomströmningen men kräver mer arbete per körning.
För SQS, bevaka ApproximateAgeOfOldestMessage för eftersläpning.

Diagram över batchstorlekskompromiss

Avvägningar kring batchstorlek

Stora batchar är effektiva men kan öka latensen.
Små batchar minskar tid till första bearbetning men ökar antalet anrop.
Välj utifrån din arbetsbelastning.

Diagram batchstorlek vs. latens

Skalning med parallellism

Flera batchar bearbetas samtidigt.
Högre parallellism ökar genomströmningen.
Men det ökar också belastningen nedströms.

Parallell batchbearbetning

Skydda nedströmssystem

För hög parallellism kan överbelasta en databas eller ett API.
Använd gränser för att styra belastningen.
Föredra små, hanterbara arbetsenheter.

Skydd av nedströmssystem

Partiella batchfel

En batch kan innehålla både giltiga och ogiltiga poster.
Utan partiell felhantering gör en felaktig post att hela batchen görs om.
Partiell felhantering gör att bara de misslyckade posterna görs om.

Flöde vid partiellt batchfel

Genomgång: rapportera partiella fel (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}

Samla messageId för misslyckade poster i batchItemFailures.
Lambda gör om enbart dessa poster.
Poster som bearbetats korrekt skickas inte igen.

Viktiga lärdomar

Händelsekällmappningar avsöker köer och strömmar.
De levererar Records i batchar till din handler.
Batchstorlek och fönster avväger latens mot genomströmning.
Partiella fel undviker ombearbetning av lyckade poster.

Sammanfattningsdiagram för mappning

Nu kör vi en övning!

Serverlösa applikationer med AWS Lambda