Mapeos de origen de eventos y procesamiento de streams

Aplicaciones sin servidor con AWS Lambda

Claudio Canales

Senior DevOps Engineer

Dónde encajan los mapeos de origen

Colas y streams se consultan a menudo en lotes.
Los mapeos de origen gestionan la consulta y el batching.

Posición del mapeo de origen

¿Qué es un mapeo de origen de eventos?

Recurso que conecta una fuente con tu función.
Lambda consulta la fuente en busca de records.
Lambda invoca tu handler con un lote.

Flujo de mapeo de origen

Push vs poll (por qué importa)

Modelo push

Las fuentes push envían eventos al instante.
Ejemplo: una carga en Amazon S3.

Modelo poll

Lambda consulta las fuentes poll.
Lambda construye un lote e invoca tu handler.
Cambia la latencia y el reintento.

Modelos push vs poll

Cola vs stream

Cola (Amazon SQS)

Cola de mensajes gestionada, como una bandeja de entrada.

Stream (DynamoDB Streams)

Registro de cambios de una tabla de DynamoDB.
Ambos llegan como Records, pero su significado difiere.

Comparación cola vs stream

Forma del evento por lotes (simplificada)

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

La mayoría de eventos empiezan con Records.
Cada record tiene messageId y un string body.
Analiza body a tu propio payload.

Paso a paso: procesar cada record

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

Lee Records con una lista por defecto.
Recorre cada record y lee body de forma segura.
Registra lo necesario y devuelve.

Paso a paso: parsear el cuerpo 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}

Importa json y lee body con un valor seguro.
Analiza con json.loads para obtener un dict.
Extrae los campos necesarios; valida primero.

Batching: tamaño y ventana del lote

Tamaño de lote: cuántos records por invocación.
Ventana de lote: cuánto espera Lambda para llenar un lote.
Lotes grandes mejoran el throughput pero añaden trabajo por ejecución.
En SQS, vigila ApproximateAgeOfOldestMessage para el backlog.

Diagrama de intercambio tamaño de lote

Intercambios del tamaño de lote

Lotes grandes son eficientes pero aumentan la latencia.
Lotes pequeños reducen el tiempo hasta el primer proceso pero aumentan invocaciones.
Elige según tu carga.

Tamaño de lote vs latencia

Escalado con concurrencia

Varios lotes se procesan al mismo tiempo.
Más concurrencia aumenta el throughput.
Pero también la carga aguas abajo.

Procesamiento concurrente de lotes

Protege los sistemas downstream

Demasiada concurrencia puede saturar una base de datos o API.
Usa límites para controlar la carga.
Prefiere unidades de trabajo pequeñas y seguras.

Protección de carga downstream

Fallos parciales de lote

Un lote puede tener records buenos y malos.
Sin fallos parciales, un record malo reintenta todo el lote.
Los fallos parciales permiten reintentar solo los fallidos.

Flujo de fallo parcial de lote

Paso a paso: informar fallos parciales (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}

Recoge los messageId fallidos en batchItemFailures.
Lambda reintenta solo esos items.
Los records correctos no se reenvían.

Puntos clave

Los mapeos de origen consultan colas y streams.
Entregan Records en lotes a tu handler.
Tamaño y ventana de lote cambian latencia vs throughput.
Los fallos parciales evitan reprocesar éxitos.

Diagrama resumen de mapeo

¡Vamos a practicar!

Aplicaciones sin servidor con AWS Lambda