Well-ArchitectedComunidade
Nível de dificuldade: Avançado (4 de 5)
Monte um mapa de responsabilidade de segurança para cada serviço AWS que você opera
Um exercício publicado na comunidade DEV vira um tutorial para arquitetos e times de DevOps documentarem, serviço por serviço, quem corrige o sistema operacional, quem controla a rede e quem lidera o incidente quando algo vaza.
Nota da redação: duas afirmações técnicas deste texto (o escopo exato da política gerenciada ReadOnlyAccess para os comandos aqui descritos, e a ausência de custo ao consultar o Cost Explorer pelo console) não puderam ser confirmadas em documentação oficial da AWS entre as fontes consultadas. São detalhes pontuais dos pré-requisitos e da seção de limpeza, não o argumento central do artigo, mas vale checar a documentação de IAM e de billing antes de assumi-los como garantidos.
Um exercício publicado na comunidade DEV vira um tutorial para arquitetos e times de DevOps documentarem, serviço por serviço, quem corrige o sistema operacional, quem controla a rede e quem lidera o incidente quando algo vaza.
O modelo de responsabilidade compartilhada da AWS é repetido em toda certificação e todo onboarding: o provedor cuida da segurança da nuvem, você cuida da segurança na nuvem. O problema aparece quando um serviço novo entra na fatura e ninguém sabe dizer, na prática, quem aplica o patch, quem fecha a porta de rede ou quem atende o telefone às três da manhã.
Um exercício publicado na comunidade DEV por learnsome-tech, plataforma que ensina certificações de nuvem, propõe resolver isso com um documento de uma página por serviço, preenchido em uma tarde. Este tutorial adapta esse exercício para quem já opera produção na AWS, com os comandos e as checagens que transformam a planilha de suposições em um mapa verificado contra o console.
O que você vai construir
Você vai sair daqui com um arquivo markdown versionado no repositório de infraestrutura, um bloco de quatro linhas por serviço em produção, respondendo sempre as mesmas perguntas: quem corrige o sistema operacional, quem decide as regras de rede, quem guarda as credenciais e quem lidera o incidente quando esse serviço especificamente falha.
A regra que nunca muda, segundo o post original, é que dado e identidade são sempre seus: classificar a informação, decidir quem tem conta, forçar MFA e remover quem saiu da empresa não é tarefa que nenhum provedor assume, seja IaaS, PaaS ou SaaS. O resto varia conforme a camada do serviço:
| Camada | Exemplo AWS | Quem corrige o SO | Quem controla a rede | Quem guarda as chaves |
|---|---|---|---|---|
| IaaS | Amazon EC2 | Você | Você (security groups, VPC) | Você (chaves SSH, IAM roles) |
| PaaS | Amazon RDS | AWS | Compartilhado (você decide o que conecta) | Você (usuários do banco, KMS) |
| SaaS | Amazon WorkMail | AWS | AWS | Você (contas, MFA, compartilhamento) |
Essa divisão segue a mesma lógica que a Microsoft publica para o Azure e que o Google descreve para o GCP: o nome muda, o princípio é o mesmo.
Pré-requisitos
Para rodar o exercício com dados reais, e não com suposição, você precisa de:
- Uma conta AWS com acesso de leitura aos serviços que vai mapear. A política gerenciada
ReadOnlyAccesscobre esse uso; se preferir um escopo mais restrito, monte uma política customizada e valide na própria documentação de IAM quais ações cada comando deste tutorial exige. - AWS CLI v2 instalado e configurado com
aws configure, apontando para a conta de produção (ou o perfil correto, se você usa múltiplas contas via Organizations). - Acesso ao Cost Explorer habilitado no console de billing, para listar o que de fato gera cobrança.
- Um repositório Git onde versionar o arquivo markdown final, de preferência o mesmo onde vive o código de infraestrutura (Terraform, CDK ou CloudFormation).
- A página do AWS Shared Responsibility Model aberta numa aba, porque toda linha que você não conseguir confirmar ali vira pergunta para o time, não espaço em branco.
Passo a passo
Nota da redação: o código desta seção não foi executado em ambiente real. Valide antes de usar em produção.
1. Liste os serviços que realmente geram custo. Não confie na memória: puxe a lista direto do billing.
aws ce get-cost-and-usage \
--time-period Start=2026-10-01,End=2026-11-01 \
--granularity MONTHLY \
--metrics "UnblendedCost" \
--group-by Type=DIMENSION,Key=SERVICEO mesmo resultado sai do console em Billing and Cost Management > Cost Explorer > Group by Service, sem custo adicional.
2. Classifique cada serviço por camada. Amazon EC2 é IaaS: você administra o sistema operacional convidado. Um banco gerenciado como Amazon RDS é PaaS: a AWS aplica o patch do motor, você decide schema, usuários e chaves de criptografia. Um serviço de e-mail e documentos como Amazon WorkMail é SaaS: a aplicação é da AWS, a conta e o compartilhamento são seus.
3. Preencha as quatro linhas por serviço, seguindo o formato do exercício original:
serviço: Amazon EC2 (servidor web de pedidos)
corrige o SO: nós (o SO convidado é nosso na EC2)
regras de rede: nós (security groups, VPC)
guarda as chaves: nós (chaves SSH, roles IAM)
lidera incidente: nós, com a AWS para tudo abaixo do hypervisor
serviço: Amazon RDS (banco de pedidos)
corrige o SO: AWS
regras de rede: compartilhado (nós decidimos o que conecta, via security group)
guarda as chaves: nós (usuários do banco, escolha de chave KMS)
lidera incidente: depende, documentar caso a caso
serviço: Amazon WorkMail (SaaS)
regras de rede: AWS
guarda as chaves: nós (contas, MFA, permissões de compartilhamento)
lidera incidente: nós, para tudo que uma conta ou um compartilhamento causou4. Confirme cada linha no console ou via CLI, em vez de supor. Para o EC2 da fila de pedidos, veja quem de fato controla as regras:
aws ec2 describe-security-groups --group-ids sg-0abc123456Para saber quem tem credencial de acesso àquela conta:
aws iam list-users --output tableSe a resposta do comando contradiz o que estava escrito no mapa, corrija o mapa, não o comando.
5. Versione o resultado. Salve como docs/responsibility-map.md no mesmo repositório da infraestrutura, com um bloco por serviço, na ordem em que aparecem na fatura.
Testando
Um mapa que ninguém testou é só um documento bonito. Reúna o time e faça a pergunta com que o autor do exercício original fecha o texto: qual é o serviço em que vocês mais discordaram sobre quem é dono do quê? A resposta aponta direto para a linha do mapa que ainda está incompleta.
Rode um tabletop curto com um cenário plausível, como um security group de um EC2 liberado para 0.0.0.0/0 na porta 22, ou uma credencial de IAM vazada em um repositório público. Leia o mapa em voz alta e veja se ele responde quem age em cada etapa, sem precisar consultar mais ninguém.
Três erros aparecem quase sempre nessa revisão, segundo o próprio exercício original:
- Ler "gerenciado" como "seguro por padrão". Mesmo em PaaS e SaaS, configuração de aplicação, segurança de código e controle de acesso continuam sendo seus.
- Usar a mesma divisão para tudo. EC2 e RDS ficam em linhas bem diferentes da tabela; tratar os dois igual é o erro mais comum.
- Deixar a liderança do incidente só com o provedor. A maioria dos incidentes começa em um recurso mal configurado ou numa credencial roubada, e os dois lados dessa equação são seus.
Se alguma célula do mapa ficou em branco depois do teste, ela não é um detalhe pendente: é a pergunta que o time ainda não respondeu sobre quem é dono daquele risco.
Limpando os recursos
Este exercício em si não cria infraestrutura nova, então não há instância ou banco para desligar só por tê-lo feito. Mas alguns cuidados valem a pena:
- Se você criou alguma instância EC2 ou RDS temporária só para validar as regras de security group do passo 4, termine-a com
aws ec2 terminate-instancesouaws rds delete-db-instanceassim que confirmar o dado, para não deixar cobrança rodando. - Se você só precisa consultar os custos uma vez, prefira abrir o Cost Explorer pelo console em vez de rodar
get-cost-and-usagerepetidamente: é mais simples e evita chamadas desnecessárias à API. - Remova qualquer usuário IAM de teste criado para validar permissões de leitura durante o exercício.
- O arquivo
docs/responsibility-map.mdem si não tem custo: é texto versionado no seu repositório, não um recurso de nuvem.
Próximos passos
O mapa feito numa tarde envelhece rápido se ninguém o atualiza quando um serviço novo entra na fatura. Vale amarrar a revisão a um gatilho concreto, não à boa vontade:
- Trate a criação do bloco de responsabilidade como item obrigatório do checklist de todo serviço novo aprovado em produção.
- Rode a lente de segurança do AWS Well-Architected Tool a cada trimestre e confira se ela expõe alguma lacuna que o mapa deixou passar.
- Use o AWS Security Hub para automatizar parte da checagem: um finding de security group aberto, por exemplo, aponta direto para a linha "regras de rede" do serviço correspondente.
- Trate o documento como material de onboarding: um engenheiro novo que lê o mapa sabe, no primeiro dia, quais alertas são dele e quais não são.
O post original está disponível na comunidade DEV, assinado por learnsome-tech, e vale a leitura completa para quem quiser o texto na forma em que foi publicado.
Fonte
DEV Community, #aws: "Write a one-page responsibility map for every cloud service you run", por learnsome-tech.
Fonte: DEV Community — #aws
Serviços neste textoWell-Architected
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: "Monte um mapa de responsabilidade de segurança para cada serviço AWS que você opera" (https://awshub.com.br/comunidade/monte-um-mapa-de-responsabilidade-de-seguranca-para-cada-servico-aws-que-voce-op). Resumo: Um exercício publicado na comunidade DEV vira um tutorial para arquitetos e times de DevOps documentarem, serviço por serviço, quem corrige o sistema operacional, quem controla a rede e quem lidera o incidente quando algo vaza. Serviços: Well-Architected 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ã?