Pular para o conteúdo
ArquiteCloud
Voltar

Deploy seguro de uma aplicação na AWS: rede, domínio, HTTPS e autenticação

Colocar uma aplicação no ar na AWS é fácil. Colocar uma aplicação no ar na AWS com segurança é outra história: envolve rede privada, controle de acesso em várias camadas, domínio próprio, HTTPS end-to-end, autenticação de usuários e proteção contra tráfego hostil. Este post cobre todos esses pontos de forma prática, comparando três arquiteturas diferentes para você escolher a que melhor cabe no seu caso.

As três arquiteturas resolvem o mesmo problema (publicar uma aplicação web segura) com perfis bem diferentes de custo, operação e flexibilidade. Elas compartilham o mesmo esqueleto de segurança: VPC com subnets públicas e privadas, Route 53 e ACM para domínio e HTTPS, Cognito User Pool para autenticação, WAF na borda e IAM com mínimo privilégio. A parte que muda é o que roda a aplicação em si.

Este post não cobre como construir a aplicação, nem como fazer CI/CD dela. O foco é o que acontece entre o código buildado e o usuário final acessando a URL com HTTPS, autenticado e dentro de uma rede controlada.

Custo: leia isso antes de executar qualquer comando

Vários componentes cobram por hora, ligados ou não

Diferente de serviços pay-as-you-go como S3 ou Lambda, boa parte dos componentes aqui (ALB, NAT Gateway, Fargate task, EC2) cobra por hora alocada, independente de tráfego. Uma VPC com NAT Gateway esquecida custa cerca de $32/mês sozinha, só pelo NAT, mesmo com zero bytes trafegando. Delete os recursos ao terminar.

Valores oficiais da AWS em outubro de 2026, região us-east-1:

ComponenteModelo de cobrançaCusto aproximado
Application Load BalancerPor hora + LCU~$16/mês + uso
NAT GatewayPor hora + GB processado~$32/mês + $0,045/GB
Fargate task (0.5 vCPU, 1 GB)Por segundo~$14/mês contínuo
EC2 t3.smallPor hora~$15/mês contínuo
API Gateway RESTPor requisição$3,50 por milhão
LambdaPor requisição + GB-sPraticamente grátis em baixo volume
CloudFrontPor GB + requisição1 TB/mês grátis para sempre
Route 53 hosted zonePor mês$0,50/mês + queries
ACM (certificado público)Grátis$0
Cognito User PoolPor MAU50 mil MAU/mês grátis
AWS WAFPor regra + requisição$5/mês/web ACL + $1/regra

A arquitetura serverless (API Gateway + Lambda) pode ficar praticamente de graça em volume baixo. As outras duas têm um piso mensal fixo por causa do ALB e, dependendo do desenho, do NAT Gateway. Volte nessa tabela sempre que precisar estimar o custo total.

Para uma visão geral de boas práticas de custo na AWS, confira o post sobre FinOps na AWS.

As três arquiteturas em uma linha

Antes de qualquer coisa, uma visão rápida das três para você se situar:

Arquitetura 1 (corporativa): ECS Fargate + ALB + CloudFront. Containers rodando em subnets privadas atrás de um Application Load Balancer, com CloudFront na frente para cache e borda. É a opção que empresas escolhem quando a app precisa de containers, controle fino de rede e já tem time operando ECS. Custo mensal piso: ~$50 (ALB + NAT + task).

Arquitetura 2 (baixo custo, serverless): API Gateway + Lambda. Nada de servidores, nada de ALB. API Gateway recebe o tráfego, autoriza via Cognito e invoca Lambda. CloudFront na frente é opcional, mas vale a pena. Custo piso: perto de zero. Escala para milhões sem você mexer. Para fundamentos de Lambda, veja o post sobre AWS Lambda.

Arquitetura 3 (didática): EC2 em subnet privada + ALB. Uma ou mais instâncias EC2 numa subnet privada, atrás de um ALB público. Acesso administrativo via SSM Session Manager (sem bastion, sem porta 22 aberta). É a mais “manual”, excelente para entender o que as outras duas abstraem. Custo piso parecido com a arquitetura 1.

Trade-offs resumidos:

CritérioECS FargateAPI Gateway + LambdaEC2 + ALB
Custo mínimo mensal~$50~$1~$50
Escala automáticaSim (ECS Service)Sim (nativa)Sim (ASG)
Cold startNãoSim (ms a s)Não
Controle do runtimeAlto (container)Baixo (runtime fixo)Total (SO)
Complexidade operacionalMédiaBaixaAlta
Melhor paraApps longas, workersAPIs event-drivenAprender, legados

Escolha pela coluna que menos dói. Se você tem container pronto e tráfego previsível, Fargate. Se é API com tráfego irregular, Lambda. Se precisa de controle total do SO ou está migrando um legado, EC2.

Pré-requisitos

Fundamentos de segurança que valem para as três

Antes de descer no detalhe de cada arquitetura, vale fixar os princípios que aparecem em todas. Se você ignorar qualquer um deles, nenhuma das três arquiteturas é segura, por melhor que esteja o resto.

Defense in depth: camadas, não castelos

Segurança na AWS funciona em camadas sobrepostas: borda (WAF, CloudFront), rede (VPC, subnets, security groups, NACLs), aplicação (autenticação, autorização), dados (criptografia em repouso e em trânsito) e identidade (IAM). Uma falha em uma camada deve ser contida pela próxima, nunca abrir caminho direto para o dado. Isso é o oposto de “firewall perimetral”: você assume que a borda pode falhar e desenha para que isso não seja catastrófico.

VPC: a fronteira que você controla

Toda arquitetura aqui vive dentro de uma VPC (Virtual Private Cloud): uma rede isolada só sua, com faixa de IPs que você escolhe (ex. 10.0.0.0/16). Dentro dela, você cria subnets:

Regra de ouro: a aplicação nunca fica em subnet pública. Nem Fargate, nem Lambda em VPC, nem EC2. Quem recebe tráfego público é o ALB (ou CloudFront, ou API Gateway), e ele conversa com a aplicação por dentro da VPC.

flowchart TD Internet((Internet)) subgraph Publica["Subnet pública · 10.0.1.0/24"] ALB[ALB] NAT[NAT Gateway] end subgraph Privada["Subnet privada · 10.0.11.0/24"] Task["Fargate task / EC2 / Lambda ENI"] end Internet --> ALB ALB --> Task Task --> NAT --> Internet

Sempre crie duas subnets públicas e duas privadas, em Availability Zones diferentes (ex. us-east-1a e us-east-1b). ALB exige no mínimo duas AZs, e isso te dá alta disponibilidade de graça.

Security Groups: firewall stateful por recurso

Security Groups (SGs) são firewalls de camada 4 anexados a cada recurso (ENI, task, instância). São stateful: se você permite entrada, a resposta sai automaticamente, não precisa configurar o retorno.

A regra que mais importa: SGs se referenciam entre si, não via IP. Em vez de “permita 10.0.11.0/24 na porta 8080”, escreva “permita o SG do ALB na porta 8080”. Assim, se as subnets mudarem, nada quebra, e a intenção fica explícita.

Exemplo típico para a arquitetura 1 (Fargate atrás de ALB):

Nunca abra portas administrativas (22, 3389) para a internet. Para acessar EC2 sem bastion, use SSM Session Manager (detalhe na arquitetura 3).

IAM: mínimo privilégio sempre

Toda arquitetura precisa de pelo menos duas IAM Roles:

Evite roles de admin em produção

AdministratorAccess em role de aplicação é a origem mais comum de incidente de segurança na AWS. Se um atacante achar uma falha de SSRF na sua app, ele usa essa role inteira. Com uma role restrita, o dano fica contido.

HTTPS end-to-end: ACM resolve, mas não automático

HTTPS entre usuário e borda (CloudFront ou ALB) é obrigatório e grátis com ACM (AWS Certificate Manager). HTTPS entre borda e aplicação é opcional mas recomendado: terminar TLS no ALB e falar HTTP interno é aceitável dentro de VPC, mas se você precisa de compliance (PCI, HIPAA), termine TLS também na aplicação ou use mTLS. Detalhes de configuração ficam na seção de domínio e HTTPS.

Arquitetura 1: ECS Fargate + ALB + CloudFront (corporativo)

Quando usar: app containerizada, tráfego previsível, time que já opera ECS ou quer evoluir para operar. Ótimo para APIs internas de empresa, backends de SPA, workers HTTP.

Diagrama:

flowchart TD User([Usuário]) CF["CloudFront<br/>WAF + cache de borda"] ALB["ALB<br/>subnet pública · SG permite 443 do CloudFront"] Task["Fargate tasks<br/>subnet privada · SG permite 8080 só do ALB"] Data["RDS / DynamoDB / S3<br/>via VPC endpoints quando possível"] User -- "HTTPS (443)" --> CF CF -- "HTTPS (443)" --> ALB ALB -- "HTTP (8080) dentro da VPC" --> Task Task --> Data

Passo 1: cluster ECS e task definition

Crie um cluster ECS tipo Fargate e uma task definition apontando para sua imagem no ECR:

// task-definition.json
{
  "family": "minha-app",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::123456789012:role/minha-app-task-role",
  "containerDefinitions": [
    {
      "name": "app",
      "image": "123456789012.dkr.ecr.us-east-1.amazonaws.com/minha-app:latest",
      "portMappings": [{ "containerPort": 8080, "protocol": "tcp" }],
      "essential": true,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/minha-app",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "app"
        }
      }
    }
  ]
}

Pontos de atenção:

Registre com:

aws ecs register-task-definition --cli-input-json file://task-definition.json

Passo 2: ALB e target group

Crie o ALB nas duas subnets públicas, com SG permitindo entrada 443 só do CloudFront (próxima etapa). Target group aponta para a porta 8080 das tasks, tipo ip (obrigatório com awsvpc).

Health check do target group: path tipo /health retornando 200. Se a app não tem health endpoint, crie um que retorne só OK. Sem health check saudável, o ALB nunca manda tráfego.

Passo 3: ECS Service

aws ecs create-service \
  --cluster meu-cluster \
  --service-name minha-app \
  --task-definition minha-app \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[subnet-priv-a,subnet-priv-b],securityGroups=[sg-task],assignPublicIp=DISABLED}" \
  --load-balancers "targetGroupArn=arn:...,containerName=app,containerPort=8080"

Pontos importantes:

Passo 4: CloudFront na frente

Crie uma distribuição CloudFront com o ALB como origem. Configure:

Para fechar o ALB só ao CloudFront, use AWS managed prefix list com.amazonaws.global.cloudfront.origin-facing no SG do ALB em vez de 0.0.0.0/0. Isso impede que alguém descubra o DNS do ALB e passe por cima do CloudFront e do WAF.

Custom header como segundo cadeado

Além da prefix list, configure o CloudFront para injetar um header X-Origin-Verify: <segredo> e faça o ALB rejeitar requisições sem esse header via listener rule. Dois cadeados, mesma porta.

Arquitetura 2: API Gateway + Lambda (baixo custo, serverless)

Quando usar: API HTTP/REST, tráfego irregular (de zero a picos), time pequeno, baixo apetite para operar servidor. Fica literalmente gratuita abaixo de ~1 milhão de requisições por mês.

Diagrama:

flowchart TD User([Usuário]) CF["CloudFront<br/>WAF + cache opcional"] APIGW["API Gateway<br/>REST ou HTTP API, com Cognito authorizer"] Lambda["Lambda<br/>opcional em VPC, com role mínima"] Data["DynamoDB / S3 / RDS Proxy"] User -- "HTTPS (443)" --> CF CF -- "HTTPS" --> APIGW APIGW -- "invocação síncrona/assíncrona" --> Lambda Lambda --> Data

Diferenças em relação à arquitetura 1:

Passo 1: função Lambda

Crie a função com runtime (Python, Node, etc.), código mínimo e role restrita. Role padrão deve ter só AWSLambdaBasicExecutionRole (logs no CloudWatch) e as policies específicas de recursos que a função acessa. Para fundamentos, veja o post sobre AWS Lambda.

Se a Lambda precisa acessar recurso dentro da VPC (RDS, por exemplo), configure VPC/subnets/SG. Só coloque em VPC se precisar: Lambda em VPC fica atrás de ENIs, aumenta cold start e exige NAT Gateway se precisar de internet.

Passo 2: API Gateway

Dois sabores:

Vamos com HTTP API. Crie rotas (GET /items, POST /items) apontando para a Lambda como integração. Deploy em stage (prod).

Autorização via Cognito User Pool (configurada na próxima seção):

{
  "AuthorizationType": "JWT",
  "JwtConfiguration": {
    "Issuer": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_XXXX",
    "Audience": ["<app-client-id>"]
  },
  "IdentitySource": ["$request.header.Authorization"]
}

Cada rota declara se é protegida. Rotas públicas (ex. GET /health) não precisam do authorizer.

Passo 3: resource policy (opcional, mas poderoso)

Se a API deve ser acessível só a partir do CloudFront (ou de IPs específicos), aplique uma resource policy no API Gateway:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Principal": "*",
      "Action": "execute-api:Invoke",
      "Resource": "arn:aws:execute-api:us-east-1:123456789012:abcd/*",
      "Condition": {
        "StringNotEquals": {
          "aws:SourceVpce": "vpce-0123456789abcdef0"
        }
      }
    }
  ]
}

Esse exemplo bloqueia tudo que não venha de um VPC Endpoint específico. Variantes comuns: bloquear por IP, por conta AWS de origem, por aws:SourceArn do CloudFront.

Passo 4: CloudFront na frente (opcional mas recomendado)

API Gateway já tem HTTPS, mas colocar CloudFront na frente dá:

Configure o CloudFront com o endpoint do API Gateway como origem e um header customizado X-Origin-Verify que o API Gateway valida via resource policy. Mesmo truque da arquitetura 1.

Lambda@Edge vs CloudFront Functions

Para lógica simples na borda (reescrever header, redirect, geoblock leve), CloudFront Functions é mais barato e mais rápido que Lambda@Edge. Lambda@Edge só vale a pena quando você precisa de runtime completo (chamar outra AWS API, ler segredo).

Arquitetura 3: EC2 em subnet privada + ALB (didático)

Quando usar: você está aprendendo e quer ver cada peça com clareza, ou está migrando um legado que precisa de controle total do SO (agentes antigos, pacotes específicos, licença amarrada a instância). Em produção nova, prefira as outras duas.

Diagrama:

flowchart TD User([Usuário]) ALB["ALB<br/>subnet pública"] EC2["EC2 instance<br/>subnet privada · SG permite 80 só do ALB"] NAT["NAT Gateway<br/>saída para apt/yum/pip"] SSM["SSM Session Manager<br/>acesso administrativo"] Internet((Internet)) User -- "HTTPS (443)" --> ALB ALB -- "HTTP (80 ou 8080)" --> EC2 EC2 --> NAT --> Internet SSM --> EC2

Passo 1: AMI e user data

Escolha uma AMI gerenciada (Amazon Linux 2023 é um bom default). O user data roda uma vez no primeiro boot e é onde você instala e sobe a aplicação:

#!/bin/bash
dnf update -y
dnf install -y python3 python3-pip
pip3 install gunicorn minha-app
cat > /etc/systemd/system/app.service <<'EOF'
[Unit]
Description=Minha app
After=network.target

[Service]
ExecStart=/usr/local/bin/gunicorn -b 0.0.0.0:8080 minha_app:app
Restart=always
User=app

[Install]
WantedBy=multi-user.target
EOF
useradd -r app
systemctl enable --now app

Para apps mais sérias, builde uma AMI própria (Packer) ou um container e migre para a arquitetura 1. User data é ótimo para aprender, ruim para repetibilidade.

Passo 2: instance profile com SSM

A instância não deve ter chave SSH associada. O acesso administrativo vai ser via SSM Session Manager: você abre um shell direto no console ou via CLI, sem porta 22 aberta, sem bastion, com log de sessão no CloudWatch.

Para isso funcionar, crie uma IAM role (instance profile) com a policy gerenciada AmazonSSMManagedInstanceCore. Anexe à instância. O agente SSM já vem instalado nas AMIs oficiais Amazon Linux.

Conectar:

aws ssm start-session --target i-0abc123def456

Caiu dentro da instância, sem nunca ter aberto a 22. Toda sessão fica logada; você pode auditar quem entrou e o que digitou.

SSM Session Manager > bastion

Bastion host é padrão antigo: custa VM extra, exige rotação de chaves, expõe porta SSH. SSM resolve com IAM, log central e zero portas abertas. Em projeto novo, não use bastion.

Passo 3: Auto Scaling Group e Launch Template

Em vez de uma instância solta, use Launch Template + Auto Scaling Group (ASG) com no mínimo duas AZs e capacidade mínima 2. O ASG:

Target group do ALB aponta para o ASG, não para IPs fixos. Instância subiu, registrou-se no target group, começou a receber tráfego. Caiu, foi desregistrada, substituída.

Passo 4: patches e hardening

EC2 é o único dos três onde você é responsável pelo SO. Isso inclui:

Isso tudo é trabalho que Fargate e Lambda fazem por você. É o preço do controle.

Domínio e HTTPS: Route 53 + ACM

Essa parte é comum às três arquiteturas e vale a pena fazer antes de expor qualquer endpoint ao usuário final.

Passo 1: hosted zone no Route 53

Mesmo que o domínio esteja em outro registrar (GoDaddy, Registro.br), crie uma hosted zone no Route 53. Você vai usar essa hosted zone para gerenciar os registros e, no registrar externo, só aponta os nameservers do Route 53.

aws route53 create-hosted-zone \
  --name seudominio.com \
  --caller-reference $(date +%s)

A resposta traz quatro nameservers (ns-123.awsdns-...). Configure eles no registrar e aguarde a propagação (de minutos a algumas horas).

Passo 2: certificado ACM

Peça um certificado público para o nome do seu app (app.seudominio.com). ACM é grátis para uso em serviços AWS integrados (ALB, CloudFront, API Gateway).

Região do certificado importa

Certificado para ALB fica na mesma região do ALB. Certificado para CloudFront precisa estar em us-east-1, sempre, independente de onde a app roda. Peça dois certificados se usa CloudFront + ALB em outra região.

aws acm request-certificate \
  --domain-name app.seudominio.com \
  --validation-method DNS \
  --region us-east-1

Validação DNS, não email. ACM mostra um CNAME que você precisa criar na hosted zone. Faça isso no mesmo Route 53 (um clique no console: “Create records in Route 53”). Em poucos minutos, o certificado fica Issued.

Passo 3: registro alias para o endpoint

Com o certificado válido, anexe-o ao CloudFront/ALB/API Gateway e crie um alias record apontando app.seudominio.com para o endpoint:

Alias é um registro específico do Route 53 que resolve direto para o recurso AWS, sem custo de query e sem precisar atualizar manualmente quando o IP muda.

Passo 4: forçar HTTPS

Configure redirecionamento HTTP (80) para HTTPS (443) na borda:

E habilite HSTS (HTTP Strict Transport Security) via header Strict-Transport-Security: max-age=63072000; includeSubDomains; preload na resposta. No CloudFront, use Response Headers Policy com a política gerenciada SecurityHeadersPolicy como ponto de partida.

Teste com SSL Labs

Depois de configurar, rode https://www.ssllabs.com/ssltest/ no seu domínio. Nota A ou A+ é alvo razoável. CloudFront com cipher suite padrão já entrega A.

Autenticação com Cognito User Pool

Até aqui, qualquer um com a URL acessa a aplicação. Agora vamos exigir que o usuário faça login antes de passar pelo ALB ou API Gateway.

Cognito User Pool é o serviço gerenciado da AWS para diretório de usuários: cadastro, login, MFA, recuperação de senha, federação com Google/Microsoft/SAML. Ele emite tokens JWT (ID token e access token) que o ALB e o API Gateway sabem validar nativamente.

Passo 1: criar o User Pool

No console, Cognito → User Pools → Create user pool. Pontos que importam:

Anote o User Pool ID (ex. us-east-1_ABCdef123).

Passo 2: App Client

Dentro do User Pool, crie um App Client:

Habilite o Hosted UI e configure um domínio Cognito (ex. minha-app.auth.us-east-1.amazoncognito.com) ou um domínio customizado (exige certificado ACM em us-east-1).

Passo 3a: integração com ALB (arquiteturas 1 e 3)

ALB tem autenticação Cognito nativa via listener rule. No listener HTTPS do ALB, antes da action forward to target group, adicione uma action authenticate-cognito:

{
  "Type": "authenticate-cognito",
  "AuthenticateCognitoConfig": {
    "UserPoolArn": "arn:aws:cognito-idp:us-east-1:123456789012:userpool/us-east-1_ABCdef123",
    "UserPoolClientId": "<app-client-id>",
    "UserPoolDomain": "minha-app",
    "SessionTimeout": 604800,
    "Scope": "openid email profile",
    "OnUnauthenticatedRequest": "authenticate"
  }
}

O que acontece: usuário sem sessão é redirecionado para o Hosted UI do Cognito, faz login, volta para o ALB, que valida o código, troca por tokens, cria uma sessão (cookie AWSELBAuthSessionCookie) e manda a requisição para a task com headers extras:

Autenticação resolvida sem código na aplicação. A app só lê o header x-amzn-oidc-data para saber quem é o usuário.

Valide a assinatura do x-amzn-oidc-data

Se a app aceitar x-amzn-oidc-data sem validar a assinatura, qualquer um que descobrir o DNS do ALB e passar o header forjado vira “usuário autenticado”. Valide com a chave pública do ALB (publicada em um endpoint regional da AWS) ou feche o ALB ao CloudFront com prefix list + custom header, como discutido antes.

Passo 3b: integração com API Gateway (arquitetura 2)

API Gateway valida JWT nativamente via JWT authorizer (HTTP API) ou Cognito authorizer (REST API). O front-end chama o Hosted UI, obtém o token, e manda em Authorization: Bearer <token> em cada requisição.

Configuração do JWT authorizer já ficou no bloco da arquitetura 2. Issuer é o endpoint do User Pool, Audience é o App Client ID.

Para autorização mais granular (ex. só admins acessam /admin/*), inclua groups no Cognito e cheque o claim cognito:groups no token, seja no API Gateway (via Lambda authorizer) ou na própria Lambda.

Passo 4: cadastro inicial e MFA

Para app corporativa, crie usuários via CLI ou SDK:

aws cognito-idp admin-create-user \
  --user-pool-id us-east-1_ABCdef123 \
  --username joao@empresa.com \
  --user-attributes Name=email,Value=joao@empresa.com Name=email_verified,Value=true \
  --desired-delivery-mediums EMAIL

Cognito envia email com senha temporária. No primeiro login, o usuário troca a senha e, se MFA for required, configura o TOTP.

WAF, logs e monitoramento

Com rede, HTTPS e autenticação no lugar, falta a camada de borda contra tráfego hostil e a observabilidade para saber que a coisa está funcionando (e para investigar quando não estiver).

AWS WAF: regras gerenciadas resolvem 90%

Crie uma Web ACL e associe ao CloudFront, ALB ou API Gateway. As regras gerenciadas da AWS cobrem a maior parte dos ataques comuns:

Adicione também uma regra customizada de rate limiting:

{
  "Name": "RateLimitPerIP",
  "Priority": 10,
  "Statement": {
    "RateBasedStatement": {
      "Limit": 2000,
      "AggregateKeyType": "IP"
    }
  },
  "Action": { "Block": {} },
  "VisibilityConfig": { "SampledRequestsEnabled": true, "CloudWatchMetricsEnabled": true, "MetricName": "RateLimitPerIP" }
}

Limite de 2000 requisições por IP em 5 minutos é razoável para APIs normais. Ajuste conforme o perfil de tráfego real.

Comece com Count, depois Block

Rode as regras em modo Count por uma semana e olhe as métricas no CloudWatch. Se nenhum falso positivo aparecer, troque para Block. Em prod ativa, ligar Block sem observar derruba tráfego legítimo.

Logs: o que ligar

Monitoramento mínimo

GuardDuty: ativar e esquecer

Amazon GuardDuty é um serviço de detecção de ameaças que lê CloudTrail, VPC Flow Logs e DNS logs em segundo plano procurando padrão suspeito (ex. instância conversando com IP de botnet conhecido). Custa pouco em contas pequenas, ativa em um clique, manda achados para EventBridge. Em qualquer conta minimamente séria, deixe ligado.

Observações importantes

Alguns pontos que não cabem em uma seção específica mas pegam todo mundo em algum momento.

NAT Gateway é o vilão silencioso do extrato. $32/mês de piso por AZ, mais $0,045 por GB processado. Se a app faz muito tráfego para internet (puxar imagens grandes do ECR, por exemplo), use VPC Endpoints de interface para ECR, S3, CloudWatch Logs, Secrets Manager. Cada endpoint custa menos que o tráfego pelo NAT em volume médio.

ALB cobra por LCU, não só por hora. Cada LCU inclui 25 conexões novas/s, 3000 conexões ativas, 1 GB processado e 1000 regras. Em app pequena, você fica dentro de 1 LCU e paga só a hora. Em volume alto, monitore o custo de LCU.

Lambda em VPC + NAT Gateway é armadilha. Se a Lambda chama só APIs AWS, prefira VPC endpoints em vez de NAT Gateway. Mais barato e mais seguro (tráfego não sai da AWS).

Troque chaves de acesso por IAM Roles. Nunca coloque access key + secret dentro de container, instância, ou Lambda. Use role (task role, instance profile, execution role) e deixe o SDK pegar credencial temporária via metadata.

Rotacione segredos no Secrets Manager, não hardcode. Senhas de banco, API keys de terceiros, qualquer coisa sensível vai no Secrets Manager com rotação habilitada. A role da aplicação lê o segredo em runtime via SDK.

Multi-conta é padrão em escala. Para projetos pequenos, uma conta basta. A partir de um certo tamanho, separe em contas (dev, staging, prod) via AWS Organizations. Isso é defesa real: falha em dev não contamina prod.

Limpeza ao terminar. Se montou o laboratório só para aprender, delete nessa ordem para evitar bloqueios de dependência:

  1. CloudFront (desabilitar + delete, demora ~15 min).
  2. ECS Service (set desired count 0 → delete) ou Lambda.
  3. ALB e target groups.
  4. NAT Gateway (demora ~5 min para sumir).
  5. VPC Endpoints.
  6. Cognito User Pool (opcional, não cobra parado).
  7. Hosted Zone no Route 53 (cobra $0,50/mês parada).
  8. VPC inteira (só delete depois que o resto saiu).

ACM certificate pode ficar, não cobra. CloudWatch logs vão expirando sozinhos se você configurou retenção (recomendado: 30 dias para log de app, 90+ para audit).

Recapitulando

Você viu três arquiteturas completas para publicar uma aplicação na AWS com segurança: ECS Fargate para quem quer container corporativo, API Gateway + Lambda para quem quer baixo custo e escala serverless, EC2 em subnet privada para quem precisa de controle total ou está aprendendo. As três compartilham o mesmo esqueleto: VPC bem desenhada, security groups referenciando security groups, IAM com mínimo privilégio, Route 53 + ACM para domínio e HTTPS, Cognito User Pool para autenticação, WAF na borda e observabilidade com CloudWatch + CloudTrail + GuardDuty.

A segurança boa na AWS não é um botão, é um conjunto de decisões pequenas e disciplinadas em cada camada. Comece simples, meça custo desde o primeiro dia, e evolua conforme a app ganha tráfego e exigências. O custo de deixar uma dessas peças de fora quase sempre aparece depois, e cobra juros.


Compartilhe este post:

Post anterior
FinOps na AWS: boas práticas para controlar custos na nuvem
Próximo post
AWS CodeArtifact: consumindo pacotes Python privados com uv