LambdaComunidade
Nível de dificuldade: Avançado (4 de 5)
Um case real mostra como montar um app serverless completo com S3, CloudFront, API Gateway, Lambda e DynamoDB
Em números
- 45 minutos é o tempo que o autor do tutorial diz levar para montar a stack inteira, da tabela vazia ao primeiro registro salvo
- 1 MB é o limite de dados que cada chamada do
Scanno DynamoDB devolve, o que obriga a paginar a leitura na função GET - 3 métodos ficam registrados no resource raiz da API:
GET,POSTe oOPTIONSque o Enable CORS cria sozinho
O que você vai construir
O tutorial, publicado por bilal_bukhari_75aeb34a969 na DEV Community, descreve um app pequeno de propósito: uma página com um formulário de Student ID, Name, Class e Age, e um botão que lista todo mundo que já foi salvo. Não há servidor para atualizar, não há container para vigiar, e a conta praticamente não é cobrada quando ninguém está usando o app.
O valor do exercício não está na aplicação em si, mas em ver uma requisição atravessar cada peça gerenciada da AWS, do navegador até o banco e de volta. A arquitetura separa duas responsabilidades: o CloudFront entrega a página estática a partir de um bucket S3 privado, e o API Gateway recebe as chamadas da API direto do JavaScript rodando no navegador.
Se seu dia a dia já inclui escrever funções Lambda e desenhar rotas no API Gateway, o ganho aqui é ver o fluxo completo de ponta a ponta numa única vez, incluindo os dois erros mais comuns: o Lambda sem permissão certa e o CORS que passa no curl e quebra no navegador.
| Camada | Serviço | Função |
|---|---|---|
| Frontend | S3 + CloudFront | Entrega o HTML/JS via HTTPS |
| API | API Gateway (REST) | Expõe endpoints HTTP públicos |
| Compute | Lambda | Roda a lógica de GET e POST |
| Banco | DynamoDB | Guarda os registros de alunos |
| Segurança | IAM | Dá à Lambda acesso ao DynamoDB |
Pré-requisitos
- Uma conta AWS com acesso ao console (o autor usou
us-east-1; mantenha todos os serviços na mesma região, para evitar o clássico "cadê minha tabela" por causa de regiões diferentes) - Permissões IAM mínimas na sua própria conta de usuário para criar tabela no DynamoDB, papel no IAM, função Lambda, API REST no API Gateway, bucket S3 e distribuição CloudFront
- O papel de execução da Lambda precisa, no mínimo, de
dynamodb:PutItemedynamodb:Scanna tabela, maislogs:CreateLogGroup,logs:CreateLogStreamelogs:PutLogEventspara gravar no CloudWatch - Python básico (para as duas funções Lambda) e JavaScript básico (para o frontend)
curlou Postman para testar a API antes de tocar no navegador
Passo a passo
1. Crie a tabela no DynamoDB
A stack nasce do dado, não da API: sem tabela, não há o que as funções Lambda lerem ou escreverem depois.
- Abra
DynamoDB>Tables>Create table - Nomeie como
studentData - Defina a partition key como
studentid, tipoString, sem sort key - Escolha o modo de capacidade
On-demand, para pagar por requisição em vez de estimar RCU/WCU
Como studentid é a única chave, salvar um ID que já existe sobrescreve o registro. Para evitar isso, dá para adicionar uma condição no put_item que falha quando o ID já existe.
2. Crie o papel IAM para a Lambda
Nunca ponha credencial dentro do código: a Lambda assume um papel de execução, e as permissões viajam junto com a função.
- Abra
IAM>Roles>Create role - Entidade confiável: AWS service, serviço
Lambda - Anexe uma policy de acesso ao DynamoDB
- Nomeie como
lambda-dynamodb-write-role
O tutorial original anexa a policy gerenciada AmazonDynamoDBFullAccess só para destravar o fluxo rápido, e avisa que isso concede muito mais acesso do que o app precisa. Anexe também AWSLambdaBasicExecutionRole, que libera a gravação de logs no CloudWatch; sem ela, uma função que falha simplesmente falha em silêncio, e não sobra nada para investigar.
3. Escreva as duas funções Lambda
Nota da redação: o código desta seção não foi executado em ambiente real. Valide antes de usar em produção.
Com integração proxy no API Gateway, o event chega com a requisição HTTP inteira, e a função precisa devolver statusCode, headers e um body em string. Quem já mexeu com proxy integration sabe que o API Gateway não monta resposta nenhuma por conta própria: o que a função retorna é exatamente o que o navegador recebe, cabeçalho de CORS incluso.
A função de POST lê o corpo JSON, valida os campos obrigatórios e grava o item:
import json
import boto3
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table("studentData")
HEADERS = {
"Content-Type": "application/json",
"Access-Control-Allow-Origin": "*",
}
def response(status, message):
return {
"statusCode": status,
"headers": HEADERS,
"body": json.dumps({"message": message}),
}
def lambda_handler(event, context):
try:
body = json.loads(event.get("body") or "{}")
student_id = str(body.get("studentid", "")).strip()
name = str(body.get("name", "")).strip()
if not student_id or not name:
return response(400, "studentid and name are required")
item = {"studentid": student_id, "name": name, "class": str(body.get("class", "")).strip()}
age = body.get("age")
if age not in (None, ""):
item["age"] = int(age)
table.put_item(Item=item)
return response(200, "Student Data Saved!")
except Exception as e:
print(f"Error: {e}")
return response(500, "Internal server error")Repare que o response() centraliza os headers, então todo caminho de retorno, incluindo o de erro, inclui o Access-Control-Allow-Origin. O print no except é o que aparece no CloudWatch Logs na hora de depurar.
A função de GET tem uma pegadinha própria: o DynamoDB devolve números como Decimal, que o json.dumps não serializa sozinho, e o Scan devolve no máximo 1 MB por chamada:
from decimal import Decimal
def to_json(value):
if isinstance(value, Decimal):
return int(value) if value % 1 == 0 else float(value)
raise TypeError(f"Cannot serialize {type(value)}")
def lambda_handler(event, context):
response_data = table.scan()
items = response_data.get("Items", [])
while "LastEvaluatedKey" in response_data:
response_data = table.scan(ExclusiveStartKey=response_data["LastEvaluatedKey"])
items.extend(response_data.get("Items", []))
return {"statusCode": 200, "headers": HEADERS, "body": json.dumps(items, default=to_json)}O Scan lê a tabela inteira, o que é inofensivo com poucos registros mas fica lento e caro conforme a tabela cresce. Antes de ligar qualquer API, teste as duas funções direto no console da Lambda, com um evento de teste simulando event["body"] como string JSON: se a função falhar ali, o API Gateway só vai esconder o motivo.
4. Monte a API REST no API Gateway
- Abra
API Gateway>Create API>REST API - Nomeie como
StudentDataAPI - No resource raiz (
/), crie o métodoGETapontando para a função de leitura e o métodoPOSTapontando para a função de escrita, ambos com integração Lambda proxy ligada - Use
Enable CORSno resource, o que cria sozinho o métodoOPTIONS(uma integraçãoMock) que responde ao preflight do navegador - Faça o deploy para um stage, por exemplo
prod
Depois do deploy você recebe uma invoke URL no formato https://<api-id>.execute-api.us-east-1.amazonaws.com/prod. Vale testar por curl antes de tocar no frontend:
curl -X POST "https://<api-id>.execute-api.us-east-1.amazonaws.com/prod" \
-H "Content-Type: application/json" \
-d '{"studentid":"1","name":"Test Student","class":"Tenth","age":21}'
curl "https://<api-id>.execute-api.us-east-1.amazonaws.com/prod"Se os dois comandos funcionarem, o backend está pronto, e tudo que falta é o navegador.
5. Resolva o CORS antes de ele te resolver
Essa foi, segundo o autor, a parte que mais consumiu tempo no projeto inteiro:
Foi aqui que eu perdi mais tempo. A API funcionava perfeitamente no teste do console e no curl, mas o navegador se recusava a mostrar o resultado.
This is where I lost the most time. The API worked perfectly in the console test and in curl, but the browser refused to show the result.Bilal Bukhari, autor do tutorial na DEV Community
A causa é que a página e a API vivem em origens diferentes (um domínio CloudFront e um domínio execute-api). O navegador manda um OPTIONS de preflight antes de qualquer POST com corpo JSON cross-origin, e três coisas precisam bater:
- O método
OPTIONSprecisa existir e devolver os headersAccess-Control-Allow-*certos Access-Control-Allow-Headersprecisa incluirContent-Type, porque é esse header que dispara o preflight- As respostas da Lambda também precisam trazer
Access-Control-Allow-Origin, porque com proxy integration o API Gateway repassa os seus headers como estão, sem completar nada
Faltando qualquer um desses três, o erro de CORS aparece no console do navegador mesmo com a API saudável, porque o curl não aplica a política de CORS e segue funcionando normalmente. Vale lembrar também que qualquer mudança no API Gateway só vale depois de um novo deploy do stage.
6. Suba o frontend estático
A página é HTML e JavaScript puro, sem framework: um formulário, dois botões e uma tabela preenchida pela resposta da API.
const API_URL = "https://<api-id>.execute-api.us-east-1.amazonaws.com/prod";
async function saveStudent() {
const payload = {
studentid: document.getElementById("studentid").value,
name: document.getElementById("name").value,
class: document.getElementById("class").value,
age: document.getElementById("age").value,
};
const res = await fetch(API_URL, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(payload),
});
const data = await res.json();
document.getElementById("status").textContent = data.message;
}
async function loadStudents() {
const rows = document.getElementById("rows");
rows.innerHTML = "";
const res = await fetch(API_URL);
const students = await res.json();
students.forEach((s) => {
const tr = document.createElement("tr");
[s.studentid, s.name, s.class, s.age].forEach((value) => {
const td = document.createElement("td");
td.textContent = value ?? "";
tr.appendChild(td);
});
rows.appendChild(tr);
});
}Troque API_URL pela sua invoke URL do passo anterior. Usar textContent em vez de innerHTML nas células é um hábito pequeno que evita que um nome de aluno como <script>...</script> execute no navegador de quem estiver vendo a tabela. Suba o index.html para o bucket S3 privado e aponte uma distribuição CloudFront para esse bucket; assim a página sai por HTTPS sem o bucket ficar público.
Testando
- Rode os dois
curldo passo 4 antes de qualquer coisa no navegador: se eles passarem, o problema (se houver) está no CORS, não no backend - Abra a URL do CloudFront, preencha o formulário e clique em Save Student Data; a mensagem "Student Data Saved!" vem direto da resposta da Lambda
- Clique em View all Students e confira a tabela; o autor nota que a ordem dos registros não segue a ordem de inserção, porque é assim que o
Scando DynamoDB se comporta, sem garantia de ordem - Se a tabela não aparecer, abra o console do navegador antes de suspeitar da Lambda: um erro de CORS ali geralmente significa que o
OPTIONSou o headerAccess-Control-Allow-Headersficou faltando
Limpando os recursos
A conta AWS não cobra enquanto o app fica parado, mas alguns recursos continuam existindo até você apagar à mão.
- Apague a tabela
studentDatano DynamoDB - Apague as duas funções Lambda
- Apague a API
StudentDataAPIno API Gateway, o que remove o stageprodjunto - Desative e depois exclua a distribuição CloudFront (leva alguns minutos para propagar a desativação antes de permitir a exclusão)
- Esvazie e apague o bucket S3
- Apague o papel
lambda-dynamodb-write-roleno IAM
Com o modo On-demand do DynamoDB e os volumes baixos de um projeto de teste, a cobrança tende a ficar próxima de zero enquanto o app fica parado, como o próprio autor descreve. Vale conferir, na sua conta, se os serviços usados (Lambda, DynamoDB, API Gateway e CloudFront) ainda estão dentro de algum período promocional de Free Tier, porque isso muda conforme o tipo e a idade da conta.
Próximos passos
O autor já deixa claro que o projeto, do jeito que está, não é produção: ele mesmo promete, mais adiante no texto original, trocar a policy AmazonDynamoDBFullAccess por uma versão de least-privilege, e volta ao tema do Scan na lista de melhorias do fim do post. Na mesma linha, fazem sentido outras lacunas para fechar antes de usar essa base para algo real:
- Trocar
AmazonDynamoDBFullAccesspor uma policy própria, restrita apenas ao necessário na tabelastudentData - Trocar
ScanporQueryquando a tabela crescer, já que oScanlê a tabela inteira e fica mais lento e mais caro a cada registro novo - Adicionar autenticação na API, hoje totalmente aberta, por exemplo com
Cognitoou um autorizador Lambda na frente do API Gateway - Descrever a stack em código (CloudFormation, SAM ou CDK) em vez de clicar no console, para reproduzir o ambiente sem repetir os seis passos manualmente
- Trocar
Access-Control-Allow-Origin: *por um domínio específico quando o CloudFront tiver um domínio fixo, fechando o CORS só para quem deveria chamar a API
Para quem escreve Lambda e desenha API Gateway no dia a dia, o valor deste case não está na arquitetura em si, que é conhecida, mas no mapa de onde cada erro realmente mora: a permissão IAM que falta, o Content-Type que destrava o preflight e o Decimal que quebra o json.dumps sem aviso.
Fonte
DEV Community, #aws: "Building a Serverless Student Data App on AWS with S3, CloudFront, API Gateway, Lambda and DynamoDB", por bilal_bukhari_75aeb34a969 (https://dev.to/bilal_bukhari_75aeb34a969/building-a-serverless-student-data-app-on-aws-with-s3-cloudfront-api-gateway-lambda-and-dynamodb-27bm).
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: "Um case real mostra como montar um app serverless completo com S3, CloudFront, API Gateway, Lambda e DynamoDB" (https://awshub.com.br/comunidade/um-case-real-mostra-como-montar-um-app-serverless-completo-com-s3-cloudfront-api). Resumo: Um tutorial publicado na DEV Community percorre a stack inteira de um app serverless simples, da tabela no DynamoDB ao CORS que trava o navegador mesmo com a API saudável. Serve de roteiro para quem escreve Lambda e configura API Gateway no dia a dia. 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ã?