AWS HubAWS HubSão Paulo operando · 2 eventos no mundo

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

Por AWS Hub10 min de leitura

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 Scan no DynamoDB devolve, o que obriga a paginar a leitura na função GET
  • 3 métodos ficam registrados no resource raiz da API: GET, POST e o OPTIONS que 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.

CamadaServiçoFunção
FrontendS3 + CloudFrontEntrega o HTML/JS via HTTPS
APIAPI Gateway (REST)Expõe endpoints HTTP públicos
ComputeLambdaRoda a lógica de GET e POST
BancoDynamoDBGuarda os registros de alunos
SegurançaIAMDá à 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:PutItem e dynamodb:Scan na tabela, mais logs:CreateLogGroup, logs:CreateLogStream e logs:PutLogEvents para gravar no CloudWatch
  • Python básico (para as duas funções Lambda) e JavaScript básico (para o frontend)
  • curl ou 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.

  1. Abra DynamoDB > Tables > Create table
  2. Nomeie como studentData
  3. Defina a partition key como studentid, tipo String, sem sort key
  4. 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.

  1. Abra IAM > Roles > Create role
  2. Entidade confiável: AWS service, serviço Lambda
  3. Anexe uma policy de acesso ao DynamoDB
  4. 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:

python
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:

python
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

  1. Abra API Gateway > Create API > REST API
  2. Nomeie como StudentDataAPI
  3. No resource raiz (/), crie o método GET apontando para a função de leitura e o método POST apontando para a função de escrita, ambos com integração Lambda proxy ligada
  4. Use Enable CORS no resource, o que cria sozinho o método OPTIONS (uma integração Mock) que responde ao preflight do navegador
  5. 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:

bash
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 OPTIONS precisa existir e devolver os headers Access-Control-Allow-* certos
  • Access-Control-Allow-Headers precisa incluir Content-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.

javascript
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 curl do 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 Scan do 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 OPTIONS ou o header Access-Control-Allow-Headers ficou 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 studentData no DynamoDB
  • Apague as duas funções Lambda
  • Apague a API StudentDataAPI no API Gateway, o que remove o stage prod junto
  • 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-role no 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 AmazonDynamoDBFullAccess por uma policy própria, restrita apenas ao necessário na tabela studentData
  • Trocar Scan por Query quando a tabela crescer, já que o Scan lê 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 Cognito ou 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ção

Leve 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ã?

Newsletter semanal

A semana da AWS, em português

Os lançamentos que importam, o que chegou à região São Paulo e o melhor tutorial da semana. Toda sexta, gratuita.