Como implantar um aplicativo Python no AWS Lambda em 2026: guia sem servidor

AWS Lambda executa seu código sem gerenciar servidores — você paga apenas pelo tempo de execução e ele escala automaticamente de zero a milhares de solicitações simultâneas. Este guia implanta uma API Python no Lambda com API Gateway do zero.

Quando usar o Lambda

• Bom ajuste: APIs com tráfego variável, jobs agendados, processamento de eventos, webhooks, microsserviços leves
• Ajuste ruim: Processos de longa duração (limite de 15 minutos), tráfego consistentemente alto (mais barato em servidores sempre ativos), aplicativos que precisam de conexões persistentes (WebSockets precisam de API Gateway v2)

Método 1: Função Lambda Simples (Console)

# handler.py — the entry point
import json

def lambda_handler(event, context):
    # event contains the request data
    name = event.get('queryStringParameters', {}).get('name', 'World')

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps({'message': f'Hello, {name}!'})
    }

Dependências de empacotamento

Lambda precisa de suas dependências agrupadas. Para pacotes comorequests:

# Install dependencies into a package directory
mkdir package
pip install requests -t package/

# Add your handler
cp handler.py package/

# Zip it
cd package
zip -r ../deployment.zip .
cd ..

# Upload deployment.zip to Lambda

Método 2: Estrutura sem servidor (recomendado)

npm install -g serverless
serverless create --template aws-python3 --path my-api
cd my-api
npm install serverless-python-requirements

# serverless.yml
service: my-api

provider:
  name: aws
  runtime: python3.12
  region: us-east-1
  environment:
    STAGE: ${sls:stage}
    DB_URL: ${env:DB_URL}

functions:
  api:
    handler: handler.lambda_handler
    events:
      - httpApi:
          path: /hello
          method: get
      - httpApi:
          path: /users/{id}
          method: get
    timeout: 29
    memorySize: 256

plugins:
  - serverless-python-requirements

custom:
  pythonRequirements:
    dockerizePip: true   # builds native deps in a Lambda-compatible container

# requirements.txt
requests==2.32.0
boto3==1.34.0

# Deploy
serverless deploy

# Output gives your API Gateway URL:
# endpoint: GET - https://abc123.execute-api.us-east-1.amazonaws.com/hello

Tratamento de eventos de gateway de API

import json

def lambda_handler(event, context):
    # httpApi (v2) event structure
    method = event['requestContext']['http']['method']
    path   = event['requestContext']['http']['path']
    params = event.get('pathParameters') or {}
    query  = event.get('queryStringParameters') or {}
    body   = json.loads(event['body']) if event.get('body') else {}

    if path.startswith('/users/'):
        user_id = params.get('id')
        return respond(200, {'userId': user_id})

    return respond(404, {'error': 'Not found'})

def respond(status, data):
    return {
        'statusCode': status,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(data)
    }

Gerenciando partidas a frio

O Lambda “inicia a frio” quando um novo contêiner é ativado (primeira solicitação ou após inatividade). Minimizar o impacto:

• Mantenha o pacote pequeno: Menos dependências = inicialização a frio mais rápida. Importe apenas o que você usa.
• Inicialize fora do manipulador: Clientes de banco de dados e configuração são carregados uma vez por contêiner, reutilizados em invocações quentes
• Usar simultaneidade provisionada para endpoints com latência crítica (mantém os contêineres aquecidos, tem custo extra)
• Aumentar a memória: Mais memória também significa mais CPU, reduzindo o tempo de inicialização

# ✅ Initialize clients OUTSIDE the handler (reused across invocations)
import boto3
dynamodb = boto3.resource('dynamodb')  # created once per container
table = dynamodb.Table('users')

def lambda_handler(event, context):
    # table is already initialized — no per-request setup cost
    return table.get_item(Key={'id': '1'})

Variáveis e segredos de ambiente

# Non-sensitive config: environment variables (serverless.yml)
environment:
  LOG_LEVEL: info

# Sensitive secrets: use AWS Secrets Manager or SSM Parameter Store
import boto3
ssm = boto3.client('ssm')

def get_secret(name):
    resp = ssm.get_parameter(Name=name, WithDecryption=True)
    return resp['Parameter']['Value']

DB_PASSWORD = get_secret('/myapp/db_password')  # loaded once per container

Perguntas Frequentes

P: Quanto custa o Lambda?
R: O nível gratuito inclui 1 milhão de solicitações e 400.000 GB-segundos mensais. Além disso, você paga por solicitação e por GB-segundo de execução. Para APIs de tráfego variável, geralmente é muito mais barato que um servidor sempre ativo.

P: Qual é o tempo máximo de execução?
R: 15 minutos. Para tarefas mais longas, use o AWS Step Functions para orquestrar vários Lambdas ou migre para o ECS/Fargate para processos de longa execução.

P: Como conecto o Lambda a um banco de dados?
R: Para bancos de dados compatíveis com serverless, use DynamoDB ou Aurora Serverless. Para Postgres/MySQL tradicional, use o RDS Proxy para gerenciar o pool de conexões (caso contrário, o dimensionamento do Lambda pode esgotar as conexões de banco de dados).

P: Posso executar uma estrutura web completa no Lambda?
R: Sim — use Mangum (para FastAPI/Starlette) ou Zappa (para Flask/Django) para adaptar aplicativos WSGI/ASGI ao Lambda. Bom para migrar aplicativos existentes, embora os manipuladores nativos sejam mais leves.

P: Como depuro o Lambda localmente?
R: Useserverless invoke local ou CLIs do AWS SAMsam local start-api para executar funções localmente. O CloudWatch Logs captura todos os logs de execução de produção.

Conclusão

O AWS Lambda permite implantar APIs Python que são dimensionadas automaticamente e não custam nada quando ociosas. A abordagem da estrutura sem servidor —serverless.yml maisserverless-python-requirements — lida com empacotamento, API Gateway e implantação em um comando. Inicialize clientes fora do manipulador para reduzir o custo de inicialização a frio, use o SSM/Secrets Manager para obter credenciais e alcance a simultaneidade provisionada somente quando a latência realmente for importante. É uma excelente opção para APIs de tráfego variável e cargas de trabalho orientadas a eventos.