segunda-feira, 16 de novembro de 2026 Edição nº 240
Buscar
Avaliação Conduzido por humano, com apoio de IA · Infraestrutura · 26 min de leitura

Cloud Run Sandboxes: Na Prática com o Limite de Isolamento, Secrets, 1.000 Sandboxes e Noisy Neighbors

Por Fabio Douek

Conduzido por humano, com apoio de IA. Pesquisa e implementação feitas com ferramentas de IA, conduzidas, testadas e editadas por mim. Como os posts são classificados

Ir para seção
Explica (TLDR) como se eu fosse...
O que é isso?

Imagine que o seu quarto de brinquedos tem uma caixa grande, e dentro dela você consegue montar vários cantinhos de brincar para visitantes que você não conhece. Cada cantinho tem as suas próprias paredes e nenhuma janela para fora, então ninguém sai passeando por aí nem espia as suas coisas.

Os cantinhos têm paredes boas, mas todos ficam no mesmo chão. Se um visitante fizer uma barulheira terrível, o quarto inteiro fica lento. E um bilhete preso no chão, como um secret que você deixou ali, ainda pode ser lido.

Os sandboxes rodam dentro de um serviço que você já opera, então não há novo fornecedor nem nova cobrança: eles usam a CPU e a memória do serviço. O runtime do sandbox não é nomeado na documentação, e o recurso está em Preview sob termos pré-GA.

Os pontos materiais: um sandbox consegue ler todos os arquivos que o container host enxerga, incluindo um secret montado, e as linhas de comando que você passa, como valores de ambiente, são gravadas nos seus logs. Trate a imagem do host como parte do limite de confiança e não passe valores confidenciais na linha de comando.

A necessidade apresentada é rodar código em que você não confia sem entregar a ele as credenciais do próprio serviço. O tratamento aqui é um sandbox gVisor com a rede desligada, sem ambiente e sem metadata server, e nos meus testes isso se manteve.

Efeitos colaterais a observar: o sandbox lê arquivos do host, incluindo um secret montado, e divide a CPU do host, então sandboxes ocupados deixaram um job de CPU no host de quatro a oito vezes mais lento. Um timeout no executor do ADK também deixou o processo do sandbox rodando. Dimensione o host e mantenha os secrets fora do disco dele.

Há um alívio real em deixar código não confiável rodar em um lugar que não consegue ligar para casa nem ver as suas variáveis de ambiente, e a maior parte desse alívio é merecida: as paredes estavam onde a documentação disse que estariam.

O desconforto vem das bordas que você só encontra olhando: um secret que estava a uma leitura de arquivo de distância, uma linha de comando que vai parar nos logs sem alarde e um vizinho que pode deixar todo mundo mais lento. Nomear isso cedo deixa a confiança da equipe no recurso mais estável.

Pense no host como o palco e em cada sandbox como um músico numa cabine sem cabo para fora. Iniciar uma nova cabine levou cerca de um quinto de segundo nas minhas execuções, e mil delas, uma depois da outra, tocaram afinadas.

O problema é a mixagem compartilhada: todas as cabines puxam do mesmo amplificador. Ponha alguns músicos num loop pesado e a banda do próprio palco se arrasta. Mantenha a passagem de som honesta: deixe os secrets de verdade fora do chão do palco.

A proposta é que os sandboxes vêm com o serviço que você já roda: uma flag, nenhum preço extra e um tempo de inicialização de cerca de um quinto de segundo no meu teste, abaixo do número do próprio Google, de 500 milissegundos.

O posicionamento honesto é para equipes que dimensionam o próprio host. As paredes são gVisor de verdade, mas os sandboxes dividem a CPU e o sistema de arquivos do host, então planeje a capacidade e mantenha os secrets fora do container. Isso é uma história sobre controle, não sobre almoço grátis.

GitHub Veja o código-fonte aqui: gcp-sandboxes/cloud-run-sandboxes

Visão geral

Os sandboxes do Cloud Run, em Preview desde 8 de julho de 2026, permitem que um container do Cloud Run inicie sandboxes filhos para código em que ele não confia. Você os ativa com uma única configuração do container, --sandbox-launcher, e o Cloud Run monta um binário sandbox no seu container em /usr/local/gcp/bin/sandbox. O seu código o chama: sandbox do -- <command> roda um comando em um sandbox novo e apaga o sandbox depois. Não há um serviço separado nem um preço separado, porque os sandboxes usam a CPU e a memória da instância em que rodam. A documentação diz que os sandboxes não têm acesso “à workload pai, a variáveis de ambiente, a secrets ou ao metadata server do Google Cloud”, e o post de lançamento do Google diz que um serviço “inicia, executa e para 1.000 sandboxes com latência média de 500 ms”. A documentação não nomeia a tecnologia de isolamento.

Este post, a parte 4 de 6 da série Google Cloud Sandboxes, testa essas afirmações. A Parte 2 cobriu o sandbox por trás do Managed Agents na Gemini API e a parte 3 os sandboxes do Agent Platform, ambos serviços operados pelo Google. Os sandboxes do Cloud Run são diferentes em um ponto que molda todos os resultados abaixo: o sandbox vive dentro da sua própria instância, então você opera o host. A Parte 1 mapeia todas as opções do Google Cloud, e as partes 5 e 6 cobrem o GKE Agent Sandbox e o Agent Substrate no GKE.

Eu testei em 14 de novembro de 2026 em us-central1, em um serviço com 2 vCPU e 4 GiB, e gravei uma execução limpa de cada teste para o vídeo. Sete resultados se destacaram:

  • O limite de isolamento é o gVisor, dentro de uma microVM de segunda geração. O host reporta Linux 6.9.12 (e 6.18.60 em instâncias posteriores); um sandbox reporta 4.19.0-gvisor e um dmesg que começa com “Starting gVisor…”. O diretório montado contém sandbox, runsc e gvisor-bin.
  • Variáveis de ambiente ficam de fora, mas arquivos não. A variável de ambiente do serviço e o secret do Secret Manager exposto como variável de ambiente estavam invisíveis. O mesmo secret montado como arquivo era legível, e um arquivo 0600 somente do root também, porque o sandbox enxerga o sistema de arquivos raiz do host. O sandbox rodou como root, e o sudo falhou.
  • A rede é fechada e o metadata server continua fechado. Com --allow-egress a internet se abriu, o metadata server continuou dando timeout, e o sandbox seguiu a configuração de Direct VPC egress do serviço.
  • Os valores de --env são registrados em log. Toda linha de comando do sandbox, incluindo --env TOKEN=..., aparece no Cloud Logging, em um stream chamado run.googleapis.com//var/log/sandbox.log.
  • Um sandbox inicia em cerca de 0,15 a 0,19 segundo, mas o host inicia só 4 a 6 por segundo. Mil sandboxes sequenciais levaram em média 153 ms (186 ms em uma execução anterior). A concorrência não aumentou o throughput, e 100 por vez produziram falhas de inicialização.
  • Sandboxes ocupados deixam o host muito mais lento. Um job de CPU que levou 0,38 s no host ocioso levou 1,4 s com 4 sandboxes ocupados e 2,8 s com 8. O esgotamento de memória matou apenas o sandbox.
  • O executor do ADK foi lançado, e o timeout dele deixa o sandbox rodando. O CloudRunSandboxCodeExecutor está no google-adk 2.14.1. Depois do timeout de 300 segundos, o processo do sandbox continuou usando uma CPU inteira.

Configuração

Novo no Cloud Run? Um serviço roda a imagem do seu container e escala instâncias para cima e para baixo; uma instância é uma cópia em execução. Os sandboxes são iniciados por código rodando dentro de uma instância, então eles vivem e morrem com ela. Por isso eu fixei o serviço em exatamente uma instância.

Usei o gcloud 593.0.0 (core 2026.11.06; os comandos beta são necessários), Python 3.13.12 no meu laptop e google-adk 2.14.1 para o último teste. O serviço está em us-central1, segunda geração, 2 vCPU e 4 GiB, mínimo e máximo de uma instância, CPU sempre alocada (para que sandboxes em segundo plano continuem rodando entre requisições), concorrência 10 e sem acesso público.

Passo 1: A imagem do host

Os sandboxes enxergam o sistema de arquivos raiz do host, então toda ferramenta que um sandbox usa precisa estar na imagem do host. A minha é uma imagem Python com curl, procps, iproute2, openssl, util-linux e sudo, um arquivo 0600 somente do root com conteúdo fictício e um pequeno endpoint de comandos (Passo 3):

FROM python:3.12-slim
RUN apt-get update \
 && apt-get install -y --no-install-recommends curl procps iproute2 openssl util-linux sudo \
 && rm -rf /var/lib/apt/lists/*
RUN echo "m2c-root-only-canary" > /etc/m2c-0600 && chmod 600 /etc/m2c-0600
COPY server.py /app/server.py
CMD ["python3", "/app/server.py"]

Passo 2: Fazer o deploy de um serviço privado

O deploy.sh faz o build da imagem com o Cloud Build e o deploy do serviço com uma variável de ambiente simples (PLAIN=visible) e um secret fictício do Secret Manager, exposto de duas formas: como a variável de ambiente DUMMY_SECRET e como um arquivo em /secrets/dummy.

gcloud run deploy sbx-host --image "$IMAGE" --no-allow-unauthenticated \
  --cpu 2 --memory 4Gi --execution-environment gen2 \
  --min-instances 1 --max-instances 1 --concurrency 10 --no-cpu-throttling --timeout 1800 \
  --set-env-vars PLAIN=visible \
  --set-secrets DUMMY_SECRET=m2c-dummy:latest,/secrets/dummy=m2c-dummy:latest

Um projeto novo precisou de um passo extra: o Cloud Build roda como a service account padrão do compute, que não tinha direito de ler o código-fonte enviado até eu conceder a ela roles/cloudbuild.builds.builder. O build da imagem levou 42 segundos.

Passo 3: Conseguir um shell na instância

Tudo nos testes roda na instância, então eu precisava de um shell lá. Usei as duas formas.

Cloud Run SSH (Preview desde 7 de outubro de 2026) precisa de --ssh no deploy, e gcloud beta run services ssh sbx-host então abre um shell root. A primeira chamada criou um perfil do OS Login e uma chave SSH no meu laptop. O comando não tem a flag --command e precisa de um terminal, então, para as execuções com script, eu o envolvi em um pseudo-terminal (ssh_run.py no repositório complementar).

Um endpoint de comandos privado. Cerca de 50 linhas de Python na imagem rodam um shell script enviado a ele e devolvem a saída em stream. É um endpoint de execução remota de código por design, então o serviço é somente IAM, e eu o chamo com gcloud auth print-identity-token:

curl -sSN -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  --data-binary @t2_boundary.sh "$SERVICE_URL/run"
⛔ O endpoint de comandos dá a quem puder chamá-lo um shell no seu serviço. Faça o deploy dele apenas com --no-allow-unauthenticated e apague-o depois. O Teste 3 mostra o porquê: um sandbox não consegue chamá-lo, porque sem o metadata server ele não consegue obter um token.

Testes

Teste 1: Ativando

Comecei no console, onde procurei a configuração. Em Create service, abri Containers, Networking, Security e passei pelas abas Settings, Variables & Secrets e Volumes do container, além de Networking e Security. Não há nenhuma configuração de sandbox em lugar nenhum.

O formulário Create service do Cloud Run com a aba Settings do container aberta: comando, argumentos, memória e CPU, e nenhuma opção de sandbox

O console mostra a configuração apenas para uma revisão existente (Revision History, depois o painel Containers): “Sandbox launcher”, com um selo Preview, indicando Disabled ou Enabled.

A página de revisão do Cloud Run, painel Containers, mostrando Sandbox launcher (Preview) Enabled

Para ativar você precisa da CLI, e somente da trilha beta:

gcloud run services update sbx-host --sandbox-launcher
ERROR: (gcloud.run.services.update) unrecognized arguments:
 --sandbox-launcher flag is available in one or more alternate release tracks. Try:
  gcloud beta run services update --sandbox-launcher

gcloud beta run services update sbx-host --sandbox-launcher levou cerca de 20 segundos e criou uma nova revisão. O YAML (gcloud run services describe --format export) ganha uma annotation e um campo no container:

metadata:
  annotations:
    run.googleapis.com/launch-stage: BETA
...
        sandboxLauncher: true

Um sandboxes: {} no nível do template está no YAML antes e depois, então ele não é o interruptor. Eu mesmo defini o ambiente de execução de segunda geração, então não consigo confirmar que ativar os sandboxes o força, como diz a documentação.

Teste 2: Qual é o limite de isolamento?

A documentação nunca nomeia o isolamento. A página de ambientes de execução diz que a segunda geração “é uma microVM”, então fiz as mesmas perguntas no host e dentro de um sandbox (t2_boundary.sh):

Host (a instância)Sandbox
uname -r6.9.12 nas minhas primeiras instâncias, 6.18.60 nas posteriores4.19.0-gvisor
dmesg”Operation not permitted""Starting gVisor…“
flag hypervisor em /proc/cpuinfo5 de 5 CPUs5 de 5 CPUs
Seccompmodo filter, NoNewPrivs: 1Seccomp: 0
PID 1meu servidor Python/usr/local/gcp/bin/sandbox default-entrypoint
Sistema de arquivos raizoverlay, leitura e escrita9p, somente leitura, mais um /tmp em tmpfs

A versão do kernel do host mudou entre as minhas primeiras instâncias e as que gravei, com horas de diferença, então o Google a muda por baixo de você. O host é um kernel guest de verdade com um hypervisor por baixo; o sandbox é gVisor. O diretório montado resolve o resto: /usr/local/gcp/bin contém sandbox, runsc (o runtime do gVisor) e gvisor-bin, e enquanto um sandbox roda, o ps mostra runsc-sandbox --network=none --overlay2=root:memory --platform=xemu. A plataforma xemu não é uma das que a documentação pública do gVisor lista entre suas plataformas, e eu não sei o que ela faz. A flag hypervisor também está ativa dentro do sandbox, porque o gVisor repassa o /proc/cpuinfo, então a flag sozinha não diz em qual camada você está. O host também reporta 5 CPUs, embora eu tenha configurado 2 vCPU.

Teste 3: O que um sandbox consegue ver?

O serviço tem PLAIN=visible, o secret como variável de ambiente, o mesmo secret como arquivo e o arquivo somente do root. De dentro de um sandbox (t3_visibility.sh):

SondaNo sandbox
AmbienteApenas HOME, PATH (que eu defini) e PWD. PLAIN e DUMMY_SECRET estão ausentes
iduid=0(root)
sudo -n trueFalha: “unable to open /etc/sudoers: Operation not permitted”
cat /etc/m2c-0600 (root, modo 0600)Legível: m2c-root-only-canary
cat /secrets/dummy (o secret montado)Legível: m2c-secret-canary-4417
ProcessosApenas os do próprio sandbox (sandbox, sh, ps)
Metadata server, a partir do hostHTTP 200
Metadata server, sandbox sem egress”Failed to connect … after 0 ms: Could not connect to server”
Metadata server, sandbox com --allow-egresso curl desiste com “Connection timed out” após 3 segundos, também pelo nome (metadata.google.internal)
⛔ Um secret do Secret Manager montado como volume é legível de dentro do sandbox. O sandbox monta o sistema de arquivos raiz do host como somente leitura, e o Cloud Run monta os secrets nesse sistema de arquivos. A versão em variável de ambiente do mesmo secret não estava visível.

Então “sem acesso a secrets” vale para variáveis de ambiente e não para arquivos. A documentação só avisa sobre isso na flag --mount (“nunca monte caminhos que contenham secrets ou credenciais”); o mesmo vale para todo o sistema de arquivos do host, então qualquer coisa na imagem do host ou montada nela fica exposta. Exponha os secrets ao host como variáveis de ambiente, ou mantenha o container do host do sandbox livre deles. A documentação também diz que os processos “rodam com privilégios de sudo como um usuário não root”. Eu vi o oposto, root sem um sudo funcional, o que coincide com o que outras pessoas relataram. Root dentro do gVisor não é root no host, mas é por isso que um arquivo 0600 somente do root não fica protegido.

Teste 4: Rede

O sandbox é fechado por padrão e --allow-egress o abre, sem meio-termo (t4_network.sh):

SondaPadrão--allow-egress
curl https://www.google.comCould not resolve host (curl exit 6)HTTP 200
getent hosts www.google.comfalha com exit status 2resolve
curl https://storage.googleapis.comnão tentadoHTTP 400 (alcançável)
curl http://127.0.0.1:8080/ (o servidor do próprio host)recusadorecusado
A URL pública do próprio serviço, sem tokennão tentadoHTTP 403, igual ao que se vê a partir do host

Sem egress a falha é de DNS, não uma conexão recusada, então não existe DNS algum. O loopback do host continua inalcançável nos dois modos, então um sandbox não consegue falar com o app que o iniciou. A última linha é a mais útil: um sandbox com egress consegue alcançar a URL pública do serviço, e o meu endpoint privado ficou protegido apenas porque o sandbox não tem como obter um identity token.

O teste opcional: o --allow-egress segue as configurações de rede do serviço? Fiz o deploy de um segundo serviço (sbx-internal) com o ingress definido como internal e enviei requisições sem token. Um 403 significa que a requisição entrou pela VPC e foi recusada por falta de token; um 404 significa que veio de fora:

Sem configurações de VPCDirect VPC egress, todo o tráfego
Host404403
Sandbox com --allow-egress404403

O egress do sandbox segue o mesmo caminho do host, então --allow-egress não é “a internet pública”: é tudo que o serviço consegue alcançar. Com Direct VPC egress ele consegue alcançar serviços privados.

Teste 5: Sistema de arquivos e estado

Segui a descrição da documentação (as escritas vão para um overlay em memória, --write é necessário fora de /tmp, os tars pulam /tmp) e olhei o fork, que só a referência da CLI menciona (t5_state.sh):

PassoResultado
touch /etc/xRead-only file system
touch /tmp/xfunciona
--write, depois olhar no hosto sandbox escreveu /etc/x; o host não tem esse arquivo
--write --export-tar: escrever /root/f e /tmp/go tar tem ./root/f e nada de /tmp
--write --import-tar em um sandbox novo/root/f volta; /tmp/g sumiu
fork w1 w2 de um sandbox contando uma vez por segundow1 estava em 6; w2 recomeçou em 1; ambos continuam contando. Um arquivo que w1 escreveu antes do fork está em w2
--rootfs /tmpFetchSpec failed: loading container: file does not exist, exit 128

Então o fork copia os arquivos graváveis e reinicia a linha de comando; não é um snapshot de um processo em execução. O fork --help também lista uma flag --publish para portas que nenhuma parte da documentação menciona. Alguns detalhes da CLI me custaram tempo: um sandbox desacoplado (run --detach) mantém aberto o pipe do seu stdout até você redirecioná-lo, o fork precisa de --detach para retornar, e o exec precisa de -- antes de comandos que começam com uma flag (exec w1 -- sh -c ...).

Teste 6: O que chega ao Cloud Logging

Um profissional relatou que toda linha de comando do sandbox, incluindo os valores de --env, vai parar no Cloud Logging, então passei um canary:

sandbox do --env TOKEN=m2c-canary-7731 -- /bin/echo hello

Procurar o canary com gcloud logging read '"m2c-canary-7731"' encontrou duas entradas no log run.googleapis.com//var/log/sandbox.log, um início e um fim:

[start] cwd=/ "/usr/local/gcp/bin/sandbox do --env TOKEN=m2c-canary-7731 -- /bin/echo hello"
[end] exit_code=0 elapsed=119ms "/usr/local/gcp/bin/sandbox do --env TOKEN=m2c-canary-7731 -- /bin/echo hello"

O Logs Explorer mostrando dois resultados para o canary: uma entrada de início e uma de fim de sandbox do --env TOKEN=m2c-canary-7731, com o canary destacado

A saída do sandbox (hello) não é registrada. Toda chamada ao sandbox é registrada assim (run, exec, delete também), então um host ocupado escreve duas entradas por chamada. A documentação diz para não passar secrets com --env porque “eles podem ficar visíveis para os processos do sandbox”, e deixa de fora que a linha de comando é registrada e permanece nos logs do seu projeto.

Teste 7: Latência de inicialização

O post do Google diz que um serviço “inicia, executa e para 1.000 sandboxes com latência média de 500 ms”, sem informar máquina, concorrência ou método. Eu medi na instância com date +%s%N em volta de sandbox do -- /bin/true (t7_latency.sh), o que inclui iniciar o sandbox, rodar o comando e apagá-lo:

ExecuçãoSandboxesMédia por sandboxp50p95TaxaFalhas
Sequencial1.000153 ms154 ms177 ms6,4 por segundo0
10 por vez3001.684 ms1.696 ms2.005 ms5,7 por segundo0
50 por vez3008.848 ms8.806 ms11.077 ms5,3 por segundo0
100 por vez30020.787 ms21.383 ms29.696 ms4,3 por segundo1
100 chamadas exec em um sandbox warm10085 ms82 ms104 ms0

Uma execução exploratória anterior, em uma instância anterior, deu 186 ms para as mil sequenciais (p95 de 247 ms), então eu diria 150 a 190 ms. A mesma exploração com 1.000 sandboxes em cada nível de concorrência deu 5,5, 4,9 e 4,2 por segundo, e 23 falhas em 1.000 com 100 por vez. O texto da falha foi failed to start container: Timeout exceeded waiting for container to start execution.

Duas coisas decorrem disso. Um sandbox novo é mais rápido que o número do Google, em uma máquina declarada: 2 vCPU e 4 GiB, us-central1, um único /bin/true. E o host inicia cerca de cinco sandboxes por segundo seja qual for a concorrência, então o tempo por sandbox que você vê é, em grande parte, fila: aproximadamente 170 ms vezes o número em andamento. O Google não informa a concorrência por trás dos seus 500 ms. Se o seu agente dispara dezenas de sandboxes de uma vez, cada um espera pelos outros, e cem de uma vez atingem timeouts de inicialização.

A reutilização warm é a dica da própria documentação: inicie um sandbox com um comando ocioso e rode cada comando com exec. 100 chamadas exec levaram em média 117 ms na minha execução exploratória, cerca de 70 ms abaixo de um do novo. Para dar contexto, um hands-on japonês da G-gen registrou elapsed=541ms para uma chamada do em um serviço em asia-northeast1; estou citando o número deles, não reproduzindo.

Teste 8: Recursos compartilhados

A documentação diz apenas que “Os sandboxes compartilham a CPU e a memória alocadas ao container host”. Três testes mostram o que isso significa.

8a: um vizinho ocupado. Iniciei sandboxes desacoplados com loops ocupados (while :; do :; done) e medi duas coisas na mesma instância de 2 vCPU: 100 requisições triviais do meu laptop (um handler que devolve “ok”) e um job de CPU fixo que o próprio host roda (um loop Python de 3 milhões de iterações, que leva pouco mais de um terço de segundo sozinho). A tabela é a execução gravada; a execução exploratória anterior está entre parênteses.

Requisição p50 / p95 a partir do laptopJob de CPU no host, média de 5
Ocioso160 / 170 ms383 ms (358)
4 sandboxes ocupados177 / 189 ms1.361 ms, 3,6 vezes mais lento (1.876, 5,2 vezes)
8 sandboxes ocupados177 / 192 ms2.755 ms, 7,2 vezes mais lento (2.834, 7,9 vezes)

A requisição trivial quase não se mexeu, cerca de 17 ms, porque precisa de quase nenhuma CPU. O job que precisa de CPU se mexeu: cinco e nove processos executáveis (quatro ou oito sandboxes ocupados mais o job) em dois vCPUs dariam 2,5 e 4,5 vezes com uma divisão igualitária, e eu vi mais. Os sandboxes não têm limite de CPU próprio, então um sandbox ocupado deixa o app que o iniciou mais lento.

8b: memória. Um sandbox alocou 64 MiB por vez e tocou em cada página, até morrer.

host before: server PID 1, MemAvailable: 3593132 kB
allocated 3072 MiB
waiting on pid 7: ... urpc method "containerManager.WaitPID" failed: EOF
sandbox exit status: 1
host after:  server PID 1, uptime 4493.38 s, MemAvailable: 3621840 kB

Ele morreu em cerca de 3 GiB dos 4 GiB da instância, em até cinco segundos. O servidor do host manteve o PID e o uptime, a memória voltou, e o log do sistema não tem entrada de reinício nem de falta de memória para a instância. Então o esgotamento de memória em um sandbox matou apenas aquele sandbox, o que coincide com o que outro testador relatou. O sandbox divide os 4 GiB, então a memória do próprio app e a de todos os outros sandboxes são espremidas primeiro.

8c: a instância some. Iniciei um sandbox desacoplado com sleep 3600 e então fiz o deploy de uma nova revisão, o que substitui a instância. O Cloud Run iniciou a nova instância cerca de seis segundos depois da minha última chamada. O log da revisão antiga tem o lançamento ([end] exit_code=0 elapsed=115ms é o run --detach retornando, não o sandbox terminando), e depois nada: nenhuma saída do sandbox, nenhuma linha de desligamento. Os sandboxes morrem com a instância sem deixar rastro no Cloud Logging, então não guarde estado em um.

Teste 9: O CloudRunSandboxCodeExecutor do ADK

A pesquisa de que parti divergia sobre se o executor do ADK tinha sido lançado. Foi: pip install google-adk deu a 2.14.1, e from google.adk.integrations.cloud_run import CloudRunSandboxCodeExecutor importa. Ele roda sandbox do <python> e passa o código por stdin, tem como padrão nenhum egress e um timeout de 300 segundos, e não pode ser stateful.

adk deploy cloud_run --with_cloud_run_sandbox fez o deploy do agente com sandboxLauncher: true no YAML, como documentado. A rota do modelo deu trabalho. O deploy usa o Vertex AI por padrão, e o gemini-3.8-flash em us-central1 retornou um 403 mesmo depois de eu dar à service account o roles/aiplatform.user; troquei o serviço para uma chave de API do Gemini, e lá o gemini-2.5-flash retornou um 404, “no longer available to new users”. Com o prompt “compute 17 * 23 with Python” o agente primeiro terminou com MALFORMED_FUNCTION_CALL, porque o modelo tentou uma chamada de função. Dizer a ele para responder com um bloco Python cercado resolveu isso, e o executor retornou 391.

Então pedi ao agente para rodar while True: pass:

codeExecutionResult -> {'outcome': 'OUTCOME_FAILED', 'output': 'Code execution timed out after 300 seconds.'}

Levou de 316 a 320 segundos. A minha primeira tentativa recebeu um 504, porque o timeout de requisição do próprio Cloud Run também é de 300 segundos por padrão e disparou primeiro. O timeout funciona, mas eu queria saber o que ele mata. O executor mata o processo cliente sandbox do com subprocess.run(timeout=...). O comentário no código do próprio executor diz que o subprocess.run “mata o sandbox” antes de relançar a exceção, mas o que ele mata é o processo cliente sandbox do. Via SSH, pouco depois do timeout, os processos runsc do sandbox em loop ainda estavam lá e usavam 102 ticks por segundo, uma CPU inteira. Na minha primeira tentativa, eles ainda estavam lá um minuto depois. A cobrança baseada em requisição limita a CPU entre requisições, então um sandbox esquecido custa mais enquanto há requisições ativas, mas nada o limpa.

Resumo dos resultados

Afirmação ou perguntaResultado
Ativação pelo consoleSomente visualização; ative com gcloud beta ... --sandbox-launcher; a trilha GA a rejeita
IsolamentogVisor (4.19.0-gvisor, runsc, plataforma xemu) dentro de uma microVM de segunda geração
Sem variáveis de ambiente, secrets, metadataVariáveis de ambiente e o metadata server: sim. Um secret montado e um arquivo somente do root: legíveis
Usuárioroot (uid=0), sudo falha; a documentação diz não root com sudo
RedeFechada (sem DNS); --allow-egress segue o egress de VPC do serviço; o loopback do host é inalcançável
EscritasSomente leitura fora de /tmp; --write é um overlay; os tars pulam /tmp; fork reinicia o comando e copia arquivos
LoggingLinhas de comando, valores de --env incluídos, em sandbox.log; a saída não é registrada
”1.000 sandboxes a cerca de 500 ms”153 ms de média sequencial (186 ms em uma execução anterior), cerca de 5 por segundo em qualquer concorrência; 500 ms corresponde a cerca de 3 em andamento
Recursos compartilhadosSem limites por sandbox: 4 sandboxes ocupados deixaram um job de CPU do host de 3,6 a 5,2 vezes mais lento, 8 o deixaram de 7,2 a 7,9 vezes mais lento; o esgotamento de memória matou apenas o sandbox
Executor do ADKLançado; o timeout de 300 s funciona; o sandbox que atingiu o timeout continuou rodando

Monitoramento

Não há uma visão de sandbox no console do Google Cloud. A página Observability > Metrics do serviço mostra os gráficos usuais do Cloud Run (contagem de requisições e latências, contagem de instâncias do container, tempo de instância faturável, latência de inicialização, health checks), e a CPU e a memória de um sandbox contam como as do container. Não encontrei um gráfico por sandbox nem uma lista de sandboxes em execução. O que o console mostra:

  • Revision History > Containers: a configuração Sandbox launcher, somente leitura (Teste 1).
  • Logs Explorer: o stream run.googleapis.com//var/log/sandbox.log, com uma entrada [start] e uma [end] por comando sandbox, incluindo o exit code e o tempo elapsed (Teste 6). Esse é o único rastro do que rodou. A saída não está lá, e nada é registrado quando um sandbox se perde junto com a instância (Teste 8).
  • SSH (Preview): um botão na página do serviço que abre um shell em uma instância em execução, se o deploy do serviço foi feito com --ssh.

Preços

Os sandboxes do Cloud Run não adicionam cobrança: o post do blog diz que há “nenhum custo adicional ou prêmio”, e a página de preços não os menciona. O que você paga é a instância, e um serviço baseado em instância cobra pela vida inteira dela, ociosa ou não. Nas tarifas de tabela de us-central1 ($0,000018 por vCPU-segundo e $0,000002 por GiB-segundo para cobrança baseada em instância), o meu serviço de 2 vCPU e 4 GiB custa cerca de $0,158 por hora, ou cerca de $3,80 por dia. A camada gratuita mensal (240.000 vCPU-segundos e 450.000 GiB-segundos) cobre aproximadamente 31 horas dele, porque a franquia de memória acaba primeiro.

O meu serviço rodou por 1 hora e 15 minutos: cerca de 9.000 vCPU-segundos e 18.000 GiB-segundos, ou cerca de $0,20 a preço de tabela antes da camada gratuita. O serviço do ADK (baseado em requisição, cobrado pelos seus poucos minutos ocupados), um segundo serviço pequeno para o teste de VPC, cinco execuções do Cloud Build e os tokens do Gemini para o agente do ADK somam centavos. Estimei tudo isso a partir das tarifas e dos tempos de execução; não esperei o relatório de cobrança.

Dois custos não são óbvios. Um sandbox que ninguém apaga continua usando a CPU da instância, como o teste do ADK mostrou. E, com cobrança baseada em requisição, o Cloud Run limita a CPU fora das requisições, o que eu esperaria que também deixasse os sandboxes desacoplados sem CPU, então usei cobrança baseada em instância em todos os testes.

Para limpar tudo o que os testes criaram (serviços, imagens, secrets, a chave de API temporária e as concessões de role):

./teardown.sh

Veredito

O que funciona

O limite de isolamento é real e bem escolhido: gVisor sem rede, sem ambiente e sem metadata server, iniciando em cerca de 0,15 a 0,19 segundo, e ele reporta o mesmo kernel 4.19.0-gvisor dos sandboxes de Code Execution e Shell na parte 3. O esgotamento de memória matou apenas o sandbox. A rede se comporta como um único interruptor que segue a própria configuração de VPC do serviço, e o sandbox não consegue obter um token para chamar nada privado. Para um serviço que já roda o código do seu próprio agente, é uma flag e nenhum serviço extra.

O que não funciona, ainda

O sandbox divide a instância, e o problema vem do compartilhamento. Ele lê todos os arquivos que o container host enxerga, incluindo um secret montado e arquivos somente do root. Ele não tem limite de CPU próprio, então alguns sandboxes ocupados deixaram um job de CPU no host de quatro a oito vezes mais lento. A linha de comando, valores de --env incluídos, vai para os seus logs. O timeout do executor do ADK deixa o sandbox rodando. O console mostra a configuração mas não consegue alterá-la, a flag existe apenas em gcloud beta, e a documentação é omissa sobre a tecnologia de isolamento e sobre o que acontece com um sandbox quando a instância dele é substituída, e descreve uma configuração de sudo que eu não vi. Comparado com os sandboxes operados pelo Google nas partes 2 e 3, você ganha velocidade e custo extra zero e assume o host: o dimensionamento, os arquivos e os logs dele.

Quem deve usar

Os sandboxes do Cloud Run servem quando você já roda um serviço do Cloud Run e quer rodar o código de um modelo ao lado dele. Dimensione a instância para o app mais todos os sandboxes concorrentes, mantenha a imagem do host livre de secrets (não monte nenhum e não passe nada sensível com --env), use cobrança baseada em instância e coloque um timeout e uma limpeza em volta de cada sandbox que você iniciar. Se você precisa de limites por sandbox, um domínio de falha separado ou um ciclo de vida gerenciado, as opções gerenciadas das partes 2 e 3 são mais adequadas.

Comments