Ciclo de Vida do Sandbox no OpenSandbox: Hands-On no Amazon EKS
Por Fabio Douek
Ir para seção
- Visão Geral
- O ciclo de vida em um relance
- Configuração
- Passo 1: O código de apoio
- Passo 2: Snapshots em um único repositório do ECR
- Passo 3: Uma única forma de mudar o servidor
- Passo 4: Um warm pool
- Testes
- Teste 1: Estados, TTL, renew e expiração
- Teste 2: Pause e resume, e o que volta
- Teste 3: O benchmark de resume do próprio projeto
- Teste 4: Pools, a quente contra a frio
- Teste 5: runc contra Kata, e por que não gVisor
- Teste 6: Um pod apagado e um node em cordon
- Resumo dos resultados
- Limpeza
- Veredito
- Com o que você se compromete
- Quem deve usar
Explica (TLDR) como se eu fosse...
Imagine um robô ajudante que trabalha em um quartinho cheio de brinquedos. Na hora da soneca, alguém tira uma foto do quarto e a guarda, e quando o robô acorda, o quarto é montado de novo a partir da foto. Os brinquedos voltam, mas aquilo que o robô estava fazendo bem naquela hora se perde, e o guarda da porta esqueceu todas as chaves.
Se alguém derruba o quarto sem querer, um quarto novo e vazio aparece na hora, e ninguém avisa o robô que os brinquedos dele sumiram. Um quarto com paredes mais grossas, só dele, também funciona. Só demora um pouquinho mais para montar.
Este post testa o que acontece com o sandbox de um agente de IA ao longo da sua vida no OpenSandbox 1.2.0, um projeto Apache 2.0 da Agentic AI Foundation, no Amazon EKS: expiração, pause e resume, warm pools, um runtime de máquina virtual e falhas. Uma pausa salva os arquivos do sandbox no registry da própria organização. Memória, processos em execução e credenciais armazenadas não são mantidos.
As constatações relevantes dizem respeito a perdas das quais ninguém é informado. Um pod de sandbox apagado é substituído imediatamente por uma cópia limpa, enquanto a plataforma continua a reportá-lo como em execução. E nada pausa um sandbox de container ocioso, então ele retém sua capacidade até o seu timeout.
A queixa principal era o que um sandbox mantém e o que ele perde ao longo da sua vida no Amazon EKS. Levei o OpenSandbox 1.2.0 por criação, expiração, pause e resume por meio de um registry, warm pools, máquinas virtuais Kata e falhas deliberadas, e registrei cada execução.
Achados: os arquivos sobrevivem a uma pausa; memória, processos e o Credential Vault, não. Um pod apagado foi substituído em segundos por um com um filesystem novo, enquanto o sandbox continuava reportando que estava saudável, uma perda silenciosa. Sob Kata, o sandbox que examinei inicializou o próprio kernel com duas CPUs, e uma criação levou 4,2 segundos contra 2,2 sob o runtime padrão.
Pause e resume soa como uma promessa de que nada se perde, e parte deste trabalho é ajustar essa expectativa com delicadeza. Os arquivos voltam. O que o sandbox estava fazendo, o que ele guardava na memória e as credenciais que recebeu não voltam, então quem o retoma precisa entregar as credenciais de novo.
O momento mais difícil foi um pod apagado. A plataforma o substituiu em segundos e continuou dizendo que estava tudo bem, enquanto os arquivos gravados antes tinham sumido. Ajuda saber disso com antecedência, e manter o que importa em um armazenamento fora do sandbox, em vez de descobrir no meio de uma sessão.
Pense na vida de um sandbox como um set com hora marcada para terminar: começa na contagem, toca até o tempo acabar e pode ser estendido no meio da música. O pause é uma gravação do palco, não da apresentação. O equipamento volta exatamente onde estava, mas as notas no ar, o ponto da música em que cada músico estava e as credenciais da porta do palco se perdem.
Um warm pool é uma banda já afinada nos bastidores. O Kata dá a cada atração sua própria sala à prova de som, com seu próprio kernel, ao custo de cerca do dobro do tempo de montagem. E quando um pod sai de cena, um substituto entra com a partitura em branco, enquanto a mesa de som continua dizendo que está tudo bem.
A história é um ciclo de vida de sandbox que você roda na sua própria conta da AWS: limites de tempo, pause e resume pelo Amazon ECR, warm pools de pods pré-iniciados e uma troca para máquinas virtuais Kata, no OpenSandbox 1.2.0, um projeto da Agentic AI Foundation, no Amazon EKS.
O posicionamento honesto vem com ressalvas sobre as quais os compradores vão perguntar. Uma pausa mantém os arquivos, não a memória, os processos ou as credenciais armazenadas, e nada pausa sozinho um sandbox de container ocioso. Um pod apagado volta vazio enquanto o sandbox ainda parece saudável. O Kata dá a cada sandbox seu próprio kernel, com cerca do dobro do tempo de criação.
Visão Geral
O OpenSandbox é um projeto da Agentic AI Foundation, um fundo dirigido da Linux Foundation, desde o anúncio de 22 de outubro de 2026; a parte 1 cobre essa mudança.
Este post, parte 3 de 6, leva sandboxes no cluster EKS da parte 2 pela vida inteira: criação, expiração e renovação, pause e resume pelo Amazon ECR, warm pools, uma troca de runc para máquinas virtuais Kata e o que acontece quando um pod é apagado ou um node entra em cordon. Um dos seis testes é o benchmark de resume do próprio projeto, rodado sem modificações.
Três descobertas definem como eu construiria em cima dele:
- Uma pausa mantém o root filesystem e nada mais. O root filesystem voltou do ECR. Memória, processos e o Credential Vault, não: o vault é zerado a cada pausa, então o que quer que retome um sandbox precisa gravá-lo de novo. Esse é o modo padrão; um modo VM-state do QEMU, experimental, para um guest QEMU dentro de um sandbox runc, também restaura a memória do guest. Não o testei.
- Nada pausa um sandbox de container ocioso por você. O auto-pause e o wake-on-access do 1.2.0 são só para o perfil Fast Sandbox. Um sandbox no caminho padrão do Kubernetes mantém seu pod, e a CPU e a memória que ele reserva, até o seu timeout, um kill ou o seu próprio
pause(). - Um pod apagado volta em silêncio. O controller o recriou em segundos a partir da imagem original, enquanto o servidor continuava reportando
Running. Os arquivos gravados antes tinham sumido, e nada avisou o cliente de que seu root filesystem era novo.
O Kata funcionou nos nodes com virtualização aninhada: o sandbox que examinei por dentro tinha inicializado o próprio kernel, com 2 vCPUs e 3,9 GiB, e uma criação levou cerca de duas vezes mais tempo do que sob runc. O gVisor está fora de questão quando o egress está ativado.
A parte 4 cobre o egress sidecar e o Credential Vault, a parte 5 assina requisições da AWS no egress, e a parte 6 faz um stress test dos mesmos dois nodes. Tudo aqui roda sob runc, exceto o Teste 5, que troca o servidor para Kata e depois de volta. Todo número vem das minhas execuções de 1º de novembro de 2026 (UTC); eu aviso quando algo vem do código ou da documentação.
O ciclo de vida em um relance
A parte 1 desenhou os oito estados da spec do ciclo de vida. Este é o mesmo diagrama, com as transições pelas quais minhas execuções passaram em destaque, e um evento que nem está na spec:
02b apaga um sandbox pausado, mas nada acompanhou seus estados), e as linhas vermelhas pontilhadas são as transições para Failed. O loop vermelho tracejado em Running nem chega a ser uma mudança de estado: um pod apagado é substituído, e o sandbox reporta Running o tempo todo.- Criação. O servidor cria um
BatchSandbox, e o controller, um pod; ocreate()retorna assim que o pod está Running (Teste 1: 2,3 segundos). - Pause. Um Job de commit no node do sandbox faz commit do root filesystem de cada container em uma imagem (Teste 2).
- Paused. As imagens estão no ECR e o pod não existe mais: um sandbox pausado não ocupa CPU nem memória em nenhum node.
- Resume. Um novo pod inicia a partir das imagens de snapshot, com o mesmo ID de sandbox (Testes 2 e 3).
- TTL (ou um kill). Na expiração, o controller apaga o
BatchSandbox(em um kill, quem o apaga é o servidor); o sandbox reportaStoppingaté seu pod sumir, e então some da API (o Teste 1 observou o caminho do TTL). - Pod apagado. O controller cria um substituto a partir da imagem original; os arquivos se perdem e o estado nunca sai de
Running(Teste 6).
Duas transições ausentes importam tanto quanto essas. Nada leva um sandbox de container de Running para Pausing, exceto o seu próprio pause(): o auto-pause e o wake-on-access cobrem “apenas o backend Fast Sandbox”, e sandboxes de Docker e de pod do Kubernetes “não são cobertos”. E um timeout só muda quando você o renova, ou pelo renew-on-access, que é opt-in e o estende para um sandbox que recebe tráfego (a tabela de expiração da parte 1 tem os detalhes).
Configuração
Passo 1: O código de apoio
Os scripts rodam no cluster da parte 2 e leem o env.sh, a API key e o checkout do código-fonte dela a partir de ../opensandbox-eks. Rode antes os scripts 01_cluster.sh a 05_gateway.sh da parte 2 (o 06_console.sh é opcional) e traga os nodes de volta com ../opensandbox-eks/08_scale.sh up se você tiver reduzido a escala deles. Os scripts Python rodam sob uv; o server_config.py roda no seu próprio python3, que precisa ser 3.11 ou posterior (ele usa só a standard library).
git clone https://github.com/fabiodouek/my2centsai-blog-samples.git
cd my2centsai-blog-samples/opensandbox-lifecycle
uv sync
| Arquivo | O que faz |
|---|---|
00_snapshot_config.sh, values/controller-snapshot.yaml | O registry de snapshots e seu token (Passo 2) |
server_config.py, switch_runtime.sh, values/runtime-*.toml | Toda mudança na config do servidor (Passo 3) |
manifests/pool.yaml | O warm pool (Passo 4) |
01_states.py a 06_failure.py, mais 02b_token_fallback.py | Um script por teste |
03_resume_benchmark.sh | O benchmark de resume do projeto, rodado sem modificações |
99_cleanup.py | Remove o que esses scripts deixam, e nada mais |
Cada script Python marca seus sandboxes com example=opensandbox-lifecycle, sai com 1 quando uma verificação falha e mantém vivo um kubectl port-forward para o servidor em 127.0.0.1:18080, iniciando um novo sempre que o /health para de responder. Isso importa aqui: trocar o runtime substitui o pod do servidor, o que encerra todo port-forward para ele.
Passo 2: Snapshots em um único repositório do ECR
Pause e resume são configurados no controller, não no servidor (guia de pause e resume). O controller precisa de um registry para onde fazer push dos snapshots, de um Secret kubernetes.io/dockerconfigjson para fazer esse push e, opcionalmente, de um template de nomes. O values/controller-snapshot.yaml os adiciona aos values do controller da parte 2:
controller:
snapshot:
registry: ${ECR_REGISTRY}/${ECR_PREFIX}/snapshots
imageURITemplate: "{{.Registry}}:{{.SandboxName}}-{{.ContainerName}}-{{.SnapshotTag}}"
snapshotPushSecret: opensandbox-snapshot-ecr
resumePullSecret: opensandbox-snapshot-ecr
O template é a parte que vale copiar. O padrão, {{.Registry}}/{{.SandboxName}}-{{.ContainerName}}:{{.SnapshotTag}}, coloca o nome do sandbox no caminho do repositório, então o ECR acaba com um repositório por sandbox. O meu o coloca na tag, e todo snapshot vai parar em opensandbox-eks/snapshots como <sandbox id>-<container>-snap-gen2. A primeira pausa é gen2, não o gen1 do guia, porque a tag carrega o metadata.generation do BatchSandbox (snapshotImageTag), que o create e o patch da pausa levam a 2.
O 00_snapshot_config.sh faz três coisas. Ele cria o repositório com as configurações do template de criação de repositórios do ECR da parte 2, porque um aws ecr create-repository explícito não aplica o template; só um push para um repositório inexistente aplica. Ele grava o Secret com um token novo do ECR. E faz upgrade do controller, o que substitui o pod dele na primeira execução.
A primeira execução do 00_snapshot_config.sh, resumida
$ ./00_snapshot_config.sh
== ECR repository opensandbox-eks/snapshots
created, with the creation template's settings: MUTABLE, AES256, project=opensandbox-eks
lifecycle rule: Expire untagged images after 7 days
== Secret opensandbox/opensandbox-snapshot-ecr
ok type kubernetes.io/dockerconfigjson, token issued 2026-11-01T06:10:23Z, valid until 2026-11-01T18:10:23Z
ok the registry accepts the token (GET /v2/ answered 200)
== controller release opensandbox-controller
revision 10 -> 11 (deployed), manifests changed
ok --snapshot-registry=<registry>/opensandbox-eks/snapshots
ok --snapshot-image-uri-template={{.Registry}}:{{.SandboxName}}-{{.ContainerName}}-{{.SnapshotTag}}
ok --snapshot-push-secret=opensandbox-snapshot-ecr
ok --resume-pull-secret=opensandbox-snapshot-ecr
...
total 34s
Um token do ECR dura 12 horas, então rode o script no início de cada sessão que pausa sandboxes. Uma nova execução levou 19 segundos: um token novo, manifests idênticos e o pod do controller intocado. O 02_pause_resume.py recusa um token que expire em menos de 10 minutos, e o benchmark, um que expire em menos de uma hora. A regra de 7 dias do template expira só imagens sem tag, então os snapshots ficam até você apagá-los; apagar um SandboxSnapshot não os apaga, já que o handler de deleção do controller remove só os Jobs de commit e de unpause. Se você continuar usando snapshots, adicione uma regra de lifecycle que selecione imagens com tag, por padrão de tag ou por idade, ou apague-as você mesmo, como faz o 99_cleanup.py. Escolha uma idade maior do que o tempo que qualquer sandbox fica pausado: a imagem de snapshot de um sandbox pausado é a única cópia dele. E rodar de novo o 04_install.sh da parte 2 desativa os snapshots; rode este script de novo depois dele.
Passo 3: Uma única forma de mudar o servidor
Daqui em diante, toda mudança no servidor de ciclo de vida passa por um único script, o server_config.py: o runtime neste post, a imagem de egress na parte 5 e o modo de egress na parte 6. Ele existe porque o config.toml inteiro do servidor é um único value do Helm. Três scripts com três ideias desse arquivo desfariam as mudanças uns dos outros, e um upgrade sem os values de gateway da parte 2 removeria o gateway sem nenhum aviso. Então ele pergunta primeiro:
./server_config.py --show
runtime=runc egress_image=base egress_mode=dns+nft ingress=gateway
Esse é o estado da parte 2 (runc, a imagem de egress do 1.2.0, dns+nft, o gateway), e é o estado em que este post deixa o servidor. Uma mudança reconstrói o release opensandbox-server a partir de values/server.yaml e values/server-gateway.yaml da parte 2, edita no config.toml só as linhas pedidas e mantém todas as outras configurações no valor da última revisão implantada do Helm, então trocar o runtime mantém a imagem de egress da parte 5, e vice-versa:
./server_config.py --runtime runc|kata-qemu|kata-clh [secure_runtime] from values/runtime-<name>.toml
./server_config.py --egress-image base|<image> [egress] image (an ECR image is checked first)
./server_config.py --egress-mode dns|dns+nft [egress] mode
./server_config.py --baseline runc, the base egress image, dns+nft
add --dry-run to see the config.toml change, checked with helm template, without upgrading
Proteções impedem que uma mudança perca outra: um lock compartilhado pelas partes 3 a 6, uma nova leitura da revisão logo antes do upgrade, uma recusa a remover um gateway ativo e verificações do config.toml renderizado e do montado, além de /health e /version. Uma mudança substitui o pod do servidor (o Deployment usa Recreate), então a API fica fora do ar enquanto o novo pod inicia. O switch_runtime.sh runc|kata é um wrapper fino em volta dele.
Passo 4: Um warm pool
Um Pool mantém pods Ready esperando, e um create com extensions={"poolRef": "osb-pool"} pega um deles em vez de iniciar um pod. O manifests/pool.yaml é o exemplo de pool do release adaptado a este cluster (resumido):
apiVersion: sandbox.opensandbox.io/v1alpha1
kind: Pool
metadata:
name: osb-pool
namespace: opensandbox
spec:
template:
spec:
automountServiceAccountToken: false
initContainers:
- name: task-executor-installer # task-executor runs the request's entrypoint after allocation
image: ${ECR_REGISTRY}/${ECR_PREFIX}/task-executor:release-1.2.0
- name: execd-installer # execd and bootstrap.sh
image: ${ECR_REGISTRY}/${ECR_PREFIX}/execd:release-1.2.0
containers:
- name: sandbox
image: ${ECR_REGISTRY}/${ECR_PREFIX}/python:3.12-slim
command: ["/bin/sh", "-c", "/opt/opensandbox/task-executor -listen-addr=0.0.0.0:5758 -log-dir=/tmp"]
resources:
requests: { cpu: "1", memory: 2Gi }
limits: { cpu: "1", memory: 2Gi }
capacitySpec:
bufferMin: 2 # Ready, unallocated pods kept waiting
bufferMax: 3
poolMin: 0 # pods in the pool in all, allocated or not
poolMax: 5
recycleStrategy:
type: Delete # a released pod is deleted and replaced, never reused
O que mudou em relação ao exemplo: toda imagem vem da minha cópia no ECR (o exemplo aponta para um registry na China); o workload é o python:3.12-slim da série, com a 1 CPU e os 2 GiB que um create comum recebe, então criações a quente e a frio rodam o mesmo formato de pod; e o tolerations: [{operator: Exists}] saiu, como no template de BatchSandbox da parte 2, porque ele tolera qualquer taint, inclusive o de um node em cordon (Teste 6). O pod existe antes de qualquer requisição, então ele roda o task-executor, e depois da alocação o controller inicia o bootstrap.sh, e com ele o execd, como uma task.
Os pools vêm com dois limites. Uma criação de pool não pode levar uma networkPolicy nem o credential proxy (o Teste 4 recebe o 400). E o [secure_runtime] do servidor não chega aos pods de pool: o provider do servidor define runtimeClassName só nos pods que ele mesmo constrói (batchsandbox_provider.py, em contraste com as L264-L265 para o caminho de template), e o guia de runtime seguro diz para defini-lo no template de cada Pool. Li isso no código e não rodei um pool com Kata.
Testes
Toda a saída abaixo vem das execuções gravadas, com cortes. Os nomes de nodes e os IDs de sandbox são reais; o host do registry aparece como <registry>.
Teste 1: Estados, TTL, renew e expiração
O 01_states.py cria um sandbox com o menor timeout que o servidor aceita, 60 segundos, roda um comando, faz o renew e depois o deixa em paz até o controller removê-lo. O servidor só responde à chamada de create quando o pod está Running e tem um IP (_wait_for_sandbox_ready, limitado pelo sandbox_create_timeout_seconds de 60 segundos), então um cliente nunca vê Pending a partir do próprio create(). Para capturá-lo, uma segunda thread lista os sandboxes da execução quatro vezes por segundo:
$ uv run python 01_states.py
image opensandbox-eks/python:3.12-slim, timeout (TTL) 60 s, sandboxes tagged run=6a4c0ba14604
== create
[06:46:35] + 0.9s Sandbox.create(timeout=60 s)
[06:46:35] + 1.5s state: Pending (CREATING)
[06:46:37] + 2.6s state: Running (RUNNING)
[06:46:37] + 3.2s create() returned: 2bb29460-6ded-4870-8b6c-be52d09c17ec
[06:46:38] + 4.1s created_at 06:46:35, expires_at 06:47:35 (61 s), BatchSandbox expireTime 2026-11-01T06:47:35.550178+00:00
== renew(90 s)
[06:46:40] + 5.6s renew() -> expires_at 06:48:08; get_info() -> 06:48:08 (+33 s); BatchSandbox expireTime 2026-11-01T06:48:08.837187+00:00
== wait for the expiry
[06:46:40] + 5.6s nothing touches the sandbox now; it expires in 89 s
[06:48:09] + 94.7s state: Stopping (DELETING)
[06:48:10] + 95.8s gone from list_sandbox_infos 1 s after expires_at
[06:48:10] + 96.1s get_info() now: SandboxApiException: Get sandbox 2bb29460-6ded-4870-8b6c-be52d09c17ec failed: Sandbox '2bb29460-6ded-4870-8b6c-
[06:48:11] + 97.3s BatchSandbox and pods left in the cluster: 0
== states seen
Pending -> Running -> Stopping -> gone
all steps passed
A criação levou 2,3 segundos a partir da chamada. O timeout é uma expiração absoluta, created_at mais 60 segundos, e o BatchSandbox carrega o mesmo instante como spec.expireTime.
O renew() não adiciona tempo; ele define uma nova expiração. O SDK calcula now + timeout no relógio do cliente (renew) e envia esse instante, então o renew(90 s) levou a expiração para 90 segundos depois da chamada, 33 segundos mais tarde do que antes. Uma duração menor do que o tempo restante encurtaria a vida do sandbox, e o limite max_sandbox_timeout_seconds do servidor não se aplica ao renew.
Na expiração, o controller agiu rápido: Stopping (DELETING) a menos de meio segundo do expires_at, fora da lista cerca de um segundo depois dele, nenhum BatchSandbox ou pod restante, e o get_info() lançou uma SandboxApiException (a parte 1 traz a release note: 404 assim que os pods somem). Nunca vi Terminated. As release notes do 1.2.0 dizem que um BatchSandbox expirado reporta Terminated com o motivo SANDBOX_EXPIRED, mas o polling, quatro vezes por segundo, não pegou nenhum no caminho até a deleção.
Teste 2: Pause e resume, e o que volta
O 02_pause_resume.py cria um sandbox com uma network policy deny-by-default e o credential proxy ativado, porque o Credential Vault vive no egress sidecar que a policy adiciona. Antes da pausa, ele grava um marcador aleatório em /root/marker.txt (o root filesystem) e em /dev/shm/marker.txt (memória), inicia um sleep 1000 e cria um vault com uma apiKey placeholder para api.example.com. Depois:
sb.pause() # 202 Accepted; the script polls until Paused
# ...
sb = SandboxSync.resume(sb.id, connection_config=connection("proxy"),
resume_timeout=timedelta(seconds=600))
As duas chamadas são assíncronas: o servidor responde 202 e o estado avança sozinho, então o timeout de create de 60 segundos não se aplica. O resume() do SDK então espera o execd ficar healthy, com um orçamento padrão de 30 segundos (o script o aumenta para 600). A execução:
$ uv run python 02_pause_resume.py
...
== what came back
ok /root/marker.txt (root filesystem): 2ff91ec1251542f5 (same as before)
ok /dev/shm/marker.txt (memory) did not come back: gone
ok the sleep process did not come back: sleep pid 1110 not running (its pid file is in the root filesystem, so the file came back)
the egress sidecar answers: policy defaultAction deny, 1 rule(s)
ok Credential Vault did not come back: 404 from the egress sidecar: no vault
ok re-created from the trusted side: revision 1, credentials ['demo-api-key'], bindings ['demo-api']
== times
pause() to Paused (commit and push included) 6.7 s
resume() to Running 5.0 s
resume() to a healthy sandbox 5.3 s
resume() to the first command 5.6 s
snapshot images, total compressed size 179.7 MB
all checks passed: the pod was replaced by one running the snapshot images; the root filesystem came back; /dev/shm, the process and the vault did not, and the vault was created again
O resto da execução: criação, pausa, as imagens no ECR e resume
== create, with a network policy (it adds the egress sidecar that holds the vault)
[09:24:09] + 10.8s created e8b91f94... in 6.6 s
[09:24:11] + 12.4s pod containers: sandbox python:3.12-slim, egress egress:release-1.2.0
== state before the pause
rootfs: 2ff91ec1251542f5 tmpfs: 2ff91ec1251542f5 sleep pid 1110 running
ok vault before the pause: revision 1, credentials ['demo-api-key'], bindings ['demo-api']
== pause
[09:24:12] + 13.3s pause() accepted in 0.1 s
[09:24:13] + 14.7s sandbox Pausing | snapshot Committing
[09:24:18] + 19.9s sandbox Paused | snapshot Succeed
[09:24:20] + 22.0s commit Job: 5 s on ip-10-60-15-81.ec2.internal
ok pods of the sandbox while Paused: 0
ok the server still lists it while Paused: Paused
== ECR opensandbox-eks/snapshots
:<id>-egress-snap-gen2 136.3 MB pushed 09:24:14
:<id>-sandbox-snap-gen2 43.4 MB pushed 09:24:14
ok 2 image(s) for this sandbox, one per container (sandbox, egress); 2 in the repository, every snapshot in this one repository
snapshot status: sandbox -> opensandbox-eks/snapshots:<id>-sandbox-snap-gen2
snapshot status: egress -> opensandbox-eks/snapshots:<id>-egress-snap-gen2
== resume
[09:24:22] + 23.9s sandbox Resuming
[09:24:27] + 28.5s sandbox Running
[09:24:27] + 28.8s SandboxSync.resume() returned (sandbox healthy) 5.3 s after the call
[09:24:28] + 29.1s first command answered 5.6 s after the call
ok a new pod (its uid differs from the paused one's)
ok container sandbox runs opensandbox-eks/snapshots@sha256:ec8d84d55bb7...
ok container egress runs opensandbox-eks/snapshots@sha256:b1133be70ce7...
imagePullSecrets on the resumed pod: ['opensandbox-snapshot-ecr']
| Depois do resume | Por quê | |
|---|---|---|
/root/marker.txt | De volta, com o mesmo valor | O root filesystem é o snapshot |
/dev/shm/marker.txt | Sumiu | /dev/shm é um tmpfs, memória |
O processo sleep | Sumiu (o arquivo de pid dele, no root filesystem, voltou) | Um novo pod inicia seus processos do zero |
| O Credential Vault | Sumiu: o sidecar respondeu 404 | Ele vivia na memória do sidecar antigo |
A pausa levou 6,7 segundos da chamada até Paused, com commit e push incluídos; o Job de commit em si rodou 5 segundos no node do sandbox, e enquanto o sandbox estava Paused ele não tinha pod nenhum. O resume levou 5,0 segundos até Running, 5,3 até um sandbox healthy e 5,6 até o primeiro comando. Os containers do pod retomado rodam as imagens de snapshot por digest, e o pod recebe opensandbox-snapshot-ecr como seus imagePullSecrets.
Uma pausa faz commit de todo container do pod, não só do seu. Com uma network policy, são duas imagens por pausa: o sandbox com 43,4 MB e o egress sidecar com 136,3 MB, 179,7 MB no total. Cada uma é mais ou menos sua imagem base mais um pequeno diff: o python:3.12-slim tem 43,3 MB no ECR, e a imagem de egress, 136,2 MB. Um sandbox sem policy, como o do benchmark no Teste 3, faz push de uma só.
Só um 404, ou um vault vazio, vindo de um sidecar que responde conta como zerado: o script lê de volta primeiro a egress policy do sidecar, então um sidecar inacessível faria a verificação falhar.
Mais dois pontos para um control plane. Segundo o guia, o root filesystem só é durável quando o snapshot chega a Succeed; qualquer coisa gravada depois do último snapshot se perde em uma eviction, em um OOM kill ou na perda de um node. E a #2526 relatou que commands.run() em um sandbox pausado trava para sempre no SDK Python. A correção, o PR #2527, teve merge no main em 1º de novembro, depois do 1.2.0. O pre-release 1.2.1-rc.1 de 4 de novembro o lista, mas release candidates não publicam pacotes de SDK, e em 7 de novembro de 2026 o SDK Python mais recente no PyPI ainda é o 1.2.0, que não define read timeout nesse stream. Não testei isso, mas no 1.2.0 eu colocaria um timeout em volta dessas chamadas.
Uma pegadinha que me custou uma execução: kubectl get sandboxsnapshots retorna o CRD do Fast Sandbox, sandboxsnapshots.sandbox.fast.io, que o chart base também instala. O do próprio OpenSandbox é sandboxsnapshots.sandbox.opensandbox.io, nome curto sbxsnap.
O token, e para que ele serve. Eu esperava que um token expirado do ECR quebrasse o resume com ImagePullBackOff. No EKS, um pull com um pull secret quebrado ainda funciona. O controller adiciona o único Secret compartilhado a todo pod retomado, então o 02b_token_fallback.py testa o pull em pods simples, em vez disso: ele pausa um sandbox, copia o pull Secret com um token ao qual o ECR responde 400 (no lugar de um expirado) e faz pull da imagem de snapshot de três formas com imagePullPolicy: Always. Isso consulta o ECR com credenciais toda vez. Um pod retomado é mais gentil com o registry: ele referencia o snapshot por digest, com o IfNotPresent padrão do servidor, então no node que fez commit do snapshot ele pode nem contatar o ECR. A pull policy é o que torna o teste mais rígido do que aquilo que o cabeçalho do script chama de “the way a resumed pod does”. O Secret compartilhado não é tocado:
$ uv run python 02b_token_fallback.py
...
== 1. a snapshot image to pull: create, write a marker, pause
sandbox eb3b001f... paused; marker ab67071eba334de6; image opensandbox-eks/snapshots:<id>-sandbox-snap-gen2, committed on ip-10-60-15-81.ec2.internal
== 2. a broken copy of the pull Secret
Secret opensandbox-lifecycle-bad-token-042162c255a3: a copy of opensandbox-snapshot-ecr's shape, with an invalid token; ECR answers 400 to it (opensandbox-snapshot-ecr's own token: 200)
== 3. pull the snapshot image the way a resumed pod does (imagePullPolicy: Always)
ok a. pull secret opensandbox-lifecycle-bad-token-04..., the committing node: Succeeded; marker: ab67071eba334de6
Successfully pulled image "opensandbox-eks/snapshots:<id>-sandbox-snap-gen2" in 90ms (90ms including waiting).
ok b. no pull secret, the committing node: Succeeded; marker: ab67071eba334de6
Successfully pulled image "opensandbox-eks/snapshots:<id>-sandbox-snap-gen2" in 68ms (68ms including waiting).
ok c. pull secret opensandbox-lifecycle-bad-token-04..., the other node: Succeeded; marker: ab67071eba334de6
Successfully pulled image "opensandbox-eks/snapshots:<id>-sandbox-snap-gen2" in 415ms (415ms including waiting).
== 4. where the kubelet's ECR credentials come from
node group role osb-nodes-...: AmazonEC2ContainerRegistryReadOnly, AmazonEKSWorkerNodePolicy, AmazonEKS_CNI_Policy
Com a cópia quebrada no node que fez commit do snapshot, sem pull secret nenhum e com a cópia quebrada no outro node, o pull funcionou em 90, 68 e 415 ms, e cada pod leu o marcador de volta. O kubelet recorre às credenciais do ECR da role do node, e a role do node group tem AmazonEC2ContainerRegistryReadOnly. Então o pull de um resume também deve passar pela role do node, o que eu deduzo e não rodei, e no EKS o resumePullSecret é redundante para um registry na mesma conta; um em outra conta precisaria dele, a menos que a policy desse repositório permita o pull para essa role de node. O token importa para o push no momento da pausa, o caso que não testei, porque testá-lo significa quebrar o Secret pelo qual todas as outras partes pausam. A tabela de troubleshooting do guia lista unauthorized no log do Job de commit para credenciais erradas, e um Job de commit que falha é seguido de um Job <snapshot>-unpause que tira os containers da pausa. Eu esperaria que um token expirado caísse aí, mas isso é a documentação, não a minha execução.
Teste 3: O benchmark de resume do próprio projeto
O projeto traz um runner exatamente para essa medição, o tests/python/benchmarks/kubernetes_resume.py, planejado na #1457, uma issue sobre a latência de resume no Kubernetes, em aberto em 7 de novembro de 2026. Segundo o guia dele, cada rodada cria um sandbox, grava um marcador fora de qualquer volume, o pausa, espera seus pods desaparecerem, o retoma e lê o marcador de volta com um comando em foreground. Ele reporta quatro tempos cumulativos, todos contados a partir da chamada resume:
| Campo | Termina quando |
|---|---|
api_ack_ms | A API de resume retorna (aceito, não pronto) |
running_ms | O primeiro GET de lifecycle reporta Running |
ready_ms | Uma nova conexão passa nos health checks do execd |
command_ms | Um comando em foreground imprime o marcador: o tempo que um usuário espera |
O 03_resume_benchmark.sh o roda como publicado, a partir do checkout da tag feito na parte 2, com 3 warmups e 30 amostras, pelo proxy do servidor e sem nenhum cache limpo ou aquecido (o cenário “uncontrolled” do guia). O runner desliga os retries do SDK, então uma conexão perdida faz uma rodada falhar, e uma falha durante a limpeza interrompe a execução: minha primeira execução completa, no forward compartilhado 18080, parou na rodada 4 quando o port-forward de outro cliente terminou. O script agora mantém um forward privado na 18081.
$ ./03_resume_benchmark.sh
image opensandbox-eks/python:3.12-slim@sha256:aa943ce41142...
runtime runc; nodes: 2 x m7i.2xlarge Amazon Linux 2023.12.20261102, kernel 6.18.56-125.164.amzn2023.x86_64, containerd://2.3.7+unknown, 8 vCPU, 30.8 GiB
trials 3 warmups + 30 samples, server proxy through 127.0.0.1:18081, output results/resume-uncontrolled-20261101T092534Z.jsonl
...
== Summary (run took 8m 03s)
completed_requested_trials: true measured 30, successful 30, failed 0, warmup failures 0, cleanup failures 0
api_ack_ms p50 125 ms p95 357 ms
running_ms p50 1534 ms p95 1967 ms
ready_ms p50 2067 ms p95 2502 ms
command_ms p50 2396 ms p95 2823 ms
command_ms over 30 trials: min 1982 ms, max 3235 ms; restored on 30 x ip-10-60-15-81
As 30 rodadas medidas tiveram sucesso, com completed_requested_trials: true, em 8 minutos e 3 segundos. O tempo que um usuário espera, command_ms, teve mediana de 2.396 ms e p95 de 2.823 ms (de 1.982 a 3.235 ms). Desse total, a API confirmou em 125 ms na mediana, o sandbox reportou Running em 1.534 ms e o execd estava healthy em 2.067 ms. Os 30 snapshots tiveram commit e restauração no mesmo node, então esta execução não diz nada sobre um resume em um node que nunca teve a imagem.
Duas ressalvas. O guia chama 30 amostras de “um ponto de partida, não uma afirmação estável sobre a latência de cauda”, e não publica números próprios, então não há nada upstream com que comparar. E esses sandboxes não têm network policy, portanto não têm sidecar e geram uma imagem por pausa. O sandbox do Teste 2, com um sidecar e uma segunda imagem, maior, levou 5,6 segundos até o primeiro comando, medidos com o polling do próprio script; eu não compararia os dois amostra por amostra, e esta execução não isola o custo do sidecar.
Teste 4: Pools, a quente contra a frio
O 04_pools.py aplica o Pool, espera o buffer dele e então alterna uma criação a frio e uma de pool, em três rodadas, com a mesma imagem e os mesmos recursos:
$ uv run python 04_pools.py
...
== 1. apply the Pool osb-pool
pool.sandbox.opensandbox.io/osb-pool created
capacitySpec {"bufferMax": 3, "bufferMin": 2, "poolMax": 5, "poolMin": 0}, recycleStrategy Delete
[09:34:19] + 0.9s pool: total 1, allocated 0, available 0
[09:34:21] + 2.7s pool: total 2, allocated 0, available 1
[09:34:23] + 4.6s pool: total 2, allocated 0, available 2
buffer filled (2 Ready pods) 5 s after the apply
== 2. cold and warm creates, 3 rounds
round 1 cold 2.7 s (586262b6-4b49-48c4-95aa-a211acb5fe37-0)
round 1 warm 1.3 s (osb-pool-lg82t, pool pod osb-pool-lg82t)
round 2 cold 2.1 s (b6ab63f6-f1f7-4f07-8aca-bf7ca4dbfff9-0)
round 2 warm 1.3 s (osb-pool-9g6zz, pool pod osb-pool-9g6zz)
round 3 cold 2.8 s (af75616d-e73b-434e-add8-c4f63e07d136-0)
round 3 warm 1.3 s (osb-pool-msk8x, pool pod osb-pool-msk8x)
median cold 2.7 s, warm 1.3 s: warm is 1.5 s faster
O buffer de dois pods Ready encheu 5 segundos depois do kubectl apply. As criações a frio levaram 2,7 s, 2,1 s e 2,8 s, e as de pool, 1,3 s cada, medianas de 2,7 e 1,3. O hostname de um sandbox de pool é o nome do pod do pool, não <sandbox id>-0, e é assim que o script verifica que ele realmente pegou um pod do pool. A parte 6 cronometrou as mesmas criações de dentro do cluster: a maior parte do 1,3 segundo a quente era o port-forward a partir do meu Mac, não o Pool.
O recycleStrategy: Delete significa que um pod usado nunca serve outro sandbox. O script grava um arquivo em um sandbox de pool, apaga o sandbox e observa o pool:
A execução da reciclagem
== 3. recycleStrategy Delete: a used pod is replaced, not reused
[09:35:36] pool pods: osb-pool-fpmgt, osb-pool-lsjvl, osb-pool-msk8x
[09:35:38] sandbox b3b71b9b... got pool pod osb-pool-lsjvl; pool: total 2, allocated 2, available 1
[09:35:39] sandbox deleted
[09:35:40] + 1s pool pods: osb-pool-fpmgt, osb-pool-lsjvl, osb-pool-msk8x Terminating
[09:36:05] + 25s pool pods: osb-pool-8dj9n Pending, osb-pool-fpmgt, osb-pool-lsjvl Terminating
[09:36:06] + 27s pool pods: osb-pool-8dj9n, osb-pool-fpmgt, osb-pool-lsjvl Terminating
[09:36:36] + 57s pool pods: osb-pool-8dj9n, osb-pool-fpmgt
osb-pool-lsjvl was deleted with its sandbox, /tmp/previous-user.txt and all; it never returns to the pool. The buffer holds 2 pods that never ran a sandbox (new: osb-pool-8dj9n)
O controller começou a apagar o pod usado 25 segundos depois do sandbox, arquivo e tudo; um substituto que nunca tinha rodado um sandbox estava Running aos 27 segundos, e o pod usado sumiu aos 57. Restart e Noop, por outro lado, reutilizam o pod, e a documentação do controller avisa que o Noop vaza arquivos e processos para a próxima alocação. Para sandboxes de agentes, eu manteria o Delete.
O último passo pede um sandbox de pool com uma network policy:
== 4. a pooled create with a network policy
ok refused with HTTP 400: Create sandbox failed: networkPolicy cannot be used together with extensions.poolRef because pooled pods are pre-created. Remove 'networkPolicy' from the request or use template mode.
(the script goes on: put an egress policy for pooled sandboxes in the Pool template)
O pod existe antes da requisição, então o egress sidecar dele não pode ser adicionado depois (_ensure_pool_mode_compatible), e a mesma função recusa credentialProxy.enabled. Regras de egress por requisição, e com elas o Credential Vault da parte 4, não se misturam com pools; uma egress policy para sandboxes de pool fica no template do Pool, a mesma para todo sandbox.
Teste 5: runc contra Kata, e por que não gVisor
O runtime pertence ao servidor, não à requisição: um processo do servidor tem um único [secure_runtime], e uma criação não pode escolher. Então o teste é uma execução sob runc, uma troca, a mesma execução sob Kata e uma troca de volta. As duas execuções do 05_runtimes.py abaixo são de uma sessão anterior naquele dia, com a mesma configuração do servidor; a troca mostrada é uma gravação posterior. O values/runtime-kata-qemu.toml é a mudança inteira:
[secure_runtime]
type = "kata"
k8s_runtime_class = "kata-qemu"
uv run python 05_runtimes.py # runc
./switch_runtime.sh kata # kata-qemu
uv run python 05_runtimes.py # a VM per sandbox
./switch_runtime.sh runc # parts 4 and 5 expect runc
A troca para kata-qemu
$ ./switch_runtime.sh kata
server now: runtime=runc egress_image=base egress_mode=dns+nft ingress=gateway (revision 15)
server wanted: runtime=kata-qemu egress_image=base egress_mode=dns+nft ingress=gateway
config.toml: changes:
--- running config.toml
+++ new config.toml
@@ -26 +26,6 @@
path = "/data/opensandbox.db"
+
+# from opensandbox-lifecycle/values/runtime-kata-qemu.toml
+[secure_runtime]
+type = "kata"
+k8s_runtime_class = "kata-qemu"
helm upgrade: revision 15 -> 16 (deployed) in 17 s, manifests changed
server pod opensandbox-server-65597b69c6-j569l replaced opensandbox-server-775f8ddf57-8k74w, ready=true
ok server /health: {"status":"healthy"}
ok server /version: {"version":"1.2.0"}
ok release revision 16 is deployed
ok the server pod runs with: runtime=kata-qemu egress_image=base egress_mode=dns+nft ingress=gateway
ok gateway kept: server.gateway and [ingress] mode = gateway, host from values/server-gateway.yaml
The server pod was replaced: a kubectl port-forward started before this has ended. The Python
scripts in this directory start their own; restart yours if you use one.
switched to kata-qemu in 29 s
A troca é um Helm upgrade com substituição de pod: 17 segundos para o Helm e 29 no total, com a API fora do ar durante parte desse tempo. A volta levou 28 segundos. O runtimeClassName de um pod não pode mudar, então sandboxes que já estão rodando mantêm o runtime com que foram criados; só os novos mudam.
O 05_runtimes.py cronometra três criações e depois olha o sistema de dentro de um sandbox, com os limites padrão de 1 CPU e 2 GiB:
O que o sandbox viu sob kata-qemu
$ uv run python 05_runtimes.py
server runtime: kata-qemu (sandboxes tagged run=9c4db5614eb3)
== 3 creates under kata-qemu
create 1: 4.2 s on ip-10-60-15-81.ec2.internal
create 2: 6.1 s on ip-10-60-36-30.ec2.internal
create 3: 4.1 s on ip-10-60-15-81.ec2.internal
== what the sandbox sees under kata-qemu
pod runtimeClassName kata-qemu
pod overhead cpu 250m, memory 160Mi
pod limits cpu 1, memory 2Gi
kernel (uname -r) 6.18.35 (node: 6.18.56-125.164.amzn2023.x86_64)
CPUs it can use 2 cgroup cpu.max: 100000 100000
CPU model Intel(R) Xeon(R) Platinum 8488C
memory (MemTotal) 3.9 GiB
machine (DMI) n/a / n/a
its kernel has been up 4 s
entries in /dev 15
-> its own kernel, not the node's: the sandbox runs in a virtual machine
| De dentro do sandbox | runc | kata-qemu |
|---|---|---|
| Kernel | 6.18.56-125.164.amzn2023.x86_64, o do node | 6.18.35, o próprio |
| Kernel ligado há | 22 minutos (o do node) | 4 segundos (a VM tinha acabado de inicializar) |
| CPUs que ele pode usar | 8, todas as do node; o limite de 1 CPU é uma quota de cgroup | 2 |
| Memória que ele vê | 30,8 GiB, a do node | 3,9 GiB |
| Máquina (DMI) | Amazon EC2 / m7i.2xlarge | Nenhum dado DMI no guest (/sys/class/dmi/id ilegível) |
Entradas em /dev | 16 | 15 |
| Overhead de pod reservado | Nenhum | 250m de CPU, 160Mi |
| Criação, 3 execuções | 2,7 / 2,0 / 2,2 s, mediana 2,2 | 4,2 / 6,1 / 4,1 s, mediana 4,2 |
O modelo de CPU, um Xeon Platinum 8488C, aparece nos dois.
O pod de gate do Kata da parte 2, sem limites, tinha 1 vCPU. Este, com limites de 1 CPU e 2 GiB, tinha 2 vCPUs e 3,9 GiB. A configuração do kata-deploy 3.32.0 nos nodes, /opt/kata/share/defaults/kata-containers/configuration-qemu.toml, define default_vcpus = 1, default_memory = 2048 (MiB) e static_sandbox_resource_mgmt = false. No modelo de dimensionamento documentado do Kata, a VM inicializa com esses padrões, e o runtime depois adiciona as vCPUs que o limite de CPU de um container pede (dimensionamento de vCPU); com o dimensionamento estático desligado, ele faz hot-add de CPU e memória na VM em execução, em vez de dimensioná-la antes do boot (configuração do QEMU). Isso dá 1 + 1 vCPUs e 2 + 2 GiB, o que bate com as 2 vCPUs e os 3,9 GiB de MemTotal que o guest reportou. Não observei o hot-plug em si. A RuntimeClass reserva só 160Mi de overhead para tudo isso, enquanto a parte 2 mediu o processo do QEMU em cerca de 272 MiB; a parte 6 examina quanto essa reserva insuficiente custa em um node cheio.
Uma criação sob Kata levou 4,2 segundos na mediana, contra 2,2 sob runc, e a única criação que caiu no outro node levou 6,1. A diferença inclui o boot de uma VM em virtualização aninhada; não a detalhei mais.
Por que não gVisor. Não o instalei: ele precisa do runsc e do shim de containerd dele em todo node, por meio de um bootstrap de node customizado, o que não valia a pena por uma mensagem de erro. O servidor o rejeita no momento em que uma requisição traz uma network policy. O ensure_egress_runtime_compatible responde HTTP 400 quando [secure_runtime] type = "gvisor": “networkPolicy is not compatible with runtime ‘gvisor’: gVisor does not support the nftables rules required by the egress sidecar. Use a compatible runtime (e.g. kata) or remove networkPolicy.” O guia de runtime seguro dá a causa: a stack de rede do gVisor não tem a tabela nat do iptables, e o redirect de DNS do sidecar precisa de uma. O committer de root filesystem também não suporta gVisor, segundo o guia de pause e resume, e a correção em draft para os redirects, o #1374, ainda um draft em 7 de novembro de 2026, espera mudanças no gVisor upstream. Quando você quer controle de egress ou o vault, sobram, pela documentação, runc ou Kata: o guia de runtime seguro diz que o egress sidecar funciona sem mudanças sob Kata, e o validador o deixa passar. Não rodei Kata com uma network policy, e pausar um sandbox Kata não aparece nem nas minhas execuções nem no guia de pause e resume.
Depois da volta, o ./server_config.py --show mostrou a mesma linha da Configuração.
Teste 6: Um pod apagado e um node em cordon
O 06_failure.py começa com um sandbox, grava um arquivo marcador nele e apaga o pod dele com kubectl, como fariam uma eviction, uma falha de node ou um operador. Depois faz polling do servidor, do BatchSandbox e dos pods, com uma pausa de 2 segundos entre os polls, o que deu cerca de um poll a cada 4 segundos aqui:
$ uv run python 06_failure.py
...
== 1. delete the pod of a running sandbox
sandbox e57f1f60-f3a8-47bf-a687-ee486d9770a2: pod e57f1f60-f3a8-47bf-a687-ee486d9770a2-0 (uid 9eb9b5e8), marker file written
[09:37:08] kubectl delete pod e57f1f60...-0 (polling every 2 s)
[09:37:11] + 2s server Running (RUNNING) | BatchSandbox phase Succeed, replicas 1, ready 1 | e57f1f60...-0 Pending uid 1a6e053a
[09:37:15] + 6s server Running (RUNNING) | BatchSandbox phase Succeed, replicas 1, ready 1 | e57f1f60...-0 Running uid 1a6e053a
after 75 s: a new pod e57f1f60...-0 (uid 1a6e053a)
a command through the SDK now: no /root/marker.txt
Running em todas as linhas, o BatchSandbox ficou em Succeed com uma réplica pronta, e o próximo comando do SDK chegou ao novo pod. O arquivo marcador tinha sumido: o novo pod começa da imagem original, não da camada gravável do pod antigo, e nada passou por snapshot. Os dados gravados no root filesystem desde a última pausa se perdem: o estado do sandbox nunca saiu de Running, e nada avisou o cliente de que seu root filesystem era novo.
Os rastros ficam em outro lugar, segundo o código, e não os testei aqui: o controller registra a recriação no log e grava um evento succeed to create pod no BatchSandbox, e a API de eventos de diagnóstico (GET /v1/sandboxes/{id}/diagnostics/events, get_diagnostic_events() no SDK) lista os eventos do Kubernetes do pod, onde a deleção apareceria.
Eu não esperava substituto nenhum. O 1.2.0 tornou restartPolicy: Never o padrão para pods de sandbox porque, como a parte 1 explicou, um reinício in-place apaga a camada gravável enquanto o sandbox continua parecendo saudável. Um pod apagado chega ao mesmo resultado por outro caminho. O scaleBatchSandbox do controller cria um pod para qualquer índice de réplica que não tenha um, com o nome <sandbox id>-<index>, a partir do template do BatchSandbox. O guia de pause e resume diz o mesmo sobre durabilidade: um novo container “não herda a camada gravável antiga”. Se os dados importam, guarde-os em um volume ou fora do sandbox. Sandboxes de pool são outro caso: a #954, em aberto em 7 de novembro de 2026, relata que um BatchSandbox de pool cujo pod é apagado nunca recebe um substituto. Esse eu não testei.
A segunda metade faz cordon do node que não roda o servidor e cria quatro sandboxes:
== 2. cordon a node, then create sandboxes
[09:38:31] kubectl cordon ip-10-60-36-30.ec2.internal
ip-10-60-15-81.ec2.internal schedulable
ip-10-60-36-30.ec2.internal unschedulable (cordoned)
taints on it: node.kubernetes.io/unschedulable:NoSchedule
sandbox 1: 3.4 s, on ip-10-60-15-81.ec2.internal
sandbox 2: 3.0 s, on ip-10-60-15-81.ec2.internal
sandbox 3: 3.0 s, on ip-10-60-15-81.ec2.internal
sandbox 4: 3.1 s, on ip-10-60-15-81.ec2.internal
ok 4 of 4 on ip-10-60-15-81.ec2.internal, 0 on the cordoned node
== the release's default toleration, on a plain pod pinned to the cordoned node
pod toleration-demo with tolerations [{operator: Exists}]: Running on ip-10-60-36-30.ec2.internal
uncordoned ip-10-60-36-30.ec2.internal
Os quatro caíram no outro node, em 3,0 a 3,4 segundos cada. O template de BatchSandbox da parte 2 não tem tolerations, então o taint node.kubernetes.io/unschedulable:NoSchedule do cordon os manteve longe. Depois o script fixou no node em cordon um pod simples com a toleration padrão do release, [{operator: Exists}], e ele rodou lá. É isso que o template padrão permite: sandboxes poderiam cair em um node que um operador está tentando esvaziar.
Fiz cordon e não fiz drain: com dois nodes, um drain também moveria o servidor, o controller e o gateway. Um drain faz eviction dos pods de sandbox no node e, pela primeira metade, eu esperaria que cada um voltasse no outro node com um root filesystem novo e sem nenhum aviso ao cliente. O script desfaz o cordon do node no final, também em caso de falha ou interrupção.
Resumo dos resultados
| Teste | Script | Execução gravada | Resultado |
|---|---|---|---|
| 1. Estados, TTL, renew | 01_states.py | 99,1 s | Pending, Running, Stopping, sumiu; apagado cerca de 1 s depois do expires_at; renew() define uma expiração absoluta |
| 2. Pause e resume | 02_pause_resume.py, 02b_token_fallback.py | 35,8 s, 43,0 s | Root filesystem de volta; /dev/shm, processos e o vault perdidos; 2 imagens com o sidecar; pausa em 6,7 s, primeiro comando 5,6 s depois do resume; um pull secret quebrado não impede o pull da imagem de snapshot no EKS |
| 3. Benchmark de resume | 03_resume_benchmark.sh | 496,0 s (runner 8m 03s) | 30/30 rodadas; command_ms p50 2.396 ms, p95 2.823 ms |
| 4. Pools | 04_pools.py | 148,8 s | A quente 1,3 s contra 2,7 s a frio (medianas de 3); pods usados apagados; poolRef com networkPolicy recusado com 400 |
| 5. runc e Kata | 05_runtimes.py, switch_runtime.sh | 20,0 s e 27,8 s; gravações da troca 30,5 s e 29,5 s | Troca do servidor 29 s, volta 28 s; Kata: kernel próprio, 2 vCPUs, 3,9 GiB; mediana de criação 4,2 s contra 2,2 s; gVisor recusado com egress (código) |
| 6. Falhas | 06_failure.py | 114,0 s | Pod apagado substituído com um root filesystem novo, sandbox Running o tempo todo; cordon respeitado; a toleration padrão o ignora; drain não rodado (esperado: o caso do pod apagado para cada sandbox no node, não testado) |
Todos os scripts saíram com 0. O vault zerado é uma verificação no 02; a substituição silenciosa é uma observação, porque o 06 imprime o que acontece com o pod apagado e só faz assert do cordon.
Limpeza
Cada script apaga seus próprios sandboxes, e o 04_pools.py apaga seu Pool, porque pods de pool ociosos ocupam uma CPU inteira cada. Depois de uma execução interrompida:
uv run python 99_cleanup.py
Ele apaga só o que este diretório criou: sandboxes com example=opensandbox-lifecycle, o Pool, os pods e o Secret do 02b e do 06, um cordon que o 06 tenha deixado para trás e as imagens de snapshot dos sandboxes deste diretório quando esses sandboxes não existem mais. Ele mantém o repositório, o Secret e as configurações de snapshot do controller, que as partes 4 e 6 usam.
Confira o ./server_config.py --show antes de parar: ele deve dizer runtime=runc, que é o que as partes 4 e 5 esperam. Entre sessões, reduza os nodes a zero a partir do diretório da parte 2 (o cluster custa cerca de $1,01 por hora ocioso, segundo a seção de preços da parte 2), e remova tudo com o teardown dela no fim da série:
../opensandbox-eks/08_scale.sh down
../opensandbox-eks/99_teardown.sh
Veredito
O ciclo de vida no caminho do Kubernetes do 1.2.0 faz o que a spec diz; planeje em torno do que ela não deixa explícito. A expiração foi exata em cerca de um segundo, a renovação é um timestamp absoluto simples, pause e resume por um único repositório do ECR funcionaram em todas as execuções, o benchmark do projeto rodou sem modificações, e a troca para Kata em virtualização aninhada foi uma tabela TOML e um Helm upgrade. Os pontos fracos são sobre estado. No modo padrão, uma pausa mantém o root filesystem e nada mais, nem mesmo o vault. Um pod apagado também perde o root filesystem, enquanto o estado do sandbox nunca sai de Running. E nenhum sandbox ocioso se pausa sozinho neste caminho.
Então o modelo que serve é o do sandbox como compute descartável, com o estado em outro lugar: arquivos que importam em um volume ou em object storage, o vault recriado pelo seu control plane depois de cada resume e sua própria política de ociosidade chamando pause() ou kill(). Nesses termos, as peças são sólidas, e o Kata dá uma VM por sandbox com cerca do dobro do tempo de criação (egress sob Kata não é testado aqui; o Teste 8 da parte 5 o roda).
Com o que você se compromete
| Ponto | O ciclo de vida do 1.2.0 no EKS, conforme testado; o que vem do código ou da documentação está marcado |
|---|---|
| Expiração | Um timeout absoluto, mínimo de 60 s; renew() define agora mais uma duração e pode encurtá-lo (código); deleção cerca de 1 s depois da expiração |
| Sandboxes ociosos | Nenhum auto-pause fora do Fast Sandbox (documentação); um sandbox mantém seu pod até o timeout, um kill ou o seu pause() |
| Pause | O root filesystem de cada container em uma imagem OCI (2 com o egress sidecar), depois o pod é apagado; memória, processos e o vault se perdem |
| Resume | Um novo pod a partir das imagens de snapshot, mesmo ID; mediana de 2,4 s até um comando sem sidecar; o vault precisa ser gravado de novo |
| Registry | Um único repositório do ECR com um imageURITemplate customizado; um token de 12 horas para o push; apagar os snapshots com tag fica por sua conta |
| Pools | Criações a quente em 1,3 s contra 2,7 s a frio; reciclagem Delete; sem networkPolicy (testado) ou credential proxy (código) por requisição; runtimeClassName no template do Pool (código e documentação) |
| Isolamento | Um runtime por servidor; VMs Kata em virtualização aninhada com cerca do dobro do tempo de criação; gVisor recusado quando o egress está ativado (código) |
| Falha | Um pod apagado é recriado a partir da imagem com um root filesystem novo, enquanto a API continua reportando Running |
Quem deve usar
Serve para um time que roda sandboxes de agentes como workers de vida curta: criar, rodar, talvez pausar entre turnos, apagar. Espere que um resume traga de volta o ambiente, não a sessão, e mantenha tudo o que precisa sobreviver em um armazenamento que o sandbox monta ou chama. Se você precisa de isolamento por VM, o Kata com virtualização aninhada em m7i funciona sem bare metal, e o egress sidecar também funciona sob ele: o Teste 8 da parte 5 o roda lá.
Ainda não serve para um workload que espera que um sandbox retomado continue de onde parou, com seus processos e sua memória, nem para um que conta com a plataforma para pausar sandboxes ociosos e economizar capacidade. Nem para um que confia em Running como sinal de que o sandbox ainda tem seus arquivos. A parte 4 leva o egress sidecar e o Credential Vault por nove testes no mesmo cluster.