OpenShell no Amazon EKS: Hands-On com uma Instalação Self-Hosted
Por Fabio Douek
Ir para seção
- Visão Geral
- Arquitetura
- Configuração
- Passo 1: Ferramentas
- Passo 2: O cluster
- Passo 3: Imagens para o ECR
- Passo 4: Agent Sandbox e o chart
- Testes
- Teste 1: O cluster atende ao nível exigido
- Teste 2: A cerca antes do OpenShell
- Teste 3: O Agent Sandbox e o preflight
- Teste 4: O gateway
- Teste 5: O CLI através de um NLB
- Teste 6: Primeiros sandboxes no EKS
- Teste 7: Kata
- Resumo dos Resultados
- Preços
- Limpeza
- Veredito
Explica (TLDR) como se eu fosse...
Imagina montar um parquinho onde cada robô ganha o seu cantinho cercado e um adulto do lado. Eu montei esse parquinho no computadorzão da Amazon, usando um livro de receitas para poder montar de novo exatamente do mesmo jeito.
Quase tudo funcionou depois que eu consertei algumas peças. As cercas impedem mesmo os robôs de sair andando por aí, mas uma cerca nova pode levar mais ou menos um segundo para fechar, e um tipo de quarto superforte que eu queria colocar vivia desabando. Ainda não sei por quê.
Este é um registro de instalação do OpenShell, um runtime open source de agentes, no Amazon EKS, na conta AWS do próprio autor. O projeto não testa o EKS, então cada constatação aqui é evidência do próprio operador, não um compromisso do fornecedor.
Os pontos relevantes para due diligence: a cerca que isola a rede depende do plugin de rede do cluster e pode ter uma breve abertura quando um sandbox inicia; a telemetria precisa ser desligada explicitamente; e a opção de isolamento mais forte, por máquina virtual, não funcionou nesta versão. Documente esses pontos antes de confiar nessa fronteira.
O procedimento foi transplantar o OpenShell para o Amazon EKS e checar três sinais vitais antes de seguir adiante: uma feature do kernel chamada Landlock, o caminho de rede entre as duas metades de cada sandbox, e o isolamento por VM. Dois estavam saudáveis na primeira leitura; o terceiro falhou de forma reproduzível.
Efeitos colaterais observados: cada sandbox precisa do próprio disco, então leva uns dez segundos para iniciar e trinta para remover, e a cerca da rede pode fechar só por volta de um segundo depois que um novo pod aparece. Contraindicado para quem precisa de isolamento por VM nesta versão.
Existe um alívio particular em ver uma instalação cuidadosa ficar verde, verificação após verificação, e um aperto particular quando a última verificação com que você se importava fica vermelha. Este build teve os dois, e a vermelha era justamente a opção que prometia mais tranquilidade.
A parte honesta é nomear o que ainda exige confiança: uma cerca que fica aberta por um segundo quando nasce, uma configuração de plugin que você precisa lembrar de ligar, um default que manda dados de uso para casa. Nada disso é alarmante, mas cada item é uma conversa que um time deveria ter antes de relaxar.
Pense nisso como montar o palco antes de a banda tocar. O equipamento tem dois nodes, uma mesa de som que só roteia canais aprovados, e cada instrumento microfonado através de um supervisor. Depois de tudo cabeado, a passagem de som saiu limpa: cada novo sandbox subia em uns dez segundos.
As notas desafinadas ficaram no timing e num instrumento que faltou. Um canal novo pode ficar aberto por uma batida, mais ou menos, antes de a cerca fechar, e o pedal de isolamento por VM, que soava ótimo sozinho, cortava toda vez que o OpenShell era plugado nele.
A história é uma instalação repetível e auditável de um runtime de agentes numa infraestrutura que um time de plataforma já possui. Terraform, Helm e nove scripts levam você de uma conta vazia a um gateway funcionando, protegido por mTLS, em bem menos de uma hora.
O posicionamento para compradores é franco: o núcleo funciona no EKS hoje, a cerca da rede precisa de uma configuração de plugin que vem desligada por padrão, e a opção de isolamento por VM não está pronta nesta release. Essa honestidade é o diferencial, não uma fraqueza a esconder.
Visão Geral
O OpenShell, aceito como projeto CNCF Sandbox em 2026-09-26, roda agentes de IA em sandboxes divididos em um workload não confiável e um supervisor confiável. A Parte 1 explicou as peças e rodou tudo num Mac. Este post, parte 2 de 6, instala o OpenShell 0.1.6 no Amazon EKS 1.37, que é a base onde rodam a parte 3, a parte 4, a parte 5 e a parte 6.
Já adianto: o OpenShell não testa o EKS. O CI dele roda os pull requests em kind com Kubernetes 1.35 e as releases em k3s 1.29, e a matriz de build da política de releases cita GKE e OpenShift como alvos suportados. Então tudo abaixo, incluindo cada workaround, é evidência minha, não uma declaração do fornecedor.
Antes de construir qualquer coisa em cima da instalação, defini três verificações go/no-go:
- Landlock ativo no kernel do node. O runtime de sandbox do OpenShell se recusa a iniciar sem ele.
- O caminho de controle: o Pod de workload de cada sandbox precisa alcançar o seu Pod supervisor passando pela NetworkPolicy aplicada pelo VPC CNI.
- Isolamento por VM: um sandbox do OpenShell rodando numa VM do Kata Containers em instâncias EC2 comuns com virtualização aninhada.
As duas primeiras passaram. A terceira não, e isso moldou o resto da série.
Arquitetura
O que o EKS precisa e os defaults não entregam:
| Item | Padrão | O que eu fiz |
|---|---|---|
| Aplicação de NetworkPolicy | O VPC CNI aceita NetworkPolicies, mas não as aplica | enableNetworkPolicy: "true" no add-on vpc-cni |
| Controller do Agent Sandbox | Não vem instalado; o preflight do chart falha sem ele | sandbox.yaml da release v1.0.3 (a versão que o CI de pull requests do OpenShell testa; a documentação diz “latest”, v1.0.9 em 2026-11-01) |
| Imagens | GHCR, nvcr.io e registry.k8s.io, através de um único NAT gateway | As seis no ECR (cinco copiadas, uma buildada); global.image.registry e sandbox.image nos values |
| Uma StorageClass padrão | O EKS não tem nenhuma | O defaultStorageClass do add-on EBS CSI (gp3) |
| Recursos do gateway | resources: {} (BestEffort) | 250m de CPU e 512 MiB em requests |
| Telemetria | Ligada | server.telemetryEnabled: false |
| Exposição do gateway | O Service do chart não aceita annotations nem source ranges, e ainda publica a porta de métricas 9090, sem autenticação | Port-forward por padrão; um Service de NLB nosso para um teste |
| Nomes no certificado | O hook de PKI nunca reemite; os SANs cobrem só nomes internos do cluster, de loopback e do host Docker | Criar o NLB primeiro e colocar o hostname dele em pkiInitJob.serverDnsNames |
| Registro no CLI | openshell gateway add --local copia os certificados de um gateway local, se o laptop tiver um | Registrar primeiro e depois gravar o bundle de cliente do cluster |
Configuração
O diretório de apoio cria tudo com Terraform e nove scripts numerados. Cada um foi pensado para ser seguro de rodar de novo; eu rodei de novo do 01 ao 06, e todos convergiram em vez de falhar.
Passo 1: Ferramentas
Terraform 1.9 ou mais novo, o AWS CLI v2, kubectl, Helm (eu usei o 4.3.1; a documentação fala em 3.x, e o chart instalou sem problemas), Docker com buildx, jq, envsubst e uv, além do CLI do OpenShell da parte 1. Nenhum segredo: a PKI do gateway é gerada dentro do cluster.
Passo 2: O cluster
O 01_cluster.sh roda o Terraform (uma VPC com um NAT gateway, EKS 1.37, dois nodes m7i.2xlarge), instala o AWS Load Balancer Controller e verifica o resultado. Duas configurações importam para o OpenShell:
vpc-cni = {
addon_version = "v1.23.2-eksbuild.8"
before_compute = true
configuration_values = jsonencode({ enableNetworkPolicy = "true" })
}
cpu_options = {
nested_virtualization = "enabled" # /dev/kvm on M7i, for Kata
}
metadata_options = {
http_tokens = "required"
http_put_response_hop_limit = 1 # no node credentials for pods
}
Tudo levou 13 minutos e 30 segundos, 12:48 disso no Terraform.
Passo 3: Imagens para o ECR
O 03_images.sh copia cinco imagens com os índices multi-arquitetura delas e faz o build de uma sexta. Depois compara cada digest no ECR com a origem:
| Imagem | Origem |
|---|---|
openshell/gateway:0.1.6, supervisor:0.1.6, sandbox:0.1.6 | ghcr.io/nvidia/openshell/* (as tags não têm v) |
agent-sandbox/agent-sandbox-controller:v1.0.3 | registry.k8s.io |
base/ubuntu:24.04 | nvcr.io/nvidia/base/ubuntu, fixada por digest |
workload:0.1.6 | buildada aqui: a base mais o AWS CLI 2.39.3, boto3 1.43.123, git, gh, curl, jq |
Levou 2 minutos e 34 segundos. Quando eu apaguei uma tag, o --verify-only saiu com código 1 e nomeou a imagem que faltava. Uma nova execução copiou só essa imagem, e o build da imagem de workload saiu do cache com o mesmo digest.
Passo 4: Agent Sandbox e o chart
O 05_install.sh instala o Agent Sandbox v1.0.3 com a imagem reescrita para o ECR. Depois aplica no namespace openshell o label de Pod Security restricted, cria o Service do NLB (para que o hostname dele exista) e roda o Helm com este arquivo de values:
global:
image:
registry: ${ECR_REGISTRY}/${ECR_PREFIX}
tag: "0.1.6"
sandbox:
image:
repository: ${ECR_REGISTRY}/${ECR_PREFIX}/workload
tag: "0.1.6"
server:
telemetryEnabled: false
drivers:
kubernetes:
allowDriverConfig: true # lets a sandbox pick a RuntimeClass
resources:
requests:
cpu: 250m
memory: 512Mi
O script passa o hostname do NLB com --set-json pkiInitJob.serverDnsNames=[...], inicia um port-forward em 127.0.0.1:17680, registra o CLI e depois grava o bundle de cliente.
Testes
Teste 1: O cluster atende ao nível exigido
O 01_cluster.sh termina com verificações, e todas passaram:
ok Kubernetes v1.37.1-eks-577a51e
ok ip-10-70-10-204.ec2.internal: crw-rw-rw-. 1 root 36 10, 232 ... /host/dev/kvm (vmx on 8 vCPUs)
ok ip-10-70-10-204.ec2.internal: kernel 6.18.56-125.164.amzn2023.x86_64, Landlock active (ABI 7),
LSMs lockdown,capability,landlock,yama,safesetid,selinux,bpf,ima
ok i-0da86c3ab4ddf08b1 (m7i.2xlarge): HttpTokens required, HttpPutResponseHopLimit 1, NestedVirtualization enabled
ok VPC CNI network policy enforcement on (aws-node 2/2 ready, aws-eks-nodeagent present)
ok eks-pod-identity-agent DaemonSet 2/2 ready
ok aws-load-balancer-controller 2/2 ready, credentials from EKS Pod Identity
ok default StorageClass ebs-csi-default-sc (ebs.csi.aws.com, ...)
O gate 1 passou. O Landlock está na lista de LSMs ativos do kernel AL2023 do EKS, na ABI 7; o OpenShell precisa da 3. A verificação do node lê a ABI com uma chamada direta a landlock_create_ruleset a partir de um debug pod. Uma segunda execução do script fez o Terraform reportar “No changes”.
Teste 2: A cerca antes do OpenShell
O driver de Kubernetes do OpenShell coloca cada Pod de workload atrás de uma NetworkPolicy sem nenhum egress exceto para o seu supervisor, e confia que o CNI vai aplicá-la (a #3862 pede uma verificação). Então, antes de instalar o OpenShell, o 04_fence.sh testou o que o VPC CNI aplica, com pods simples e o mesmo tipo de policy:
| Verificação | Resultado |
|---|---|
| Pod com egress deny-all vs sem policy | Deny-all: internet e DNS do cluster bloqueados. Sem policy: os dois abertos |
| Pods novos em modo standard, 10 compartilhando um prefixo de nome | 1 de 10 conseguiu mandar requests para fora antes de a policy ser aplicada (10 das suas 40 requests; cada uma é um curl com timeout de 1 s, seguido de uma pausa de 100 ms) |
| Pods novos em modo standard, 10 com prefixos de nome únicos | 10 de 10 mandaram 9 ou 10 requests para fora antes |
| Pod cercado para o IP do próprio node, porta 18080 | Aberto |
| Pod cercado para o IP do outro node | Bloqueado |
Modo strict (NETWORK_POLICY_ENFORCING_MODE=strict) | 0 de 10 vazaram; um pod novo que nenhuma policy seleciona começa com todo o tráfego negado |
Três conclusões disso:
- Existe uma brecha na inicialização de um segundo ou um pouco mais no modo padrão. O agente de network policy programa as regras de um pod novo depois que o pod já iniciou. O agente do VPC CNI compartilha essas regras entre pods cujos nomes coincidem até o último
-. Então só um pod com um prefixo novo abre uma brecha: aqui foi o primeiro dos dez que compartilhavam um prefixo, e todos os dez com prefixos únicos. O OpenShell nomeia os Pods de workload como<workspace>--<sandbox>, então sandboxes com nomes sem hífen no workspacedefaultcompartilham todos o prefixodefault-, enquanto um nome comowarm-1ganha o próprio prefixo, e a própria brecha. - O IP do próprio node é sempre alcançável. Isso é proposital no agente de network policy do VPC CNI: o código-fonte dele adiciona o IP do node a toda allow list para que os probes do kubelet funcionem. Um pod cercado consegue alcançar todas as portas do próprio node.
- O modo strict fecha a brecha, mas aí qualquer pod que nenhuma policy seleciona começa com todo o tráfego negado, incluindo pods de sistema como o CoreDNS (pods com host network ficam isentos), então o script ligou o modo, mediu e voltou ao anterior. Cada troca levou 23 segundos.
Quanto a brecha importa para o OpenShell? Menos do que para um pod simples. O OpenShell segura a inicialização do agente até o supervisor confirmar, e os sockets do agente passam pelo broker dentro do pod de qualquer forma. A NetworkPolicy é a segunda camada, não a primeira. Mas é a camada que pega qualquer coisa que o broker deixe passar, então eu rodaria o modo strict num cluster dedicado a sandboxes.
Teste 3: O Agent Sandbox e o preflight
Instalar o chart antes do Agent Sandbox falha antes de qualquer coisa ser criada:
Error: execution error at (helm-chart/templates/agent-sandbox-preflight.yaml:9:4): Agent Sandbox is required
but neither agents.x-k8s.io/v1beta1 nor agents.x-k8s.io/v1alpha1 is served
Com o controller v1.0.3 instalado (CRD v1beta1), a instalação levou 31 segundos. O NLB ganhou um hostname 6 segundos depois de o Service dele ser criado.
Teste 4: O gateway
openshell-0 1/1 Running
openshell-data-openshell-0 Bound 1Gi RWO ebs-csi-default-sc
ok gateway env OPENSHELL_TELEMETRY_ENABLED=false
ok server certificate lists the NLB hostname
- O Pod Security
restrictedse manteve. O gateway e o hook de certificado foram admitidos sobrestricted, assim como todos os Pods de sandbox (teste 6). - Os dados sobrevivem. Apagar o
openshell-0fez o Pod voltar no mesmo volume. - Uma nova execução converge. Ela gerou a revisão 2 do Helm com manifests idênticos, e o hook de certificado foi pulado porque os três Secrets dele já existiam.
- A autenticação é por chamada, não por conexão. Um cliente TLS sem certificado completa o handshake, e a primeira chamada de API retorna o status gRPC 16,
missing authorization header. Com o certificado de cliente do cluster, o CLI reportaAuthenticated (mTLS transport).
O registro no CLI foi o único tropeço de verdade da instalação. A documentação registra um gateway Kubernetes com openshell gateway add https://127.0.0.1:8080 --local. Meu laptop também roda o gateway local da parte 1, e o --local (o texto de ajuda diz “um gateway mTLS local rodando em Docker nesta máquina”) preencheu o novo registro com os certificados daquele gateway:
Error: × client error (Connect)
╰─▶ invalid peer certificate: BadSignature
A correção é registrar primeiro e depois gravar o bundle de cliente do cluster, a partir do Secret openshell-client-tls, em ~/.config/openshell/gateways/osh-eks/mtls/. A porta 8080 já estava ocupada no meu laptop, então o port-forward usa a 17680.
Teste 5: O CLI através de um NLB
O Service do chart não aceita annotations de load balancer, então o manifests/gateway-nlb.yaml é um Service nosso: internet-facing, targets do tipo IP, TCP passthrough só na porta 8080, loadBalancerSourceRanges definido para o meu IP. O TLS passa direto, então o certificado de cliente chega ao gateway:
Gateway: osh-eks-nlb
Server: https://k8s-openshel-openshel-....elb.us-east-1.amazonaws.com:8080
Status: Connected
Authentication: Authenticated (mTLS transport)
metrics port 9090 through the NLB: 000 (not exposed)
Quando eu defini o source range como 203.0.113.7, o CLI ficou bloqueado e o script parou com erro, mas não instantaneamente: mesmo depois de o security group mostrar só o novo endereço, mais uma chamada de status passou antes de a chamada seguinte ser recusada. Uma nova execução colocou meu IP de volta. A minha primeira versão desse teste passou por engano porque rodou antes de o AWS Load Balancer Controller atualizar o security group, então agora o script espera pela regra antes de testar. Depois do teste, o 06_remote.sh --delete removeu o NLB.
Teste 6: Primeiros sandboxes no EKS
O gate 2 passou. Os sandboxes chegam a Ready, então o VPC CNI permite o caminho do workload até o supervisor. Um sandbox corresponde a nove objetos do Kubernetes:
sandboxes.agents.x-k8s.io 1 default--first
pods 2 default--first (workload), os-supervisor-<id> (supervisor)
services 2 os-boundary-<id>, os-supervisor-<id>
networkpolicies 1 os-control-<id>
secrets 2 os-sandbox-<id>-..., os-supervisor-<id>-...
persistentvolumeclaims 1 workspace-default--first
Mais três policies para o namespace inteiro: as duas cercas (workloads ficam sem egress, supervisors ganham egress aberto) e a regra de ingress SSH do chart. Dentro do workload:
$ id
uid=10001 gid=10001 groups=10001
$ sh -c "grep -E '^(Seccomp|NoNewPrivs|CapEff)' /proc/self/status"
CapEff: 0000000000000000
NoNewPrivs: 1
Seccomp: 2
Seccomp_filters: 6
$ sh -c "env | grep -ciE 'proxy|token'"
0
O driver roda o workload como UID 10001, independentemente do que diz o USER da imagem, sem capabilities e com um filtro seccomp, e não existe nenhuma variável de proxy ou de token para roubar.
Tempos, da chamada de criação até Ready:
| Criação | Tempo |
|---|---|
| Primeira, com a imagem removida dos dois nodes mas as layers ainda em cache (pull de 81 ms) | 16,8 s |
| A quente | 8,3 s |
| Mais cinco a quente, mediana (mais rápida, mais lenta) | 10,4 s (8,9 s, 10,7 s) |
| Remoção, por sandbox | cerca de 31 s |
Não é a imagem que custa tempo: o kubelet reportou o pull da imagem de workload de 175 MB em 81 ms, porque as layers dela ainda estavam no node. Os eventos de uma criação a quente mostram para onde vão os dez segundos:
- o volume EBS: cerca de 2 s para provisionar e de 2 a 3 s para anexar,
- três containers iniciando: cerca de 2 s,
- a sessão do supervisor.
Localmente, no Docker, a mesma criação levou 2,5 segundos. Apagar é ainda mais lento, porque o DeleteSandbox só retorna depois que os Pods e o volume deixam de existir. Isso passa um pouco do timeout de RPC padrão de 30 segundos do SDK de Python, então o código de apoio aumenta esse valor para 120.
Teste 7: Kata
O kata-deploy 3.32.0 instalou em 66 segundos (um pull de 1,6 GB por node). Um pod Kata simples iniciou em 3 segundos com o próprio kernel guest, 6.18.35 contra o 6.18.56 do node. O OpenShell escolhe um runtime por sandbox, desde que a RuntimeClass tenha um label de aprovação:
kubectl label runtimeclass kata-qemu openshell.ai/sandbox-attachable=true
openshell sandbox create --name kata1 \
--driver-config-json '{"kubernetes":{"pod":{"runtime_class_name":"kata-qemu"}}}'
Sem o label, a criação é recusada na hora: RuntimeClass 'kata-qemu': external resource not admitted by required labels.
Com o label, o gate 3 falhou. O Pod de workload ganhou a sua VM Kata, e o primeiro init container terminou dentro dela. O segundo, workspace-init, roda openshell-sandbox seed-workspace como UID 10001 para preencher o volume de workspace. Uns 50 segundos depois da criação, ele terminou com exit code 255 e nenhuma saída, e o Pod foi para Failed. O runtime do Kata no node, que gera logs através do containerd, reportou isto nos cinco minutos anteriores:
3 Dead agent
1 QEMU exited with an error
Dead agent significa que o host tinha perdido contato com o agente do Kata, o processo dentro da VM que roda os containers. QEMU exited with an error (na íntegra, signal: killed) significa que o processo da VM foi morto. Então a VM caiu. Essas linhas não mostram por quê, nem o que veio primeiro: elas não têm timestamps, e o Kata também mata o QEMU quando desmonta um Pod que falhou. Eu não capturei os logs do próprio guest, então a causa continua em aberto. O Kata também ainda não está no CI do OpenShell (#4459, aberta).
O sandbox em si ficou em Provisioning (motivo ConfigurationPending) até o timeout de provisionamento de 300 segundos. Ele falhou do mesmo jeito com --cpu 2 --memory 4Gi. Um pod Kata simples com o mesmo UID, o mesmo fsGroup e um volume EBS escreveu no volume sem problema, então a falha é específica do Pod de workload do OpenShell sob o Kata, não do Kata, do UID ou do volume isoladamente. Eu não testei um node bare-metal: o próprio Kata funciona nesses nodes com virtualização aninhada, então era improvável que um host diferente ajudasse.
Por isso, o resto desta série roda os sandboxes do OpenShell em runc, que compartilha o kernel do node. A Parte 3 explica o que isso significa.
Resumo dos Resultados
| Resultado | |
|---|---|
| Gate 1: Landlock no EKS 1.37 AL2023 | Passou (kernel 6.18.56, ABI 7) |
| Gate 2: caminho do workload até o supervisor sob o VPC CNI | Passou |
| Gate 3: sandbox do OpenShell numa VM Kata | Falhou: o seed do workspace falha dentro da VM e a VM cai; a causa continua em aberto (pods Kata simples funcionam) |
| Build do cluster | 13 min 30 s |
| Imagens para o ECR | 2 min 34 s (6 imagens) |
| Instalação do OpenShell | 31 s para o chart, hostname do NLB em 6 s |
| Criação de sandbox | 8,3 s a 16,8 s (mediana de cinco a quente: 10,4 s) |
| Remoção de sandbox | cerca de 31 s cada |
| Objetos por sandbox | 9, mais 3 policies para o namespace inteiro |
| Brecha na inicialização do VPC CNI | um segundo ou um pouco mais para um pod com prefixo de nome novo; fechada pelo modo strict |
| Novas execuções | Os scripts 01 a 06 convergiram numa segunda execução |
Preços
Custo ocioso do que isto cria, em us-east-1 (tabela de preços da AWS, outubro de 2026):
| Item | Preço | Por hora | Por dia |
|---|---|---|---|
| Control plane do EKS (suporte padrão) | $0,10/h | $0,100 | $2,40 |
2 × m7i.2xlarge on-demand (a virtualização aninhada não custa nada a mais) | $0,4032/h cada | $0,806 | $19,35 |
| NAT gateway (+ $0,045/GB processado) e o IPv4 público dele | $0,045/h + $0,005/h | $0,050 | $1,20 |
| Volumes raiz EBS gp3, 2 × 100 GiB, e trocados (ECR, o 1 GiB do gateway) | $0,08/GB-mês | ≈ $0,023 | ≈ $0,55 |
| Total ocioso | ≈ $0,98 | ≈ $23,50 | |
| NLB enquanto existir (2 AZs, ocioso) | $0,0225/h + IPv4 | ≈ $0,033 | ≈ $0,78 |
| Volume gp3 de 2 GiB de cada sandbox em execução | $0,08/GB-mês | ≈ $0,0002 | ≈ $0,005 |
Os nodes são 80% disso. O 09_scale.sh down reduz os nodes a zero entre sessões e deixa cerca de $0,15 por hora.
Limpeza
./09_scale.sh down # between sessions: zero nodes
./09_scale.sh up # two nodes, gateway, port-forward
./99_teardown.sh # everything, when you're done with the series
O 99_teardown.sh apaga os sandboxes e o NLB, e desinstala as três releases do Helm e o Agent Sandbox. Depois remove o que o chart deixa para trás na desinstalação: os Secrets de TLS, JWT e criptografia de chaves, o volume do gateway e qualquer volume de workspace. Por último vêm todos os repositórios openshell-eks/* do ECR, o terraform destroy e o log group do Container Insights da parte 6, que o agente dele cria fora do Terraform. Ele termina listando qualquer volume EBS, load balancer, repositório do ECR, role IAM ou bucket osh-eks, ou log group do Container Insights que tenha sobrado, e falha se houver algum. Se você rodou a parte 5, destrua o Terraform dela primeiro: o 99_teardown.sh para antes de apagar qualquer coisa enquanto as roles e o bucket da parte 5 ainda existirem.
Veredito
O OpenShell instala sem problemas no EKS depois que você conhece as seis coisas, mais ou menos, que o chart pressupõe e o EKS não fornece: um CNI que aplica as policies, o controller do Agent Sandbox, uma StorageClass padrão, imagens que você consegue baixar de forma confiável, um nome no certificado para acesso remoto e um registro no CLI que não pegue emprestados os certificados de um gateway local. Nada que o OpenShell instala roda como privilegiado (o kata-deploy roda, by design), tudo no namespace openshell passou no Pod Security restricted, e a autenticação é exigida em toda chamada. Para uma release de saída do alpha que o projeto não testa no EKS, é um bom resultado.
Três coisas merecem atenção antes de você confiar nisso:
- A cerca depende de uma configuração que vem desligada por padrão. Sem
enableNetworkPolicy, as policies que o OpenShell cria são aceitas e ignoradas. Com ela, um pod com um prefixo de nome novo ainda tem uma brecha de mais ou menos um segundo na inicialização, e um pod cercado consegue alcançar o próprio node; o modo strict num cluster dedicado fecha a brecha. - Cada sandbox custa um volume EBS. São cerca de 10 segundos para criar, 30 segundos para apagar e um dos attachments de volume por node. A Parte 6 mede o efeito disso na densidade.
- O isolamento por VM ainda não está lá. O Kata roda em nodes M7i com virtualização aninhada, mas com um sandbox do OpenShell 0.1.6 sob o Kata, o seed do workspace falha dentro da VM e a VM cai; a causa continua em aberto. Se você precisa de um kernel separado por agente hoje, esta release neste setup não te dá isso.
Comparado a rodar num laptop, o EKS dá ao OpenShell o que o driver Docker não consegue dar: admission do Pod Security, NetworkPolicies por sandbox, workspaces persistentes e um gateway num volume de verdade. Também dá mais coisas para você acertar. O próximo post, a parte 3, acompanha a vida de um sandbox neste cluster, e o isolamento que você tem só com runc.