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

Agent Platform Sandboxes: Na Prática com Code Execution, Shell, Computer Use e Custom Containers

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 uma loja de brinquedos com quatro tipos de caixas de brincar: uma caixa para fazer contas, uma caixa para digitar comandos, uma caixa com um navegadorzinho dentro e uma caixa que você enche com seus próprios brinquedos. Você pede uma caixa para a loja e ela entrega uma em dois segundos, porque guarda algumas de reserva na prateleira.

As caixas podem ser colocadas para dormir e acordadas, e a loja pode tirar uma foto de uma caixa e fazer uma gêmea a partir dela. A caixa de contas, porém, não tem timer na tampa: se você esquecer dela, ela fica na prateleira e a loja continua contando.

O serviço oferece quatro tipos de sandbox gerenciados por trás de uma única API, todos rodando em um projeto gerenciado pelo Google. O acesso à rede vem desligado por padrão, o metadata server é inalcançável mesmo com acesso à internet ligado, e o audit log registra quem criou, pausou ou executou algo em um sandbox.

As lacunas são específicas. Sandboxes de Code Execution não têm expiração padrão e são cobrados enquanto existirem, vários limites documentados diferem do que eu medi, e o audit log não contém o código que foi executado. Confirme a expiração, as cotas e os termos de cobrança do seu contrato.

A necessidade apresentada é um lugar seguro para rodar código escrito por um agente. O tratamento é um sandbox gVisor sem rede por padrão, criado em cerca de dois segundos a partir de um pool pré-aquecido. Nos meus testes, os dois tipos que consegui identificar, Code Execution e Shell, mostraram gVisor.

Efeitos colaterais a monitorar: um sandbox de Code Execution que nunca expira, um resume que retorna antes de o sandbox responder, e uma documentação que discorda do produto sobre tamanhos, limites e o que uma pausa preserva. Peça os exames você mesmo antes de prescrever em larga escala.

É tranquilizador pedir um sandbox e tê-lo em dois segundos, e saber que a rede está fechada, a menos que você a abra. Boa parte da ansiedade que acompanha rodar código gerado desaparece quando os padrões são tão cautelosos.

O atrito aparece nas pequenas surpresas: um sandbox que nunca expira, uma pausa que preserva mais do que a página prometia e um console que não consegue mostrar nada disso. Você acaba conferindo as coisas por conta própria, o que é reconfortante depois de feito e cansativo enquanto você faz.

Pense em quatro instrumentos em um mesmo rack, cada um ligado à mesma mesa de som. Eles entram rápido, porque a mesa mantém alguns aquecidos e prontos, e os dois que consegui ouvir de perto, Code Execution e Shell, ficam na mesma sala acústica, um sandbox gVisor.

O andamento é constante, cerca de dois segundos por take, exceto no caso em que você pede um patch novo e espera quase vinte. Pause é uma nota sustentada: o processo continua soando quando você volta. E nada no palco informa o volume da sala, você lê isso nos logs.

A proposta é uma API para quatro tipos de sandbox: rodar código, rodar comandos de shell, controlar um navegador ou trazer seu próprio container. A criação leva cerca de dois segundos, o acesso à rede vem desligado por padrão, e um sandbox pausado volta com o processo em execução intacto.

A história honesta para um slide: nenhum console de sandbox, um sandbox de Code Execution que nunca expira a menos que você defina um time to live, e uma cobrança de cerca de 18 centavos por hora para o tamanho padrão do Code Execution, durante todo o tempo em que ele existir.

GitHub Veja o código-fonte aqui: gcp-sandboxes/agent-platform-sandboxes

Visão geral

Os sandboxes do Agent Platform são a família de sandboxes do Gemini Enterprise Agent Platform do Google, o produto antes conhecido como Vertex AI. Uma API cria quatro tipos de “container isolado com gVisor” em um projeto tenant gerenciado pelo Google: Code Execution (roda Python ou JavaScript), Shell (roda comandos bash), Computer Use (um navegador Chrome que um agente pode controlar) e custom containers (sua própria imagem do Artifact Registry). A documentação diz que os sandboxes “podem ser de curta duração, baseados em sessão ou stateful por vários dias”, e eles podem ser pausados, ter snapshots criados e ser restaurados. Os estágios de lançamento são desiguais: Shell e Computer Use chegaram a GA em 9 de setembro de 2026, enquanto Code Execution está em preview desde setembro de 2025 sem nenhum aviso de GA, e custom containers, templates e snapshots entraram em preview em 26 de maio de 2026, também sem aviso, embora Shell e Computer Use em GA dependam de templates.

Este post, parte 3 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, onde um modelo decide o que rodar. Aqui você chama o sandbox diretamente, com uma simples chamada execute. A Parte 1 mapeia todas as opções do Google Cloud, e as partes 4 a 6 cobrem sandboxes do Cloud Run, o GKE Agent Sandbox e o Agent Substrate no GKE.

Eu testei em 14 de novembro de 2026 em us-central1, com o SDK Python e com chamadas REST diretas, e gravei uma execução limpa de cada teste para o vídeo. Sete resultados se destacaram:

  • A criação é rápida quando algo está aquecido. Um sandbox de Code Execution, Shell ou Computer Use a partir de um template levou de 1,0 a 3,0 segundos. Pedir um sandbox Shell sem template levou cerca de 19 segundos, porque o SDK cria um template novo a cada vez. O primeiro sandbox de Code Execution em um projeto novo levou 142 segundos.
  • Os tamanhos são quase todos não documentados. Um sandbox Shell padrão tem 0,5 vCPU e 0,5 GiB e o Computer Use tem 2 vCPU e 4 GiB; a documentação não informa nenhum dos dois. O sandbox de Code Execution reporta 2 GiB, não os 1,5 GiB documentados.
  • A rede é fechada, e o metadata server é fechado mesmo quando a rede não é. Com acesso à internet ligado, www.google.com e um IP puro responderam; o metadata server e as faixas privadas continuaram dando timeout.
  • Um sandbox de Code Execution nunca expira por padrão. Shell e Computer Use ganham 2 horas. Todos são cobrados enquanto existirem.
  • Pause preserva mais do que a documentação diz. Um processo em segundo plano, um pacote e o boot id sobreviveram a uma pausa. Um snapshot restaurado em um novo sandbox também os preservou.
  • O audit log registra o ciclo de vida, mas não o trabalho. Create, pause, resume e snapshot são registrados, e execute é registrado quando os Data Access logs estão ligados, mas o código que eu rodei não apareceu em lugar nenhum.
  • Nenhum console mostra nada disso. A página do Agent Runtime não lista nenhuma instância e nenhum sandbox. Cotas, logs e cobrança são as únicas visões do console.

Configuração

Novo no Google Cloud? Tudo vive em um projeto: as APIs que você ativa, as permissões e a cobrança. Eu usei um projeto dedicado e com cobrança em us-central1, com o billing ativado e estas APIs ligadas: aiplatform, artifactregistry, cloudbuild, iamcredentials e logging.

Passo 1: Instalar o SDK

python3.12 -m venv .venv && .venv/bin/pip install google-cloud-agentplatform==2.9.0 google-genai httpx requests websockets

Tudo usa agentplatform.Client().sandboxes.* com api_version="v1beta1": a API GA v1 não tem computerUseEnvironment nem bidiExecute, e todo quickstart fixa v1beta1. O quickstart do Shell mistura um SDK mais antigo (vertexai); eu usei apenas o agentplatform. Versões: Python 3.12.13, google-cloud-agentplatform 2.9.0, google-genai 3.3.0, Google Cloud CLI 593.0.0.

Passo 2: Criar a instância do Agent Runtime

Todo sandbox, template e snapshot é filho de uma instância do Agent Runtime, o mesmo recurso que hospeda agentes implantados. Você não precisa fazer deploy de um agente nela. O client.runtimes.create() exige pacotes extras, então criei a instância com uma chamada REST (t0_setup.py):

curl -s -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H 'Content-Type: application/json' \
  "https://us-central1-aiplatform.googleapis.com/v1beta1/projects/$PROJECT/locations/us-central1/reasoningEngines" \
  -d '{"displayName": "sbx-part3"}'

Ela ficou pronta em cerca de dois segundos. O SDK exige Application Default Credentials; para evitar um login no navegador, o sbx.py do repositório complementar entrega a ele o seu token do gcloud. Abra com python -i sbx.py e você tem um client pronto e helpers de uma linha.

Passo 3: Permissões para Computer Use e custom containers

Code Execution e Shell precisam apenas de roles/aiplatform.user para quem chama. O Computer Use fala com o endpoint HTTPS do próprio sandbox com um JWT assinado via iamcredentials, então precisa de uma service account com roles/aiplatform.user, e quem chama precisa de roles/iam.serviceAccountTokenCreator nela. As mudanças de IAM levaram um ou dois minutos para valer: minha primeira chamada de token retornou 403 e funcionou alguns minutos depois.

Custom containers precisam de um repositório no Artifact Registry e de roles/artifactregistry.reader para service-<project number>@gcp-sa-vertex-sandbox.iam.gserviceaccount.com. O Cloud Build também falhou no início: a service account padrão do Compute do projeto não tinha acesso ao próprio bucket de código-fonte, então concedi a ela roles/cloudbuild.builds.builder.

Passo 4: Templates

Code Execution recebe uma spec inline. Shell e Computer Use são baseados em template: um template nomeia a categoria do container, seu tamanho e sua configuração de rede, e a plataforma mantém um pool de sandboxes prontos para ele. Eu criei três, uma vez, e os reutilizei (t1_create.py): Shell com internet desligada, Shell com internet ligada e Computer Use.

Testes

Teste 1: O que são os sandboxes

# Code Execution: ask Python
os.cpu_count(), MemTotal, platform.uname(), dmesg
# Shell: bash
uname -r; dmesg | head -2; id; nproc; free -m
# Computer Use: ask the browser
navigator.hardwareConcurrency, navigator.userAgent
Code ExecutionShellComputer Use
Kernel4.19.0-gvisor4.19.0-gvisor(somente navegador)
dmesg”Starting gVisor…""Starting gVisor…“n/a
Usuárioroot (uid 0)appuser (uid 999)n/a
SO e runtimePython 3.12.5, Node 18Debian 12, Python 3.11.2, sem NodeChrome 139 no Linux
Memória vista por dentro2 GiB (4 GiB no tamanho maior)512 MiBn/a
Tamanho atribuído pela plataformadocs: 2 vCPU, 1,5 GiB0,5 vCPU, 0,5 GiB2 vCPU, 4 GiB

Code Execution e Shell são gVisor, cujo dmesg recebe você com “Starting gVisor…” e um boot log bem-humorado. No Computer Use eu só pude perguntar ao navegador, então não tenho uma string de kernel para ele, e os custom containers que testei servem apenas HTTP, então também não fiz o fingerprint deles. Os tamanhos deram trabalho. O Code Execution tem duas configurações de máquina, e MACHINE_CONFIG_VCPU4_RAM4GIB me deu 4 GiB por dentro, mas ambas reportam 8 CPUs, as do host, então a contagem de vCPU não pode ser lida de dentro; a documentação diz 2 e 4. Os tamanhos de Shell e Computer Use não são documentados. Cada sandbox tem um routing token, um JWT, com as claims machine_vcpu e machine_memory_gib, e os resources.limits do template dizem o mesmo: Shell 0,5 vCPU, 0,5 GiB (512 Mi), Computer Use 2 vCPU, 4 GiB. O nproc de um sandbox Shell reporta 2 CPUs enquanto o limite é 0,5.

Teste 2: Tempos de criação

op, secs = timed(client.sandboxes.create, name=rt, config={"sandbox_environment_template": tpl, "ttl": "600s"})
CriaçãoExecuçõesTempo
Code Execution, spec inline51,0 a 2,4 s (mediana 1,6 s)
Shell, a partir de um template51,6 a 3,0 s (mediana 1,7 s)
Computer Use, a partir de um template31,6 a 2,1 s (mediana 1,7 s)
Shell, spec inline, sem template218,5 e 19,3 s
Um template, da criação até ACTIVE (três em paralelo)317,8 a 18,0 s

A documentação promete “menos de um segundo” para Code Execution (não alcançado: 1,0 a 2,4 segundos, mais 0,5 a 1,1 segundo para o primeiro execute) e “cerca de 20 segundos” para Shell, que foi o que obtive somente sem um template. Com um template, a plataforma entrega um sandbox de um warm pool pré-aquecido. O recurso REST diz o tamanho desse pool: todo template que criei tinha warmPoolConfig.targetInstanceCount: 10, um padrão não documentado. Os sandboxes Shell que peguei de um pool já estavam de pé havia entre 105 segundos e 27 minutos (/proc/uptime).

Mais duas coisas. A criação inline do Shell cria um template novo a cada vez: depois de duas criações, a instância tinha dois templates extras chamados shell-sandbox-template, que mantêm seus warm pools, e o SDK nunca os apaga. E o “cold” é real, mas só na primeira vez: meu primeiro sandbox de Code Execution em um projeto novo levou 142 segundos (a documentação diz “até 2 minutos”), o primeiro template em uma nova instância do Agent Runtime levou cerca de 2 minutos e 40, e uma segunda instância no mesmo projeto não mostrou nada disso: 2,1 segundos, e templates prontos em 18 segundos. O campo REST warmPoolConfig não está no SDK, mas funciona: criei um template com um pool de 1, que testes posteriores usaram para os custom containers mais baratos. Um template com pool de 0 nunca produziu um sandbox nos 13 minutos que esperei.

Teste 3: Identidade e rede

whoami; id; sudo -n true; env | wc -l; which curl
python3 probe.py <url>     # prints the HTTP status, or why it failed

O sandbox Shell roda como appuser, não tem sudo, não tem curl, tem 21 variáveis de ambiente e nenhuma com nome de secret, além de 8 variáveis KUBERNETES_*: é um pod. Depois, as mesmas sondas contra cada destino, com acesso à internet desligado e ligado no template, e Code Execution como controle:

DestinoShell, internet desligadaShell, internet ligadaCode Execution
Metadata server (169.254.169.254)timeouttimeoutinalcançável
metadata.google.internalsem DNSsem DNSsem DNS
www.google.comsem DNSHTTP 200sem DNS
storage.googleapis.comsem DNSHTTP 400 (o servidor respondeu)sem DNS
8.8.8.8 (IP puro)timeoutHTTP 200inalcançável
10.128.0.2, 192.168.0.1 (privados)timeouttimeoutinalcançável
pip install cowsayfalhafuncionafalha

Com a internet desligada, o DNS não resolve e IPs puros dão timeout. Com ela ligada, o sandbox recebe a internet pública, mas não o metadata server nem as faixas privadas, como documentado. Não há allowlist no meio: o campo do template é um booleano, e o controle por domínio exige um VPC attachment com um firewall que você mesmo opera. Então “acesso à internet” é tudo ou nada, diferente das allowlists da parte 2. A nota de GA vende o Shell para instalar pacotes, mas sem internet e sem root, isso só funciona depois que você abre a rede e instala no virtualenv gravável pelo usuário (/opt/venv): pip install --user falha ali.

Teste 4: Estado e TTL

run(sb, "x = 41"); run(sb, "print(x + 1)")      # 42
rest("GET", sandbox)["expireTime"]                 # after creating with no ttl

O Code Execution mantém seu estado Python entre as chamadas. Quanto à expiração, a documentação discorda de si mesma (2 horas, 7 dias, 14 dias, “não é excluído automaticamente”). Criei cada tipo sem ttl e li de volta via REST:

TipoExpiração padrão
Code Executionnenhuma: nenhum expireTime
Shell2 horas
Computer Use2 horas

Também criei um sandbox de Code Execution e um Shell com ttl: 300s, rodei um comando aos 240 segundos e li expireTime de novo: ele não se mexeu. Um execute não reinicia o relógio, embora o quickstart do Code Execution diga que cada execução reinicia. Após a expiração, um GET retornou 404 e o audit log mostrou uma entrada AutoDeleteSandboxEnvironment.

⚠️ Um sandbox de Code Execution criado sem ttl nunca expira, e sandboxes são cobrados enquanto existirem. No preço de tabela para o tamanho padrão documentado, isso dá cerca de US$ 0,18 por hora, US$ 4,40 por dia. Sempre defina um ttl.

Teste 5: Limites do Code Execution

client.sandboxes.execute_code(name=sb, input_data={"code": code, "files": [...]})
  • JavaScript funciona: com code_language: LANGUAGE_JAVASCRIPT, console.log(process.version, typeof require) imprimiu Node v18.20.1 e function. A visão geral não menciona JavaScript.
  • As bibliotecas vêm pré-instaladas, o pip não: numpy 2.1.3, pandas 2.2.3, matplotlib 3.10.1, openpyxl 3.1.5, scipy 1.15.2 e Pillow estão lá; pip install cowsay falhou, já que o sandbox não tem rede.
  • Arquivos de saída voltam como chunks extras com um nome de arquivo: um PNG do matplotlib (16.656 bytes) e um XLSX (4.850 bytes) chegaram como arquivos válidos. Os dados já são bytes brutos: o content.b64decode() do exemplo da documentação é um bug, e um base64.b64decode também não é necessário.
  • O limite de 100 MB não pegou. Enviei 99 e 101 MiB como arquivos de entrada, e ambos funcionaram (blob101.bin 105906176 bytes por dentro). Cada um levou cerca de 9 minutos na minha conexão doméstica, então rodei este fora da execução gravada (t5b_upload.py).

Teste 6: Pause vs snapshot

Eu preparei um sandbox Shell com internet ligada: um http.server em segundo plano, um arquivo em /workspace, outro em /tmp, um pacote instalado e o boot id. Depois:

client.sandboxes.pause(name=sb)
client.sandboxes.resume(name=sb)
snap = client.sandboxes.snapshots.create(source_sandbox_environment_name=sb, config={"ttl": "7200s"})
new = client.sandboxes.create(name=rt, config={"sandbox_environment_snapshot": snap.name})
Após pause e resumeApós snapshot e restore (novo sandbox)
Processo em segundo planovivo, a porta respondeuvivo, a porta respondeu
Arquivos em /workspace e /tmppreservadospreservados
Pacote instaladopreservadopreservado
boot_ido mesmoo mesmo

A documentação diz que uma pausa preserva o sistema de arquivos e que um snapshot preserva também a memória. Nas minhas execuções, ambos preservaram o processo em execução e o mesmo boot id, então não consegui distingui-los por esse caminho. Os tempos nas minhas execuções: pause de 5,3 a 9,8 segundos, resume() de 4,1 a 8,5 segundos, snapshot de 5,1 a 9,4 segundos, restore em um novo sandbox de 4,5 a 8,1 segundos. O sandbox restaurado é um recurso diferente, e a origem continuou rodando depois. Um segundo restore do mesmo snapshot também funcionou.

As surpresas estão nas bordas:

  • Rodar um comando em um sandbox pausado o retoma. A chamada falha com 503 UNAVAILABLE: Sandbox environment is paused; resume has been initiated. Please retry the request. e uma dica de retry de 10 segundos, e o sandbox estava rodando de novo 4 a 5 segundos depois. A documentação diz que o data plane “retorna erros até você retomar”.
  • O resume() retorna antes de o sandbox responder. Após um resume() explícito, o primeiro comando que teve sucesso no meu loop de retry (a cada 3 segundos, até 36) veio cerca de 34 segundos depois nas três execuções; após o resume automático, ele respondeu na hora. Trate 34 segundos como “até meio minuto”, não como um tempo de prontidão medido.
  • Retomar um sandbox em execução não é um erro. Retornou normalmente. FAILED_PRECONDITION apareceu apenas enquanto o sandbox ainda estava retomando (must be in PAUSED or STOPPED state to be resumed).
  • O recurso de snapshot é enxuto. O REST retorna createTime, expireTime (7.200 segundos, meu ttl), owner e sourceSandboxEnvironment, mas nenhum sizeBytes e nenhum parentSnapshot, embora a referência documente ambos. Não consegui desenhar uma árvore de ancestralidade nem medir o armazenamento que um snapshot usa.
  • Code Execution não faz nenhum dos dois. Um snapshot retornou 404 Failed to get OSS Agent Sandbox CR e uma pausa retornou 500 Internal error. O texto do 404 é o único lugar onde vi isso, e sugere que a plataforma procura um custom resource do projeto open source Agent Sandbox, o mesmo que o Agent Sandbox do próprio GKE usa (parte 5). Isso é inferência minha, não algo que a documentação diga.

Teste 7: Computer Use

cdp(sb, "Page.navigate", {"url": "https://cloud.google.com/docs"})
png = cdp(sb, "Page.captureScreenshot")["data"]

O sandbox serve uma pequena API HTTP na porta 8080: GET / retorna {"status":"healthy"}, e POST /cdp recebe um comando do Chrome DevTools Protocol. É um Chrome 139 a 1280 por 720. Um navigate mais um screenshot deu um PNG de 190 KB da página inicial da documentação do Google Cloud.

A página inicial da documentação do Google Cloud, capturada como PNG através do endpoint Chrome DevTools do sandbox Computer Use

Depois, o loop (cu_loop.py, cerca de 100 linhas com a tradução para CDP): screenshot para o Gemini 3.8 Flash com a ferramenta computer-use, executar a ação do modelo, traduzi-la para CDP (Input.dispatchMouseEvent, Input.insertText, Page.navigate), novo screenshot, no máximo 6 passos. A página do modelo e as páginas do sandbox não referenciam uma à outra, então a cola entre elas é por sua conta.

step 1: click {'x': 608, 'y': 33, ...}   step 3: scroll {'direction': 'down', ...}
step 2: type {'text': 'Agent Platform sandboxes', 'press_enter': True}   step 4: click {'x': 432, 'y': 84}

Tarefa: pesquisar “Agent Platform sandboxes” na documentação do Google Cloud e abrir o primeiro resultado. Levou 4 ações, cerca de 30.300 tokens (alguns centavos no preço de tabela) e 34 segundos, com 3 a 4 segundos por chamada ao modelo na execução gravada (13 a 17 segundos em uma chamada lenta nas execuções anteriores), e terminou em “Sandboxes overview”. As coordenadas vão de 0 a 999 nos dois eixos e mapeiam para a página de 1280 por 720. Os nomes das ações diferem dos documentados: vi click, type e scroll, não click_at, type_text_at e scroll_document.

noVNC: o sandbox tem três portas, 5091, 8080 e 9222. A porta 5091 serve um cliente noVNC (GET /vnc.html retornou a página de 15.850 bytes, título “noVNC”), que é a visualização ao vivo que a documentação menciona sem informar a porta. Não consegui abrir seu websocket com os headers que o websocket do CDP usa (HTTP 400), então não posso dizer que a visualização ao vivo funciona.

Um screenshot da página de documentação do Google Cloud "Sandboxes overview", capturado através do sandbox Computer Use após a quarta ação do loop do Gemini

O screenshot que o modelo viu após sua quarta ação: o primeiro resultado da busca, aberto.

Pause e snapshot funcionam também em um navegador. Deixei essa página aberta, pausei e retomei o sandbox, depois criei um snapshot dele e o restaurei em um novo sandbox. A página continuava aberta nas duas vezes. Uma armadilha: em uma tentativa anterior, o objeto de sandbox que eu já tinha em mãos respondeu Bad Gateway: Unable to reach the sandbox environment durante os cinco minutos em que meu loop de retry rodou após um resume. Quando li o sandbox de novo com get() e usei esse objeto novo, ele respondeu em 0,6 segundo. Acredito que o connection_info muda no resume, mas não comparei os valores.

Teste 8: Custom containers

A documentação pede uma imagem Linux com “um runner ou entry point compatível” que “não pode exigir root”, do Artifact Registry. O runner não é descrito em lugar nenhum da documentação, então testei três imagens, todas FROM python:3.12-slim e construídas com gcloud builds submit:

USER 1000
CMD ["python", "-m", "http.server", "8080"]     # image 1: HTTP on 8080, non-root
CMD ["sleep", "infinity"]                         # image 2: no HTTP server
USER 0                                            # image 3: like image 1, as root

Cada uma recebeu um template com a porta 8080, 1 CPU e 500 Mi (e um warm pool de 1), e depois um sandbox (eu consultei o estado do template a cada poucos segundos, então leia a coluna do template como “cerca de 11 s”):

ImagemTemplate ACTIVESandbox RUNNINGChamada à porta 8080
HTTP, USER 1000cerca de 11 s4,5 so container respondeu
sem servidor HTTPcerca de 11 s4,1 sBad Gateway: Unable to reach the sandbox environment
HTTP, USER 0cerca de 11 s4,2 so container respondeu

Então o contrato é um servidor em uma porta declarada. A mesma chamada de duas formas: :execute com a URI da requisição e a porta como chunks (o que execute_bash faz para /exec) e send_command pelo data plane. O http.server do Python respondeu à primeira com a própria página 501 Unsupported method ('POST'), o que mostra que o control plane encaminha sua chamada como um POST; send_command com um GET retornou a listagem do diretório. Mais três observações:

  • RUNNING não significa alcançável. A imagem sem servidor chegou a STATE_RUNNING em 4 segundos e toda chamada a ela falhou.
  • Root não foi rejeitado. A imagem USER 0 iniciou e serviu. Não consegui rodar id nela, então não posso dizer qual uid a plataforma realmente usou.
  • Um repositório recriado quebrou os templates. Eu havia apagado meu repositório do Artifact Registry e o recriado com o mesmo nome e as mesmas permissões. Templates apontando para ele ficaram em PROVISIONING por 25 minutos, e os que apaguei ficaram em DEPROVISIONING. Um repositório com nome novo funcionou na hora.

Teste 9: O que é registrado

Os audit logs de Admin Activity estão sempre ligados. Eu liguei os Data Access logs para aiplatform.googleapis.com (ADMIN_READ e DATA_WRITE), rodei um ciclo de vida de Code Execution, um de Shell (create, execute, pause, resume, snapshot, delete) e um de Computer Use com código que imprime MARKER-4f2a, e li as entradas de volta:

gcloud logging read 'protoPayload.serviceName="aiplatform.googleapis.com" AND protoPayload.methodName:"SandboxEnvironment"' --freshness=1h
LogMétodos que apareceram
Admin ActivityCreateSandboxEnvironment, DeleteSandboxEnvironment, PauseSandboxEnvironment, ResumeSandboxEnvironment, SnapshotSandboxEnvironment, DeleteSandboxEnvironmentSnapshot (e AutoDeleteSandboxEnvironment quando um ttl acabou, e Create/DeleteSandboxEnvironmentTemplate)
Data AccessExecuteSandboxEnvironment, GetSandboxEnvironment, ListSandboxEnvironments, GetSandboxEnvironmentSnapshot, AuthorizeSandboxEnvironmentAccess
  • Pause e resume são registrados, como Admin Activity. A página geral de audit logging os omite e a visão geral de sandboxes os lista; a visão geral está certa.
  • O código não é registrado. Uma busca por MARKER-4f2a encontrou 0 entradas. Uma entrada ExecuteSandboxEnvironment tem quem chamou, de onde e qual sandbox, e sua requisição contém apenas o nome do sandbox: nenhum código, nenhuma saída.
  • O Computer Use aparece como verificações de autorização. Os comandos CDP que enviei não são chamadas execute: o único rastro foi AuthorizeSandboxEnvironmentAccess.

As entradas apareceram em um ou dois minutos, e algumas operações são registradas mais de uma vez. Os Data Access logs acrescentam custo de ingestão, pequeno aqui; desliguei depois.

Resumo dos resultados

Afirmação ou perguntaResultado
IsolamentogVisor (4.19.0-gvisor) em Code Execution e Shell; sem fingerprint em Computer Use ou custom containers
”Menos de um segundo” para criar1,0 a 2,4 s a partir do aquecido; 142 s na primeira vez em um projeto
Shell “cerca de 20 s”Cerca de 19 s sem template, 1,6 a 3,0 s com um
TamanhosShell 0,5 vCPU / 0,5 GiB, Computer Use 2 / 4, Code Execution 2 GiB por dentro
Rede padrãoDesligada. Ligada: internet pública, sem metadata server, sem faixas privadas
Expiração padrãoCode Execution nunca, Shell e Computer Use 2 h; execute não a reinicia
Code ExecutionJavaScript funciona, sem pip, entrada de 101 MiB aceita
Pause preservaO processo, os arquivos, o pacote e o boot id; um comando em um sandbox pausado o retoma
SnapshotIgual ao pause, em um novo sandbox em 4,5 a 8 s; o REST não tem tamanho nem parent
Computer UseCDP puro e um loop com Gemini funcionam; noVNC servido na porta 5091
Custom containersUm servidor em uma porta declarada; sem servidor ainda chega a RUNNING; root não é rejeitado
AuditoriaCiclo de vida e execute registrados; código e comandos CDP não

Monitoramento

Não existe uma visão de sandboxes no console do Google Cloud. A página do Agent Runtime (Agents, Deployments) diz “No agent instances” enquanto a instância que guarda meus sandboxes existe:

A página Deployments do Agent Runtime no console do Google Cloud, com uma tabela vazia e o texto No rows to display

O que o console mostra:

  • Cotas (IAM & Admin, filtrado por “sandbox”): a documentação publica cotas apenas para Code Execution, mas o projeto tem linhas para toda a família, por região: 500 entidades de sandbox, 500 entidades de template, 400 requisições de escrita de sandbox por minuto, 100 requisições de escrita de template por minuto e 500 requisições de execute por minuto.

    A página de cotas do IAM e Admin filtrada por sandbox, com linhas para Vertex Sandbox Environment Template Entities (500) e Template Write Requests (100)

  • Logs Explorer: as entradas de auditoria do Teste 9. Nada de dentro de um sandbox: stdout e stderr não são coletados.

  • Cloud Monitoring: listei os 373 tipos de métrica aiplatform.googleapis.com do projeto. Nenhum é sobre sandboxes; os reasoning_engine cobrem agentes implantados.

  • Billing > Reports agrupa o custo por SKU, mas atrasa: cerca de nove horas depois dos meus primeiros sandboxes, o relatório ainda terminava em 13 de novembro, e nenhum dos SKUs da primeira página era do Agent Platform.

Preços

A página de preços cobra os ambientes de sandbox em dois SKUs, Agent Compute a US$ 0,085 por vCPU-hora e Agent Memory a US$ 0,009 por GiB-hora, arredondados ao segundo, e a documentação diz que os sandboxes são cobrados “enquanto existirem”. Shell e custom containers não são detalhados separadamente, então eu os precifiquei da mesma forma. O Agent Storage custa US$ 0,30 por GiB-mês. Com os tamanhos do Teste 1:

SandboxTamanhoPor horaExpiração padrãoPior caso se esquecido
Shell0,5 vCPU, 0,5 GiBUS$ 0,0472 hUS$ 0,09
Computer Use2 vCPU, 4 GiBUS$ 0,2062 hUS$ 0,41
Code Execution (tamanho da documentação)2 vCPU, 1,5 GiBUS$ 0,184nenhumaUS$ 4,40 por dia
Code Execution, 4 vCPU, 4 GiB4 vCPU, 4 GiBUS$ 0,376nenhumaUS$ 9,02 por dia
Custom container (meu template)1 vCPU, 500 MiUS$ 0,089não medido

Esses são preços de tabela da planilha de preços; não consegui ver minha própria fatura (acima). O que não consigo precificar:

  • Warm pools. Todo template mantém 10 sandboxes prontos por padrão. Se eles forem cobrados como sandboxes, um template Shell custaria cerca de US$ 0,47 por hora e um template Computer Use cerca de US$ 2,06 por hora, enquanto ocioso. A documentação não diz. Mantive os templates vivos apenas durante os testes e defini um pool de 1 para os custom containers.
  • Sandboxes pausados e snapshots. A documentação diz que um sandbox pausado custa “significativamente menos”, sem nenhum valor, e nenhuma página diz se snapshots são cobrados como Agent Storage. Deixei um sandbox Shell em execução e outro pausado lado a lado por cerca de 40 minutos para comparar, o que é curto demais para o relatório diário de qualquer forma.
  • Tokens do modelo para Computer Use: a execução de 4 ações usou cerca de 30.300 tokens, alguns centavos nos preços de tabela do Gemini 3.8 Flash, que dobram em 1º de janeiro de 2027.

No preço de tabela, o tempo de sandbox de toda a exploração e da gravação (várias dezenas de sandboxes curtos) ficou bem abaixo de um dólar. A questão em aberto são os warm pools, que poderiam somar alguns dólares se forem cobrados como sandboxes. Para limpar:

python teardown.py   # sandboxes, snapshots, templates, the instance, the repo, the service account, audit logs

Veredito

O que funciona

Criar um sandbox é rápido e uniforme: dois segundos a partir de um warm pool, a mesma API para quatro tipos e gVisor nos dois tipos que consegui identificar. Os padrões são cautelosos: sem rede, sem metadata server mesmo com a rede ligada, um usuário sem privilégios no Shell. Pause é melhor do que o documentado: um processo, uma página de navegador e um pacote voltaram, e um snapshot, que a documentação diz que preserva a memória, é restaurado em um sandbox novo em segundos. O Computer Use é simples de controlar com um loop de cerca de 100 linhas, e o audit log responde quem criou, pausou e rodou o quê.

O que ainda não funciona

Você não vê nada disso no console, e a documentação e o produto discordam em muitos pontos: tamanhos, o limite de 100 MB, o que uma pausa preserva, o que um execute faz com a expiração, as cotas. Um sandbox de Code Execution que nunca expira é um risco de cobrança, e “acesso à internet” é uma única chave sem allowlist. O resume() retorna antes de o sandbox responder, uma conexão obsoleta após um resume do Computer Use responde apenas Bad Gateway, e o recurso de snapshot não tem os campos de tamanho e parent que a referência lista. Se os pools de templates são cobrados ou não, ninguém diz.

Quem deve usar

Use quando você quer sandboxes como uma API sem operar um cluster, e quando a criação em dois segundos e o pause e resume importam mais do que um console. Defina um ttl em tudo, mantenha poucos templates e apague-os, coloque seu próprio firewall na frente se abrir a rede e leia o audit log, não o código, para saber quem fez o quê. Se você precisa ver sandboxes em um console ou rodá-los ao lado das suas próprias workloads, a parte 4 analisa os sandboxes do Cloud Run, e as partes 5 e 6 o GKE.

Comments