Tools: Helm, Kustomize, Argo CD, Flux

GitOps training for your Kubernetes deployments

Learn to package applications with Helm, adapt configuration with Kustomize or manage deployments from Git with Argo CD and Flux. Find the live online workshop that matches your work and experience.
Find the right workshopCompare the tools

Understanding GitOps

Create manifests. Manage deployments from Git.

Helm and Kustomize describe what should run in the cluster. Argo CD and Flux reconcile that desired state with what is running. Your GitOps training can focus on either task: creating application configuration or managing its delivery. This overview shows which workshop covers each part.

Technical basis: OpenGitOps Principles

FROM MANIFEST TO RECONCILED CLUSTER

From configuration to an application in the cluster

How the tasks fit together

  1. 01

    Create manifests

    Create Helm charts or adapt configuration to environments with Kustomize

    Course code: DW9Introduction to Helm for KubernetesCourse code: DW22Introduction to Kustomize
  2. 02

    Version in Git

    Record the desired state in Git; review changes through branches and pull requests

    Course code: DW19Introduction to Git for Teams
  3. 03

    Fetch and reconcile the state

    Argo CD or Flux reconcile Git and the cluster according to the configured rules

    Course code: DW27Introduction to Argo CDCourse code: DW28Introduction to Flux CD
  4. Goal

    Spot configuration drift

    Check whether the running state matches the desired revision in Git

RESPONSIBILITIES AROUND GITOPS

Which tasks does GitOps handle?

Describe and reconcile the desired state
The desired state is declared and versioned in Git. A controller in the cluster fetches it automatically and continuously reconciles it with the actual state. Helm and Kustomize provide the description, Argo CD and Flux the reconciliation.
What sits outside this step
The CI pipeline builds, tests and scans images. Provisioning clusters and cloud resources and monitoring operations with metrics and logs are separate tasks. This page focuses on delivering finished artifacts to existing Kubernetes clusters.

Where GitOps helps in practice

GitOps helps teams that run a Kubernetes cluster, want to review changes through pull requests and compare the running revision with the configuration in the repository.

What you need before you start

Argo CD and Flux require Kubernetes experience with kubectl and Git skills covering branches and pull requests. The introductory Kubernetes or Git workshops cover any missing foundations. Team adoption also requires decisions about secrets, access rights and repository structure.

TASKS IN GITOPS OPERATIONS

The work behind your deployments

  • Package and version applicationsCharts, values, OCI registry

    Helm bundles an application's configuration into a reusable package.

    • Charts contain templates and defaults; values adapt them per environment.
    • Chart versions identify package revisions for updates and comparisons.
    • OCI registries store and distribute charts alongside container images.

    In Introduction to Kubernetes Helm (DW9), you practise developing, testing and publishing Helm charts.

    View in the catalogue
  • Adapt configuration without templatesBase, overlay, patch, generator

    Kustomize separates shared configuration from differences between environments.

    • The base contains the shared manifests.
    • Overlays and patches add or change configuration for each environment.
    • Generators create ConfigMaps and Secrets from files or values. They do not encrypt secrets.

    In Introduction to Kustomize (DW22), you practise this separation and structure a repository for GitOps.

    View in the catalogue
  • Roll out from Git and correct driftPull, sync, self-healing, rollback

    A GitOps controller reconciles the desired state with the running state.

    • Pull instead of push: the controller fetches the state from Git. The CI pipeline needs no cluster credentials for this step.
    • Drift means differences, such as those caused by manual cluster changes. The controller detects or corrects them according to the configured rules.
    • A Git revert can restore an earlier desired state. Whether the application can be rolled back also depends on its data and dependencies.

    Introduction to Argo CD (DW27) covers Argo CD with its web UI; Introduction to Flux CD (DW28) covers Flux through Git and controller objects.

    View in the catalogue
  • Update image versions automaticallyWatch registry, tag policies, Git commit

    Image automation updates image references in Git according to defined policies.

    • A controller watches the registry and selects matching tags according to policies.
    • Image references are updated through a commit. The change remains traceable in Git.
    • The GitOps controller applies the new revision according to its reconciliation rules.

    Only Introduction to Flux CD (DW28) includes hands-on image automation. Courses on building and checking images beforehand are listed in the Docker overview.

    View in the catalogue
  • Roll out step by stepCanary, blue-green, analysis

    Progressive delivery controls when a new version receives requests.

    • Canary gradually increases the share of requests sent to the new version.
    • Blue-green keeps the existing and new revisions running in parallel for switching.
    • Analysis steps can use metrics to decide whether to continue or abort.

    Introduction to Argo CD (DW27) covers canary and blue-green in a full Argo Rollouts module. Introduction to Flux CD (DW28) offers only an overview of Flagger.

    View in the catalogue
  • Secrets in the Git workflowEncrypt, operators, no plaintext

    Passwords and tokens need dedicated handling in a GitOps workflow.

    • SOPS with Flux: encrypted manifests live in Git; the Flux controller decrypts them in the cluster.
    • In-cluster operators: External Secrets retrieves values from a secret store; Sealed Secrets decrypts encrypted resources from the repository.
    • No plaintext in Git: Kustomize generators alone do not provide encryption.

    Introduction to Flux CD (DW28) covers native SOPS decryption. Introduction to Argo CD (DW27) covers integration with secret operators, the approach Argo CD recommends. The project warns against injecting secrets during manifest generation because they are cached in plaintext.

    See the FAQ answer
  • Further workshops in preparationCGOA, no preparationCAPA, no preparation

    Workshops on Kargo, Tekton and Backstage, plus exam preparation for CGOA and CAPA, are in preparation. You can enquire about them, but these offerings are not yet bookable.

    Kargo manages the promotion of application versions between environments in the Argo ecosystem. Tekton supports Kubernetes-native pipelines. Backstage is a developer portal with a software catalogue.

    CGOA tests GitOps principles; CAPA tests knowledge of the Argo projects. Both are Linux Foundation exams. The practical courses currently available do not prepare you for either exam.

    View in the catalogue

CORE TERMS

, , ,

GitOps
In GitOps, the desired state is described declaratively and stored as immutable revisions. Software agents fetch it automatically and continuously reconcile it with the actual state. Here, Git serves as the source.
Reconciliation
Reconciliation is the repeated comparison between the state described in Git and the state running in the cluster. Depending on its configuration, the controller reports differences or updates the cluster to match the desired state.
Drift
Drift is any deviation of the cluster from the declared state, for example through a manual change. If self-healing is enabled for it, the controller corrects the difference automatically.
Pull model
In the pull model a controller in the cluster fetches changes from Git itself. The CI pipeline needs no cluster credentials for this delivery step.

PACKAGES AND VARIANTS

, , ,

Chart
A chart bundles an application's templates, default values and metadata into a versioned Helm package. Helm generates Kubernetes manifests from the chart; an installation of the chart is called a release.
Values
Values are the parameters of a Helm chart. Environment-specific values adapt the generated manifests without changing the templates.
Overlay
An overlay is a Kustomize layer that changes a shared base in targeted ways, such as namespace, replicas or image tag, without templates.
OCI artifact
OCI artifacts are distributed through registries. Besides container images, they can contain Helm charts or Kubernetes manifests. The artifacts a tool can process depend on its OCI support.

CONTROLLER OBJECTS

, , ,

Application
In Argo CD, an Application defines an application's source, target cluster, namespace and reconciliation rules. Git is one possible source.
ApplicationSet
An ApplicationSet generates Argo CD Applications from a template, for example per cluster or directory. This helps manage similar applications across environments and clusters.
Kustomization
A Flux Kustomization builds manifests from a source, applies them to the cluster and reconciles them regularly. A HelmRelease manages Helm releases instead; drift detection for those releases is configured separately.
Source
In Flux, a Source describes a watched origin, such as a Git repository, Helm repository or OCI registry. It supplies artifacts for reconciliation.

Unsure which step comes first?

Describe your next task, Kubernetes experience and preferred way of working. The finder explains which workshops fit and what prior knowledge you need.

Open the workshop finder

STARTING POINTS AT A GLANCE

Helm, Argo CD or Flux: Where does your team start?

Helm is the starting point for building application packages. To manage deployments from Git, compare Argo CD and its browser-based application overview with Flux and its Git, command-line and controller workflow. For environment-specific configuration without templates, see the Kustomize workshop in the catalogue.

DELIVERY WITH A UI

Intermediate

Introduction to Argo CD

3 daysLive onlineCourse code: DW27

Kubernetes practice with kubectl and Git basics with commits, branches and pull requests are required. The workshop introduces Argo CD and covers Helm and Kustomize as sources for delivery.

Your learning path

Before: Introduction to Kubernetes

Course code: DW2

Now: Introduction to Argo CD

Deploy applications from Git with Argo CD, inspect them in the UI and release them gradually with Argo Rollouts

View workshop

BUILD AND SHARE PACKAGES

Intermediate

Introduction to Helm for Kubernetes

You need Kubernetes experience with kubectl, knowledge of YAML and terminal skills. Previous Helm, Git or programming knowledge is not required.

3 daysCourse code: DW9View workshop

GIT-NATIVE DELIVERY

Intermediate

Introduction to Flux CD

Kubernetes practice with kubectl, Git basics with branches and pull requests, and YAML syntax are required. The workshop introduces Flux and covers Helm and Kustomize as sources for delivery.

3 daysCourse code: DW28View workshop

FIND YOUR GITOPS WORKSHOP

Helm or Kustomize, Argo CD or Flux: What fits your team?

Start with the task: Helm and Kustomize create application configuration; Argo CD and Flux deliver it. Then compare prerequisites and course content. Tool details are based on the project documentation (as of September 2026).

STARTING POINT

Suited for

DW9 Introduction to Helm for Kubernetes
Building, testing and sharing applications as versioned packages
DW22 Introduction to Kustomize
Adapting shared configuration to different environments without templates
DW27 Introduction to Argo CD
Track deployments from Git and their status in the browser
DW28 Introduction to Flux CD
Manage deployments through Git and adopt new image versions automatically

Not the right fit if

DW9 Introduction to Helm for Kubernetes
you only need to maintain configuration for different environments without templates
DW22 Introduction to Kustomize
you need to create and share Helm charts as versioned application packages
DW27 Introduction to Argo CD
your main goal is hands-on practice with automatic image updates
DW28 Introduction to Flux CD
your main priority is a shared application overview in the browser

Prerequisites

DW9 Introduction to Helm for Kubernetes
Practical Kubernetes, kubectl and YAML skills, with no Helm experience needed
DW22 Introduction to Kustomize
Practical Kubernetes and kubectl skills with configuration files, no Helm experience needed
DW27 Introduction to Argo CD
Practice: Kubernetes, kubectl, Git branches, pull requests; no Argo CD experience required
DW28 Introduction to Flux CD
Practice: Kubernetes, kubectl, YAML, Git branches, pull requests; no Flux experience required

TOOLS IN PRACTICE

What you use the tool for

DW9 Introduction to Helm for Kubernetes
Package applications as charts and generate manifests from templates and values
DW22 Introduction to Kustomize
Adapt shared configuration to different environments using overlays
DW27 Introduction to Argo CD
Continuously reconcile the cluster with Git; correct drift when self-healing is enabled
DW28 Introduction to Flux CD
Correct drift automatically for Kustomizations; enable drift correction separately for HelmReleases

How you stay in control

DW9 Introduction to Helm for Kubernetes
Manage charts from the command line; no continuously running controller or graphical interface of its own
DW22 Introduction to Kustomize
Work with and apply configuration directly through kubectl; no graphical interface of its own
DW27 Introduction to Argo CD
One central installation with a browser overview of applications across several clusters
DW28 Introduction to Flux CD
Set up Flux for each cluster; configure it in Git and operate it from the command line

Automation and gradual delivery

DW9 Introduction to Helm for Kubernetes
Installation and updates only when invoked, without continuous reconciliation
DW22 Introduction to Kustomize
Generate manifests and apply them with kubectl or a controller; Kustomize itself does not reconcile continuously
DW27 Introduction to Argo CD
Full course block: Argo Rollouts for Canary and Blue-Green
DW28 Introduction to Flux CD
Practise setting up image updates in Git; an outlook on Flagger for gradual releases

FORMAT AND LEARNING PATH

Duration

DW9 Introduction to Helm for Kubernetes
3 days
DW22 Introduction to Kustomize
2 days
DW27 Introduction to Argo CD
3 days
DW28 Introduction to Flux CD
3 days

Level

DW9 Introduction to Helm for Kubernetes
Intermediate
DW22 Introduction to Kustomize
Beginner
DW27 Introduction to Argo CD
Intermediate
DW28 Introduction to Flux CD
Intermediate

Price

DW9 Introduction to Helm for Kubernetes
€1,665.00per person, plus 19% VAT
DW22 Introduction to Kustomize
€1,110.00per person, plus 19% VAT
DW27 Introduction to Argo CD
€1,665.00per person, plus 19% VAT
DW28 Introduction to Flux CD
€1,665.00per person, plus 19% VAT

Possible next step

DW9 Introduction to Helm for Kubernetes
Next: Introduction to Argo CD or Introduction to Flux CD
DW22 Introduction to Kustomize
Next: Introduction to Argo CD or Introduction to Flux CD
DW27 Introduction to Argo CD
Next: Introduction to Helm for Kubernetes for custom charts or Kubernetes Monitoring and Observability for monitoring rollouts
DW28 Introduction to Flux CD
Next: Introduction to Helm for Kubernetes for custom charts or Introduction to GitLab CI/CD for image build pipelines

Workshop pages

Agenda & dates

TRAINING FOR GITOPS WORK

GitOps workshops at a glance

Choose your focus and open a course page for its agenda, prerequisites and dates. You can also enquire about planned workshops for your team.

Workshop index

7 published workshops, 4 learning goals
2 workshops

Build prerequisite knowledge for GitOps

All practical GitOps courses require Kubernetes and kubectl skills. Argo CD and Flux also require Git branches and pull requests. These introductory courses cover the foundations.

  • DW2Introduction to KubernetesPractise working with Pods, Deployments, Services and configuration using kubectl as a foundation for GitOps3 days
  • DW19Introduction to Git for TeamsCollaborate on changes using commits, branches, merges and pull requests as a foundation for GitOps workflows3 days
2 workshops

Charts and environment variants

Helm for versioned application packages; Kustomize for environment variants without templates. The Kustomize workshop also covers using both tools together.

  • DW9Introduction to Helm for KubernetesPackage applications as versioned Helm charts and distribute them through OCI registries3 days
  • DW22Introduction to KustomizeUse overlays to derive environment configurations from a shared base without templates2 days
5 workshops

Manage deployments from Git

Argo CD with its UI and Argo Rollouts, or Flux with image automation and SOPS. Kargo and CGOA/CAPA preparation are planned and not yet bookable.

  • DW27Introduction to Argo CDDeploy applications from Git with Argo CD, inspect them in the UI and release them gradually with Argo Rollouts3 days
  • DW28Introduction to Flux CDDeploy manifests, charts and OCI artifacts with Flux and automatically update image references in Git3 days
  • DW50Introduction to KargoUse Kargo to control and verify the promotion of application versions between environmentsRequest
  • DW43Preparation for the Certified Argo Project Associate (CAPA) ExamKnowledge questions: Argo Workflows, CD, Rollouts, Events, GitOps deliveryRequest
  • DW44Preparation for the Certified GitOps Associate (CGOA) ExamGitOps fundamentals: declarative configuration, reconciliation, delivery, security, and toolingRequest
3 workshops

Pipelines and developer portals

Build, check and publish images with GitLab CI/CD. Workshops on Tekton pipelines and the Backstage developer portal are in preparation and not yet bookable.

  • DW14Introduction to GitLab CI/CDCreate GitLab pipelines to build, check and publish images for subsequent delivery2 days
  • DW51Introduction to TektonCreate and trigger Kubernetes-native pipelines with TektonRequest
  • DW52Introduction to BackstageBuild a developer portal with a software catalogue, templates and documentation in BackstageRequest

Bookable workshops link to their detail pages. Entries marked "Request" are in preparation and open a non-binding corporate training request.

YOUR LEARNING PATH TO DELIVERY FROM GIT

From Kubernetes foundations to automated delivery

Start where you need practice: Kubernetes, structuring your manifests or operating a GitOps controller. Helm and Kustomize are alternatives, as are Argo CD and Flux.

Recommended route

Suggested route, not a fixed sequence

  1. 01

    KUBERNETES FOUNDATIONS

    Manage workloads with kubectl

    • FOUNDATION IF NEEDEDIntroduction to KubernetesLearn about Pods, Deployments, Services, storage and configuration in a cluster; GitOps is outside the course scope.Beginner3 daysCourse code: DW2
  2. 02

    HELM OR KUSTOMIZE

    Structure manifests as charts or overlays

    • CHARTS AND OCIIntroduction to Helm for KubernetesDevelop, test and version your own charts, distribute via OCI registries and hand over to GitOps.Intermediate3 daysCourse code: DW9
    • BASE AND OVERLAYSIntroduction to KustomizeDerive environment variants from a shared base without templates and structure the repository for GitOps.Beginner2 daysCourse code: DW22
  3. 03

    ARGO CD OR FLUX

    Automate reconciliation from Git

    • UI AND ROLLOUTSIntroduction to Argo CDInstall and configure Argo CD with sync, self-healing, ApplicationSets and Argo Rollouts.Intermediate3 daysCourse code: DW27
    • GIT-NATIVE AND OCIIntroduction to Flux CDBootstrap Flux with Kustomization, HelmRelease, image automation and SOPS-encrypted secrets.Intermediate3 daysCourse code: DW28

You do not need to attend every stage. With Kubernetes experience, you can start directly with Helm or Kustomize. Argo CD and Flux also require Git skills covering branches and pull requests. Each workshop is booked individually; the stages are not a course bundle.

View the GitOps learning path

VOICES FROM THE WORKSHOPS

What participants say about the Kubernetes introduction before GitOps

There is no feedback from the GitOps courses yet. The following comes from the Kubernetes introduction that the Helm, Kustomize, Flux and Argo CD courses build on.

DW2 Introduction to Kubernetes

„Overall, I thought the training was very good. The instructor was technically very competent and gave plenty of input on every topic. On a personal level it was very pleasant too, which made it fun. The learning environment was absolutely exemplary in its setup and usability. I will definitely recommend the training and DevNinjas.“

Marius B.

Dataport, Introduction to Kubernetes

Participant voice on DW2

„The instructor responded to questions and requests, explained ambiguities calmly and clearly, and helped when problems arose. The mood and atmosphere during the online sessions was relaxed as well.“

Josh H.

Introduction to Kubernetes

Participant voice on DW2

„Relaxing and instructive course. Very interesting if you are interested in Kubernetes and want to learn it.“

B. Karzkowiak

Domcura AG, Introduction to Kubernetes

Vincent Sturm - DevNinjas

Choose a GitOps workshop for your IT team

Vincent Sturm

Key Account Manager

Tell us how you deploy today and what your team needs to handle next. We will help you choose a workshop and check the Kubernetes or Git knowledge it requires. For specific requirements, we can discuss a tailored agenda.

vincent@devninjas.io
+49 221 9865099-4
WhatsApp Chat

Frequently asked questions about GitOps training

Helm or Kustomize: which should I learn first?

Helm suits creating and sharing application packages; Kustomize suits adapting existing manifests for different environments.

In the Helm workshop, you build and test versioned charts and distribute them through a registry. In the Kustomize workshop, you create development, staging and production variants without templates. You can combine them: Kustomize can adapt a Helm chart's output. Argo CD and Flux process both formats. The workshop finder considers your task and experience.

Argo CD or Flux: how do they differ?

Argo CD provides an integrated web interface with SSO and its own RBAC policies; Flux uses Kubernetes controllers and Kubernetes RBAC. Both support managing multiple clusters.

Argo CD's application overview helps with central operations. Flux can be controlled through Git and Kubernetes resources, with interfaces added from its ecosystem. For automatic image updates, Flux uses its image automation controllers; Argo CD can use the additional Argo CD Image Updater. Your operating model and access-control requirements guide the choice.

Do I need every GitOps workshop, and in what order?

You do not need every GitOps course; workshops can be booked individually, and you start according to your existing skills.

Begin with the foundations if you have no Kubernetes experience. Helm or Kustomize help structure manifests; Argo CD or Flux handle delivery and reconciliation. The controller courses cover Helm and Kustomize integration, so you do not automatically need both preparatory courses. The GitOps learning path shows one possible sequence.

Can I start learning GitOps without Kubernetes experience?

The GitOps workshops on Helm, Kustomize, Argo CD and Flux require practical Kubernetes skills with kubectl.

These include pods, deployments and services. Introduction to Kubernetes (DW2) provides that foundation. Argo CD and Flux also require Git skills covering branches and pull requests; Introduction to Git (DW19) prepares you for those. These Git skills are not prerequisites for Helm or Kustomize.

Do I still need CI with Argo CD or Flux?

Yes: Argo CD and Flux do not replace a CI pipeline; builds, tests and image scans still run in CI.

The pipeline publishes images to a registry. The GitOps controller reads the desired state from Git and reconciles the cluster with it; the pipeline needs no cluster credentials for this delivery step. The GitLab CI/CD workshop (DW14) covers pipeline work. The Flux workshop (DW28) shows how new image references reach Git automatically.

How do I manage secrets safely with GitOps?

With GitOps, encrypt secrets before committing them or store their values outside Git; plaintext does not belong in the repository.

Flux natively decrypts SOPS files inside the cluster. Argo CD recommends operators in the target cluster: External Secrets reads values from an external store, while Sealed Secrets decrypts SealedSecret objects. The Argo CD workshop covers integration. Kustomize generators do not encrypt secrets. Inserting secrets during manifest generation can leave them in plaintext in Argo CD's cache.

Which GitOps certifications exist, and do the workshops prepare for them?

CGOA and CAPA are Linux Foundation GitOps certifications; DevNinjas workshops on Argo CD and Flux do not systematically cover their exam syllabuses.

CGOA (Certified GitOps Associate) tests GitOps principles, while CAPA (Certified Argo Project Associate) tests knowledge of the Argo projects, both through multiple-choice questions. Dedicated courses for these exams are in preparation and are not yet bookable. Dates have not been set. The certification overview lists existing preparation courses for Kubernetes exams.

Is Flux still a safe choice after Weaveworks closed?

Flux continues to be developed independently of Weaveworks and is a Graduated project of the Cloud Native Computing Foundation (CNCF). Weaveworks closing therefore does not mean that Flux has ended.

Project status is not a security guarantee: maintained versions, available support and responsibility for updates within your team also matter to your decision. The Flux workshop covers working with the GitOps controllers.