The secrets reef
Every command of the secrets reef: vaults, and the secrets in them, encrypted before they leave the machine
O reef secrets
Todos os comandos do reef secrets: vaults, e os secrets dentro deles, cifrados antes de saírem da máquina
The source of truth for the commands of the secrets reef (#477). Every command here is built: the CLI builds them itself (cli/src/nereus/commands/secrets.py, #530 (the Vault and Secret kinds of the secrets reef)), and the outputs are what they print, recorded on a throwaway cluster by make scene.
A value never leaves the machine in the clear: the CLI encrypts it with the public key of the vault's Mandate, and only the Nereid behind that Mandate can open it. The cluster holds envelopes; get and list show the names of the keys, never a value.
A fonte da verdade dos comandos do reef secrets (#477). Todo comando aqui está pronto: o próprio CLI os constrói (cli/src/nereus/commands/secrets.py, #530 (os kinds Vault e Secret do reef secrets)), e as saídas são o que eles imprimem, gravadas num cluster descartável pelo make scene.
Um valor nunca sai da máquina às claras: o CLI o cifra com a chave pública do Mandate do vault, e só a Nereid por trás desse Mandate consegue abri-lo. O cluster guarda envelopes; get e list mostram os nomes das chaves, nunca um valor.
Three kinds: where secrets are kept, the secrets themselves, and where they are used
- Vault: where secrets are kept, the Mandate whose Nereid keeps them and the namespaces allowed to bind them ·
nereus secrets vault - Secret: keys and their encrypted values, in a vault, named
<vault>/<secret>·nereus secrets - SecretBinding: a Kubernetes Secret made from a secret, in the namespace of whoever asks for it ·
nereus secrets binding
Três kinds: onde os secrets ficam, os próprios secrets, e onde eles são usados
- Vault: onde os secrets ficam, o Mandate cuja Nereid os guarda e os namespaces que podem vinculá-los ·
nereus secrets vault - Secret: chaves e os seus valores cifrados, num vault, com o nome
<vault>/<secret>·nereus secrets - SecretBinding: um Secret do Kubernetes feito de um secret, no namespace de quem o pede ·
nereus secrets binding
The three kinds live in secrets.getnereus.dev/v1alpha1: Vault and Secret in the namespace Nereus runs in, a SecretBinding in its consumer's namespace. Every kind takes create, apply, list, get and delete (ADR 0013, command conventions: create builds from flags and refuses an existing object, apply takes only files or folders), and every change takes --dry-run.
A Vault's Mandate is spec.mandate, or the reef's default Mandate when absent, and it never changes: the secrets already in it are encrypted with its key. --allow-namespace lists the namespaces a binding of the vault may write a Kubernetes Secret to; absent, Nereus's own.
Secret is the reef's default kind: nereus secrets create is nereus secrets secret create. A secret is named <vault>/<secret>, its object <vault>.<secret>; a bare name is in the vault --vault names, or the vault default.
Os três kinds vivem em secrets.getnereus.dev/v1alpha1: Vault e Secret no namespace onde o Nereus roda, um SecretBinding no namespace de quem o consome. Todo kind aceita create, apply, list, get e delete (ADR 0013, convenções de comando: o create monta a partir de flags e recusa um objeto que já existe, o apply recebe só arquivos ou pastas), e toda mudança aceita --dry-run.
O Mandate de um Vault é o spec.mandate, ou o Mandate padrão do reef quando ausente, e ele nunca muda: os secrets que já estão nele foram cifrados com a sua chave. O --allow-namespace lista os namespaces onde um binding do vault pode escrever um Secret do Kubernetes; ausente, o do próprio Nereus.
Secret é o kind padrão do reef: nereus secrets create é nereus secrets secret create. Um secret tem o nome <vault>/<secret>, e o seu objeto <vault>.<secret>; um nome sozinho fica no vault que o --vault nomeia, ou no vault default.
What comes before the first secret?
O que vem antes do primeiro secret?
The profile brings the secrets reef ready to use, with its key and the vault default
O profile traz o reef secrets pronto para uso, com a sua chave e o vault default
# Install core and the internal developer platform profile$ nereus init \ --profile internal-developer-platform✓ reef secrets 0.0s core/reefs/secrets 0.1.0 created (secrets.getnereus.dev/v1alpha1: secrets, secretbindings, vaults)✓ nereid openbao 21.5s core/nereids/openbao created, Ready✓ mandate default 0.0s core/mandates/default created (reef: secrets, nereid: openbao, default)✓ public key 5.0s rsa-4096, SHA256:yJi61pETATOGjDo6b6B2y5+V8jiPPDruqOUYp2CtPFs, version 1✓ vault default 0.1s secrets/vaults/default created (mandate: default)
These are the secrets reef's lines of init; the other steps are in What init does (docs/reference/init.md).
The openbao Nereid runs OpenBao next to it: it creates an RSA key in OpenBao's Transit engine and publishes its public key in the status of the Mandate default, which init waits for and checks against its fingerprint. OpenBao keeps its key and values on the volume openbao-data and unseals itself, so a restart changes neither; only a lost volume makes a new key, with the next version. The vault default is where a secret goes when no vault is named.
openbao serves the reef's kinds (#531): it answers each Vault and Secret, and keeps every secret's values in OpenBao's KV engine. Every output from here on comes from it.
Estas são as linhas do reef secrets no init; os outros passos estão em What init does (docs/reference/init.md).
A Nereid openbao roda o OpenBao ao lado, em modo dev: ela cria uma chave RSA no engine Transit do OpenBao e publica a sua chave pública no status do Mandate default, que o init espera e confere pela sua fingerprint. O modo dev guarda tudo em memória: um restart cria uma chave nova, com a próxima version. O vault default é para onde vai um secret quando nenhum vault é nomeado.
A openbao serve os kinds do reef (#531): ela responde a cada Vault e Secret, e guarda os valores de cada secret no engine KV do OpenBao. Toda saída daqui em diante vem dela.
How does a value reach the cluster without being seen?
Como um valor chega ao cluster sem ser visto?
A secret is encrypted on your machine, before it leaves it
Um secret é cifrado na sua máquina, antes de sair dela
# Two keys, each from an environment variable$ nereus secrets create google-oauth \ --from-env GOOGLE_CLIENT_ID \ --from-env GOOGLE_CLIENT_SECRET✓ secrets/vaults/default/secrets/google-oauth created (key SHA256:GQ8TrJ9h6ZrNYHItBycWK+tXkURjowfJWcjEyabRIKI)Stored encrypted; a Kubernetes Secret is made only when a binding asks for it (#532). Next steps: nereus secrets get default/google-oauth
Envelope encryption, on the client: each value gets a fresh AES-256-GCM data key and a 12-byte nonce, and the data key is wrapped with RSA-OAEP-256 by the public key the vault's Mandate publishes in its status; the ciphertext is bound to <vault>.<secret>/<key>, so an envelope copied elsewhere does not open. The output names the fingerprint of that key. The cluster only ever holds the envelopes.
Values come from --from-env VAR, --from-env KEY=VAR or --from-file KEY=PATH, never from a flag's value, which would land in the shell's history.
No Kubernetes Secret is made yet: a binding asks for one, with #532 (a binding writes a secret into a namespace).
Envelope encryption, no cliente: cada valor ganha uma data key AES-256-GCM nova e um nonce de 12 bytes, e a data key é embrulhada com RSA-OAEP-256 pela chave pública que o Mandate do vault publica no seu status; o ciphertext fica preso a <vault>.<secret>/<key>, e um envelope copiado para outro lugar não abre. A saída nomeia a fingerprint dessa chave. O cluster só guarda os envelopes.
Os valores vêm de --from-env VAR, --from-env KEY=VAR ou --from-file KEY=PATH, nunca do valor de uma flag, que ficaria no histórico do shell.
Nenhum Secret do Kubernetes é criado ainda: um binding pede um, com o #532 (um binding escreve um secret num namespace).
Creating it again is refused, with how to change it
Criar de novo é recusado, com o jeito de mudá-lo
# Create it again$ nereus secrets create google-oauth \ --from-env GOOGLE_CLIENT_ID✗ secrets/vaults/default/secrets/google-oauth already exists. To change it, write it as a file, then apply the file: nereus secrets create google-oauth --from-env GOOGLE_CLIENT_ID --dry-run --output yaml > google-oauth.yaml nereus secrets apply --from-file google-oauth.yaml
create builds from flags and refuses an existing object; apply takes only files or folders (ADR 0013). The refusal prints the two commands that change the secret, with the flags given ([nereus secrets apply](#apply) shows them).
O create monta a partir de flags e recusa um objeto que já existe; o apply recebe só arquivos ou pastas (ADR 0013). A recusa imprime os dois comandos que mudam o secret, com as flags dadas (o [nereus secrets apply](#apply) os mostra).
A key can come from a file, such as a private key
Uma chave pode vir de um arquivo, como uma chave privada
# A private key from a file, and an id from the environment$ nereus secrets create github-app \ --vault default \ --from-file private-key=key.pem \ --from-env APP_ID✓ secrets/vaults/default/secrets/github-app created (key SHA256:GQ8TrJ9h6ZrNYHItBycWK+tXkURjowfJWcjEyabRIKI)Stored encrypted; a Kubernetes Secret is made only when a binding asks for it (#532). Next steps: nereus secrets get default/github-app
--from-file KEY=PATH takes the file's bytes as the value of KEY, here private-key; --from-env APP_ID keeps the variable's name as the key. --vault default names the vault, the same as default/github-app.
O --from-file KEY=PATH usa os bytes do arquivo como o valor de KEY, aqui private-key; o --from-env APP_ID mantém o nome da variável como chave. O --vault default nomeia o vault, o mesmo que default/github-app.
Apply takes a folder of secrets, and the second apply changes nothing
O apply recebe uma pasta de secrets, e o segundo apply não muda nada
# Write each secret as a file$ nereus secrets create google-oauth \ --from-env GOOGLE_CLIENT_ID \ --from-env GOOGLE_CLIENT_SECRET \ --dry-run \ --output yaml > secrets/google-oauth.yaml # The second one$ nereus secrets create github-app \ --from-file private-key=key.pem \ --from-env APP_ID \ --dry-run \ --output yaml > secrets/github-app.yaml # Apply the folder$ nereus secrets apply \ --from-file secrets✓ secrets/vaults/default/secrets/github-app configured✓ secrets/vaults/default/secrets/google-oauth configured Next steps: nereus secrets list # Apply it again$ nereus secrets apply \ --from-file secretssecrets/vaults/default/secrets/github-app unchangedsecrets/vaults/default/secrets/google-oauth unchanged Next steps: nereus secrets list
create --dry-run --output yaml writes the secret as apply --from-file takes it, its values already encrypted: the file holds envelopes, never a value. Each run makes a fresh data key and nonce, so the new files differ from what the cluster holds, and the first apply reports configured; the same files again report unchanged.
apply reports created when the secret is new, configured when the file changes it, unchanged when it already holds. A file made with a key that is no longer the vault's is reported by the Nereid in the status (KeyMismatch): write it again.
O create --dry-run --output yaml escreve o secret como o apply --from-file o recebe, com os valores já cifrados: o arquivo guarda envelopes, nunca um valor. Cada execução cria uma data key e um nonce novos, então os arquivos novos diferem do que o cluster guarda, e o primeiro apply reporta configured; os mesmos arquivos de novo reportam unchanged.
O apply reporta created quando o secret é novo, configured quando o arquivo o muda, unchanged quando ele já vale. Um arquivo feito com uma chave que não é mais a do vault é reportado pela Nereid no status (KeyMismatch): escreva-o de novo.
The list shows every secret with its keys, never a value
A lista mostra todo secret com as suas chaves, nunca um valor
# Every secret$ nereus secrets listVAULT NAME KEYS STATUS AGEdefault github-app APP_ID, +1 Ready 4sdefault google-oauth GOOGLE_CLIENT_ID, +1 Ready 5s
KEYS shows the first key and how many more; get lists them all. --vault keeps one vault's secrets, and --output yaml prints the objects with the names of their keys instead of the envelopes.
KEYS mostra a primeira chave e quantas mais há; o get lista todas. O --vault mantém os secrets de um vault só, e o --output yaml imprime os objetos com os nomes das suas chaves no lugar dos envelopes.
One secret, by its vault and name
Um secret, pelo seu vault e o seu nome
# One secret$ nereus secrets get default/google-oauthVault defaultName google-oauthKeys GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRETVersion 2Location openbao: secret/nereus/default/google-oauthBindings -Status ReadyAge 10s
Version is the Tool's version of the value, written by the Nereid: each apply that changed the secret is a new version in OpenBao, here the second. Location is where the Tool keeps it, secret/nereus/<vault>/<secret> in OpenBao's KV engine. Bindings lists what writes the secret into a namespace ([nereus secrets binding](#binding-create)); none yet.
Version é a versão do valor na ferramenta, escrita pela Nereid: cada apply que mudou o secret é uma nova versão no OpenBao, aqui a segunda. Location é onde a ferramenta o guarda, secret/nereus/<vault>/<secret> no engine KV do OpenBao. Bindings lista o que escreve o secret num namespace (o [nereus secrets binding](#binding-create)); nenhum ainda.
As YAML, the object shows the names of its keys instead of the envelopes
Em YAML, o objeto mostra os nomes das suas chaves no lugar dos envelopes
# The object, without its values$ nereus secrets get google-oauth \ --output yamlapiVersion: secrets.getnereus.dev/v1alpha1kind: Secretmetadata: name: default.google-oauth namespace: nereus-systemspec: vault: default keys: - GOOGLE_CLIENT_ID - GOOGLE_CLIENT_SECRETstatus: location: 'openbao: secret/nereus/default/google-oauth' mandate: default nereid: openbao phase: Ready version: '2'
Abridged: the output also prints the metadata kubectl adds (timestamps, the finalizer, labels, resourceVersion, uid) and, in the status, the Ready condition, the keys again, observedGeneration, the steps and updatedAt; every line shown is printed as is.
The object's name is <vault>.<secret>, and a bare name is in the vault default. spec.data, the envelopes, is replaced by spec.keys; the steps say what openbao did: unwrap (Transit unwrapped each data key), decrypt (each value opened in memory, bound to its place) and store ("Stored the 2 keys as version 2 of secret/nereus/default/google-oauth in OpenBao."). No value is in the status, the Nereid's log or the cluster.
Resumida: a saída também imprime os metadados que o kubectl acrescenta (timestamps, o finalizer, labels, resourceVersion, uid) e, no status, a condition Ready, as chaves de novo, observedGeneration, os steps e updatedAt; toda linha mostrada é impressa como está.
O nome do objeto é <vault>.<secret>, e um nome sozinho fica no vault default. O spec.data, os envelopes, é trocado pelo spec.keys; os steps dizem o que a openbao fez: unwrap (o Transit abriu cada data key), decrypt (cada valor aberto em memória, preso ao seu lugar) e store ("Stored the 2 keys as version 2 of secret/nereus/default/google-oauth in OpenBao."). Nenhum valor está no status, no log da Nereid ou no cluster.
Where are secrets kept, and who may bind them?
Onde os secrets ficam, e quem pode vinculá-los?
The list shows every vault, its Nereid and how many secrets it holds
A lista mostra todo vault, a sua Nereid e quantos secrets ele guarda
# Every vault$ nereus secrets vault listNAME NEREID NAMESPACES SECRETS STATUS AGEdefault openbao nereus-system 2 Ready 4m
NEREID is the Nereid of the vault's Mandate, here openbao, through the reef's default Mandate default. NAMESPACES are the namespaces a binding of the vault may write to: with no --allow-namespace, Nereus's own.
NEREID é a Nereid do Mandate do vault, aqui a openbao, pelo Mandate padrão do reef, default. NAMESPACES são os namespaces onde um binding do vault pode escrever: sem --allow-namespace, o do próprio Nereus.
A vault for a team, with the namespaces allowed to bind its secrets
Um vault para um time, com os namespaces que podem vincular os seus secrets
# A vault the identity and tools namespaces may bind$ nereus secrets vault create team-a \ --allow-namespace identity \ --allow-namespace tools✓ secrets/vaults/team-a created Next steps: nereus secrets create <secret> --vault team-a --from-env <VAR>
--mandate picks the vault's Mandate, so its Nereid and its key; absent, the reef's default. It never changes: the secrets in the vault are encrypted with its key. Like a secret, vault create refuses an existing vault and points to vault apply --from-file.
O --mandate escolhe o Mandate do vault, portanto a sua Nereid e a sua chave; ausente, o padrão do reef. Ele nunca muda: os secrets do vault são cifrados com a sua chave. Como um secret, o vault create recusa um vault que já existe e aponta para o vault apply --from-file.
A vault that holds secrets is refused, with what to delete first
Um vault que guarda secrets é recusado, com o que apagar antes
# The vault default still holds two secrets$ nereus secrets vault delete default✗ secrets/vaults/default holds secrets github-app, google-oauth. Delete them first: nereus secrets delete default/github-app nereus secrets delete default/google-oauth
Nothing is left in a vault that is gone: the refusal names the secrets it holds and the commands that delete them ([nereus secrets delete](#delete)).
Nada fica num vault que saiu: a recusa nomeia os secrets que ele guarda e os comandos que os apagam (o [nereus secrets delete](#delete)).
A secret goes by its full name, or by its name in the vault default
Um secret sai pelo seu nome completo, ou pelo seu nome no vault default
# By vault and name$ nereus secrets delete default/google-oauth✓ secrets/vaults/default/secrets/google-oauth deleted Next steps: nereus secrets list # A bare name is in the vault default$ nereus secrets delete github-app✓ secrets/vaults/default/secrets/github-app deleted Next steps: nereus secrets list
--dry-run says what would be deleted. openbao destroys every version of the secret in OpenBao, then its metadata, and only then lets the secret go: nothing is left behind.
O --dry-run diz o que seria apagado. A openbao destrói toda versão do secret no OpenBao, depois os seus metadados, e só então deixa o secret ir: nada fica para trás.
An empty vault goes
Um vault vazio sai
# Delete the vault team-a$ nereus secrets vault delete team-a✓ secrets/vaults/team-a deleted Next steps: nereus secrets vault list
A vault holding secrets is refused ([nereus secrets vault delete default](#vault-delete-held)); an empty one goes at once. --dry-run says what would be deleted.
Um vault que guarda secrets é recusado ([nereus secrets vault delete default](#vault-delete-held)); um vazio sai na hora. O --dry-run diz o que seria apagado.
How does a pod read a secret?
Como um pod lê um secret?
A binding makes a Kubernetes Secret from a secret, in a namespace the vault allows
Um binding faz um Secret do Kubernetes a partir de um secret, num namespace que o vault permite
# Keycloak, in the namespace identity, reads the Google client under its own key names$ nereus secrets binding create keycloak-google \ --secret default/google-oauth \ --namespace identity \ --key client-id=GOOGLE_CLIENT_ID \ --key client-secret=GOOGLE_CLIENT_SECRET✓ secrets/vaults/default/secrets/google-oauth/secretbindings/identity/keycloak-google createdSecret keycloak-google ready in namespace identity. Next steps: nereus secrets binding get keycloak-google --namespace identity
A Kubernetes Secret exists only when a binding asks for it (#532): the SecretBinding lives in the consumer's namespace, and the Nereid of the vault's Mandate reads the secret's current version from OpenBao and writes the Secret keycloak-google there, owned by the binding and labelled with the binding, the secret and the vault. --key name=KEY renames a key; without one, every key under its own name. --secret-name names the Kubernetes Secret, the binding's name by default.
The vault decides where: its spec.allowedNamespaces must hold the namespace (here identity and tools, added with vault apply), since whoever can create a binding in a namespace can read what the vault allows there. The CLI waits for Ready; --wait=false returns at once, --dry-run shows the object.
Um Secret do Kubernetes só existe quando um binding o pede (#532): o SecretBinding vive no namespace de quem o consome, e a Nereid do Mandate do vault lê a versão atual do secret no OpenBao e escreve ali o Secret keycloak-google, de dono o binding e com os labels do binding, do secret e do vault. O --key nome=CHAVE renomeia uma chave; sem ele, toda chave com o seu próprio nome. O --secret-name dá nome ao Secret do Kubernetes, o do binding por padrão.
O vault decide onde: o seu spec.allowedNamespaces precisa ter o namespace (aqui identity e tools, somados com vault apply), já que quem pode criar um binding num namespace pode ler o que o vault permite ali. O CLI espera o Ready; o --wait=false volta na hora, o --dry-run mostra o objeto.
A namespace the vault does not allow, or a key the secret does not have, is refused before anything is written
Um namespace que o vault não permite, ou uma chave que o secret não tem, é recusado antes de qualquer escrita
# The vault default does not allow the namespace payments$ nereus secrets binding create payments \ --secret default/google-oauth \ --namespace payments✗ secrets/vaults/default does not allow namespace payments (it allows: nereus-system, identity, tools). Allow it: write the vault as a file, add payments to spec.allowedNamespaces, then apply the file: nereus secrets vault get default --output yaml > default.yaml nereus secrets vault apply --from-file default.yaml # The secret has no key NOT_A_KEY$ nereus secrets binding create missing \ --secret default/google-oauth \ --namespace identity \ --key x=NOT_A_KEY✗ secrets/vaults/default/secrets/google-oauth has no key NOT_A_KEY (it has: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET)
The CLI checks what it can see first: the vault's namespaces, the secret's keys, the secret itself. A binding written by other means (a chart, kubectl) gets the same answers from the Nereid, as its Ready reason: NamespaceNotAllowed, KeyMissing, SecretMissing, or WriteFailed when a Secret of that name exists and is not the binding's.
O CLI confere primeiro o que consegue ver: os namespaces do vault, as chaves do secret, o próprio secret. Um binding escrito por outro meio (um chart, o kubectl) recebe as mesmas respostas da Nereid, como a razão do seu Ready: NamespaceNotAllowed, KeyMissing, SecretMissing, ou WriteFailed quando existe um Secret com esse nome que não é do binding.
A chart asks for its secret with a SecretBinding among its templates
Um chart pede o seu secret com um SecretBinding entre os seus templates
# The template of test/charts/binding-demo$ cat test/charts/binding-demo/templates/secretbinding.yamlapiVersion: {{ .Values.apiGroup }}/v1alpha1kind: SecretBindingmetadata: name: {{ .Release.Name }} namespace: {{ .Release.Namespace }} labels: {{- include "binding-demo.labels" . | nindent 4 }}spec: secret: {{ required "secret is <vault>/<secret>" .Values.secret | quote }} # Installed with Helm, into the namespace tools$ helm install binding-demo test/charts/binding-demo \ --namespace tools \ --create-namespace \ --wait
No CLI and no Nereus code in the chart: a SecretBinding is a template like any other, so helm uninstall removes it, and with it the Kubernetes Secret. The Nereid reads the chart's name from its Helm labels and shows it as who asked (chart binding-demo).
Nem CLI nem código do Nereus no chart: um SecretBinding é um template como qualquer outro, então o helm uninstall o remove, e com ele o Secret do Kubernetes. A Nereid lê o nome do chart nos seus labels do Helm e o mostra como quem pediu (chart binding-demo).
Every binding, with who asked for it
Todo binding, com quem o pediu
# In every namespace$ nereus secrets binding listNAME SECRET NAMESPACE FOR STATUS AGEkeycloak-google default/google-oauth identity system:admin Ready 12sbinding-demo default/google-oauth tools chart binding-demo Ready 4s
FOR is who asked: a release (release/releases/<name>), a chart (chart <name>), or the person who ran the CLI, which writes the user Kubernetes names in the annotation core.getnereus.dev/created-by. --namespace narrows the list to one namespace.
FOR é quem pediu: uma release (release/releases/<nome>), um chart (chart <nome>), ou a pessoa que rodou o CLI, que escreve o usuário que o Kubernetes nomeia na anotação core.getnereus.dev/created-by. O --namespace restringe a lista a um namespace.
A secret says where it is used, and is not deleted while it is
Um secret diz onde é usado, e não sai enquanto é
# The secret lists its bindings$ nereus secrets get default/google-oauthVault defaultName google-oauthKeys GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRETVersion 2Location openbao: secret/nereus/default/google-oauthBindings identity/keycloak-google by system:admin Ready tools/binding-demo by chart binding-demo ReadyStatus ReadyAge 30s # And is refused while they are there$ nereus secrets delete default/google-oauth✗ secrets/vaults/default/secrets/google-oauth is used by 2 bindings: identity/keycloak-google, tools/binding-demo. Delete them first: nereus secrets binding delete keycloak-google --namespace identity nereus secrets binding delete binding-demo --namespace tools
Nothing is left reading a secret that is gone: the refusal names the bindings and the commands that delete them, as a vault that holds secrets does ([vault delete](#vault-delete-held)).
Nada fica lendo um secret que saiu: a recusa nomeia os bindings e os comandos que os apagam, como faz um vault que guarda secrets (o [vault delete](#vault-delete-held)).
A binding goes, and its Kubernetes Secret with it
Um binding sai, e o seu Secret do Kubernetes com ele
# The binding keycloak-google$ nereus secrets binding delete keycloak-google \ --namespace identity✓ secrets/vaults/default/secrets/google-oauth/secretbindings/identity/keycloak-google deleted Next steps: nereus secrets binding list --namespace identity
The Nereid deletes the Kubernetes Secret, then lets the binding go (the finalizer secrets.getnereus.dev/cleanup), and the CLI waits until both are gone. A rotated secret reaches the Kubernetes Secret on the Nereid's next pass; a pod reading it as environment variables needs a restart to see it.
A Nereid apaga o Secret do Kubernetes, depois deixa o binding ir (o finalizer secrets.getnereus.dev/cleanup), e o CLI espera até os dois saírem. Um secret rotacionado chega ao Secret do Kubernetes na próxima passada da Nereid; um pod que o lê como variáveis de ambiente precisa de um restart para vê-lo.