Agentes de IA deixaram de só responder perguntas. Hoje eles escrevem um script, instalam uma dependência e executam o resultado para conferir se funcionou. Quem opera a plataforma precisa decidir onde esse código roda. Se a resposta for "num contêiner comum", o código que ninguém revisou passa a compartilhar o kernel do host com todo o resto do nó.
Esse é o problema que o Google atacou no anúncio de 5 de novembro de 2026, publicado no blog de código aberto da empresa às vésperas do KubeCon + CloudNativeCon América do Norte, em Salt Lake City: a doação do gVisor e do Agent Substrate à CNCF (Cloud Native Computing Foundation), com status Sandbox. Neste artigo você vai entender por que contêiner não basta como fronteira de segurança, como o gVisor funciona, o que o Agent Substrate acrescenta e como testar o gVisor num cluster de laboratório.
Por que contêiner não é fronteira de segurança suficiente
Primeiro, dois conceitos. Uma syscall (chamada de sistema) é o pedido que um programa faz ao kernel: abrir um arquivo, criar um processo, abrir um socket. Todo programa Linux depende delas, e são centenas.
Um contêiner é um processo comum isolado por dois recursos do kernel. Os namespaces mudam o que o processo enxerga: ele vê a própria árvore de processos, as próprias interfaces de rede e o próprio sistema de arquivos. Os cgroups limitam o que ele consome: CPU, memória, I/O.
O ponto central é o kernel compartilhado: todos os contêineres de um nó fazem syscalls direto no mesmo kernel do host. Namespaces e cgroups isolam a visão e os recursos, mas não reduzem a superfície do kernel exposta ao código. Se esse código explorar uma falha no kernel, ele não fica preso no contêiner: ganha o nó inteiro, e com ele os outros Pods.
As falhas recentes no kernel Linux, inclusive na pilha de rede, mostram que essa superfície é grande e que bugs graves continuam aparecendo. Para o código que você mesmo escreveu e revisou, o risco costuma ser aceitável. Para código gerado por um agente a partir de um pedido qualquer, não é.
Três formas de isolar, comparadas
Existem três abordagens principais, e cada uma coloca uma quantidade diferente de camadas entre o código e o kernel do host.
Uma microVM é uma máquina virtual enxuta, feita para subir rápido e carregar só o necessário. O código roda com um kernel convidado próprio, e o isolamento vem da virtualização de hardware (KVM). Exemplos abertos: Firecracker (criado pela AWS, escrito em Rust), Cloud Hypervisor e Kata Containers (projeto da OpenInfra Foundation, que usa VMs leves por trás de uma interface de contêiner).
Critério | Contêiner comum | gVisor | microVM |
|---|---|---|---|
Isolamento | Namespaces e cgroups, kernel do host compartilhado | Kernel de aplicação em espaço de usuário entre o código e o host | Kernel convidado e virtualização de hardware |
Custo de desempenho | Praticamente nenhum | Maior em cargas com muitas syscalls e muito I/O | Moderado, mais memória por instância |
Tempo de partida | Milissegundos | Próximo ao de um contêiner | Rápido para uma VM, mais lento que um contêiner |
Compatibilidade | Total | Boa, mas nem toda syscall está implementada | Alta, roda um kernel Linux de verdade |
Requisito no nó | Nenhum | Só o runtime runsc | Virtualização (KVM) disponível no nó |
A tabela é qualitativa. Os números reais dependem da carga, da plataforma e do hardware, e vale medir no seu ambiente antes de decidir.
Como o gVisor funciona
O gVisor é um kernel de aplicação de código aberto, escrito em Go, uma linguagem com segurança de memória. Ele implementa uma interface parecida com a do Linux e roda em espaço de usuário. O runtime que você instala nos nós se chama runsc e segue o padrão OCI, o mesmo que o runc usado pelos contêineres comuns.
O caminho de uma syscall
Sem gVisor, o programa chama open() e o kernel do host atende. Com runsc, a syscall é interceptada e entregue ao Sentry, o componente que faz o papel de kernel. O Sentry trata a chamada por conta própria, com sua própria gestão de memória, processos e pilha de rede. Quando precisa de algo do host, ele usa um conjunto reduzido de syscalls. O acesso a arquivos passa por um processo separado, o Gofer, que media o sistema de arquivos.
A interceptação é feita por uma plataforma. A padrão hoje é a systrap, que substituiu a antiga ptrace em 2023. Há também a plataforma KVM, que rende melhor em servidores físicos.
O que ele não faz, e quando quebra
A documentação do gVisor é direta sobre os limites:
o custo por syscall é maior, e cargas com muitas chamadas de sistema ou muito I/O podem perder desempenho;
nem toda syscall está implementada, e algumas funções vêm desligadas ou parciais, como io_uring e iptables dentro do sandbox;
não dá para carregar módulos de kernel próprios nem usar KVM dentro do sandbox.
Para o código típico de um agente (Python, Node.js, ferramentas de linha de comando), isso raramente atrapalha. Para um banco de dados com I/O pesado ou uma ferramenta que depende de recursos específicos do kernel, teste antes.
Checkpoint e restore
Checkpoint é congelar um processo em execução e salvar todo o seu estado (memória, arquivos abertos, processos) em disco. Restore é recriar esse processo exatamente do ponto em que parou, na mesma máquina ou em outra. Como o gVisor controla a própria memória e a própria tabela de processos, ele consegue fazer isso com o comando runsc checkpoint e retomar com runsc restore. Há restrições: o nó de destino precisa ter os mesmos recursos de CPU do nó de origem, e conexões de rede abertas não sobrevivem à mudança.
O que o Agent Substrate acrescenta
O gVisor isola um sandbox. O Agent Substrate, que chegou à versão 1.0, resolve outro problema: manter milhares de sessões de agentes sem pagar por milhares de Pods parados. Ele cria um plano de controle e de dados baseado em atores sobre o Kubernetes.
Actor: representa a sessão de um agente, com sistema de arquivos, variáveis de ambiente, memória e regras de rede.
Worker: um Pod pré-aquecido num pool compartilhado, o WorkerPool.
atenet-router: o proxy L7 por onde entram as requisições. Quando chega a vez de um agente, ele segura a requisição enquanto o Actor é restaurado num Worker livre.
Armazenamento em camadas: quando a vez termina, o estado do Actor é salvo ali e a vaga do Worker é liberada.
Segundo o Google, a retomada leva menos de 500 milissegundos. É um número do próprio projeto, sem medição independente até agora. O ganho de custo vem da separação: a sessão ociosa vira dado em armazenamento, não um Pod ocupando CPU e memória. Os Actors rodam sob gVisor ou, para cargas que precisam de virtualização de hardware ou módulos de kernel próprios, em microVMs do Cloud Hypervisor. O anúncio diz que o Substrate roda em qualquer cluster Kubernetes conforme. O workshop do KubeCon fez a implantação no GKE.
O mesmo anúncio cita o OpenRL, uma camada nativa de Kubernetes para orquestrar treino por reforço. Os registros da CNCF confirmam que ele também foi aceito no Sandbox, junto com os outros dois.
O que significa entrar na CNCF como Sandbox
A CNCF classifica seus projetos em três níveis de maturidade:
Sandbox: porta de entrada para projetos em estágio inicial, ainda pouco testados em produção.
Incubating: projetos usados com sucesso em produção por um grupo menor de usuários, com uma base saudável de contribuidores.
Graduated: projetos estáveis, amplamente adotados e considerados prontos para produção.
Pelos registros públicos do repositório de Sandbox da CNCF, o comitê técnico (TOC) aprovou a entrada do gVisor, do Agent Substrate e do OpenRL em votação concluída em 28 de setembro de 2026, e os acordos de contribuição foram assinados em outubro. O anúncio público veio em novembro.
O que o status Sandbox representa: o código e a marca passam a uma fundação neutra, com governança aberta, o que facilita a contribuição de outras empresas. O que ele não representa: um selo de maturidade. Há uma diferença aqui. O gVisor é usado em produção há anos, e o Agent Substrate é 1.0, mas para a CNCF os dois começam do primeiro degrau. Avalie a maturidade pelo histórico de cada projeto, não pelo nível na fundação.
Laboratório: gVisor num cluster Kubernetes
Os passos abaixo seguem a documentação oficial do gVisor (gvisor.dev) e valem para nós Debian ou Ubuntu com containerd. O mecanismo de RuntimeClass é do Kubernetes e da documentação do gVisor, não do anúncio do Google. Faça num cluster de laboratório.
1. Instalar o runsc em cada nó
sudo apt-get update && sudo apt-get install -y apt-transport-https ca-certificates curl gnupg
curl -fsSL https://gvisor.dev/archive.key | sudo gpg --dearmor -o /usr/share/keyrings/gvisor-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/gvisor-archive-keyring.gpg] https://storage.googleapis.com/gvisor/releases release main" | sudo tee /etc/apt/sources.list.d/gvisor.list > /dev/null
sudo apt-get update && sudo apt-get install -y runscConfira se o runtime e o shim do containerd ficaram no PATH:
which runsc containerd-shim-runsc-v12. Registrar o handler no containerd
No containerd 1.x (configuração version = 2), acrescente em /etc/containerd/config.toml:
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runsc]
runtime_type = "io.containerd.runsc.v1"No containerd 2.x, a documentação do gVisor recomenda o cabeçalho version = 3. Nesse formato o caminho do plugin muda para plugins.'io.containerd.cri.v1.runtime'.containerd.runtimes.runsc, com o mesmo runtime_type. Depois, reinicie:
sudo systemctl restart containerd3. Criar a RuntimeClass e um Pod
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
name: gvisor
handler: runsc
---
apiVersion: v1
kind: Pod
metadata:
name: teste-gvisor
spec:
runtimeClassName: gvisor
containers:
- name: ubuntu
image: ubuntu:24.04
command: ["sleep", "3600"]O campo handler precisa ter o mesmo nome do runtime registrado no containerd (runsc). Aplique com kubectl apply -f gvisor.yaml.
4. Comparar com e sem gVisor
Suba um segundo Pod igual, sem runtimeClassName, e compare:
kubectl exec teste-gvisor -- dmesg
kubectl exec teste-gvisor -- uname -rNo Pod comum, uname -r mostra a versão do kernel do host. No Pod com gVisor, aparece uma versão própria do gVisor, e o dmesg traz mensagens como "Starting gVisor...". A própria documentação avisa que essas mensagens são fáceis de imitar: servem para o laboratório, não como prova de segurança. Para confirmar o runtime de verdade, use kubectl get pod teste-gvisor -o jsonpath='{.spec.runtimeClassName}' e, no nó, sudo crictl inspect no contêiner.
Fechamento
Isolar carga não confiável deixou de ser assunto de nicho. Quando agentes executam código o dia todo, isso vira requisito de plataforma, assim como RBAC e NetworkPolicy. O anúncio do Google não inventa a técnica: ele leva para uma fundação neutra duas peças que já existiam e as junta com um modelo de sessões que barateia a ociosidade.
Para seguir estudando: namespaces e cgroups na prática (crie um "contêiner" à mão com unshare), seccomp e capabilities, o objeto RuntimeClass e a seleção de nós com scheduling, e os conceitos de KVM que sustentam as microVMs. Depois disso, leia a documentação do Agent Substrate e teste um WorkerPool no laboratório.