O blog da AWS

Automatize a criação de políticas IAM com o IAM Policy Autopilot

Por Marcelo Oliveira, Arquiteto de Soluções.

Criar políticas AWS Identity and Access Management (IAM) é uma das tarefas que mais consomem tempo durante o desenvolvimento de aplicações na AWS. Identificar quais permissões cada chamada de SDK necessita, entender dependências entre serviços (como permissões de AWS KMS ao usar criptografia no Amazon S3), e depurar erros de Access Denied são desafios recorrentes para desenvolvedores de todos os níveis.

Pensando nisso, a AWS lançou o IAM Policy Autopilot, uma ferramenta open source de análise estática de código que gera automaticamente políticas IAM baseadas nas chamadas de SDK presentes no seu código. A ferramenta está disponível como CLI (linha de comando) e como servidor Model Context Protocol (MCP), integrando-se diretamente com assistentes de codificação com IA como Kiro.

Neste blog post, vamos explorar como o IAM Policy Autopilot funciona na prática, como instalá-lo, e como utilizá-lo para acelerar seu ciclo de desenvolvimento na AWS.

Como o IAM Policy Autopilot funciona?

O IAM Policy Autopilot realiza uma análise determinística do seu código-fonte, identificando chamadas ao AWS SDK e gerando as políticas IAM de identidade necessárias. Suporta aplicações escritas em Python, Go e TypeScript, JavaScript e Java.

A ferramenta se destaca em três aspectos:

  • Geração de políticas a partir do código fonte: Analisa as chamadas de SDK no seu código e gera políticas IAM com as permissões necessárias, incluindo dependências entre serviços. Por exemplo, ao identificar uma chamada s3.putObject(), a ferramenta gera não apenas a permissão s3:PutObject, mas também as permissões de KMS (kms:Encrypt, kms:GenerateDataKey) que podem ser necessárias em cenários de criptografia.
  • Correção de erros Access Denied: Quando você encontra erros de permissão durante a fase de testes, o IAM Policy Autopilot analisa a mensagem de erro e propõe correções direcionadas na política IAM.
  • Integração com assistentes de IA via MCP: Como um servidor MCP, a ferramenta permite que seu assistente de codificação invoque a geração de políticas automaticamente durante o fluxo de desenvolvimento.

Pré-requisitos

Antes de começar, você precisará de:

  • Python 3 instalado
  • AWS CLI configurado com suas credenciais
  • uv (gerenciador de pacotes Python)
  • Kiro CLI

Instalação

Neste blog post, instalaremos o IAM Policy Autopilot usando o “uv tool install”, que disponibiliza o comando diretamente no seu terminal:

uv tool install iam-policy-autopilot

Para verificar se está funcionando corretamente:

iam-policy-autopilot --help

Exemplo prático: Gerando políticas para uma função Lambda

Vamos criar um cenário prático. Imagine que você está desenvolvendo uma função AWS Lambda em TypeScript que faz upload de arquivos para o Amazon S3 com criptografia usando uma chave KMS gerenciada pelo cliente.

Passo 1 – Criar o código da aplicação

Crie o arquivo uploadHandler.ts:

import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';

const s3Client = new S3Client({ region: 'sa-east-1' });

export const handler = async (event: any) => {
  const { fileName, fileContent } = JSON.parse(event.body);

  await s3Client.send(new PutObjectCommand({
    Bucket: process.env.BUCKET_NAME,
    Key: fileName,
    Body: fileContent,
    ServerSideEncryption: 'aws:kms',
    SSEKMSKeyId: process.env.KMS_KEY_ID
  }));

  return {
    statusCode: 200,
    body: JSON.stringify({ message: 'Upload realizado com sucesso' })
  };
};

Passo 2 – Gerar a política IAM com o CLI

Execute o comando abaixo para gerar a política IAM baseada no código:

iam-policy-autopilot generate-policies \
  ./uploadHandler.ts \
  --region sa-east-1 \
  --account 123456789012 \
  --pretty

O IAM Policy Autopilot analisará o código, identificará a chamada PutObjectCommand, e gerará a seguinte política:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Resource": "arn:aws:s3:::*/*"
    },
    {
      "Effect": "Allow",
      "Action": ["kms:Encrypt", "kms:GenerateDataKey"],
      "Resource": "arn:aws:kms:sa-east-1:123456789012:key/*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      "Resource": "arn:aws:logs:sa-east-1:123456789012:*"
    }
  ]
}

Observe que a ferramenta gerou automaticamente:

  • Permissões de S3 para o PutObject
  • Permissões de KMS para cenários de criptografia (dependência entre serviços)
  • Permissões de CloudWatch Logs para a execução da função Lambda

Passo 3 – Refinar os recursos (Resource)

Observe que as Actions geradas são específicas (como s3:PutObject, kms:Encrypt), o IAM Policy Autopilot identifica exatamente quais operações seu código utiliza. Porém, os Resources (ARNs) utilizam wildcards (*). No código do Passo 1, o nome do bucket vem da variável de ambiente BUCKET_NAME e a chave KMS de KMS_KEY_ID. Como a ferramenta faz análise estática, ela não resolve valores de variáveis de ambiente em tempo de compilação, gerando wildcards nos ARNs. Você deve refinar os ARNs para seguir o princípio de menor privilégio.

{
  "Effect": "Allow",
  "Action": ["s3:PutObject"],
  "Resource": "arn:aws:s3:::meu-bucket-de-uploads/*"
}

Passo 4 (Opcional) – Usar service hints para maior precisão

Se o seu código possui métodos com nomes genéricos que podem coincidir com chamadas de SDK de múltiplos serviços, use a opção –service-hints para indicar quais serviços sua aplicação realmente utiliza:

iam-policy-autopilot generate-policies \
  ./uploadHandler.ts \
  --region sa-east-1 \
  --account 123456789012 \
  --service-hints s3 kms \
  --pretty

Corrigindo erros de Access Denied

Outro recurso valioso é a correção de erros Access Denied. Quando sua aplicação retorna um erro de permissão, você pode usar o comando fix-access-denied:

iam-policy-autopilot fix-access-denied \
  "User: arn:aws:iam::123456789012:user/dev is not authorized to perform: \
  s3:GetObject on resource: arn:aws:s3:::meu-bucket/arquivo.txt \
  because no identity-based policy allows the s3:GetObject action"

A ferramenta analisará a mensagem de erro e sugerirá a correção necessária na política IAM.

Integração com assistentes de codificação via MCP

Para integrar o IAM Policy Autopilot com seu assistente de codificação, configure o servidor MCP. Abaixo um exemplo de configuração para o Kiro:

Adicione a seguinte configuração no arquivo .kiro/settings/mcp.json do seu projeto:

{
  "mcpServers": {
    "iam-policy-autopilot": {
      "command": "uvx",
      "args": ["iam-policy-autopilot", "mcp-server"],
      "env": {
        "AWS_PROFILE": "seu-perfil",
        "AWS_REGION": "sa-east-1"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Para o Kiro CLI, você pode configurar diretamente via comando:

kiro-cli mcp add \
  --name iam-policy-autopilot \
  --command "uvx" \
  --args "iam-policy-autopilot","mcp-server"

Com essa integração, ao pedir para seu assistente de IA criar a infraestrutura da sua aplicação, ele automaticamente invocará o IAM Policy Autopilot para gerar as políticas IAM corretas, sem que você precise se preocupar com permissões manualmente.

O IAM Policy Autopilot também está disponível como Kiro Power, oferecendo instalação com um clique diretamente do Kiro IDE, eliminando a necessidade de configuração manual do servidor MCP.

Usando o IAM Policy Autopilot com o Kiro

O Kiro é o IDE da AWS com IA agêntica integrada. Quando combinado com o IAM Policy Autopilot, o Kiro consegue gerar políticas IAM automaticamente enquanto você desenvolve sua aplicação. Vamos ver alguns cenários práticos dessa integração.

Cenário 1 – Criando uma API com DynamoDB do zero

Imagine que você pede ao Kiro para criar uma API REST com Lambda e DynamoDB. No chat do Kiro, você digita:

Prompt no Kiro:

"Crie uma função Lambda em Python que receba um pedido via API Gateway
e salve os dados em uma tabela DynamoDB chamada Pedidos.
Inclua as políticas IAM necessárias usando CDK."

O Kiro gera o código da Lambda. Nos bastidores, ele invoca o IAM Policy Autopilot via MCP para analisar o código gerado e obter as permissões corretas:

# app.py - Código gerado pelo Kiro
import boto3
import json
import os

dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(os.environ["TABLE_NAME"])

def handler(event, context):
    body = json.loads(event["body"])
    table.put_item(Item=body)
    return {"statusCode": 201, "body": json.dumps({"message": "Pedido criado"})}

O IAM Policy Autopilot identifica a chamada put_item() e gera a política. O Kiro então sugere no chat a incorporação dessa política no stack CDK:

# Política gerada pelo IAM Policy Autopilot e incorporada pelo Kiro no CDK
pedidos_table.grant_write_data(lambda_function)

# Que resulta na seguinte política IAM:
# {
#   "Effect": "Allow",
#   "Action": [
#     "dynamodb:PutItem",
#     "dynamodb:BatchWriteItem"
#   ],
#   "Resource": "arn:aws:dynamodb:sa-east-1:123456789012:table/Pedidos"
# }

Cenário 2 – Depurando Access Denied com o Kiro

Outro cenário comum: você fez o deploy da sua aplicação e recebe um erro de Access Denied nos logs do CloudWatch. No Kiro, você pode colar o erro no chat:

Prompt no Kiro:

"Minha Lambda está retornando este erro:
AccessDeniedException: User: arn:aws:sts::123456789012:assumed-role/
PedidosLambdaRole/PedidosFunction is not authorized to perform:
dynamodb:Query on resource: arn:aws:dynamodb:sa-east-1:123456789012:
table/Pedidos/index/StatusIndex

Pode corrigir?"

O Kiro invoca a ferramenta “generate_policy_for_access_denied” do IAM Policy Autopilot, que analisa a mensagem e identifica que falta a permissão dynamodb:Query no índice secundário global (GSI). O Kiro então sugere a correção:

# Correção sugerida pelo Kiro (via IAM Policy Autopilot)
# Adicionar ao stack CDK:

lambda_function.add_to_role_policy(
    iam.PolicyStatement(
        actions=["dynamodb:Query"],
        resources=[
            f"arn:aws:dynamodb:sa-east-1:123456789012:table/Pedidos/index/StatusIndex"
        ]
    )
)

Você revisa, aprova, e o Kiro aplica a mudança. Sem precisar pesquisar documentação ou decifrar mensagens de erro manualmente.

Cenário 3 – Instalando via Kiro Power (um clique)

A forma mais direta de usar o IAM Policy Autopilot com o Kiro é através do Kiro Power, que elimina a configuração manual do MCP. O Power já está disponível no catálogo oficial do Kiro.

  1. Abra o Kiro e acesse o menu “Powers” na barra lateral esquerda.
  2. Na aba “Available”, busque por “IAM Policy Autopilot”.
  3. Selecione “Install” para ativar o Power.
  4. O Power aparecerá na aba “Installed” e estará pronto para uso.

Com o Kiro Power instalado, o IAM Policy Autopilot é carregado de forma mais seletiva e eficiente, reduzindo o uso de tokens do LLM e fornecendo orientações mais precisas ao agente de IA sobre quando e como utilizar as ferramentas de geração de políticas.

Boas práticas

Ao utilizar o IAM Policy Autopilot no seu fluxo de desenvolvimento, considere as seguintes recomendações:

  • Use-o como ponto de partida, não como resultado final – As políticas geradas priorizam funcionalidade. Refine os ARNs dos recursos e remova permissões desnecessárias antes de ir para produção.
  • Entenda o escopo da ferramenta – O IAM Policy Autopilot gera políticas de identidade (identity-based policies). Ele não cria políticas baseadas em recurso (como bucket policies do S3 ou key policies do KMS).
  • Combine com o IAM Access Analyzer – Use o AWS IAM Access Analyzer para identificar permissões não utilizadas ao longo do tempo e refinar suas políticas progressivamente.
  • Revise modificações do assistente de IA – Quando usado via MCP, seu assistente de codificação pode modificar a política gerada ao criar templates de infraestrutura. Sempre revise o resultado final antes do deploy.

Conclusão

O IAM Policy Autopilot transforma a criação de políticas IAM de um desafio manual e propenso a erros em um processo automatizado e integrado ao seu fluxo de desenvolvimento. Seja utilizando diretamente pela CLI ou através da integração com assistentes de codificação via MCP, a ferramenta permite que você foque no que realmente importa: construir sua aplicação.

A ferramenta é open source, gratuita, e está disponível no repositório GitHub do IAM Policy Autopilot (https://github.com/awslabs/iam-policy-autopilot). Comece a utilizá-la hoje e reduza o tempo gasto com políticas IAM no seu próximo projeto.

Autor

Marcelo Oliveira é Solutions Architect no time AWS. Apoia clientes do setor FSI (Financial Service Industry) em sua jornada para nuvem AWS. Tem foco em projetos que envolvam arquiteturas distribuídas e escaláveis, além de grande interesse na área de Infraestrutura, Networking, Segurança e Containers.