In GitOps practices, when does CD take part?
B
Explanation:
In GitOps, Continuous Deployment (CD) follows after Continuous Integration (CI). CI is responsible
for building and testing application code, while CD automates the delivery and deployment of these
changes into runtime environments. The Git repository serves as the single source of truth, and
when CI merges new changes into the main branch, CD reconciles the state of the environment to
match what is declared in Git.
“GitOps builds on the principles of DevOps by using Git as the source of truth for declarative
infrastructure and applications. CI pipelines handle the integration and testing of code, and CD
pipelines or agents automatically reconcile the desired state in Git with the actual state in the
cluster.”
This shows that CD is triggered after CI to handle deployment automation, ensuring systems remain
in sync with what is declared in version control.
Reference: GitOps Principles (CNCF GitOps Working Group), GitOps Working Group Terminology &
Principles documents.
In the context of GitOps, what happens to a GitOps-managed Kubernetes cluster if there is drift
divergence?
B
Explanation:
A GitOps-managed Kubernetes cluster uses reconciliation loops to continuously compare the actual
state of the system with the desired state declared in Git. When drift (divergence between declared
configuration and live cluster state) is detected, the GitOps operator automatically reconciles the
difference to bring the system back into alignment.
“In GitOps, a reconciliation loop ensures that the desired state as declared in Git is continuously
compared with the observed state of the system. If drift is detected, the system automatically takes
corrective action to reconcile the difference and restore the declared configuration.”
This ensures consistency, reliability, and self-healing. Manual intervention is not required for drift
correction, as the automated reconciliation is a core principle of GitOps.
Reference: GitOps Principles (CNCF GitOps Working Group), GitOps Principles Document — Principle
4: Software agents automatically pull the desired state declarations from the source and
continuously observe actual system state, reconciling differences.
In GitOps, what does the principle of Versioned and Immutable mean?
C
Explanation:
One of the four fundamental GitOps principles is Versioned and Immutable. This means that the
entire system’s desired state must be stored in a Git repository with version control. Each change
must be represented as a commit, and Git’s immutability guarantees a reliable, auditable history of
how the system evolved.
“The desired state is stored in a version control system. The record of truth is stored in an immutable
history, and changes can be audited and reverted if necessary. This guarantees that the system’s
configuration is versioned, immutable, and traceable.”
Thus, configuration and infrastructure must be version-controlled and immutable, never changed
directly in production.
Reference: GitOps Principles (CNCF GitOps Working Group), Principle 2: The desired system state is
stored as versioned and immutable.
===========
When are progressive delivery patterns useful in software development and deployment?
C
Explanation:
Progressive delivery is a GitOps pattern used to release software gradually, reducing risks associated
with deploying new versions. Techniques such as canary releases, feature flags, and blue-green
deployments allow teams to incrementally roll out changes, validate functionality with subsets of
users, and minimize potential disruptions.
“Progressive delivery builds on continuous delivery by enabling safer, incremental rollouts. This
pattern reduces risk, improves reliability, enhances user experience, and allows for validation of
features with a portion of users before wider release.”
Therefore, progressive delivery is useful in multiple scenarios (not just one-time deployments or
small teams), making option C correct.
Reference: GitOps Patterns (CNCF GitOps Working Group), Progressive Delivery Patterns
documentation.
===========
When deciding whether to use an in-cluster reconciler or an external reconciler, what factors should
be considered?
B
Explanation:
In GitOps, reconcilers ensure the actual state matches the desired state. Reconcilers may run inside
the cluster (in-cluster) or outside (external). The choice depends primarily on operational scale and
the complexity of reconciliation logic.
“When determining reconciler placement, factors such as the size of the environment, the
operational complexity of the reconciler, and the performance requirements should be evaluated. In-
cluster reconcilers are common for straightforward deployments, while external reconcilers may be
chosen for large-scale or complex systems.”
Thus, the most important considerations are cluster size and complexity of reconciler logic, making B
correct.
Reference: GitOps Related Practices (CNCF GitOps Working Group), GitOps Reconciler Guidelines.
===========
In GitOps, what does it mean to Continuously Reconcile?
C
Explanation:
Continuous reconciliation is another core GitOps principle. It means that software agents (operators
or controllers) run loops that continuously observe the live system and compare it against the
desired state declared in Git. If any divergence (drift) is found, the agent automatically reconciles the
system to match the declared configuration.
“Software agents continuously observe the actual system state and compare it with the desired state
declared in Git. If a divergence is detected, the agents automatically reconcile the difference to bring
the system back into alignment.”
This provides automation, consistency, and self-healing, which are hallmarks of GitOps.
Reference: GitOps Principles (CNCF GitOps Working Group), Principle 4: Continuously reconciled.
How can you achieve the declarative GitOps principle in managing infrastructure and applications?
D
Explanation:
The first GitOps principle is Declarative Descriptions. This means the desired system configuration
(for infrastructure, services, and applications) is expressed declaratively and stored in version control.
Git becomes the single source of truth.
“The desired system state must be expressed declaratively. This provides a clear, machine-readable
blueprint for the system, and ensures that what is in Git is what should be running in the
environment.”
Therefore, infrastructure and application configurations must be defined declaratively and stored in
Git, not managed imperatively or manually.
Reference: GitOps Principles (CNCF GitOps Working Group), Principle 1: The system is described
declaratively.
===========
In the context of GitOps, which of the following is the primary purpose of Desired State?
A
Explanation:
The Desired State in GitOps is the declarative specification of how the system should behave. It is
stored in Git and serves as the reference point for reconciliation against the actual state.
“The desired state is a complete specification of the system stored in Git. It acts as the blueprint from
which the actual state is continuously reconciled, ensuring the system remains consistent and
reproducible.”
Thus, the primary purpose of Desired State is to act as a blueprint to recreate and ensure consistency
of the system.
Reference: GitOps Terminology (CNCF GitOps Working Group).
===========
Can you choose one example where Configuration as Code may be utilized to manage an
application’s configuration and source code?
C
Explanation:
Configuration as Code is a GitOps-related practice where configurations are stored as declarative
definitions in version control. Helm charts, for example, allow applications deployed on Kubernetes
to have both their container images and configuration specified declaratively.
“Configuration as Code enables teams to manage application and infrastructure configuration in
version control systems, using declarative approaches such as Kubernetes manifests or Helm charts.
This ensures repeatability, automation, and auditability.”
Thus, Helm charts are a prime example of this practice, making C correct.
Reference: GitOps Related Practices (CNCF GitOps Working Group), Configuration as Code.
===========
Which of the following is part of a declaratively defined system?
C
Explanation:
In GitOps, systems are defined declaratively. This means that the desired state is described in Git,
while the steps to achieve it are not explicitly defined. Instead, reconciliation agents interpret the
declarative definition and automatically apply changes as needed.
“A declaratively defined system specifies only the desired state. It does not describe the sequence of
steps required to reach that state. The reconciliation process ensures the system converges to the
declared state automatically.”
Therefore, the correct answer is C: Only the Desired State.
Reference: GitOps Principles (CNCF GitOps Working Group), Principle 1: The system is described
declaratively.
Which statement describes Blue-Green deployments?
A
Explanation:
Blue-Green deployments are a progressive delivery pattern where two environments exist: Blue
(current version) and Green (new version). The new version is deployed in parallel, and once
validated, traffic is switched over from Blue to Green.
“Blue-Green deployments provide zero-downtime releases by running two production environments:
one active and one idle. A new version is deployed to the idle environment, tested, and when ready,
traffic is switched to it.”
Thus, the correct description is A.
Reference: GitOps Patterns (CNCF GitOps Working Group), Progressive Delivery patterns.
===========
In a GitOps framework, what distinct advantage does Configuration as Code (CaC) provide in
comparison to traditional infrastructure management approaches?
B
Explanation:
Configuration as Code (CaC) in GitOps ensures that infrastructure and application definitions are
stored in Git, version-controlled, and immutable. Unlike traditional approaches (manual changes,
scripts, mutable infrastructure), GitOps uses CaC for immutable infrastructure deployments,
guaranteeing reproducibility and environment consistency.
“Configuration as Code ensures that system configuration is stored declaratively in version control.
This allows immutable deployments, reproducibility, consistency across environments, and prevents
ad-hoc manual changes.”
Thus, the distinct advantage is immutable deployments and consistent environments, making B
correct.
Reference: GitOps Related Practices (CNCF GitOps Working Group).
===========
A GitOps-managed Software System includes which of the following?
B
Explanation:
A GitOps-managed software system is defined as one or more runtime environments whose
resources are managed declaratively via GitOps practices.
“A GitOps-managed software system includes one or more runtime environments, such as clusters,
where resources are under management. The desired state of these resources is declared in Git and
reconciled continuously.”
Thus, the correct option is B.
Reference: GitOps Terminology (CNCF GitOps Working Group).
===========
In GitOps, what is a pull-based approach?
D
Explanation:
In GitOps, pull-based deployment is fundamental. Instead of pushing changes into a cluster, GitOps
agents running inside the cluster continuously pull from Git to reconcile desired state.
“GitOps uses a pull-based model: agents inside the cluster continuously poll the Git repository for
desired state changes. If changes are found, they reconcile the live system automatically to match
the declared state.”
This ensures secure, automated, and consistent deployments.
Thus, D is correct.
Reference: GitOps Principles (CNCF GitOps Working Group), Pull-based Reconciliation Model.
A GitOps project wants to leverage both ArgoCD and Flux for a deployment. Can ArgoCD and Flux be
used in conjunction?
C
Explanation:
ArgoCD and Flux are the two primary CNCF GitOps tools. While both are reconciliation engines, they
can be used together carefully if configured properly to avoid conflicts. For example, Flux can be used
to manage configuration sources, while ArgoCD handles application-level delivery. Extensions and
integration points allow them to complement each other.
“ArgoCD and Flux implement the GitOps reconciliation principle. Though they provide overlapping
functionality, they can be integrated by carefully managing their scope. For instance, Flux can
manage sources and Helm charts, while ArgoCD handles higher-level deployments. Extensions exist
to allow cooperation without conflict.”
Thus, the correct answer is C.
Reference: GitOps Tooling (CNCF GitOps Working Group).
===========