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

OpenShell no Amazon EKS: Hands-On com uma Instalação Self-Hosted

Por Fabio Douek

Ir para seção
Explica (TLDR) como se eu fosse...
O que é isso?

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.

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

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:

  1. Landlock ativo no kernel do node. O runtime de sandbox do OpenShell se recusa a iniciar sem ele.
  2. 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.
  3. 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

LAPTOP Terraform scripts 01–09 openshell CLI cert de cliente mTLS port-forward 127.0.0.1:17680 EKS 1.37 · 2 × m7i.2xlarge · AL2023 · kernel 6.18 · virtualização aninhada NAMESPACE openshell · PSA restricted StatefulSet do gateway (1 réplica) SQLite em PVC de 1 GiB · mTLS na 8080 · telemetria off por sandbox Pod supervisor egress aberto Service :5500 Pod de workload egress: só supervisor UID 10001 volume de workspace gp3 de 2 GiB NetworkPolicy · 2 Services · 2 Secrets · Sandbox CR cercas do namespace: workloads sem egress, supervisors com egress aberto AGENT-SANDBOX-SYSTEM Agent Sandbox v1.0.3 Sandbox CR → Pod de workload KUBE-SYSTEM VPC CNI + agente de network policy agente EKS Pod Identity EBS CSI (gp3 padrão) LB Controller kata-deploy 3.32.0 SÓ NO TESTE 5 (APAGADO DEPOIS) NLB internet-facing · TCP passthrough · porta 8080 · uma origem /32 Service nosso; SAN do certificado definido na instalação AMAZON ECR openshell-eks/* gateway · supervisor sandbox · controller base ubuntu · workload AMAZON EBS um volume por sandbox gRPC
Como construído. Toda imagem vem do ECR; o gateway é acessado por um port-forward; cada sandbox é composto por dois Pods e um volume EBS.

O que o EKS precisa e os defaults não entregam:

ItemPadrãoO que eu fiz
Aplicação de NetworkPolicyO VPC CNI aceita NetworkPolicies, mas não as aplicaenableNetworkPolicy: "true" no add-on vpc-cni
Controller do Agent SandboxNão vem instalado; o preflight do chart falha sem elesandbox.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)
ImagensGHCR, nvcr.io e registry.k8s.io, através de um único NAT gatewayAs seis no ECR (cinco copiadas, uma buildada); global.image.registry e sandbox.image nos values
Uma StorageClass padrãoO EKS não tem nenhumaO defaultStorageClass do add-on EBS CSI (gp3)
Recursos do gatewayresources: {} (BestEffort)250m de CPU e 512 MiB em requests
TelemetriaLigadaserver.telemetryEnabled: false
Exposição do gatewayO Service do chart não aceita annotations nem source ranges, e ainda publica a porta de métricas 9090, sem autenticaçãoPort-forward por padrão; um Service de NLB nosso para um teste
Nomes no certificadoO hook de PKI nunca reemite; os SANs cobrem só nomes internos do cluster, de loopback e do host DockerCriar o NLB primeiro e colocar o hostname dele em pkiInitJob.serverDnsNames
Registro no CLIopenshell gateway add --local copia os certificados de um gateway local, se o laptop tiver umRegistrar 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:

ImagemOrigem
openshell/gateway:0.1.6, supervisor:0.1.6, sandbox:0.1.6ghcr.io/nvidia/openshell/* (as tags não têm v)
agent-sandbox/agent-sandbox-controller:v1.0.3registry.k8s.io
base/ubuntu:24.04nvcr.io/nvidia/base/ubuntu, fixada por digest
workload:0.1.6buildada 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çãoResultado
Pod com egress deny-all vs sem policyDeny-all: internet e DNS do cluster bloqueados. Sem policy: os dois abertos
Pods novos em modo standard, 10 compartilhando um prefixo de nome1 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 únicos10 de 10 mandaram 9 ou 10 requests para fora antes
Pod cercado para o IP do próprio node, porta 18080Aberto
Pod cercado para o IP do outro nodeBloqueado
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 workspace default compartilham todos o prefixo default-, enquanto um nome como warm-1 ganha 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 restricted se manteve. O gateway e o hook de certificado foram admitidos sob restricted, assim como todos os Pods de sandbox (teste 6).
  • Os dados sobrevivem. Apagar o openshell-0 fez 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 reporta Authenticated (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çãoTempo
Primeira, com a imagem removida dos dois nodes mas as layers ainda em cache (pull de 81 ms)16,8 s
A quente8,3 s
Mais cinco a quente, mediana (mais rápida, mais lenta)10,4 s (8,9 s, 10,7 s)
Remoção, por sandboxcerca 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 AL2023Passou (kernel 6.18.56, ABI 7)
Gate 2: caminho do workload até o supervisor sob o VPC CNIPassou
Gate 3: sandbox do OpenShell numa VM KataFalhou: o seed do workspace falha dentro da VM e a VM cai; a causa continua em aberto (pods Kata simples funcionam)
Build do cluster13 min 30 s
Imagens para o ECR2 min 34 s (6 imagens)
Instalação do OpenShell31 s para o chart, hostname do NLB em 6 s
Criação de sandbox8,3 s a 16,8 s (mediana de cinco a quente: 10,4 s)
Remoção de sandboxcerca de 31 s cada
Objetos por sandbox9, mais 3 policies para o namespace inteiro
Brecha na inicialização do VPC CNIum segundo ou um pouco mais para um pod com prefixo de nome novo; fechada pelo modo strict
Novas execuçõesOs 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):

ItemPreçoPor horaPor 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.

Comments