Engineering Roles line, station 2 of 8
DevOps: CI/CD, Containers and Infrastructure as Code
Automate the path from commit to production: CI pipelines people trust, small safe containers, Kubernetes basics, infrastructure as code, safe releases, a secure supply chain and the DORA metrics.
- 6lessons
- 4 hto read and do
- Intermediatelevel
- 6podcast episodes
- 6checked exercises
Tools you'll use in this course
The lessons open these with a template ready. They work for your own job too, no course needed.
About this course
DevOps is how teams ship many small changes a day without breaking things. This course teaches the core toolkit and the reasons behind it: pipelines that test every commit fast enough that people wait for them, containers that run the same everywhere, Kubernetes manifests that keep a service healthy, infrastructure described as reviewed code, releases that can be stopped and rolled back automatically, and the metrics that show whether delivery is really improving.
You automate delivery for the order service of Mangrove Market, a fictional grocery chain whose app takes about 60,000 orders a day and four times that at festival peaks. Today the service is deployed by hand twice a month and releases often break checkout. Lesson by lesson you build a GitHub Actions pipeline with caching and test shards, cut the container image to a fraction of its size and run it as non-root, deploy it to a small Kubernetes cluster with probes and resource limits, manage its database and cache with Terraform or OpenTofu and plans in pull requests, release it with canaries and feature flags that roll back on their own, and secure the pipeline with OIDC, pinned actions, SBOMs and signed images before measuring it with the DORA metrics.
Everything runs locally or in free tiers, including a small Kubernetes cluster on your laptop. Lessons have diagrams, quick checks, a Build it section with real workflow files and manifests, auto-checked JavaScript and SQL exercises in your browser, flashcards and a podcast episode.
What you will be able to do
- Build CI pipelines that test, scan and package every change in minutes, with caching, test shards and a policy for flaky tests
- Package services as small, non-root container images and run them on Kubernetes with probes, resource limits and rolling updates
- Manage cloud infrastructure as code with modules, remote state, plans reviewed in pull requests and drift detection
- Release safely with rolling, blue-green and canary deployments, feature flags and automatic rollback on metric gates
- Secure the delivery pipeline with OIDC, pinned actions, SBOMs and signed images, and measure delivery with the DORA metrics
Syllabus
6 stops, about 4 h in total. Each stop fills in when you complete the lesson.
Continuous integration that people trust
A pipeline only protects you if people wait for it and believe it. This lesson takes Mangrove Market's order service from a 24-minute pipeline that developers work around to one that answers in about 8 minutes and can be required on every merge.
CI/CDGitHub ActionsTest shardingFlaky tests
Containers from the inside
A container is an ordinary Linux process with walls around it, and an image is a stack of read-only layers. Once you see those two mechanisms, you can write Dockerfiles that build in seconds, ship a fraction of the bytes, and stop cleanly in the middle of a festival rush.
DockerCI/CDSupply-chain security
Kubernetes for application teams
Your order service now ships as a small container image. This lesson puts it on a Kubernetes cluster the way an application team should: four copies behind a stable address, config and secrets kept out of the image, probes that restart only what is truly stuck, honest resource numbers, and a rollout you can watch and undo from the command line.
KubernetesCI/CDDocker
Infrastructure as code
The order service's database and Redis were made by hand in a cloud console, and nobody can say exactly how. This lesson puts them in Terraform or OpenTofu files, so every change is planned, reviewed in a pull request and applied by the pipeline, and so staging can be rebuilt from Git.
TerraformGitOpsCI/CD
Releasing safely
Most broken checkouts at Mangrove start with a release. This lesson turns the order service's release into a series of small, watched steps: a canary that a machine judges against the old version, feature flags that switch behaviour without a deploy, and a rollback that happens by itself before anyone is paged.
CI/CDKubernetesCanary releasesFeature flagsAutomatic rollback
Secure supply chain and delivery metrics
Your pipeline now ships the order service many times a week. That makes it a target: whoever controls the pipeline controls what runs in production. This lesson closes the main doors an attacker uses, proves which image is safe to run, and then measures whether delivery is really getting better, with the five DORA metrics.
Supply-chain securityGitHub ActionsDORA metricsCI/CD
Capstone: Automate delivery for the order service
A realistic project with a rubric and a model answer.
Final exam and certificate
10 questions drawn at random, 70% to pass.
Capstone project
Automate delivery for the order service
Mangrove Market's order service (a NestJS API with PostgreSQL and Redis) is deployed by hand twice a month, a release takes an afternoon, and about one release in three breaks checkout and is fixed by another manual deploy. Ken, the engineering manager, wants the team to be able to deploy any commit on main safely, several times a day, before the festival season. Build the delivery system for it: use a small open-source NestJS or Node API of your own as a stand-in for the order service, a local Kubernetes cluster (kind or minikube) and Terraform or OpenTofu against a local or free-tier target, and measure the result.
You will hand in
- A CI/CD pipeline as code (GitHub Actions) that lints, tests with a database service, scans, builds and pushes an image on every change
- A Dockerfile and Kubernetes manifests with probes, resource requests and limits, a non-root user and a rollout strategy
- Infrastructure as code for one environment with remote state and a plan posted to pull requests
- A release plan with a canary or blue-green step, metric gates and automatic rollback, plus a feature flag for one risky change
- A one-page delivery report: the DORA metrics before and after (real or simulated), and the next improvement
Check what you know
Already know some of this? Answer 6 quick questions, one from each lesson, and we will mark the lessons you can skim. It takes about 3 minutes and nothing is graded.
Questions
Do I need a cloud account?
No. Everything runs locally or in free tiers: GitHub Actions on a public repository, a Kubernetes cluster on your laptop with kind or minikube, and Terraform or OpenTofu against a local or free-tier target.
Which tools does it use?
GitHub Actions, Docker, Kubernetes and Terraform or OpenTofu, the most common combination in job listings. The ideas carry over to GitLab CI, Jenkins, Podman, Pulumi and others, and the lessons point out what is tool-specific.
What should I know first?
Git and pull requests (Git from the Inside and GitHub for Teams), and Linux from the command line (TechOps). Knowing a little Node or TypeScript helps, since the example service is a NestJS API, but you do not need to change its code.
How long does the course take?
About 4 to 5 hours for the six lessons with their checkpoints and practice tasks, plus roughly 60 to 70 minutes of podcast episodes. Allow 8 to 12 hours for the capstone.
Is it really free?
Yes. Every lesson, podcast episode, exercise, quiz, final exam and certificate is free. The labs and their templates for real work are free too. Plus and Premium add every lab challenge, weekly extras and a mentor on top, and they never lock the tools or the courses.
How does the final exam work?
You get 15 questions drawn at random from a larger bank. You need 70% to pass. If you do not pass, you can try again after 24 hours. The exam is graded on the server and you never see the answer key.