OnCallReadyStart learning

GitOps, Argo CD & Delivery: glossary

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

allowEmpty
Sync-policy switch; left false it refuses to sync when git renders nothing, so a wrong path cannot prune everything. Lesson 41.9
app of apps (app-of-apps)
A root Application whose path contains only other Application manifests, so one apply brings up every app from git. Lesson 41.16
Application (Argo CD) (Argo CD Application, Argo CD Applications, Application CRD)
The Argo CD object that says "take this path of this repo and keep it applied to this namespace of this cluster", plus its sync policy. Lesson 41.4
ApplicationSet (ApplicationSets, applicationset-controller)
An Argo CD object that generates Applications from one template, e.g. one per directory in overlays/* or one per cluster. Lesson 41.16
AppProject (AppProjects, Argo CD project)
Argo CD's fence around a team's Applications: which repos they may use, which clusters and namespaces they may deploy to, which object kinds, who may sync. Lesson 41.16
Argo CD (ArgoCD, argocd)
A GitOps controller that runs in the cluster, renders what git says, compares it with the live cluster, and syncs the difference. Has a web UI and the argocd CLI. Lesson 41.4
Argo CD Image Updater (Image Updater)
A tool that watches a registry and commits the new image when a matching tag appears. Fine for dev, risky for prod. Lesson 41.18
Argo Rollouts (kubectl argo rollouts)
A controller that replaces the Deployment with a Rollout object that knows canary and blue-green steps, pauses and analysis. Lesson 41.26
argocd admin initial-password (initial admin password, argocd-initial-admin-secret)
Prints the first admin password, which Argo CD keeps in a Secret in its namespace.
argocd app history (app history, history ID)
Lists an app's past syncs, each with an ID, the git commit and when it ran. Lesson 41.4
argocd app rollback
Re-applies the content of an older history ID. Refused while auto-sync is on; leaves the app OutOfSync with git. Lesson 41.4
argocd app wait
Block until an app reaches a state (--health, --sync) or a timeout runs out. Handy in scripts and pipelines. Lesson 41.4
argocd CLI (argocd app get, argocd app diff, argocd app list)
The argocd command-line client, shaped argocd app VERB APP: get, diff, sync, wait, history, rollback, set, create. Lesson 41.4
argocd-application-controller (application-controller, application controller)
The Argo CD reconciler: compares rendered desired state with the live cluster, works out sync and health, and runs syncs. Lesson 41.4
argocd-rbac-cm (policy.csv, policy.default)
The ConfigMap with Argo CD-wide permissions: lines like p, role, applications, sync, project/*, allow, and a default role for everyone else. Lesson 41.16
argocd-repo-server (repo-server)
The Argo CD component that clones git and renders manifests (helm template, kustomize build, plain YAML). Rendering errors show in its logs. Lesson 41.4
argocd-server
The Argo CD component that serves the API, the web UI and the endpoint the argocd CLI talks to; handles logins and permissions. Lesson 41.4
asymmetric encryption (public-key encryption)
Encryption with two keys: what the public key locks, only the matching private key opens. So anyone can encrypt, one holder can decrypt. Lesson 41.22
auto-sync (automated sync)
Argo CD applies every new commit that renders differently, without anyone pressing Sync. Lesson 41.9
automated canary analysis (AnalysisTemplate, AnalysisTemplates)
At each canary step, query the monitoring system for error rate and latency of canary vs stable, and abort by itself if the canary is worse. Lesson 41.26
AWS Secrets Manager (AWS SM)
Amazon's cloud service for storing secrets, the AWS counterpart of Azure Key Vault.
base (kustomize) (base/)
In kustomize: the environment-neutral manifests of a service, valid YAML you could apply on its own. Overlays build on it. Lesson 41.2
behavior: merge
On an overlay's generator: add to or override the keys of the base's generator with the same name, instead of making a second one. Lesson 41.2
blue-green (blue-green deployment, blue/green)
Run the new version (green) at full size next to the old (blue), test it, then switch the Service to it at once. Rollback = switch back. Lesson 41.26
bot token (CONFIG_TOKEN)
A credential for an automated user that can only push to one repository - all a GitOps pipeline needs instead of cluster access. Lesson 41.18
branch protection
Git-host settings on a branch like main: no direct pushes, pull requests need reviews and green checks before they can be merged. Lesson 41.1
ciphertext
Encrypted data - unreadable without the key. The opposite is plaintext. Lesson 41.22
CODEOWNERS
A file in a git repo that names who must approve changes to which paths, e.g. only the platform leads may approve overlays/prod/. Lesson 41.1
configMapGenerator (secretGenerator)
A kustomize entry that builds a ConfigMap (or Secret) from key=value lines and adds a hash of the content to its name. Lesson 41.2
DB
Short for database.
default project
The AppProject every Argo CD install starts with. It allows everything - fine for a lab, an audit finding in production. Lesson 41.16
delivery strategy (deployment strategy, rollout strategy, delivery strategies)
How a new version replaces the old one: rolling, recreate, blue-green, or canary. Lesson 41.26
dex (argocd-dex-server)
The single sign-on connector Argo CD ships with: lets people log in with Entra ID, GitHub or a company directory. Lesson 41.4
ESO
Short for External Secrets Operator: a controller that copies secrets from an outside store such as Key Vault into Kubernetes Secrets. Lesson 41.22
ExternalSecret (ExternalSecrets, externalsecret)
ESO object saying which vault entries to copy into which Kubernetes Secret, and how often (refreshInterval). The team writes it. Lesson 41.22
Flagger
The Flux-world equivalent of Argo Rollouts: automated canary and blue-green releases. Lesson 41.26
Flux
The other widely used GitOps controller, next to Argo CD: a set of controllers configured with Kubernetes objects, no built-in web UI. Lesson 41.1
generator (ApplicationSet) (git generator, cluster generator, matrix generator)
The part of an ApplicationSet that produces the list the template is filled from: a list, clusters, git directories, pull requests, or a combination. Lesson 41.16
git webhook (push webhook)
An HTTP call the git server makes to Argo CD when someone pushes, so Argo CD re-reads the repo at once instead of waiting for its 3-minute poll. Lesson 41.4
GitOps
A way of deploying where git holds the desired state of everything that runs, and a program inside the cluster keeps making the cluster match it. Nobody pushes changes into the cluster by hand. The pipeline builds the image and commits the new digest to a config repo; Argo CD (or Flux) notices the commit and applies it. Lesson 41.1
goTemplate ({{.path.basename}})
ApplicationSet switch for Go-template placeholders like {{.path.basename}}, filled per generated Application. Lesson 41.16
hash suffix (name suffix hash, disableNameSuffixHash, hashed name)
The short content fingerprint kustomize appends to generated names (payments-config-7k2fdm9t4c). New content, new name, so pods referencing it roll. Lesson 41.2
health status (Argo CD) (Health Status)
Argo CD's answer to "does what runs work?": Healthy, Progressing, Degraded, Missing or Suspended. Independent of sync status. Lesson 41.4
helmCharts (--enable-helm)
A kustomization field that renders a Helm chart inside kustomize so the output can be patched. Needs --enable-helm. Lesson 41.2
hook delete policy (BeforeHookCreation, HookSucceeded, HookFailed)
When Argo CD deletes an old hook Job: just before the next run (BeforeHookCreation), or right after it succeeds or fails. Lesson 41.9
ignoreDifferences
An Application field listing exact fields Argo CD must not compare, for fields another controller legitimately owns (an HPA's replicas). Lesson 41.12
images transformer (newTag)
The kustomize entry that changes a container image's tag, name or digest wherever that image name appears, without writing a patch. Lesson 41.2
InvalidSpecError
The condition Argo CD sets on an Application that points outside what its AppProject allows. The app is not synced. Lesson 41.16
jsonPointers (JSON Pointer, jqPathExpressions)
Ways to name one field for ignoreDifferences: a path like /spec/replicas, or a jq path. Lesson 41.12
kubeseal (kubeseal --fetch-cert)
The command that encrypts a Secret into a SealedSecret with the controller's public key. --fetch-cert saves the key for sealing offline. Lesson 41.22
kustomization.yaml (kustomization, Kustomization)
The file in each kustomize directory that lists which files go in (resources:) and which edits to make. Lesson 41.2
kustomize edit set image (kustomize edit)
The standalone kustomize command that rewrites the images: entry in kustomization.yaml - a pipeline's one-line promotion commit. Lesson 41.18
managed fields (managedFields, managedFieldsManagers)
The API server's record, in metadata.managedFields, of which tool last set each field of an object. Lesson 41.12
manual sync
No automated block: Argo CD only reports OutOfSync, and a person or pipeline runs argocd app sync. Lesson 41.9
MutatingWebhookConfiguration (mutatingwebhookconfigurations)
The object that registers a mutating admission webhook, a program that may rewrite objects before they are stored. Lesson 41.12
OpenGitOps (OpenGitOps principles, four principles)
The project that wrote down what GitOps means as four principles: declarative, versioned and immutable, pulled automatically, continuously reconciled. Lesson 41.1
overlay (kustomize) (overlays/dev, overlays/prod, kustomize overlay)
In kustomize: a directory for one environment that points at the base and lists only what differs there. Lesson 41.2
preview Service (payments-preview, previewService)
A Service that selects only the new version, so you can test it before real traffic moves. Lesson 41.26
progressive delivery
Releasing to a growing share of users step by step, with checks between steps - canary with analysis, in practice. Lesson 41.26
pruning (auto-prune, --auto-prune, prune: true)
Deleting from the cluster the objects that are no longer in git. Off by default: removed files leave their objects running. Lesson 41.9
pull-based (pull-based GitOps, pull model, pull-based CD)
The GitOps direction: an agent inside the cluster pulls the desired state from git and applies it. Nothing outside needs credentials to change the cluster. Lesson 41.1
push-based CD (push-based deployment, push model, push-based)
Deploying by having something outside the cluster (a pipeline) apply changes into it, e.g. running helm upgrade. It needs cluster credentials, and the cluster is whatever the last run left. Lesson 41.1
refresh (Argo CD) (--hard-refresh, hard refresh)
Make Argo CD re-read git and re-render the app now instead of waiting for its 3-minute poll. A hard refresh also drops its manifest cache. Lesson 41.4
refreshInterval
How often ESO re-reads the vault; a rotated value reaches the Secret within this time. Lesson 41.22
Reloader (Stakater Reloader)
A controller that restarts Deployments when a Secret or ConfigMap they use changes, so env vars pick up the new value. Lesson 41.22
render (manifests) (rendered manifests)
Turn a chart or an overlay into the plain Kubernetes YAML it stands for, as helm template or kubectl kustomize print it. Lesson 41.2
resource tree
The Argo CD console's picture of an app: each object and what it created (Deployment -> ReplicaSet -> Pods), each with its own health.
resource.customizations (argocd-cm)
Argo CD-wide settings in the argocd-cm ConfigMap, e.g. ignore rules or health checks for every app. Lesson 41.12
resources finalizer (resources-finalizer.argocd.argoproj.io)
The marker on an Application that makes deleting it also delete everything it deployed. Without it, the objects stay, orphaned. Lesson 41.9
RespectIgnoreDifferences (RespectIgnoreDifferences=true)
Sync option that also stops a sync from overwriting the ignored fields. Without it the fight with the other controller continues. Lesson 41.12
retry (sync) (sync retry)
Sync-policy block that retries a failed sync a few times with growing waits. Without it, auto-sync never retries the same commit. Lesson 41.9
Rollout (Argo Rollouts) (kind: Rollout)
The Argo Rollouts object: a Deployment's pod template plus a canary or blueGreen strategy with steps. Lesson 41.26
root app (root application, root.yaml, payments-root)
The one Application you apply by hand in the app-of-apps pattern; it creates all the others. Lesson 41.16
SCM provider (SCM)
Source code management - the git hosting service (GitHub, GitLab, Azure Repos). An ApplicationSet generator can list every repo in an organisation there. Lesson 41.16
Sealed Secrets (sealed-secrets-controller, Sealed Secrets controller)
A controller that holds a private key in the cluster; you encrypt Secrets with its public key, commit them, and only it can decrypt them. Lesson 41.22
SealedSecret (SealedSecrets, sealedsecret)
The encrypted form of a Secret, safe to commit. The controller turns it into a normal Secret it owns. Lesson 41.22
sealing key (sealed-secrets-key)
The controller's private key. Lose it with the cluster and every SealedSecret in git is useless - back it up. Lesson 41.22
sealing scope (strict scope)
Where a SealedSecret may be opened, baked into the encryption: strict (this namespace and name), namespace-wide, or cluster-wide. Lesson 41.22
SecretStore (ClusterSecretStore, SecretStores)
ESO object saying how to reach a vault and log in to it: SecretStore for one namespace, ClusterSecretStore for the whole cluster (platform-owned). Lesson 41.22
self-heal (selfHeal, --self-heal, self-healed)
Argo CD syncs again when the live state drifts, even though git did not change - it undoes kubectl edits within seconds. Lesson 41.9
server-side diff (ServerSideDiff)
Argo CD asks the API server to dry-run the apply and compares with that, so webhook changes appear on both sides and stop showing as diffs. Lesson 41.12
SOPS
A tool that encrypts only the values inside YAML files (with age or cloud keys), so they stay readable and diffable in git. Lesson 41.22
sourceRepos (clusterResourceWhitelist, namespaceResourceBlacklist)
AppProject fields: where manifests may come from, where they may go, which cluster-wide kinds are allowed, which namespaced kinds are forbidden. Lesson 41.16
stable (version) (stableService)
In a canary release: the current version that keeps most traffic while the canary is tested. Lesson 41.26
sync (Argo CD) (argocd app sync)
Argo CD applying what git renders to the cluster - its equivalent of kubectl apply. Lesson 41.4
sync hook (argocd.argoproj.io/hook, PreSync hook)
A manifest, usually a Job, annotated to run in another phase - e.g. a database migration before the Deployment changes. Lesson 41.9
sync options (syncOptions, CreateNamespace=true, PruneLast)
Flags that tune how a sync applies things: create the namespace, prune last, apply only what differs, use server-side apply... Lesson 41.9
sync phase (PreSync, PostSync, SyncFail)
The stages of one sync, in order: PreSync, Sync, PostSync, and SyncFail only if it failed. Normal manifests are in Sync. Lesson 41.9
sync policy (syncPolicy)
The part of an Application that says whether Argo CD syncs by itself and how far it goes (automated, prune, selfHeal, retry, options). Lesson 41.9
sync status (OutOfSync, Sync Status)
Argo CD's answer to "does the cluster match git?": Synced, OutOfSync, or Unknown when it cannot render or compare. Lesson 41.4
sync wave (sync waves, sync-wave, argocd.argoproj.io/sync-wave)
An annotation number that orders objects inside a phase: lower waves are applied first, and each wave must be healthy before the next. Lesson 41.9
sync window (sync windows, syncWindows, manualSync)
An AppProject time range (cron schedule + duration) when syncs are allowed or denied - a change freeze written as config. Lesson 41.16
targetRevision
In an Application: which version of the repo to deploy - a branch, a tag or a commit. HEAD = latest on the default branch. Lesson 41.4
timeout.reconciliation (reconciliation timeout, 3-minute poll)
The Argo CD setting for how often it re-reads git on its own: 180 seconds by default. Lesson 41.4
track label (track: blue, track: green)
The label (track: blue / track: green) that tells the two versions apart so a Service selector can pick one.
tracking-id (argocd.argoproj.io/tracking-id, resource tracking)
The annotation Argo CD puts on every object it applies, naming the app. It is how Argo CD knows which objects it owns. Lesson 41.4
traffic split (traffic splitting, setWeight)
Sending an exact share of requests (5%, 20%) to one version regardless of pod counts, done by the ingress controller, Gateway API or a service mesh. Lesson 41.26
transformer (transformers)
One kind of edit kustomize can make to every object: namespace:, namePrefix:, labels:, images:, replicas:, patches:. Lesson 41.2