Pular para o conteúdo

Instalação

kubectl

Para times que não podem ou não rodam Helm. Os mesmos quatro contêineres, o mesmo contrato, aplicados como manifestos puros numerados em vez de um chart: deploy/kubectl/ espelha o deploy/helm/sreorbit com defaults no formato de produção.

Pré-requisitos

RequisitoVersãoPor quê
Kubernetes1.30+Casa com o piso do caminho do Helm; nada específico do kubectl o eleva.
kubectlcompatível com a versão minor do seu clusterAplica os manifestos desta página
Um ingress controlleras anotações entregues pressupõem nginxCaso contrário, troque as anotações em 60-ingress.yaml pelo equivalente de SSE do seu controller; veja troubleshooting.md.
kustomizeopcionalSó se você quiser overlays em vez de editar à mão; veja "Uma nota sobre o kustomize" abaixo.

Arquivos, na ordem de aplicação

Numerados para que a ordem lexical seja a ordem de dependência: kubectl apply -f deploy/kubectl/ aplica namespace, depois identidade, depois configuração, depois workloads, depois roteamento e políticas, e falha rápido se você aplicá-los fora de ordem à mão:

ArquivoO que cria
00-namespace.yamlO namespace sreorbit, com os labels restricted de Pod Security Admission já definidos.
01-namespace-node.yamlO namespace sreorbit-node, exclusivo para o DaemonSet do node-exporter: privileged de Pod Security (ele monta seis caminhos do host somente leitura), mantido à parte para que o resto da instalação continue em restricted.
10-serviceaccounts.yamlUma ServiceAccount por componente, mais uma para o agente (orbit-agent) e outra para o kube-state-metrics (os dois leem o cluster) e uma para o node-exporter (sem vínculo a nada, sem token). web e nocturne não são vinculados a nada e não projetam token (automountServiceAccountToken: false); o orbit-api projeta um, porque ele lê este cluster.
15-rbac-orbit-api.yamlUm ClusterRole somente-leitura (get/list/watch, nunca secrets, nunca um verbo de escrita) vinculado ao sreorbit-orbit-api. Estes manifestos definem ORBIT_DEMO_DATA: "false", então o orbit-api precisa de um cluster para ler; com ORBIT_KUBECONFIG vazia, esse cluster é este. Para ler um cluster remoto, apague este arquivo, volte automountServiceAccountToken: false em 10- e 41-, monte um kubeconfig e aponte ORBIT_KUBECONFIG para ele. Uma credencial ou a outra, nunca as duas.
17-rbac-telemetry.yamlRBAC dos dois componentes que leem o cluster para montar métricas: um ClusterRole para o agente (get em nodes/metrics, list/watch em nodes, mais list/watch namespaced em pods, services e endpointslices no sreorbit e em pods no sreorbit-node) e o ClusterRole padrão do kube-state-metrics (o mesmo conjunto, menos secrets). Nenhum dos dois ganha nodes/proxy.
20-configmaps.yamlConfiguração não secreta por componente, incluindo, entregue aqui pela primeira vez, o ConfigMap sreorbit-orbit-stack que outros arquivos já referenciavam. Vários CHANGEME aqui, incluindo ORBIT_CLUSTER_ID e ORBIT_STACK_URL.
30-secret.yamlO invólucro do Secret: sem chaves de dados, para que reaplicar o diretório nunca apague uma chave que você definiu por fora. Os comentários dele listam todas as chaves, inclusive as três chaves opcionais de identidade.
40/41/42/43-deployment-*.yamlOs quatro Deployments. O 41 é o orbit-api: uma réplica, porque o armazenamento de identidade dele tem um único escritor, com o diretório de dados em um emptyDir (veja "O primeiro administrador, e os dados do orbit-api" abaixo). O 43 é o engine: uma réplica, Recreate, com os dados no claim abaixo.
44-pvc-orbit-stack.yamlO PersistentVolumeClaim do engine. Contém um CHANGEME: dimensione-o para a sua retenção e defina uma StorageClass se a padrão do cluster não for a que você quer.
45-deployment-orbit-agent.yamlO agente de scrape, orbit-agent (services/rust/orbit-agent): sem consulta local, remote-write para o orbit-stack. Veja "Telemetria" abaixo.
46-deployment-orbit-state.yamlO orbit-state (services/rust/orbit-state) sob o nome, o Service e a porta do kube-state-metrics, coletado pelo agente.
47-daemonset-orbit-node.yamlO orbit-node (services/rust/orbit-node) sob o nome do node-exporter, um pod por node, no sreorbit-node. Não roda em nodes Fargate.
50-services.yamlServices do tipo ClusterIP, mais um para o kube-state-metrics (o agente não precisa de nenhum: nada o chama).
60-ingress.yamlO Ingress único.
70-poddisruptionbudgets.yamlUm PDB para o web e outro para o nocturne, os dois Deployments com mais de uma réplica.
80-networkpolicies.yamlNegação por padrão mais a lista explícita de permissões: oito objetos no total, dois deles novos para telemetria (o agente e o kube-state-metrics; outros três já existentes ganharam uma regra admitindo o agente). Contém dois CHANGEMEs: o endereço do API server, escrito para o endereço do Service do API server no k3s e agora lido por três políticas (orbit-api, o agente, o kube-state-metrics; kubectl get svc kubernetes -n default imprime o seu); e os CIDRs de node do agente, com default nas faixas privadas (estreite-os para a sua VPC ou sub-redes de node). Erre um dos dois numa CNI que impõe política e o componente afetado sobe e, depois, não consegue alcançar o que precisa.

Se o seu deploy/kubectl/ for anterior ao Adendo v0.2

Enquanto esta página é escrita, os manifestos versionados roteiam /api no Ingress direto para o orbit-api, não carregam variáveis de modo de autenticação e expõem uma porta por serviço em vez de uma porta de API mais uma de métricas; o ../status.md traz o estado atual. Confirme com:

bash
grep -q ORBIT_AUTH_MODE deploy/kubectl/20-configmaps.yaml && echo "addendum applied" || echo "needs the patch below"

Se for preciso aplicar o patch, faça todas as mudanças desta seção antes de continuar. Cada mudança acrescenta algo aos arquivos existentes; nenhuma os reescreve.

20-configmaps.yaml. Acrescente ao data: do sreorbit-web:

yaml
  ORBIT_API_URL: "http://sreorbit-orbit-api.sreorbit.svc.cluster.local:8080"

Acrescente ao data: do sreorbit-orbit-api:

yaml
  ORBIT_AUTH_MODE: "static"
  ORBIT_OIDC_ISSUER: ""
  ORBIT_OIDC_AUDIENCE: ""
  ORBIT_METRICS_ADDR: ":9090"

Acrescente ao data: do sreorbit-nocturne:

yaml
  NOCTURNE_AUTH_MODE: "static"
  NOCTURNE_OIDC_ISSUER: ""
  NOCTURNE_OIDC_AUDIENCE: ""
  NOCTURNE_METRICS_ADDR: ":9090"

Dados do Secret. O 30-secret.yaml já é entregue como um invólucro vazio; preencha-o (veja "Crie o Secret de credenciais" abaixo) em vez de editar o arquivo.

40-deployment-web.yaml. Acrescente à especificação do contêiner web, com o mínimo privilégio (apenas a única chave de que este componente precisa):

yaml
          env:
            - name: ORBIT_AUTH_TOKEN
              valueFrom:
                secretKeyRef: { name: sreorbit-secrets, key: ORBIT_AUTH_TOKEN }

41-deployment-orbit-api.yaml. Acrescente à especificação do contêiner orbit-api:

yaml
          env:
            - name: ORBIT_AUTH_TOKEN
              valueFrom:
                secretKeyRef: { name: sreorbit-secrets, key: ORBIT_AUTH_TOKEN }
            - name: NOCTURNE_AUTH_TOKEN
              valueFrom:
                secretKeyRef: { name: sreorbit-secrets, key: NOCTURNE_AUTH_TOKEN }

E acrescente uma segunda porta de contêiner tanto em 41-deployment-orbit-api.yaml quanto em 42-deployment-nocturne.yaml (o nocturne já lê o Secret inteiro pelo envFrom existente, então ele precisa apenas da porta, não de novas entradas env):

yaml
            - name: metrics
              containerPort: 9090
              protocol: TCP

50-services.yaml. Acrescente uma segunda porta aos Services sreorbit-orbit-api e sreorbit-nocturne (não ao web: o CONTRACT.md diz que o Next.js não expõe /metrics):

yaml
    - name: metrics
      port: 9090
      targetPort: metrics
      protocol: TCP

60-ingress.yaml. Substitua a lista paths: para que o web seja o único backend (Adendo v0.2: uma regra de ingress para o orbit-api deixa o parque a um salto não autenticado da internet):

yaml
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: sreorbit-web
                port:
                  number: 3000

80-networkpolicies.yaml. Duas mudanças. Primeiro, remova o bloco namespaceSelector de ingress-nginx da lista ingress: do sreorbit-orbit-api: nada mais roteia para ele a partir do ingress controller, apenas o web. Segundo, a regra existente de scrape do Prometheus tanto no sreorbit-orbit-api quanto no sreorbit-nocturne aponta para a porta 8080/8081 (a porta da API) com um seletor de label de pod entre namespaces sem restrição. Isso estava correto antes de o /metrics ter listener próprio, e não é estreito o bastante depois disso: um seletor de label de pod sem restrição de namespace permite que qualquer workload em qualquer namespace reivindique app.kubernetes.io/name: prometheus no próprio pod e o alcance. Substitua-a, nas políticas de ambos os Deployments, por uma regra delimitada ao seu namespace de monitoramento, na porta de métricas:

yaml
  ingress:
    # ...existing web/orbit-api peer rule stays...
    - from:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: monitoring   # CHANGEME: your Prometheus namespace
          podSelector:
            matchLabels:
              app.kubernetes.io/name: prometheus
      ports:
        - protocol: TCP
          port: 9090

Se você ainda não tem um Prometheus, omita este bloco em vez de deixar o antigo no lugar. Sem a regra, :9090 continua inalcançável de fora do namespace, que é o default seguro (veja security.md).

Crie o Secret de credenciais

bash
ORBIT_AUTH_TOKEN=$(openssl rand -hex 32)NOCTURNE_AUTH_TOKEN=$(openssl rand -hex 32)ORBIT_STACK_AUTH_TOKEN=$(openssl rand -hex 32) kubectl -n sreorbit create secret generic sreorbit-secrets \  --from-literal=ORBIT_AUTH_TOKEN="$ORBIT_AUTH_TOKEN" \  --from-literal=NOCTURNE_AUTH_TOKEN="$NOCTURNE_AUTH_TOKEN" \  --from-literal=ORBIT_STACK_AUTH_TOKEN="$ORBIT_STACK_AUTH_TOKEN" \  --from-literal=NOCTURNE_API_KEY="" \  --dry-run=client -o yaml | kubectl apply -f -

--dry-run=client -o yaml | kubectl apply -f - (em vez de um create puro) torna isso seguro de rodar de novo: o kubectl apply só mexe nos campos que ele possui, então uma chave que você definiu de outra forma sobrevive.

O primeiro administrador, e os dados do orbit-api

Toda página do Deck exige um usuário logado, e o orbit-api cria o primeiro na primeira inicialização (../identity.md → "O primeiro administrador"). Coloque esse administrador no Secret antes de aplicar os Deployments; as três chaves são opcionais (optional: true no 41-deployment-orbit-api.yaml):

bash
openssl rand -base64 24 > admin-password && chmod 600 admin-passwordVERIFIER="$(node apps/web/scripts/hash-password.mjs < admin-password)"kubectl -n sreorbit patch secret sreorbit-secrets --type merge \  -p "{\"stringData\":{\"ORBIT_ADMIN_USER\":\"admin\",\"ORBIT_ADMIN_PASSWORD_VERIFIER\":\"$VERIFIER\",\"ORBIT_SESSION_SECRET\":\"$(openssl rand -base64 48 | tr -d '\n')\"}}"unset VERIFIER

Sem o par do administrador, o orbit-api registra no log um código de configuração de uso único (kubectl -n sreorbit logs deploy/sreorbit-orbit-api | grep setup_code), que a página /login aceita para criar o primeiro administrador.

O 41-deployment-orbit-api.yaml monta o ORBIT_DATA_DIR (/var/lib/sreorbit, definido no 20-configmaps.yaml) em um emptyDir: cada usuário, sessão, dashboard salvo e linha de auditoria some junto com o pod, inclusive a cada rollout. Para mantê-los, crie um claim ReadWriteOnce chamado sreorbit-orbit-api-data do mesmo jeito que o 44-pvc-orbit-stack.yaml faz, troque o emptyDir do volume data por persistentVolumeClaim: {claimName: sreorbit-orbit-api-data} e defina o strategy.type do Deployment como Recreate. Mantenha replicas: 1 em qualquer caso: o armazenamento tem um único escritor. Faça backup do claim como o ../operations.md descreve.

O próprio login do web

O web autentica com HTTP Basic cada requisição que atende: páginas, o Deck, toda chamada /api/*, incluindo os streams de SSE, e os arquivos estáticos. Só o GET /healthz fica isento: o proxy responde a ele sozinho, 200 {"status":"ok"}, antes de a autenticação ou o roteamento de idioma rodarem. O 40-deployment-web.yaml liga isso de forma incondicional, sem um toggle como o components.web.auth.enabled do chart Helm; edite esse arquivo você mesmo se precisar desligar isso:

yaml
          env:
            - name: WEB_AUTH_MODE
              value: "basic"
            - name: WEB_AUTH_USER
              valueFrom:
                secretKeyRef: { name: sreorbit-secrets, key: WEB_AUTH_USER }
            - name: WEB_AUTH_VERIFIER
              valueFrom:
                secretKeyRef: { name: sreorbit-secrets, key: WEB_AUTH_VERIFIER }

As duas chaves são obrigatórias (sem optional: true), então um pod que não tiver uma delas fica em CreateContainerConfigError em vez de servir sem credencial nenhuma.

Gere uma senha e faça o hash dela; o web e os manifestos só enxergam o hash:

bash
openssl rand -base64 24 > web-password && chmod 600 web-passwordWEB_AUTH_VERIFIER="$(node apps/web/scripts/hash-password.mjs < web-password)"

O hash-password.mjs lê a senha só via stdin, nunca como argumento de linha de comando; recusa um terminal interativo; remove uma quebra de linha final; e recusa qualquer coisa com menos de 15 caracteres. Ele imprime um verificador PBKDF2, nunca a própria senha: pbkdf2-sha256$<iterations>$<base64 salt>$<base64 hash>, PBKDF2-HMAC-SHA256 com um salt aleatório de 16 bytes e um hash de 32 bytes, nas 600.000 iterações que o script grava (o formato do verificador aceita qualquer valor a partir de 210.000).

Acrescente as duas chaves ao Secret, junto com as quatro acima:

bash
kubectl -n sreorbit create secret generic sreorbit-secrets \  --from-literal=ORBIT_AUTH_TOKEN="$ORBIT_AUTH_TOKEN" \  --from-literal=NOCTURNE_AUTH_TOKEN="$NOCTURNE_AUTH_TOKEN" \  --from-literal=ORBIT_STACK_AUTH_TOKEN="$ORBIT_STACK_AUTH_TOKEN" \  --from-literal=NOCTURNE_API_KEY="" \  --from-literal=WEB_AUTH_USER="admin" \  --from-literal=WEB_AUTH_VERIFIER="$WEB_AUTH_VERIFIER" \  --dry-run=client -o yaml | kubectl apply -f -

Ativando isso em uma instalação que já está rodando: rodar de novo o comando acima só com as duas novas flags --from-literal derrubaria as quatro chaves existentes em vez de somar a elas: o kubectl apply só mexe nos campos presentes no manifesto que você fornece, e as quatro que ficaram de fora desapareceriam junto. Acrescente as duas chaves com patch, que mexe apenas nas chaves que você nomeia, e então reinicie o Deployment; o env é lido uma única vez, na largada do contêiner, então mais nada percebe essa mudança:

bash
VERIFIER="$(node apps/web/scripts/hash-password.mjs < /path/to/web-password)"kubectl -n sreorbit patch secret sreorbit-secrets --type merge --dry-run=server \  -p "{\"stringData\":{\"WEB_AUTH_USER\":\"admin\",\"WEB_AUTH_VERIFIER\":\"$VERIFIER\"}}"kubectl -n sreorbit patch secret sreorbit-secrets --type merge \  -p "{\"stringData\":{\"WEB_AUTH_USER\":\"admin\",\"WEB_AUTH_VERIFIER\":\"$VERIFIER\"}}"unset VERIFIERkubectl -n sreorbit rollout restart deploy/sreorbit-webkubectl -n sreorbit rollout status deploy/sreorbit-web --timeout=180s

As sondas de startup, liveness e readiness do web têm todas como alvo GET /healthz (saindo de /, que agora exige a credencial). Um curl simples ali, sem -u, ainda distingue o caminho da sonda de tudo o mais.

Mude antes de aplicar, sempre

O host: sreorbit.example.com e o secretName: sreorbit-tls do 60-ingress.yaml e o ORBIT_CORS_ORIGINS: "https://sreorbit.example.com" do 20-configmaps.yaml são os três placeholders CHANGEME, e os três precisam concordar entre si (o esquema e o host da origem de CORS precisam bater com o que o Ingress serve, ou o navegador rejeita as chamadas de mesma origem do próprio web). Edite estes três valores no lugar antes de aplicar. Este caminho não tem mecanismo de override como o --set do Helm: um manifesto puro é o arquivo de values.

Instale

bash
kubectl apply -f deploy/kubectl/00-namespace.yamlkubectl apply --dry-run=server -f deploy/kubectl/

Leia a saída do dry-run. Então aplique de verdade:

bash
kubectl apply -f deploy/kubectl/

Como é uma instalação saudável

bash
kubectl -n sreorbit get pods,svc,ingress,pdb,networkpolicykubectl -n sreorbit rollout status deploy/sreorbit-web --timeout=180skubectl -n sreorbit rollout status deploy/sreorbit-orbit-api --timeout=180skubectl -n sreorbit rollout status deploy/sreorbit-nocturne --timeout=180s

Todo pod em Running/Ready, o Ingress mostrando o seu hostname e (assim que a sua CNI impuser NetworkPolicy; veja security.md) oito objetos NetworkPolicy existindo: negação por padrão, liberação de DNS, um para cada um dos quatro componentes de aplicação, um para o agente e um para o kube-state-metrics.

Verifique

bash
kubectl -n sreorbit port-forward svc/sreorbit-orbit-api 8080:8080 &curl -fsS localhost:8080/healthzcurl -fsS localhost:8080/readyzcurl -fsS -H "Authorization: Bearer $ORBIT_AUTH_TOKEN" localhost:8080/api/v1/auth/statekill %1

A última chamada prova que o bearer está certo (401 caso contrário) e diz se o primeiro administrador já existe ("setupRequired":false). Todas as outras rotas também exigem uma sessão: ../identity.md → "Entrar pelo shell". Este caminho não traz a loja de demonstração; o APM mostra os traces que os seus próprios serviços enviam (../apm.md).

Telemetria

Os mesmos três componentes do chart Helm, com os engines orbit padrão dele (o orbit-agent, o orbit-state no lugar do kube-state-metrics e o orbit-node no lugar do node-exporter), só que como manifestos estáticos em vez de gerados a partir de um template. Sem parâmetro de ajuste aqui: quem não quiser um componente apaga os arquivos correspondentes (45/46/47-*.yaml, as ServiceAccounts em 10-, o RBAC em 17-rbac-telemetry.yaml e as regras em 80-networkpolicies.yaml). Uma vez instalados, eles não dependem de nada que já exista no cluster: nem Prometheus, nem kube-state-metrics, nem node-exporter, nem a CRD do ServiceMonitor, nem um namespace de monitoramento. As imagens upstream continuam ao lado deles como 45-deployment-prometheus-agent.yaml.example, 46-deployment-kube-state-metrics.yaml.example e 47-daemonset-node-exporter.yaml.example, que o kubectl apply -f deploy/kubectl/ ignora; o cabeçalho de cada arquivo traz os comandos para colocá-lo no lugar.

O agente só faz scrape e remote-write (sem consulta local, só WAL) para o orbit-stack, apresentando o ORBIT_STACK_AUTH_TOKEN vindo do sreorbit-secrets; este caminho sempre sobe o orbit-stack com autenticação estática. O job de scrape cadvisor do agente valida o certificado de serviço do kubelet contra a CA do cluster (ORBIT_AGENT_KUBELET_INSECURE_SKIP_VERIFY: "false" no 45-deployment-orbit-agent.yaml); inverta isso só se os seus nodes apresentarem um certificado de kubelet autoassinado.

Três placeholders para trocar antes de aplicar:

  • O endereço do API server em 80-networkpolicies.yaml, com default no endereço do Service do API server no k3s e agora lido por três políticas (orbit-api, o agente, o kube-state-metrics).
  • Os CIDRs de node do agente, na sua própria NetworkPolicy, com default nas faixas privadas, o que cobre EKS e k3d; estreite-os para a sua VPC ou sub-redes de node.
  • O label de cluster, ORBIT_AGENT_CLUSTER no 45-deployment-orbit-agent.yaml; mantenha-o igual ao ORBIT_CLUSTER_ID do 20-configmaps.yaml.

O DaemonSet do node-exporter vive no seu próprio namespace, sreorbit-node (criado por 01-namespace-node.yaml, com privileged de Pod Security porque ele monta caminhos do host somente leitura), então ele não aparece na checagem de costume:

bash
kubectl -n sreorbit-node get pods

Confirme que o engine está recebendo amostras:

bash
kubectl -n sreorbit port-forward svc/sreorbit-orbit-stack 8082:8082 &curl -fsS localhost:8082/api/v1/query --data-urlencode 'query=count by (job) ({__name__=~".+"})' \  -H "Authorization: Bearer $ORBIT_STACK_AUTH_TOKEN"

Cada job deve aparecer com contagem maior que zero: cadvisor, kube-state-metrics, node-exporter, sreorbit e, com o agente do Prometheus, kubelet.

Atualize

Edite a tag da imagem em 40/41/42-deployment-*.yaml (ou use kubectl set image) e reaplique:

bash
kubectl set image deployment/sreorbit-web web=ghcr.io/sreorbit/web:NEW_TAG -n sreorbitkubectl set image deployment/sreorbit-orbit-api orbit-api=ghcr.io/sreorbit/orbit-api:NEW_TAG -n sreorbitkubectl set image deployment/sreorbit-nocturne nocturne=ghcr.io/sreorbit/nocturne:NEW_TAG -n sreorbitkubectl -n sreorbit rollout status deploy/sreorbit-web --timeout=180s

Ou edite os manifestos e rode kubectl apply -f deploy/kubectl/ de novo; os dois produzem a mesma atualização gradual (maxUnavailable: 0, maxSurge: 1, então a capacidade nunca cai para o web e o nocturne; o orbit-api e o engine rodam uma réplica cada, então, no caso deles, há uma breve interrupção).

Faça rollback

bash
kubectl -n sreorbit rollout undo deploy/sreorbit-webkubectl -n sreorbit rollout undo deploy/sreorbit-orbit-apikubectl -n sreorbit rollout undo deploy/sreorbit-nocturnekubectl -n sreorbit rollout status deploy/sreorbit-web --timeout=180s

O kubectl rollout undo volta para o template de pod do ReplicaSet anterior, que é reprodutível apenas na medida em que a referência de imagem dentro dele for: uma tag pura pode ter se movido por baixo de você entre um rollout e outro. Use um digest (web@sha256:...) nos manifestos em vez de uma tag se o rollback byte a byte importa para você; o kubectl puro não tem um mecanismo de overlay separado para isso como o digests.yaml do Helm tem, então o digest precisa ser o valor versionado (ou passado por kubectl set image) desde o começo.

Desinstale de forma limpa

bash
kubectl delete -f deploy/kubectl/70-poddisruptionbudgets.yamlkubectl delete -f deploy/kubectl/60-ingress.yamlkubectl delete -f deploy/kubectl/50-services.yamlkubectl delete -f deploy/kubectl/40-deployment-web.yaml -f deploy/kubectl/41-deployment-orbit-api.yaml -f deploy/kubectl/42-deployment-nocturne.yamlkubectl delete -f deploy/kubectl/80-networkpolicies.yamlkubectl delete -f deploy/kubectl/30-secret.yamlkubectl delete -f deploy/kubectl/20-configmaps.yaml -f deploy/kubectl/10-serviceaccounts.yamlkubectl delete -f deploy/kubectl/00-namespace.yaml

Ou rode kubectl delete namespace sreorbit, que é mais rápido e remove tudo em um passo (não há anotação resource-policy: keep neste caminho como o chart Helm opcionalmente coloca no próprio Secret, então nada sobrevive a um delete de namespace; guarde ORBIT_AUTH_TOKEN/NOCTURNE_AUTH_TOKEN em algum lugar antes, se for precisar deles de novo).

Uma nota sobre o kustomize

Nenhum kustomization.yaml é versionado em deploy/kubectl/, de propósito: um arquivo desses ali faz o kubectl apply -f deploy/kubectl/ falhar (o kubectl tenta aplicá-lo como um recurso bruto), e colocá-lo em um subdiretório também não funciona: o load restrictor do kustomize se recusa a ler arquivos acima da própria raiz. Se você quer overlays, gere a base no lugar e use -k daí em diante:

bash
(cd deploy/kubectl && kustomize create --autodetect)kubectl apply -k deploy/kubectl/

Para onde ir em seguida

  • Cada variável citada acima: ../configuration.md.
  • O raciocínio por trás do estreitamento de NetworkPolicy acima, e o que ele impõe e não impõe no seu cluster: ../security.md.
  • Helm permitido, afinal: helm.md, com menos manifesto para manter à mão e o único rollback reprodutível por construção.