gVisor e Agent Substrate na CNCF: como isolar o código que agentes de IA executam no Kubernetes

O Google doou gVisor e Agent Substrate à CNCF. Entenda o isolamento por kernel em espaço de usuário e teste o gVisor no seu cluster.

Eddwan HallenInstrutor & Co-fundador · 9 min de leitura

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.

Comparação entre contêiner comum, gVisor e microVM, mostrando o caminho das syscalls até 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.

Fluxo do Agent Substrate: atenet-router, WorkerPool e armazenamento em camadas
  • 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 runsc

Confira se o runtime e o shim do containerd ficaram no PATH:

which runsc containerd-shim-runsc-v1

2. 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 containerd

3. 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 -r

No 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.

Fontes consultadas

Newsletter da EDCA

Receba os próximos artigos por e-mail.

Um resumo por semana, só quando sai coisa nova: artigos, ferramentas e cursos de VoIP, redes e programação.

Ao se inscrever, você concorda em receber a newsletter da EDCA por e-mail e com a política de privacidade. Você pode cancelar quando quiser.