LambdaComunidade
Nível de dificuldade: Intermediário (3 de 5)
Chord roda todo o backend em Go Lambda e mantém a fatura da AWS baixa
A Chord é um estúdio de gravação no navegador (parecido com o Riverside): cada convidado grava localmente no próprio computador, o arquivo sobe em segundo plano e depois vira edição, transcrição, cortes e show notes. Quem documentou a arquitetura foi a própria equipe, no post "How We Built Chord's Backend on Go Lambdas (and Kept the AWS Bill Small)", publicado no DEV Community. O recorte interessa a quem escreve funções Lambda e desenha rotas em API Gateway: é uma decisão de arquitetura inteira, não um anúncio de serviço novo.
Em números
- 30 segundos é o teto fixo de timeout de integração das HTTP APIs do API Gateway, sem exceção.
- 15 minutos é a duração máxima de uma função Lambda, usada para os jobs assíncronos.
- 6 MB é o limite de payload síncrono (requisição e resposta) do Lambda, por isso mídia nunca passa pela API.
- 250 MB é o limite de pacote de deploy descompactado, somando código e camadas (layers) como o ffmpeg.
O problema
Uma sessão de gravação dura uma hora e depois fica ociosa por horas. Tráfego de produto de gravação é por natureza espaçado: picos curtos, vales longos. Dimensionar servidores para aguentar o pico e deixá-los ligados 24 horas por dia não fazia sentido para uma equipe pequena em estágio inicial.
O backend da Chord cobre gerenciamento de sessão, autenticação, upload de arquivos grandes, transcrição, fluxos de IA (como o Enhance speech) e renderização de exports. Um desenho clássico seria um punhado de servidores sempre ligados mais uma fila de jobs mais workers dedicados. A equipe queria o oposto: infraestrutura que custe perto de zero quando ninguém está gravando. Isso apontou direto para computação serverless.
A arquitetura
- O navegador do usuário chama um domínio customizado apontando para uma HTTP API do API Gateway.
- Um authorizer de JWT do Cognito valida o token antes de qualquer coisa chegar ao código: requisição não autenticada nunca invoca uma Lambda, e nunca é cobrada.
- Uma função Lambda em Go, rodando no runtime
provided.al2023, processa a lógica de negócio e fala com DynamoDB e S3. - Upload de mídia nunca passa pela API: o navegador recebe uma URL pré-assinada e envia o arquivo direto para o S3, contornando o limite de payload e o timeout da API.
- Tudo que pode levar mais que alguns segundos vira um job: a API grava um registro no DynamoDB, devolve
202com umjobIde um worker assíncrono (acionado por evento do S3, fila ou invocação assíncrona) faz o trabalho pesado com até 15 minutos de execução. - Para encode de vídeo completo, que estoura os 15 minutos e precisa de CPU constante, o worker roda em uma tarefa Fargate em vez de Lambda, mas lê e escreve nos mesmos buckets S3 e atualiza o mesmo registro de job.
- O cliente consulta o status do job até o resultado aparecer no S3, e rotas sensíveis a latência (como entrar numa sessão ao vivo) contam com concorrência provisionada agendada via Application Auto Scaling nos horários de pico de uso.
Os serviços envolvidos
- AWS Lambda: unidade de computação principal, rodando binários Go sobre
provided.al2023em arquiteturaarm64(Graviton). - API Gateway (HTTP APIs): expõe cada domínio de função como endpoint HTTPS, cuida de CORS, domínio customizado e integra o authorizer.
- Amazon Cognito: emite e valida os JSON Web Tokens checados pelo authorizer antes da invocação da Lambda.
- Amazon DynamoDB: guarda sessões, metadados e os registros de job que rastreiam o progresso do trabalho assíncrono.
- Amazon S3: recebe uploads via URL pré-assinada e armazena as saídas de processamento; é o contrato comum entre Lambda e Fargate.
- Amazon EventBridge: dispara o ping periódico que mantém ambientes de execução aquecidos nas rotas de baixo tráfego.
- AWS Fargate: processa encodes de vídeo completos, sem limite de duração, mas só cobrando enquanto a tarefa roda.
- Lambda Layers: empacotam
ffmpegeffprobecompartilhados entre as funções de mídia, sem duplicar o binário em cada zip.
Trade-offs
O pilar de otimização de custos do Well-Architected Framework é o fio condutor de toda a escolha: pagar por requisição e por milissegundo de computação, em vez de por capacidade de pico ligada o tempo todo. A tabela abaixo resume como a equipe comparou as duas abordagens.
| Aspecto | Servidores sempre ligados | Lambda + API Gateway |
|---|---|---|
| Custo em baixo tráfego | Paga capacidade de pico 24h | Paga por requisição, perto de zero ocioso |
| Escalonamento | Grupos de auto scaling, load balancer | Resolvido por função, pela AWS |
| Autenticação na borda | Middleware na aplicação | Authorizer do Cognito antes do código |
| Patch e atualização de SO | Responsabilidade do time | Responsabilidade da AWS |
| Trabalho de longa duração | Tranquilo | Limite rígido, exige outro desenho |
O pilar de confiabilidade aparece no padrão de job assíncrono: como cada job vira um registro no DynamoDB, uma nova tentativa sabe exatamente o que já foi feito, em vez de reprocessar do zero. E o pilar de excelência operacional guia a divisão de funções: a Chord não usa uma "Lambdalith" única nem uma função por rota, e sim uma função por domínio (sessions, recordings, tools), cada uma com memória, timeout e permissões IAM próprias — um meio-termo que mantém o número de unidades de deploy administrável.
Um detalhe que pesa desde agosto de 2025: a AWS passou a cobrar a fase de INIT também para funções empacotadas em ZIP em runtimes gerenciados. Runtimes customizados, caso do Go via provided.al2023, já eram cobrados nessa fase antes disso. Na prática, um init rápido deixou de ser só uma questão de latência e virou questão de custo direto na fatura.
Custo estimado
O post não publica um valor em dólares da fatura mensal da Chord, e por isso não há número de bill aqui — o que ele detalha é o modelo de precificação que mantém o gasto baixo. Lambda cobra por requisição e por milissegundo de execução, com uma camada gratuita que, segundo a equipe, cobre uma fatia surpreendente do tráfego inicial. Funções Graviton (arm64) custam menos por GB-segundo do que x86, e o Go cruza a compilação para ARM sem esforço extra, então essa economia é praticamente de graça.
O único custo fixo e previsível do desenho é a concorrência provisionada, usada apenas nas rotas onde a latência é o próprio produto, como entrar em uma sessão ao vivo. Ela é cobrada por hora enquanto estiver configurada, independente de tráfego — exatamente o custo "sempre ligado" que o resto da arquitetura tenta evitar. A saída foi agendar a concorrência provisionada com Application Auto Scaling, subindo nos horários de pico de uso dos usuários e descendo à noite.
Lambda não é de graça em escala. Passado um certo patamar de carga constante, containers ou VMs ganham no preço. Para um produto ainda encontrando seu mercado, com tráfego espaçado, esse ponto de equilíbrio está bem longe.
Lambda isn't free at scale. Past a certain steady load, containers or VMs win on price. For a product finding its market with spiky traffic, that break-even point is a long way off.Equipe de engenharia da Chord, post no DEV Community
Como adaptar
Quem quer replicar o padrão em Go sobre Lambda precisa decidir cedo onde ficam os limites, não depois que eles derem erro em produção:
- Compile para
arm64comCGO_ENABLED=0e a taglambda.norpc, que remove código de RPC usado só pelo runtime antigogo1.x(já descontinuado) e reduz o binário:
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 \
go build -tags lambda.norpc -o bootstrap ./cmd/sessions
zip sessions.zip bootstrap- Crie clientes de SDK (como o
dynamodb.Client) uma vez, eminit()ou em variável de pacote, nunca dentro do handler — eles sobrevivem entre invocações quentes e evitam custo de setup repetido. - Nunca envie mídia pela API: gere uma URL pré-assinada do S3 e deixe o navegador subir o arquivo direto, contornando ao mesmo tempo o limite de 6 MB e o timeout de 30 segundos.
- Transforme qualquer rota síncrona que passe de poucos segundos em um job: grave o registro no DynamoDB, devolva
202comjobId, processe num worker assíncrono com até 15 minutos, e deixe o cliente consultar o status. - Configure o timeout da Lambda sempre um pouco abaixo do timeout do API Gateway. Se o gateway desiste aos 30 segundos e a função tem 60, o cliente recebe um
504e a função continua rodando (e sendo cobrada) à toa. - Se usar
ffmpeg, empacote em uma layer combin/ffmpegebin/ffprobe(o/opt/binjá entra noPATH), compilado para a mesma arquitetura da função — um bináriox86numa funçãoarm64falha comexec format error. Dê mais memória às funções de mídia, porque a Lambda escala CPU junto com a memória, e derive um deadline do contexto para encerrar offmpeguns 10 segundos antes do limite:
if dl, ok := ctx.Deadline(); ok {
var cancel context.CancelFunc
ctx, cancel = context.WithDeadline(ctx, dl.Add(-10*time.Second))
defer cancel()
}
cmd := exec.CommandContext(ctx, "/opt/bin/ffmpeg", args...)- Meça antes de otimizar cold start: o CloudWatch já registra
Init Durationem todo cold start. Só depois de ver a frequência real por função decida entre um ping de aquecimento via EventBridge (barato, mas só garante ~1 ambiente quente) ou concorrência provisionada (cara, mas garantida) nas rotas onde latência é crítica. - Quando o trabalho passar dos 15 minutos ou precisar de CPU constante por muito tempo, como encode de vídeo completo, mova-o para Fargate mantendo o mesmo contrato: ler do S3, escrever no S3, atualizar o mesmo registro de job. A Chord relata que, ao paralelizar o encode em etapas e ajustar a qualidade (CRF 26 em saída 1080p), reduziu bastante o tamanho de arquivo sem perda perceptível, antes de simplesmente comprar mais computação.
Fonte: DEV Community — #aws
Serviços neste textoLambdaAPI Gateway
Na dúvida sobre qual usar?ECS, EKS ou Lambda?Três perguntas, a comparação e a nossa recomendaçãoLeve para a sua IA
Decida com o seu assistente, com o contexto deste texto já montado.
1. O que você quer saber
Ver o prompt
Li no AWS Hub: "Chord roda todo o backend em Go Lambda e mantém a fatura da AWS baixa" (https://awshub.com.br/comunidade/chord-roda-todo-o-backend-em-go-lambda-e-mantem-a-fatura-da-aws-baixa). Resumo: A equipe por trás da ferramenta de gravação Chord documentou, em post no DEV Community, como colocou sessões, uploads e até encoding de vídeo em funções Lambda escritas em Go, sem nenhum servidor rodando o dia inteiro. Serviços: Lambda, API Gateway Minha stack: [descreva em uma linha: serviços, linguagem, volume, região] Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?