segunda-feira, 16 de novembro de 2026 Edição nº 240
Buscar
Avaliação · Infraestrutura · 27 min de leitura

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...
O que é isso?

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.

GitHub Veja o código-fonte aqui: openshell-lifecycle

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:

Pod supervisor Pod workload /tmp, processos workspace GERAÇÃO 1 GERAÇÃO 2 PARADO GERAÇÃO 3 os-supervisor-<id> default--<name> perdidos ao fim da geração novo Pod, novo UID novo Pod, novo UID vazio de novo sem PodsPVC mantido novo Pod, novo UID novo Pod, novo UID vazio de novo /sandbox · volume EBS de 2 GiB em uma availability zone · mantido até o delete create processo principal termina política de reinício on-failure ou always stop start delete Cada geração recebe tokens e certificados novos. Um Pod do workload apagado é recriado, mas nunca roda; um Pod do supervisor apagado para o sandbox (Teste 3).
Um sandbox no driver do Kubernetes, conforme medido nos Testes 1 a 3. Os Pods do supervisor e do workload são substituídos juntos; só o volume de workspace passa para a geração seguinte.
EventoPodsGeração/sandbox/tmp, processos, memória
Processo principal termina, política nevercontinuam rodando (verificado após o exit 3); fase Error (diferente de zero) ou Completed (zero)a mesmamantidofora de alcance: exec é recusado até o start
Processo principal termina, on-failure ou alwaysambos substituídosnovamantidoperdidos
stop, depois startremovidos, depois um novo parnovamantidoperdidos
Pod do supervisor apagadoambos removidos após cerca de um minutoparadomantidoperdidos
Pod do workload apagadoo substituto nunca roda; fase Errora mesma até stop e startmantidoperdidos
suspendnão suportado no 0.1.6
deleteremovidosapagadoperdidos

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 em Error e o manteve lá, com a mesma geração. Uma execução separada com exit 0 terminou em Completed. Após o exit 3, os dois Pods continuaram rodando, mas o exec foi recusado (“not ready (phase: Error)”). O gateway aceita start a partir de Completed ou de um Error causado pelo processo principal, o que inicia uma nova geração.
  • on-failure: toda saída diferente de zero iniciou uma nova geração. A coluna next restart mostra 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 para Error).
  • 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:

CamadaVerificaçãoResultado
IdentidadeidUID e GID 10001, não importa o que o USER da imagem diga
Privilégios/proc/self/statusnenhuma capability efetiva, NoNewPrivs: 1
seccompSeccomp: 2modo de filtro (6 filtros empilhados na execução da parte 2)
Landlockgravar em /sandbox, /tmppermitido
Landlockgravar em /etcnegado (caminho somente leitura); ler /etc/hostname funciona
Landlockgravar ou listar /var/tmpnegado: um caminho que a policy não nomeia não pode nem ser lido
syscallsunshare -UOperation not permitted
syscallssocket raw AF_PACKETPermissionError: [Errno 1]
syscallssocket raw ICMPOSError: [Errno 93] Protocol not supported
syscallsmount -t tmpfsmust be superuser
Processospso PID 1 é o runtime do OpenShell, /.openshell/runtime/openshell-sandbox, como UID 10001
Credenciaistoken de ServiceAccountnenhum token montado
Credenciaisambientenenhuma variável de proxy, token ou secret
RedeDNS para pypi.org198.18.0.2, uma resposta sintética do DNS de policy do OpenShell
RedeHTTPS para pypi.orgrecusado em menos de um milissegundo
Redemetadata da instância 169.254.169.254recusado

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
neverExit 3 → Error, exit 0 → Completed; os Pods ficam (verificado após o exit 3), exec recusado até o start
on-failure / alwaysReinício com backoff crescente; cada reinício substitui os dois Pods e inicia uma nova geração
Da saída até Ready de novo11 a 20 s no Teste 1; cerca de 6 s em uma verificação separada
stop / start7,5 a 8,7 s / 11,7 a 12,7 s; Pods removidos, workspace mantido, nova geração
suspendNão suportado por nenhum driver nativo no 0.1.6
--no-keepSome 20,3 s após a chamada de create
/sandbox entre stop e startMantido (volume EBS)
/tmp, processos, memóriaPerdidos
Start com a zona do volume em cordonWorkload Pending, sandbox Starting durante os dois minutos que esperei; Ready 13 s após o uncordon
Posicionamento do supervisor e do workloadPodem cair em zonas diferentes
Pod do supervisor apagadoexec recusado; parado aos 65 s; start → Ready em 11,7 s
Pod do workload apagadoSubstituto bloqueado pelo gate para sempre; Error aos 30 s; stop + start → Ready em 36 s
Dentro do workloadUID 10001, sem capabilities, filtro seccomp, allow-list do Landlock, sem token, sem rede
KernelO mesmo do node
User namespacesFuncionaram: 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 Stopped ou Error; o start o traz de volta com seu workspace, depois de um stop se ele estiver em Error. 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.

Comments