OnCallReadyStart learning

Vault & Secrets Management: glossary

103 terms, in plain words, with where each one is taught.

-output-policy (output-policy)
A CLI flag that prints the policy a command would need, without running it. Lesson 24.11
/vault/secrets
The in-memory directory where the injected agent writes secret files, shared with every container of the pod. Lesson 24.27
~/.vault-token (.vault-token, token helper)
The file where vault login saves your token. The CLI reads it when VAULT_TOKEN is not set. Lesson 24.5
AES-256-GCM (AES, AES-GCM, GCM)
A standard symmetric cipher (AES with a 256-bit key) in a mode (GCM) that also detects tampering. Vault's barrier and transit keys use it by default. Lesson 24.3
agent sink (sink "file")
Where Vault Agent writes the token it holds, usually a file with tight permissions. Lesson 24.24
agent template (template stanza, consul-template)
A Vault Agent block that renders secrets into a file using Go template syntax and can run a command when the file changes. Lesson 24.24
AppRole (approle, auth/approle)
The Vault auth method for machines: a role ID plus a secret ID log in and get a token with the role's policies. Lesson 24.16
audit device (audit devices, vault audit enable, file audit device)
A place Vault writes one JSON line for every request and every response - who, what path, which operation, from where - with values hashed. Vault keeps no history without one. Lesson 24.30
auth method (auth methods, vault auth enable)
A way of logging in to Vault - userpass, approle, kubernetes, oidc - that checks an identity and returns a token with policies. Mounted under auth/; vault auth list shows them. Lesson 24.1
auto-auth (auto_auth)
The Vault Agent block that logs in with an auth method, renews the token and logs in again before the max TTL. Lesson 24.24
auto-unseal (seal stanza, awskms, azurekeyvault)
Configuring Vault to have a key service (a cloud KMS, an HSM, another Vault) decrypt its root key at start, so a restart does not need people with unseal keys. Lesson 24.3
barrier (security barrier)
Vault's encryption layer: everything written to storage is encrypted on the way through it, so the disk only ever holds ciphertext. Lesson 24.3
batch token (hvb.)
A lightweight token that is not stored on the server: it cannot be renewed or create children, but costs almost nothing to issue. Lesson 24.5
bound_service_account_names (bound_service_account_namespaces)
The two lists in a Vault Kubernetes auth role that say which ServiceAccounts, in which namespaces, may log in with that role. Lesson 24.27
BSL (Business Source License, BUSL-1.1)
The licence Vault (and other HashiCorp tools) moved to in 2023: source available and free to use, but not for offering a competing product. Lesson 24.30
check-and-set (CAS, -cas, cas_required)
A write that succeeds only if the secret is still at the version you expect, so two writers cannot silently overwrite each other. Lesson 24.8
child token (child tokens, skip_child_token)
A token created by another token. Revoking the parent revokes all its children and their leases too. The Vault provider for Terraform makes a short-lived child of your token for each run unless skip_child_token is set. Lesson 24.5
creation statements (creation_statements, revocation_statements)
The SQL a database role runs to create a user ({{name}}, {{password}}, {{expiration}} filled in); revocation statements drop it. Lesson 24.18
cubbyhole
Private storage that belongs to one token and disappears with it. Response wrapping keeps the wrapped answer there. Lesson 24.16
database secrets engine (database/, database/creds, database/config)
The Vault engine that holds a privileged database connection and creates a user per client from a role's statements. Lesson 24.18
default policy
The policy every token gets unless told otherwise: it lets a token look up, renew and revoke itself and use its cubbyhole, but read no secrets. Lesson 24.5
deny capability ("deny")
The policy capability that forbids a path. It wins over every other rule and policy. Lesson 24.11
dev mode (vault server -dev, dev server)
A Vault server for trying things: in memory, already unsealed, plain HTTP, a root token you choose. Everything is gone when it stops. Lesson 24.1
dynamic secret (dynamic secrets, dynamic credentials)
A credential Vault creates on request for one client, with a lease, and deletes when the lease ends. Lesson 24.18
ephemeral resource (ephemeral block, ephemeral "vault_kv_secret_v2")
A Terraform 1.10+ block that reads a value during plan and apply without ever writing it to state or the plan file. Lesson 24.34
ETL
Extract, transform, load: a batch job that copies data out of one system, reshapes it and loads it into another. Lesson 24.34
failure tolerance (Failure Tolerance)
How many servers a raft cluster can lose and still keep a quorum: 1 for three voters, 2 for five, 0 for one. Lesson 24.30
force-sync
An annotation on an ExternalSecret: changing its value makes ESO refresh the Secret at once instead of waiting for refreshInterval. Lesson 24.27
GCP (Google Cloud)
Google Cloud Platform, Google's public cloud. Lesson 24.1
generate-root (vault operator generate-root)
Creating a new root token from a quorum of key holders, for an emergency; it should be revoked as soon as the work is done. Lesson 24.30
HMAC (hmac-sha256)
A keyed hash: the same input and key always give the same string, but the string does not reveal the input. Vault's audit log stores values as HMACs. Lesson 24.30
IAM
Identity and access management: a cloud's system of users, roles and permissions. Vault's cloud auth methods let workloads log in with their IAM identity. Lesson 24.5
IBM
The company that bought HashiCorp, the maker of Vault and Terraform, in 2025. Lesson 24.1
integrated storage (storage "raft", raft storage)
Vault's built-in storage, replicated between servers with the Raft protocol, so no external database is needed. Lesson 24.3
key holder (key holders, key ceremony)
A person who keeps one unseal key share. A key ceremony is the planned meeting where shares are created, handed out or tested. Lesson 24.30
key version (vault:v1:, min_decryption_version, transit/keys)
Each rotation of a transit key adds a version; ciphertexts start with vault:vN: to say which version made them. Lesson 24.21
kubernetes auth method (auth/kubernetes, vault auth enable kubernetes, Kubernetes auth)
Vault's way of letting pods log in with their ServiceAccount token: Vault checks the token with a TokenReview and maps ServiceAccount + namespace to policies through a role. Lesson 24.27
KV metadata (vault kv metadata, metadata/)
The record kept for each KV v2 secret: versions, when each was created or deleted, max_versions, custom metadata. Lesson 24.8
KV v1 (kv-v1, kv version 1)
The original key/value engine: one value per path, no versions, the API path equals the path you type. Lesson 24.8
KV v2 (kv-v2, versioned KV, kv version 2)
Vault's key/value secrets engine with versions: every write is a new version, deletes are soft, and data and metadata live under separate API paths. A read of secret/app goes to secret/data/app, a list to secret/metadata/. Lesson 24.8
listener block (listener "tcp")
The block in a Vault server's config that says where it accepts connections and with which TLS certificate. Lesson 24.3
max TTL (max_ttl, token_max_ttl, explicit_max_ttl)
The hard ceiling on a token's or lease's life, counted from its creation. No renewal goes past it; 768h by default. Lesson 24.5
max_versions
How many versions of a KV v2 secret are kept (10 by default); older ones are removed as new ones arrive. Lesson 24.8
MPL (Mozilla Public License)
The Mozilla Public License, the open-source licence Vault used before 2023 and OpenBao still uses. Lesson 24.1
OpenBao (bao)
The open-source (MPL) fork of Vault run by the Linux Foundation, with the CLI bao and the same API for the core features. Lesson 24.30
operator init (vault operator init, initialise, initialized)
The one-time step that creates a new Vault's keys: it prints the unseal key shares and the initial root token, once. Lesson 24.3
orphan token (-orphan, create-orphan)
A token without a parent: revoking the token that created it does not revoke it. Lesson 24.5
periodic token (token_period)
A token with no max TTL: each renewal resets it to its period, so it lives as long as it is renewed in time. Lesson 24.5
PGP (-pgp-keys, GPG)
A public-key encryption format. vault operator init can encrypt each unseal key share to one person's PGP key, so only that person can read it. Lesson 24.3
PKI role (allowed_domains, allow_subdomains, pki_int/issue)
The rules for what certificates may be issued at one issue path: domains, subdomains, IP SANs, key type, max TTL. Lesson 24.21
PKI secrets engine (pki/, pki_int, vault secrets enable pki)
Vault as a certificate authority: a root or intermediate CA in Vault that issues certificates through roles. Lesson 24.21
raft snapshot (vault operator raft snapshot, snapshot save)
A copy of all of Vault's integrated storage, taken while it runs: the backup. Still encrypted, so it needs the unseal keys of the cluster it came from. Lesson 24.30
recovery keys (recovery key)
What vault operator init gives with auto-unseal instead of unseal keys: shares that authorise rekey and generate-root, but cannot unseal. Lesson 24.3
rekey (vault operator rekey)
Making a new set of unseal key shares (and a new threshold) from a quorum of the current ones, e.g. after a key holder leaves. Lesson 24.30
response wrapping (-wrap-ttl, vault unwrap)
Vault keeps the real response and returns a single-use wrapping token instead; the receiver unwraps it once. A second unwrap fails, so interception shows. Lesson 24.16
rewrap (transit/rewrap)
Re-encrypting an old transit ciphertext with the newest key version without revealing the plaintext. Lesson 24.21
role ID (role_id, role-id)
The AppRole half that names the role. It is not secret on its own and can sit in a job's config. Lesson 24.16
root key (master key)
The key that decrypts Vault's encryption keyring. It is never stored in plain form: the unseal key (or a KMS) protects it. Lesson 24.3
root token (root policy, Initial Root Token)
A token with the root policy: every permission, no expiry. Used to set Vault up, then revoked. Lesson 24.5
rotate-root (database/rotate-root)
Changing the password of the database user Vault connects with to one only Vault knows, so the bootstrap password is dead. Lesson 24.18
sealed Vault (Sealed true, vault operator seal, Vault is sealed)
The state of a Vault server that has its encrypted data but not the key to decrypt it. It answers only status and health; everything else gets 503 "Vault is sealed". Every start and every vault operator seal leaves it sealed. Lesson 24.3
secret ID (secret_id, secret-id, secret_id_num_uses)
The AppRole half that works like a password: short-lived, often single-use, delivered to the job at run time. Lesson 24.16
secret version (vault kv rollback)
One saved state of a KV v2 secret. Each put or patch makes the next version; old ones can be read or rolled back to. Lesson 24.8
secret zero (secret-zero)
The first credential a program needs to fetch all its other secrets. Good designs make it something the platform hands out (a ServiceAccount token) rather than something stored. Lesson 24.27
secrets engine (secrets engines, vault secrets enable)
A Vault component mounted at a path that stores, creates or encrypts secrets: kv, database, pki, transit and others. vault secrets list shows what is mounted where. Lesson 24.1
segment wildcard (+ wildcard)
A + in a policy path: it matches exactly one path segment, anywhere in the path. Lesson 24.11
Shamir's secret sharing (Shamir, key-threshold, key threshold)
A method that splits a key into N shares so that any K of them rebuild it and fewer reveal nothing. Vault uses it for the unseal key (5 shares, threshold 3 by default). Lesson 24.3
soft delete (vault kv delete, vault kv undelete, deletion_time)
A KV v2 delete that only marks a version deleted; undelete brings it back. Lesson 24.8
static role (static-creds, static roles, rotation_period)
A database role for an existing user whose password Vault rotates on a schedule, for apps that need a fixed username. Lesson 24.18
sudo capability ("sudo")
The extra capability a policy needs on root-protected paths, such as enabling audit devices or creating orphan tokens. Lesson 24.11
sys/audit-hash (audit-hash)
The Vault endpoint that returns the HMAC an audit device would write for a value, so you can search the log for a value without the log containing it. Lesson 24.30
sys/health (/v1/sys/health)
Vault's unauthenticated health endpoint: the HTTP status code is the state - 200 active, 429 standby, 501 not initialised, 503 sealed. Load balancers and monitoring use it. Lesson 24.30
system:auth-delegator (auth-delegator)
A built-in ClusterRole that lets a ServiceAccount ask the API server to check other tokens (TokenReview). Whoever reviews tokens for Vault needs it. Lesson 24.27
templated policy (identity.entity, {{identity)
A policy whose paths contain placeholders filled from the caller's identity, so one policy gives each user their own path. Lesson 24.11
token accessor (accessor)
A second ID for a token that can look it up, renew or revoke it, but cannot be used to log in. Audit logs record accessors. Lesson 24.5
token capabilities (vault token capabilities, sys/capabilities)
The command that shows what a token may do on a path, or deny if nothing. Lesson 24.11
token renewal (vault token renew)
Asking Vault to extend a token's TTL before it expires. It works only up to the max TTL; then the client must log in again. Lesson 24.5
token TTL (token_ttl, default_lease_ttl)
How long a Vault token has left before it expires. Renewing resets it, up to the max TTL. Lesson 24.5
token_reviewer_jwt
A long-lived ServiceAccount token Vault uses to make TokenReviews. Without it (and with Vault outside the cluster), Vault reviews each pod token with that same token. Lesson 24.27
TokenReview (TokenReviews, tokenreviews, tokenreviews.authentication.k8s.io)
A Kubernetes API call that asks "is this ServiceAccount token valid, and whose is it?". Vault sends one for every pod login. The caller needs create on tokenreviews.authentication.k8s.io, which the ClusterRole system:auth-delegator grants. Lesson 24.27
transit engine (transit/encrypt, transit/decrypt, encryption as a service)
The Vault engine that encrypts and decrypts data for apps with keys that never leave Vault; apps store only the ciphertext. Lesson 24.21
trusted orchestrator
The system that starts a job (a deploy service, the build platform) and is allowed to fetch wrapped secret IDs for it. The job itself cannot mint them. Lesson 24.16
unseal key (unseal keys, key shares, key share)
One share of the key that opens a sealed Vault. A set number of shares (the threshold) must be entered to unseal it. Lesson 24.3
userpass (auth/userpass)
The Vault auth method that logs a person in with a username and password stored in Vault. Lesson 24.5
Vault (HashiCorp Vault, vault server)
A secrets manager: one server that stores secrets encrypted, hands them out only to clients that log in and are allowed by a policy, and records every request. The CLI is vault, the API is HTTP under /v1/, the default port 8200. Lesson 24.1
Vault Agent (vault agent)
A Vault process that runs next to an app: it logs in, keeps the token alive and writes secrets into files for the app. Lesson 24.24
Vault Agent Injector (Agent Injector, vault-agent-injector, vault-k8s)
A webhook that rewrites pods annotated with vault.hashicorp.com/agent-inject: an init container and a sidecar running Vault Agent write secrets into files under /vault/secrets. Lesson 24.27
Vault capabilities (capabilities = [)
The verbs a policy grants on a path: create, read, update, patch, delete, list, plus sudo and deny. Lesson 24.11
vault kv destroy (kv destroy)
Removing the data of KV v2 versions permanently. The history in the metadata stays. Lesson 24.8
Vault lease (lease_id, lease ID, vault lease renew)
Vault's record of a secret it handed out with a lifetime. Renew it to keep the secret, revoke it to end it early; it is revoked with the token that owns it. Lesson 24.18
Vault mount (mount path)
In Vault, the path where a secrets engine or auth method is enabled, such as secret/ or auth/approle/. Requests under that path go to it. Lesson 24.1
Vault policy (vault policy write, ACL policy, token_policies)
An HCL document of path rules that says what a token may do. Anything not granted is denied. Lesson 24.11
Vault provider (hashicorp/vault, terraform-provider-vault, provider "vault")
The Terraform provider that manages Vault: mounts, auth methods, policies, roles and secrets as resources. Lesson 24.34
Vault Proxy (vault proxy)
A separate Vault mode that forwards an app's own API calls to Vault with an auto-auth token, instead of rendering files. Lesson 24.24
Vault Secrets Operator (VSO, VaultStaticSecret, VaultDynamicSecret)
HashiCorp's own Kubernetes operator that copies Vault secrets into Kubernetes Secrets (like ESO, but Vault-only) and can restart workloads when they change. Lesson 24.27
Vault token (hvs., service token, client token)
The credential every Vault request carries. It has policies, a TTL and an accessor; logging in exchanges an identity for one. Service tokens start with hvs., batch tokens with hvb.. Lesson 24.5
VAULT_ADDR
The environment variable that tells the vault CLI which server to talk to, scheme included (http:// or https://). Unset, the CLI uses https://127.0.0.1:8200. VAULT_CACERT names the CA file to trust for a TLS listener. Lesson 24.1
vault_kv_secret_v2 (data_json, data_json_wo)
The Terraform resource that writes a KV v2 secret. Its data_json ends up in state in plain text; data_json_wo (write-only) does not. Lesson 24.34
vault-agent-init (vault-agent)
The two containers the injector adds: vault-agent-init renders the files once before the app starts, vault-agent stays running to renew and re-render. A pod stuck at Init:0/1 is waiting on the first. Lesson 24.27
vault.hashicorp.com/agent-inject (agent-inject, agent-inject-secret, agent-inject-template)
The pod annotations the injector reads: inject or not, the Vault role to log in with, which secret to render into which file, and the template for it. They must be on the pod template (spec.template.metadata.annotations), and the secret path is the API path (secret/data/... for KV v2). Lesson 24.27
vault.hcl (/etc/vault.d/vault.hcl)
The Vault server's configuration file in the Ubuntu package: storage, listener, api_addr, cluster_addr, ui and seal settings. Lesson 24.3
wrapping token (wrapping_token)
The short-lived, single-use token that response wrapping returns in place of the real answer. Lesson 24.16
X-Vault-Token
The HTTP header that carries a Vault token on API requests. Every CLI command sends it for you. Lesson 24.1