Lambda

O AWS Lambda executa handlers Python sem gerenciar servidores. O boto3 permite invocar funções, publicar versões e automatizar implantações, mantendo o código da função em seu repositório.

Receita

import json
import boto3
 
client = boto3.client("lambda")
 
resp = client.invoke(
    FunctionName="process-order",
    InvocationType="RequestResponse",
    Payload=json.dumps({"order_id": "ord_123"}),
)
print(resp["StatusCode"], resp["Payload"].read())

Quando usar isso:

• Tarefas orientadas a eventos (S3, SQS, EventBridge)
• Cargas de trabalho infrequentes onde servidores sempre ativos desperdiçam dinheiro
• Fan-out assíncrono com InvocationType="Event"
• Código de cola entre serviços AWS gerenciados

Exemplo de Trabalho

Atualização de metadados de artefato de implantação, invocação síncrona e invocação assíncrona com tratamento de erros.

import json
import logging
 
import boto3
from botocore.exceptions import ClientError
 
log = logging.getLogger(__name__)
lambda_client = boto3.client("lambda")
 
def invoke_sync(function_name: str, payload: dict) -> dict:
    try:
        resp = lambda_client.invoke(
            FunctionName=function_name,
            InvocationType="RequestResponse",
            Payload=json.dumps(payload).encode(),
        )
    except ClientError as exc:
        log.error("invoke failed: %s", exc.response["Error"]["Code"])
        raise
    raw = resp["Payload"].read()
    return json.loads(raw or b"{}")
 
def invoke_async(function_name: str, payload: dict) -> int:
    resp = lambda_client.invoke(
        FunctionName=function_name,
        InvocationType="Event",
        Payload=json.dumps(payload).encode(),
    )
    return resp["StatusCode"]
 
if __name__ == "__main__":
    result = invoke_sync("demo-python-fn", {"action": "ping"})
    print(result)
    status = invoke_async("demo-python-fn", {"action": "enqueue"})
    print("async status", status)

O que isso demonstra:

• RequestResponse espera pelo retorno do handler; Event é "dispare e esqueça"
• O Payload deve ser bytes JSON para eventos estruturados
• Os códigos ClientError incluem ResourceNotFoundException, TooManyRequestsException

Mergulho Profundo

Como Funciona

• Envie o arquivo zip/imagem de contêiner para o Lambda; a string do handler aponta para module.function
• O "cold start" carrega o runtime Python e as importações; reutilize clientes fora do handler
• Limites de concorrência e concorrência reservada protegem sistemas downstream
• Versões e aliases (prod) permitem rollouts seguros

Notas de Empacotamento

Notas de Python

# handler.py - crie clientes boto3 fora do handler
import boto3
s3 = boto3.client("s3")
 
def handler(event, context):
    return {"ok": True, "remaining_ms": context.get_remaining_time_in_millis()}

Armadilhas

• Criar cliente boto3 a cada invocação - retarda cold/warm starts. Correção: reutilização do cliente no nível do módulo.
• Pacotes de implantação enormes - cold starts lentos. Correção: dependências enxutas, layers ou contêiner com venv pré-compilado.
• Bloquear o loop de eventos em handlers assíncronos - timeouts. Correção: descarregar trabalho de CPU ou usar handler síncrono com timeout/memória apropriados.
• Sem idempotência em retentativas assíncronas - efeitos colaterais duplicados. Correção: handlers idempotentes com chaves de deduplicação (SQS FIFO ou escritas condicionais do DynamoDB).
• Logging apenas para stdout sem estrutura - difícil de rastrear. Correção: logs JSON com request_id de context.aws_request_id.

Alternativas

FAQs

Relacionado

• AWS Lambda & Serverless - empacotamento e cold starts
• SQS & SNS - fontes de eventos
• S3 - gatilhos de objeto
• Noções Básicas de Boto3 - padrões de cliente
• Secrets Manager & SSM - segredos de ambiente

Versões da Stack: Esta página foi escrita para Python 3.14.0 (3.14 estável, 3.13 de manutenção), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ e uv 0.6+.