Continuous Integration & Continuous Delivery Pipelines

GitHub Actions, GitLab CI, Artifact Caching & Blue-Green Rollouts

A complete course on delivery pipelines and GitOps as IDE-style videos, built from one set of lesson scripts. 6 modules, 30 lessons, five to ten minutes each.

Intermediate · 2 hours · 30 lessons · 74 labs

Who it is for

Intermediate level.

For developers and operations engineers who want every change tested, built and deployed the same way, from a first workflow file to GitOps with Argo CD and Flux.

What you don't need yet:

What helps:

Before you start:

Take first:

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

Labs

74 labs, 22 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First 4 lessons free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Introduction to Pipelines and Runners

  1. What Is a Pipeline? (3 labs): You can describe a pipeline as a trigger, an ordered set of steps, a machine to run them on and the artifacts they leave behind, and you can point at the same three steps written first as a shell script and then as a workflow file.
  2. Runners: Where Code Executes (4 labs): You can say what a runner is, choose one with the runs-on key by image label or by self-hosted labels, and explain why two jobs in the same workflow never see each other's files.
  3. Workflows, Jobs, Steps, and Actions (5 labs): You can name the four levels of a workflow file, read a needs key as an edge in a graph of jobs, tell a run step from a uses step, choose between a version tag and a pinned commit, and move a value from one step to another through the outputs file.
  4. Triggers and the Event Model (5 labs): You can choose the right event and filters for a workflow, read the event payload and the github context that every run carries, keep fork code out of a privileged trigger, and stop two deploys racing with a concurrency group.
  5. DORA Metrics: Measuring Your Pipeline (3 labs): You can name the five DORA metrics as the research publishes them, say which data each one is computed from, and compute change lead time and deployment frequency yourself from a commit list and a deployment log your pipeline appends to.

Optimizing the Build

  1. Passing Data Between Jobs: Artifacts (4 labs): You can move a built package from one job to the next with the upload and download artifact actions, choose a path and a retention period for it, and say in one sentence why an artifact is not a cache and not a release store.
  2. Speeding Up Builds: Caching Dependencies (4 labs): You can write a cache step whose key changes exactly when the dependencies change, read a restore keys near miss in a job log, and explain why an immutable cache entry makes a fixed key a liability rather than a speed-up.
  3. Scaling with Matrix Builds (4 labs): You can expand one job into a cross product of combinations with a strategy matrix, adjust the set precisely with include and exclude, control failure and concurrency with fail-fast and max-parallel, and build a matrix at run time from a job output parsed with fromJSON.
  4. Securing Pipelines: Secrets Management (4 labs): You can say where a secret lives, choose how it reaches a step, and explain why masking stops protecting a value the moment the value is transformed.
  5. Keyless Authentication: OIDC to the Cloud (4 labs): You can explain why a stored cloud access key is the wrong answer, read the issuer, audience and subject claims of a GitHub identity token, and wire a job to assume a cloud role using the ID-token permission and a trust policy pinned to your repository.

Delivery and Environments

  1. Building and Pushing Container Images (3 labs): You can build a reproducible image, tag it with an immutable commit identifier, and explain which part of publishing needs a registry.
  2. Defining Environments in GitHub Actions (2 labs): You can attach a job to a named environment and use that name to organize deployment configuration and policy.
  3. Environment Protection and Manual Approvals (3 labs): You can place a protected production gate after verification and explain what GitHub pauses and resumes when a reviewer approves it.
  4. Artifact Promotion: Staging to Production (3 labs): You can promote the exact image digest tested in staging into production without rebuilding it, and recognize a rebuild as a different release.
  5. The Push Model vs. The Pull Model (2 labs): You can contrast a pipeline that pushes a deployment with a GitOps controller that pulls desired state, and choose the boundary that fits a system.

GitOps with Argo CD

  1. What is GitOps? (1 lab): You can describe Git as the desired state for a service and distinguish reconciliation from a one time deployment command.
  2. Argo CD Architecture and Applications (2 labs): You can read an Argo CD Application and explain how the API, repository server, application controller, source, and destination fit together.
  3. Sync Waves and Dependency Management (2 labs): You can order Argo CD resources with sync waves and explain why dependencies belong in the desired state rather than in a shell script.
  4. Drift Detection and Self-Healing (1 lab): You can explain how Argo CD reports drift and how self-healing returns a live resource to the Git declared state.
  5. Repository Layout for Environments (2 labs): You can organize base manifests and environment overlays so Argo CD points each Application at one clear, reviewable path.

GitOps with Flux

  1. Flux as the Alternative (1 lab): You can compare Flux with Argo CD and identify the source, kustomize, and helm controllers that make a Flux reconciliation happen.
  2. Bootstrapping Flux on a Cluster (1 lab): You can explain what Flux bootstrap installs and why bootstrap is a cluster operation that must remain a declared transcript here.
  3. Sources, Kustomizations, and HelmReleases (2 labs): You can connect a Flux source to a Kustomization or HelmRelease and choose the object that matches the way an application is packaged.
  4. Image Update Automation (2 labs): You can describe Flux image automation from registry scan to policy choice to a Git commit that updates the desired state.

Release Engineering

  1. Introduction to Release Strategies (1 lab): You can choose a release strategy by its traffic shape, risk boundary, and rollback mechanism.
  2. Rolling Updates and Rollbacks (1 lab): You can read a rolling update policy and explain how to pause, inspect, and undo a rollout.
  3. Blue-Green Deployments (1 lab): You can describe blue green traffic switching and identify the two complete environments needed for a release.
  4. Rolling Back Blue-Green (2 labs): You can execute the local part of a blue green rollback plan and explain which route change still needs a cluster.
  5. Canary Releases (1 lab): You can describe a canary progression from a small traffic share to full rollout and name the signal that stops it.
  6. Feature Flags and DORA Metrics (1 lab): You can separate deployment from user release with a feature flag and measure the finished pipeline with the five DORA metrics.

Certification courses