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
| Requisito | Versão | Por quê |
|---|---|---|
| Kubernetes | 1.30+ | Casa com o piso do caminho do Helm; nada específico do kubectl o eleva. |
kubectl | compatível com a versão minor do seu cluster | Aplica os manifestos desta página |
| Um ingress controller | as anotações entregues pressupõem nginx | Caso contrário, troque as anotações em 60-ingress.yaml pelo equivalente de SSE do seu controller; veja troubleshooting.md. |
kustomize | opcional | Só 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:
| Arquivo | O que cria |
|---|---|
00-namespace.yaml | O namespace sreorbit, com os labels restricted de Pod Security Admission já definidos. |
01-namespace-node.yaml | O 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.yaml | Uma 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.yaml | Um 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.yaml | RBAC 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.yaml | Configuraçã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.yaml | O 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-*.yaml | Os 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.yaml | O 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.yaml | O 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.yaml | O 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.yaml | O 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.yaml | Services do tipo ClusterIP, mais um para o kube-state-metrics (o agente não precisa de nenhum: nada o chama). |
60-ingress.yaml | O Ingress único. |
70-poddisruptionbudgets.yaml | Um PDB para o web e outro para o nocturne, os dois Deployments com mais de uma réplica. |
80-networkpolicies.yaml | Negaçã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:
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:
ORBIT_API_URL: "http://sreorbit-orbit-api.sreorbit.svc.cluster.local:8080"Acrescente ao data: do sreorbit-orbit-api:
ORBIT_AUTH_MODE: "static"
ORBIT_OIDC_ISSUER: ""
ORBIT_OIDC_AUDIENCE: ""
ORBIT_METRICS_ADDR: ":9090"Acrescente ao data: do sreorbit-nocturne:
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):
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:
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):
- name: metrics
containerPort: 9090
protocol: TCP50-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):
- name: metrics
port: 9090
targetPort: metrics
protocol: TCP60-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):
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: sreorbit-web
port:
number: 300080-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:
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: 9090Se 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
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):
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 VERIFIERSem 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:
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:
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:
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:
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=180sAs 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
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:
kubectl apply -f deploy/kubectl/Como é uma instalação saudável
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=180sTodo 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
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 %1A ú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_CLUSTERno45-deployment-orbit-agent.yaml; mantenha-o igual aoORBIT_CLUSTER_IDdo20-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:
kubectl -n sreorbit-node get podsConfirme que o engine está recebendo amostras:
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:
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=180sOu 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
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=180sO 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
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.yamlOu 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:
(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.