Linux Foundation Certified GitOps Associate

GitOps has precise terms, and the principles depend on them. You define desired state, state drift, reconciliation, the state store, the feedback loop and rollback, and use each term correctly in an example.

• Desired state and actual state
• State drift and how it arises
• Reconciliation and the feedback loop
• The state store and its role
• Rollback in a GitOps system
• What continuous means in GitOps

You build A glossary with a worked example for each term, drawn from one small system.

A GitOps system describes what should exist, not the steps to create it. You learn what makes a description declarative, how it is expressed in manifests, and why that makes systems predictable and easier to review.

• Declarative and imperative descriptions compared
• Describing a whole system as data
• Manifest formats: YAML, JSON and templates
• Idempotence and why it matters
• Reviewing declarative changes

You build A declarative description of a small application stack, with notes on what is left implicit.

Desired state is stored where history cannot quietly change. You see how Git provides versioning, review and audit, how immutability applies to artifacts and tags, and how protected branches and signed commits add trust.

• Git as a versioned state store
• Commits, pull requests and review as change control
• Immutable artifacts: tags and digests
• Branch protection and signed commits
• Audit trails from Git history
• Alternatives to Git as a state store

You build A repository policy that protects the state store, with the review rules written down.

An agent inside the environment pulls desired state and keeps pulling. You compare pull and push delivery, follow a reconciliation loop, see how drift is detected and corrected, and understand the feedback it provides.

• Pull-based and push-based delivery compared
• Software agents that pull desired state
• The reconciliation loop step by step
• Detecting and correcting drift
• Feedback: health, status and notifications
• Security benefits of pulling

You build A sequence diagram of one change flowing from commit to running state, including a drift correction.

GitOps overlaps with several practices and replaces none of them. You place it among configuration as code, infrastructure as code, DevOps, DevSecOps, CI and CD, and learn where each begins and ends.

• Configuration as code
• Infrastructure as code and GitOps together
• DevOps culture and GitOps tooling
• DevSecOps: security in the flow
• CI and CD versus GitOps
• What GitOps adds to each practice

You build A one-page map showing how GitOps relates to each neighboring practice, with an example of each overlap.

How you arrange repositories and environments shapes how changes move. You compare repository and environment layouts, promotion strategies, progressive delivery, and pull-based against event-driven triggers.

• Monorepo and multi-repo layouts
• Environment per branch or per directory
• Promotion between environments
• Progressive delivery: canary and blue/green
• Pull-based and event-driven reconciliation
• Handling rollbacks and hotfixes

You build A repository and promotion design for three environments, with the trade-offs of the layout explained.

Where the reconciler runs changes what it can do and what it risks. You compare an agent per cluster with a central controller managing many, and consider how secrets, scale and multi-tenancy fit in.

• Agent per cluster and central controllers
• Multi-cluster and fleet management
• Managing secrets in a Git-driven flow
• Multi-tenancy and access boundaries
• Scale and reconciliation intervals
• Failure modes of reconcilers

You build An architecture sketch for a reconciler across three clusters, with credentials and boundaries marked.

A handful of tools carry most GitOps in practice. You see how manifests are packaged with Helm and Kustomize, how Git and OCI registries serve as state stores, and how Argo CD and Flux reconcile and notify.

• Plain manifests, Helm and Kustomize
• Git and OCI registries as state stores
• Argo CD and Flux compared
• Notifications and integrations
• Connecting GitOps to CI and policy tools
• Choosing a tool for a given team

You build A working GitOps loop on a local cluster, reconciled by Argo CD or Flux, with a manual change corrected.

Apply every principle to one small system. You design the repository, choose a reconciler, set promotion and rollback rules, and explain how each decision follows from the principles.

• Describing the system declaratively
• Choosing the state store and protections
• Selecting a reconciler and its pull model
• Defining promotion, drift and rollback behavior
• Mapping decisions back to the principles

You build A running GitOps setup for a small system, with a design document that ties each decision to a principle.