Ciclo de Vida e Isolamento de Sandboxes do OpenShell: Hands-On no Amazon EKS
Por Fabio Douek
Ir para seção
Explica (TLDR) como se eu fosse...
Cada robô ganha seu próprio quartinho, com um adulto na porta. Eu testei o que acontece quando o robô cai no sono, quando eu desligo o quarto e ligo de novo, e quando eu tiro o adulto de lá.
A caixa de brinquedos do robô sobrevive a tudo, mas os rabiscos dele na lousa são apagados toda vez. Sem o adulto, o quarto se tranca sozinho. O robô realmente não consegue abrir as portas que não tem permissão para abrir, mas todos os quartos continuam no mesmo andar. E um quarto de que ninguém se lembra fica com as luzes acesas até alguém apagar.
Este post registra como o OpenShell 0.1.6 se comporta no Amazon EKS quando sandboxes reiniciam, param, perdem um componente ou não podem ser agendados, e quais controles se aplicam dentro de um sandbox. Cada resultado é um teste do próprio autor, em seu próprio cluster.
Para fins de due diligence: dados persistentes sobrevivem a reinícios, mas memória e processos em execução não; perder qualquer uma das metades de um sandbox o para ou o faz falhar, por design, em vez de deixá-lo desprotegido, e somente uma inicialização manual o traz de volta; e o agente compartilha o kernel do host, o que um teste publicado pela Red Hat mostrou ser uma exposição real.
Examinei o ciclo de vida de um sandbox no Amazon EKS: reinícios, paradas, a perda de qualquer um dos seus dois Pods e uma zona indisponível, e depois verifiquei cada camada de isolamento por dentro. Os reflexos de contenção foram consistentes: quando o supervisor morre, o paciente é sedado, e não deixado vagando.
Risco residual: o workload e o node compartilham um único kernel, então um exploit de kernel contorna todas as camadas acima dele. User namespaces reduzem o dano de uma fuga; um kernel separado por sandbox não estava disponível nesta versão, nestes nodes.
Ajuda saber exatamente o que você perde quando algo dá errado. Aqui a resposta é reconfortantemente consistente: os arquivos no workspace ficam, tudo o que está em memória vai embora, e quando a metade confiável de um sandbox desaparece, a metade não confiável é parada, e não libertada.
A conversa mais difícil é sobre o kernel compartilhado. Todas as salvaguardas testadas aqui se sustentam, mas todas ficam sobre um único kernel, junto com o node. Dar nome a esse limite cedo evita que um time confie no sandbox mais do que ele conquistou.
Imagine uma banda em que cada música é um novo take. Quando uma música termina, a política de reinício decide se ela será tocada de novo; cada novo take ganha uma mixagem nova e músicos novos, enquanto as faixas gravadas no workspace passam de um take para o outro.
Se o engenheiro de som sai, a banda para em vez de tocar sem monitoramento. Os músicos não podem mexer em equipamentos fora do seu canto do palco, mas todos estão no mesmo palco que o equipamento da casa, e esse piso é a única coisa que ninguém trocou ainda.
A história aqui é previsibilidade. Um sandbox reinicia, para e inicia em segundos, mantém seu workspace e falha de forma fechada quando uma parte dele some. As verificações de isolamento dentro do sandbox passam uma após a outra, com negações claras e explicáveis.
A ressalva honesta que os compradores devem ouvir: nesta versão, os sandboxes compartilham o kernel do node, e um volume de workspace prende cada sandbox a uma availability zone. Os dois pontos são gerenciáveis, e os dois merecem estar no pitch, e não nas letras miúdas.
Visão Geral
O OpenShell, projeto CNCF Sandbox desde 2026-09-26, divide todo sandbox de agente em um workload não confiável e um supervisor confiável. A parte 1 explicou essa divisão, e a parte 2 instalou o OpenShell 0.1.6 no Amazon EKS 1.37. Este post, parte 3 de 6, usa esse cluster para responder a duas perguntas.
A primeira é sobre a vida de um sandbox. O que acontece quando seu processo principal termina, quando você o para e o inicia, quando um dos seus dois Pods desaparece e quando o node de que seu volume precisa não existe mais? No Kubernetes, cada um desses casos envolve Pods, volumes e uma availability zone, e a documentação cobre só parte disso.
A segunda é sobre isolamento. De dentro de um sandbox, verifiquei o que o workload pode e não pode fazer com a policy padrão: arquivos, syscalls, privilégios, credenciais, rede e o kernel. Depois ativei user namespaces.
Todos os sandboxes aqui rodam em runc. A tentativa da parte 2 de rodá-los em VMs Kata falhou, então o workload compartilha o kernel do node, e essa é a última coisa que este post examina. A parte 4 cobre network policy e credenciais, a parte 5, credenciais da AWS, e a parte 6, um stress test.
O Ciclo de Vida em um Relance
No Kubernetes, a vida de um sandbox abrange várias gerações. Uma geração é uma execução de um par de Pods, com seus próprios tokens e certificados. O volume de workspace é a única coisa que sobrevive a todas elas:
| Evento | Pods | Geração | /sandbox | /tmp, processos, memória |
|---|---|---|---|---|
Processo principal termina, política never | continuam rodando (verificado após o exit 3); fase Error (diferente de zero) ou Completed (zero) | a mesma | mantido | fora de alcance: exec é recusado até o start |
Processo principal termina, on-failure ou always | ambos substituídos | nova | mantido | perdidos |
stop, depois start | removidos, depois um novo par | nova | mantido | perdidos |
| Pod do supervisor apagado | ambos removidos após cerca de um minuto | parado | mantido | perdidos |
| Pod do workload apagado | o substituto nunca roda; fase Error | a mesma até stop e start | mantido | perdidos |
suspend | não suportado no 0.1.6 | |||
delete | removidos | apagado | perdidos |
O sandbox mantém seu nome e seu ID durante tudo isso. Se você já usou Kubernetes, a surpresa é que quem decide quando os Pods voltam é o OpenShell, e não o kubelet nem o controller. Um Pod do workload apagado à mão é recriado pelo controller, mas nunca roda.
Configuração
Tudo roda no cluster e no gateway da parte 2: dois nodes m7i.2xlarge em duas availability zones, OpenShell 0.1.6 com o driver do Kubernetes e a CLI conectada por um kubectl port-forward em 127.0.0.1:17680. Se você reduziu a escala dos nodes, traga-os de volta primeiro:
cd my2centsai-blog-samples/openshell-eks
./09_scale.sh up
Os scripts em openshell-lifecycle são bash puro. Eles fazem source do env.sh da parte 2 por meio de um pequeno lib.sh, que também define alguns helpers:
os() { openshell -g osh-eks "$@"; } # -g before the subcommand, never after a -- command
in_sb() { local n="$1"; shift; os sandbox exec "$n" --no-login-shell --no-tty -- "$@"; }
# One line per change: phase, restart count, last exit code, seconds to next restart, generation.
sandbox_state() {
os sandbox get "$1" -o json 2>/dev/null | jq -r '[.phase, (.restart_count|tostring), (.exit_code // "-" | tostring),
(if (.next_restart_at_ms // 0) > 0 then "\(((.next_restart_at_ms / 1000) - now) | floor)s" else "-" end),
(.annotations["internal.openshell.ai/runtime-generation"] // "-" | .[0:8])] | join(" ")'
}
O comentário do wrapper os vem da experiência. Minha primeira versão adicionava -g osh-eks no final, o que o colocava depois do -- e o transformava em um argumento do comando do sandbox.
O watch_sandbox consulta o sandbox_state uma vez por segundo e imprime uma linha sempre que a fase, a contagem de reinícios, o exit code ou a geração mudam. A geração vem da annotation internal.openshell.ai/runtime-generation, encurtada para oito caracteres. Cada script apaga seus sandboxes em um trap, e o 99_cleanup.sh também faz uncordon dos nodes e desativa de novo os user namespaces, caso uma execução tenha sido interrompida.
Testes
Teste 1: Políticas de reinício e gerações
O comando depois do -- em openshell sandbox create é o processo principal do sandbox. A política de reinício decide o que acontece quando ele termina. A política pertence ao gateway, não ao Kubernetes; os próprios Pods têm restartPolicy: Never. Dei a cada política um comando que dorme 5 segundos e sai:
os sandbox create --name rp-never --restart-policy never --detach --no-tty -- sh -c 'sleep 5; exit 3' >/dev/null 2>&1
watch_sandbox rp-never 45 '^(Completed|Error)$'
Saída: três políticas de reinício
$ openshell sandbox create --name rp-never --restart-policy never -- sh -c 'sleep 5; exit 3'
t phase restarts exit next restart generation
0.6s Ready 0 - - 1c611af4
5.3s Error 0 3 - 1c611af4
$ openshell sandbox create --name rp-onfail --restart-policy on-failure -- sh -c 'sleep 5; exit 3'
t phase restarts exit next restart generation
0.5s Ready 0 - - 94c9c2fe
5.2s Starting 1 3 - d05122fc
25.2s Ready 1 - - d05122fc
29.8s Starting 2 3 0s d05122fc
31.4s Starting 2 3 - 0a15a471
40.6s Ready 2 - - 0a15a471
45.3s Starting 3 3 1s 0a15a471
48.4s Starting 3 3 - a81ca285
62.1s Ready 3 - - a81ca285
66.7s Starting 4 3 3s a81ca285
71.5s Starting 4 3 - 884a1227
$ openshell sandbox create --name rp-always --restart-policy always -- sh -c 'sleep 5; exit 0'
t phase restarts exit next restart generation
0.5s Ready 0 - - 232fb351
5.1s Starting 1 0 -1s 232fb351
6.6s Starting 1 0 - da5b8a76
23.6s Ready 1 - - da5b8a76
28.2s Starting 2 0 0s da5b8a76
29.7s Starting 2 0 - a809c4d9
42.1s Ready 2 - - a809c4d9
O que as três execuções mostram:
never(o padrão): o exit code 3 colocou o sandbox emErrore o manteve lá, com a mesma geração. Uma execução separada com exit 0 terminou emCompleted. Após o exit 3, os dois Pods continuaram rodando, mas oexecfoi recusado (“not ready (phase: Error)”). O gateway aceitastarta partir deCompletedou de umErrorcausado pelo processo principal, o que inicia uma nova geração.on-failure: toda saída diferente de zero iniciou uma nova geração. A colunanext restartmostra o backoff crescendo. A documentação o descreve como 1 segundo, dobrando até 3 minutos, e zerado após 10 segundos de uptime. Meu processo viveu só 5 segundos, então ele nunca foi zerado.always: o mesmo, para exit 0.
Da saída até Ready de novo foram de 11 a 20 segundos nessas execuções, com no máximo 4 segundos de backoff. Um reinício não é um reinício de processo: uma verificação separada mostrou que cada reinício substitui os dois Pods. O Pod do supervisor e o Pod do workload recebem novos UIDs, e o volume de workspace é montado de novo no novo Pod do workload. Nessa verificação, com um comando que rodou por 12 segundos, o sandbox ficou Ready de novo cerca de 6 segundos após cada saída. Não sei por que os dois diferem tanto.
Uma nova geração é mais do que um contador. Os tokens e os certificados TLS do OpenShell são vinculados a um sandbox e a uma geração, então todo reinício emite novos. Uma credencial vazada de uma geração é inútil na seguinte. O outro lado é que tudo o que está em memória, incluindo o estado da conversa de um agente, se perde.
Depois, stop, start e suspend:
$ openshell sandbox create --name life (then stop, start, suspend)
ready, generation 6b2ca65f
stop: Stopped after 8.7 s
supervisor pods while stopped: 0
start: Ready after 12.7 s, generation dff0118f
$ openshell sandbox suspend life
Error: × code: 'The system is not in a state required for the operation's
│ execution', message: "compute driver does not support sandbox suspend"
E um sandbox de execução única, os sandbox create --name oneshot --no-keep --no-tty -- echo "hello from a one-shot sandbox":
hello from a one-shot sandbox
oneshot gone after 20.3 s: not listed
O stop levou 8,7 segundos e removeu os dois Pods. O recurso Sandbox do Agent Sandbox continua lá, definido como operatingMode: Suspended, e o PVC do workspace também. O start o trouxe de volta em 12,7 segundos, com uma nova geração.
O suspend está na CLI e na API, mas nenhum driver nativo o implementa no 0.1.6. O gateway verifica primeiro as capacidades do driver e recusa com FAILED_PRECONDITION, cuja descrição padrão é a estranha primeira linha acima. Também não há idle timeout: um sandbox que você esquece continua rodando, e gerando custo, até você pará-lo ou apagá-lo.
O --no-keep funciona como anunciado: o comando rodou, imprimiu sua linha, e o sandbox tinha sumido 20,3 segundos após a chamada de create, incluindo o próprio create e o delete.
Teste 2: O que sobrevive, e onde o volume vive
O 02_persistence.sh grava um arquivo no workspace, um arquivo em /tmp e inicia um processo em background, depois para e inicia o sandbox:
in_sb "$NAME" sh -c 'echo kept > /sandbox/keep.txt; echo lost > /tmp/gone.txt; nohup sleep 3600 >/dev/null 2>&1 & echo " background sleep pid $!"'
# then, simplified: os sandbox stop "$NAME"; os sandbox start "$NAME"; wait for Ready; read the files back
$ openshell sandbox stop persist && openshell sandbox start persist
stopped after 7.5 s
ready again after 12.5 s
/sandbox/keep.txt: kept
/tmp/gone.txt: missing
sleep process: gone
O /sandbox é o workspace: um volume EBS de 2 GiB (/dev/nvme2n1 dentro do sandbox). O /tmp fica no filesystem raiz do container, que vai embora com o Pod. Então a regra para agentes é simples: tudo o que precisa sobreviver a um reinício vai para /sandbox.
O problema está no volume. Um volume EBS vive em uma única availability zone, e o node group da parte 2 tem um node em us-east-1a e um em us-east-1b. Para ver o que isso significa, o script para o sandbox, faz cordon do node na zona do volume e o inicia de novo:
$ openshell sandbox stop persist; kubectl cordon ip-10-70-20-30.ec2.internal; openshell sandbox start persist
the workspace volume is an EBS volume in us-east-1a; the nodes:
ip-10-70-20-30.ec2.internal us-east-1a
ip-10-70-40-237.ec2.internal us-east-1b
+122.4s workload pod: Pending openshell: Starting
0/2 nodes are available: 1 node(s) didn't match PersistentVolume's node affinity, 1 node(s) were unschedulable. preemption: 0/2 nodes are available: 2
supervisor pod on: ip-10-70-40-237.ec2.internal
$ kubectl uncordon ip-10-70-20-30.ec2.internal
t phase restarts exit next restart generation
0.5s Starting 0 - - f000503a
13.0s Ready 0 - - f000503a
usable 14.3 s after uncordon; /sandbox/keep.txt: kept
Por dois minutos, o Pod do workload ficou em Pending, e a fase do OpenShell continuou Starting. Foi no evento do scheduler que eu vi o motivo. Assim que o node voltou a aceitar agendamento, o sandbox ficou Ready em 13 segundos, com seu arquivo.
O Pod do supervisor foi para a outra zona. O Pod do supervisor não tem affinity com seu workload, então as duas metades de um sandbox podem rodar em availability zones diferentes. Todo o tráfego de rede do agente passa pelo seu supervisor, então, nesse caso, todo ele atravessa zonas, e a AWS cobra pelos dados que atravessam zonas.
O que tirar disso:
- Um sandbox fica preso à zona do seu volume pela vida toda. Se você roda nodes em várias zonas, mantenha capacidade suficiente em cada uma, ou uma zona sem node livre deixa seus sandboxes em
Starting(por até 30 minutos, segundo o deadline de start de 1.800 segundos da documentação, antes de irem paraError). - Se o tráfego entre zonas importa, um node group de zona única (ou um node group por zona) mantém as duas metades juntas.
Teste 3: Perdendo um Pod
As duas metades de um sandbox são Pods separados, e qualquer um deles pode desaparecer: uma falha de node, uma eviction, um operador com kubectl delete. O 03_supervisor_loss.sh apaga cada um deles, um de cada vez.
Primeiro o supervisor. O README do sandbox diz que o workload congela quando seu supervisor se desconecta, e é encerrado se nenhum supervisor se reconectar dentro de um deadline (30 segundos por padrão). A documentação de arquitetura acrescenta que um novo supervisor não pode assumir um sandbox em execução, mesmo com credenciais válidas; a exceção é o pool compartilhado de supervisors, que usa um takeover grant assinado pelo gateway.
$ kubectl delete pod os-supervisor-be28e52f-... (the supervisor)
t phase restarts exit next restart generation
0.5s Ready 0 - - bb3450ce
exec while the supervisor is gone: refused
31.1s Provisioning 0 - - bb3450ce
65.3s Stopped 0 - - bb3450ce
(no pods)
$ openshell sandbox start sup
started again: Ready after 11.7 s, generation 2fb3eded
/sandbox/marker: written-before
O exec foi recusado em poucos segundos, já que toda sessão passa pelo supervisor. Aos 31 segundos, batendo com o deadline de 30 segundos, a fase mudou para Provisioning, que, segundo a documentação, também é o que um sandbox mostra até seu supervisor se reconectar. Aos 65 segundos ele estava Stopped, sem nenhum Pod. Nada reiniciou sozinho. Um start depois, ele estava Ready em 11,7 segundos, com uma nova geração e o workspace intacto.
Esse é o comportamento que eu gostaria de ver. Segundo a documentação, o workload ficou congelado nesse meio-tempo, e depois foi removido. O custo é um stop e uma sessão perdida. Nem o gateway nem o controller do Agent Sandbox trouxeram o sandbox de volta sem um start.
Depois o workload.
$ kubectl delete pod default--sup (the workload)
t phase restarts exit next restart generation
0.5s Ready 0 - - 2fb3eded
30.3s Error 0 - - 2fb3eded
default--sup workload Pending
os-supervisor-be28e52f-... supervisor Running
$ openshell sandbox stop sup && openshell sandbox start sup
started again: Ready after 36.1 s, generation 0a2f7d82
/sandbox/marker: written-before
O controller do Agent Sandbox percebeu o Pod faltando e o recriou, mas o substituto nunca rodou. Uma verificação separada mostrou o que o segura: o scheduling gate openshell.ai/bootstrap. O OpenShell só remove esse gate depois de validar o Pod durante seu próprio bootstrap, então um Pod que o controller recria por conta própria nunca roda. O Pod fica SchedulingGated, e após 30 segundos o gateway marca o sandbox como Error. Um start simples é recusado em Error; stop e depois start o trouxeram de volta em 36 segundos, com o workspace intacto.
Os dois casos falham de forma fechada, por design: o OpenShell não substitui um Pod perdido enquanto o agente continua rodando. A recuperação é manual e mantém o workspace: start após a perda do supervisor, stop e depois start após a perda do workload. Esse segundo caminho existe desde o 0.1.5 (o #4231, que corrigiu a #3308, em que um sandbox com erro recusava os dois comandos). Simulei as duas perdas com kubectl delete e não derrubei um node de verdade. Também as rodei com a política de reinício padrão, never; a documentação descreve políticas de reinício apenas para saídas do processo principal, e não testei on-failure nem always aqui. Para a perda do supervisor, o pool compartilhado de supervisors, que é experimental (parte 6), é a exceção: segundo a documentação, o gateway move os sandboxes de um membro que falhou para membros ativos sem reiniciá-los. Isso eu também não testei. Então, se seus agentes precisam voltar sem intervenção, algo fora do OpenShell tem que monitorar Error e Stopped e iniciá-los de novo. Fiquei atento ao estado travado em Provisioning relatado na #4371 e não o encontrei.
Teste 4: Dentro do workload
O 04_isolation.sh roda uma lista de verificações em um sandbox com a policy padrão, que não permite nenhum destino de rede. Cada linha mostra uma verificação, seu exit code e sua saída:
check() { # label, shell command run inside the sandbox
local out rc
out="$(in_sb "$NAME" sh -c "$2" 2>&1)"; rc=$?
printf ' %-34s exit %-3s %s\n' "$1" "$rc" "$(tr '\n' ' ' <<<"$out" | cut -c1-90)"
}
check "write /var/tmp/x (not in policy)" "echo x > /var/tmp/x && echo written"
check "unshare a user namespace" "unshare -U true && echo unshared"
Saída: todas as verificações
$ who am I
id exit 0 uid=10001 gid=10001 groups=10001
capabilities, seccomp exit 0 CapEff: 0000000000000000 NoNewPrivs: 1 Seccomp: 2
kernel (shared with the node) exit 0 6.18.56-125.164.amzn2023.x86_64
node kernel: 6.18.56-125.164.amzn2023.x86_64
$ files (Landlock: read-write /sandbox and /tmp, read-only system paths, nothing else)
write /sandbox/ok exit 0 written
write /tmp/ok exit 0 written
write /var/tmp/x (not in policy) exit 2 sh: 1: cannot create /var/tmp/x: Permission denied
list /var/tmp (not in policy) exit 2 ls: cannot open directory '/var/tmp': Permission denied
write /etc/x (read-only) exit 2 sh: 1: cannot create /etc/x: Permission denied
read /etc/hostname (read-only) exit 0 default--iso
$ processes and syscalls (seccomp, no privileges)
unshare a user namespace exit 1 unshare: unshare failed: Operation not permitted
raw packet socket exit 1 Traceback (most recent call last): File "<string>", line 1, in <module> File "/usr/lib
mount a tmpfs exit 32 mount: /tmp/m: must be superuser to use mount. dmesg(1) may have more information a
processes visible exit 0 PID USER COMMAND 1 10001 openshell-sandb 63 10001 bash 95 10001 sh 96 10001 ps 97 10
$ credentials and network
service account token exit 2 ls: cannot access '/var/run/secrets/kubernetes.io/serviceaccount': No such file or directo
env: proxy or token variables exit 0 0
DNS for pypi.org exit 0 198.18.0.2 pypi.org
https://pypi.org exit 0 curl: (7) Failed to connect to pypi.org port 443 after 1 ms: Couldn't connect to server 00
instance metadata 169.254.169.254 exit 0 curl: (7) Failed to connect to 169.254.169.254 port 80 after 0 ms: Couldn't connect to ser
Camada por camada:
| Camada | Verificação | Resultado |
|---|---|---|
| Identidade | id | UID e GID 10001, não importa o que o USER da imagem diga |
| Privilégios | /proc/self/status | nenhuma capability efetiva, NoNewPrivs: 1 |
| seccomp | Seccomp: 2 | modo de filtro (6 filtros empilhados na execução da parte 2) |
| Landlock | gravar em /sandbox, /tmp | permitido |
| Landlock | gravar em /etc | negado (caminho somente leitura); ler /etc/hostname funciona |
| Landlock | gravar ou listar /var/tmp | negado: um caminho que a policy não nomeia não pode nem ser lido |
| syscalls | unshare -U | Operation not permitted |
| syscalls | socket raw AF_PACKET | PermissionError: [Errno 1] |
| syscalls | socket raw ICMP | OSError: [Errno 93] Protocol not supported |
| syscalls | mount -t tmpfs | must be superuser |
| Processos | ps | o PID 1 é o runtime do OpenShell, /.openshell/runtime/openshell-sandbox, como UID 10001 |
| Credenciais | token de ServiceAccount | nenhum token montado |
| Credenciais | ambiente | nenhuma variável de proxy, token ou secret |
| Rede | DNS para pypi.org | 198.18.0.2, uma resposta sintética do DNS de policy do OpenShell |
| Rede | HTTPS para pypi.org | recusado em menos de um milissegundo |
| Rede | metadata da instância 169.254.169.254 | recusado |
Algumas coisas se destacam.
O Landlock é allow-list, incluindo leituras. A policy padrão de filesystem concede leitura e escrita no workspace e em /tmp, somente leitura em caminhos do sistema como /usr, /lib e /etc, e nada mais. O /var/tmp não está na lista, então o agente não consegue nem listá-lo. Isso é mais restrito do que um filesystem raiz somente leitura, e vale para todo processo que o agente inicia.
O runtime é o PID 1 e o agente é filho dele. O runtime do OpenShell inicia como o entrypoint do container, configura Landlock e seccomp para os processos que inicia e intercepta as conexões de rede deles. Ele faz isso antes de iniciar o agente. Ele não é a metade confiável: compartilha a fronteira com o agente, roda com o mesmo UID e, segundo a documentação de arquitetura, nunca toma decisões de policy.
A rede tem duas trancas. A NetworkPolicy do Pod do workload não permite egress, exceto para seu próprio supervisor. Dentro do Pod, o runtime intercepta todo connect() e o entrega ao supervisor, que decide; sem regras de policy, ele recusa todos. O DNS continua respondendo, com um endereço de 198.18.0.0/15 que não significa nada fora do sandbox. O endpoint de metadata também foi recusado, e a documentação do OpenShell diz que endereços link-local são sempre bloqueados, não importa o que a policy diga. A parte 4 abre a rede uma regra de cada vez.
Nada para roubar. Nenhum token de ServiceAccount, nenhuma variável de proxy, nenhuma credencial no ambiente. O supervisor tem um token projetado para o gateway; o workload não tem. A parte 4 e a parte 5 mostram como o agente usa credenciais que recebe só como placeholders, e onde isso tem limites.
O kernel é o do node. O uname -r dentro do sandbox e a versão do kernel do node são a mesma string. Todas as camadas acima são aplicadas por esse kernel, então um bug de kernel fica por baixo de todas elas. Isso não é hipotético: a Red Hat publicou um teste em que um exploit de page cache do kernel (CVE-2026-31431), executado a partir de um pod protegido apenas pelo OpenShell, comprometeu o host. A explicação deles: o supervisor e o proxy “share the same kernel and page cache as the workload, so a kernel-level attack could potentially corrupt the enforcement mechanism, not just bypass it.” Não rodei nenhum exploit; o ponto é que o runc dá a você as camadas do OpenShell sobre um kernel compartilhado, e nada mais.
Uma VM por sandbox é a resposta usual, e o OpenShell oferece suporte a isso por meio de uma RuntimeClass do Kubernetes. Nestes nodes, o Kata em si rodou bem, mas um sandbox do OpenShell 0.1.6 sob Kata falhou ao popular o workspace, e a VM caiu por um motivo que não encontrei (parte 2, Teste 7). Até isso funcionar, o que há de mais próximo no EKS é o teste a seguir.
Teste 5: User namespaces
O OpenShell pode rodar Pods do workload com hostUsers: false, de modo que os UIDs dentro do Pod são mapeados para uma faixa sem privilégios no node. Isso vem desativado por padrão. O valor do chart é server.enableUserNamespaces:
# what 05_user_namespaces.sh runs, simplified
helm upgrade openshell "${INSTALL}/charts/helm-chart-0.1.6.tgz" -n openshell --reuse-values \
--set server.enableUserNamespaces=true --wait --timeout 10m
kubectl -n openshell rollout restart statefulset/openshell
$ helm upgrade openshell --reuse-values --set server.enableUserNamespaces=true
sandbox: Ready
workload Pod hostUsers: false
$ inside the sandbox
id: uid=10001 gid=10001 groups=10001
/proc/self/uid_map: 0 1439956992 65536
server.enableUserNamespaces back to false
Por dentro, nada parece diferente: continua UID 10001. O mapa de UIDs diz que os UIDs 0 a 65535 do Pod são UIDs do node a partir de 1.439.956.992, então o UID 10001 do agente é 1.439.966.993 no node, um usuário que não é dono de nada lá. Se algo de fato escapasse do container, chegaria como esse usuário, e não como o UID 10001 compartilhado com todos os outros sandboxes do node.
O sandbox iniciou e o exec funcionou sem nenhuma outra mudança, no containerd e no kernel 6.18 do EKS 1.37. Não rodei de novo os outros testes com isso ativado. Ativar e desativar reinicia o gateway a cada vez, então o script também reinicia o port-forward.
User namespaces não ajudam contra um exploit de kernel como o descrito acima: o kernel continua compartilhado. Eles fazem uma fuga do container cair como um estranho sem privilégios, em vez de um UID conhecido. No meu teste no EKS 1.37, eles não tiveram nenhum custo visível, então eu os ativaria.
Resumo dos Resultados
| Resultado | |
|---|---|
never | Exit 3 → Error, exit 0 → Completed; os Pods ficam (verificado após o exit 3), exec recusado até o start |
on-failure / always | Reinício com backoff crescente; cada reinício substitui os dois Pods e inicia uma nova geração |
Da saída até Ready de novo | 11 a 20 s no Teste 1; cerca de 6 s em uma verificação separada |
stop / start | 7,5 a 8,7 s / 11,7 a 12,7 s; Pods removidos, workspace mantido, nova geração |
suspend | Não suportado por nenhum driver nativo no 0.1.6 |
--no-keep | Some 20,3 s após a chamada de create |
/sandbox entre stop e start | Mantido (volume EBS) |
/tmp, processos, memória | Perdidos |
| Start com a zona do volume em cordon | Workload Pending, sandbox Starting durante os dois minutos que esperei; Ready 13 s após o uncordon |
| Posicionamento do supervisor e do workload | Podem cair em zonas diferentes |
| Pod do supervisor apagado | exec recusado; parado aos 65 s; start → Ready em 11,7 s |
| Pod do workload apagado | Substituto bloqueado pelo gate para sempre; Error aos 30 s; stop + start → Ready em 36 s |
| Dentro do workload | UID 10001, sem capabilities, filtro seccomp, allow-list do Landlock, sem token, sem rede |
| Kernel | O mesmo do node |
| User namespaces | Funcionaram: hostUsers: false, UID 10001 → 1.439.966.993 no node |
Limpeza
./99_cleanup.sh # sandboxes from these tests, uncordon, user namespaces off
cd ../openshell-eks
./09_scale.sh down # zero nodes between sessions
O 99_cleanup.sh apaga qualquer sandbox que esses scripts criaram, faz uncordon de qualquer node em cordon e desativa de novo o server.enableUserNamespaces se ele ainda estiver ativado. O cluster em si é removido com o 99_teardown.sh da parte 2, no fim da série.
Veredito
O ciclo de vida do OpenShell no Kubernetes é previsível quando você enxerga a regra por trás dele: o gateway é dono do sandbox, e um Pod é sempre apenas uma execução descartável dele. Reinícios, stops e starts criam, todos eles, um novo par de Pods com credenciais novas; o volume de workspace é a única coisa que passa adiante. Quando um Pod desaparece, o sandbox para ou falha, em vez de rodar meio protegido. Esse é o padrão certo para uma fronteira de segurança.
O isolamento dentro do workload é sólido para o que ele é. Toda verificação que rodei foi recusada por um motivo claro, e a allow-list do Landlock é mais restrita do que eu esperava.
Três coisas para planejar:
- Nada se cura sozinho, por design. Um Pod perdido deixa o sandbox em
StoppedouError; ostarto traz de volta com seu workspace, depois de umstopse ele estiver emError. A recuperação sem intervenção precisa de algo fora do OpenShell monitorando essas fases. Não há idle timeout nem suspend, então um sandbox esquecido mantém seus Pods e seu volume. - Zonas importam. O workspace prende um sandbox a uma zona, um sandbox esperando capacidade fica em
Starting(por até 30 minutos), e suas duas metades podem cair em zonas diferentes e pagar por tráfego entre zonas. - O kernel é compartilhado. Todas as camadas testadas aqui ficam sobre o kernel do node. User namespaces funcionaram de primeira e vale a pena ativá-los. Uma VM por sandbox, a solução real, não funcionou com o OpenShell 0.1.6 nestes nodes.
Para um agente que roda código não confiável em um cluster compartilhado, esse último ponto é o que deve ser pesado. A seguir, a parte 4 dá uma rede ao sandbox: policies, regras com escopo por binário, inspeção L7 e credenciais que o agente recebe só como placeholders.