Skip to content

Latest commit

 

History

History
290 lines (206 loc) · 26.5 KB

learning-roadmap.md

File metadata and controls

290 lines (206 loc) · 26.5 KB

Learning roadmap: from zero to DevOps mastery

The labs in this repo are the practice. This roadmap is the curriculum: every skill area a strong DevOps / SRE / platform engineer needs, in what order, how deep, and how you know you've got it.

How to use it

  1. Work level by level. Finish Level 1 in every domain before going deep into Level 3 of one. Breadth first, then depth.
  2. For each topic: learn → practice → prove.
    • Learn: the resources listed, plus the lab's knowledge.md.
    • Practice: the linked lab, typed by you, not copy-pasted.
    • Prove: you can do the checkpoint without notes, and explain it to someone else.
  3. Write as you go. Notes in each lab's knowledge.md ("My notes") and README ("What broke", "Lessons learned"). Writing is where understanding gets tested.
  4. Tick the checkpoints in this file as you reach them. It's your progress tracker.

Levels

Level Meaning Roughly
1. Foundation You can use it and explain the basics Junior
2. Practitioner You can build and run it on your own, and fix common problems Mid-level
3. Advanced You can design it, run it in production, and debug the hard problems Senior
4. Expert You know the internals and trade-offs, and you teach others Staff / principal

Levels 1–3 are the goal of this roadmap. Level 4 comes from years of running real systems.


The domains

1. Linux and the operating system

Level Learn Practice Checkpoint: you can…
1 Shell, files and permissions, users and sudo, packages, processes, services, logs 01, 02 - [ ] Harden a fresh server without notes, and explain each step
2 systemd in depth, signals, cron/timers, storage (partitions, LVM, mounts), boot process 17, 19, 03 - [ ] Fix a server whose disk is full, a service that won't start, and a bad fstab
3 Namespaces, cgroups, kernel tuning, performance analysis (USE, perf), security modules 18, 20, 21 - [ ] Find why a server is slow within 15 minutes, with evidence

Resources: The Linux Command Line (free book) · How Linux Works (Brian Ward) · Systems Performance (Brendan Gregg) · Julia Evans' zines · man pages.

2. Networking

Level Learn Practice Checkpoint
1 IP, ports, TCP vs UDP, DNS, HTTP(S), firewalls 01, 02, 05 - [ ] Explain what happens when you type a URL and press Enter, down to TCP and TLS
2 Subnets/CIDR, routing, NAT, load balancing, TLS and certificates, packet capture 13, 15, 16 - [ ] Debug "can't connect" by layer: DNS, route, firewall, port, TLS, app
3 Container and Kubernetes networking internals, VPNs, BGP basics, cloud networking (VPCs) 14, 28, 35 - [ ] Draw how a packet reaches a pod in Kubernetes, rule by rule

Resources: Computer Networking: A Top-Down Approach (Kurose & Ross) · High Performance Browser Networking (free) · Beej's Guide to Network Programming · Julia Evans' networking zines · Wireshark.

3. Scripting and programming

Level Learn Practice Checkpoint
1 Bash: variables, loops, conditionals, pipes, set -euo pipefail, exit codes every lab's scripts (deploy.sh, smoke-test.sh) - [ ] Write a script that passes shellcheck and fails safely
2 One real language: Go (you already have hello-api) or Python; HTTP, JSON, tests, CLIs apps/hello-api - [ ] Add a feature to hello-api with tests, through CI
3 Automation tools and services: API clients, a small CLI, a Kubernetes controller your own project - [ ] Ship a tool other people use

Resources: A Tour of Go · Learning Go (Jon Bodner) · Automate the Boring Stuff with Python (free) · ShellCheck wiki.

4. Git and collaboration

Level Learn Practice Checkpoint
1 Commit, branch, merge, PRs, .gitignore, never committing secrets this repo: a branch and PR per lab - [ ] Write commit messages and PRs others understand
2 Rebase, conflicts, revert, bisect, tags and semantic versioning, code review — - [ ] Find a bad commit with git bisect; recover a "lost" commit with reflog
3 Trunk-based development, release strategy, monorepos, branch protection Phase 14 - [ ] Design a branching and release process for a team

Resources: Pro Git (free) · Conventional Commits · trunkbaseddevelopment.com.

5. Containers

Level Learn Practice Checkpoint
1 Images, containers, volumes, ports, Compose 04, 06 - [ ] Containerize an app with its database from scratch
2 Multi-stage, small and non-root images, layer caching, multi-arch, healthchecks, registries 04, 07 - [ ] Get an image under 30 MB that runs as non-root
3 What a container is (namespaces, cgroups, overlayfs), runtimes (containerd), image security 18, 37, Phase 13 - [ ] Build a container by hand with unshare

Resources: Docker docs · Docker Deep Dive (Nigel Poulton) · What even is a container?.

6. CI/CD and delivery

Level Learn Practice Checkpoint
1 Pipelines: test, build, push, deploy; secrets in CI 07 - [ ] Build a pipeline from an empty repo to a running deploy
2 Zero-downtime deploys, rollback, immutable artifacts, GitOps 08, 12 - [ ] Deploy under load with zero errors, and roll back in one command
3 Multiple environments and promotion, canary and feature flags, DORA metrics 27, 42, Phase 14 - [ ] Measure your deployment frequency, lead time, change failure rate, recovery time

Resources: Continuous Delivery (Humble & Farley) · Accelerate (Forsgren, Humble, Kim) · dora.dev · GitHub Actions docs.

7. Infrastructure as Code and configuration management

Level Learn Practice Checkpoint
1 Declarative vs imperative, idempotency, Ansible playbooks 09 - [ ] Rebuild a server from zero with one command
2 Terraform: state, plan, providers, modules; secrets (Vault, ansible-vault) 10 - [ ] Create and destroy a cloud environment from code, with remote state
3 Reusable modules, testing IaC, policy as code, drift detection at team scale 27, Phase 13 - [ ] Write a Terraform module others reuse, with tests

Resources: Ansible docs · Terraform: Up & Running (Yevgeniy Brikman) · Terraform tutorials.

8. Cloud: Google Cloud (GCP)

Level Learn Practice Checkpoint
1 Resource hierarchy, projects, billing budgets, IAM (roles, service accounts), gcloud, Compute Engine, Cloud Storage 26, 29 - [ ] A budget alert exists before anything else; SSH to a VM with no public IP (IAP)
2 Project structure as code, VPC and Cloud NAT, load balancing, instance groups, Artifact Registry, Cloud Run, Cloud SQL, Secret Manager, Workload Identity Federation 27–30 - [ ] CI deploys to GCP with no service account key anywhere
3 GKE in production, Workload Identity, Cloud Logging/Monitoring, FinOps, multi-region design 31, 32 - [ ] Explain the bill line by line, and design for a given budget and availability target

How the projects are laid out (one per environment, state, IAM, CI access): ADR 0004.

Resources: Google Cloud Skills Boost (hands-on labs) · Google Cloud documentation · Google Cloud Architecture Framework · Terraform Google provider · Associate Cloud Engineer, then Professional Cloud DevOps Engineer certification.

⚠️ Set a budget alert before creating anything, and terraform destroy dev after each lab. Cloud mistakes cost real money. The concepts (IAM, VPCs, managed services) carry over to AWS and Azure.

9. Kubernetes: from basics to deep dive

Level Learn Practice Checkpoint
1 Pods, Deployments, Services, namespaces, labels, kubectl fluency; ConfigMaps, Secrets, volumes, StatefulSets, Jobs 12, 33, 34 - [ ] Deploy an app with a database from YAML you write yourself, without looking anything up
2 Networking (Services, DNS, Ingress, Gateway API, NetworkPolicies), scheduling and resources, Helm, GitOps, troubleshooting 35, 36, 38, 23 - [ ] Fix CrashLoopBackOff, Pending, ImagePullBackOff, and OOMKilled pods in minutes; pass CKAD
3 Security (RBAC, Pod Security, policy as code), control-plane internals, kubeadm, upgrades, etcd backup, GKE 37, 39, 40, 31 - [ ] Build a cluster with kubeadm, upgrade it, and restore etcd; pass CKA
4 Operators and CRDs, admission control, progressive delivery, multi-environment GitOps 41, 42 - [ ] Write an operator in Go; canary with automatic rollback; pass CKS

Resources: Kubernetes docs (also allowed during CKA/CKAD/CKS) · Kubernetes Up & Running · Kubernetes in Action (Marko Lukša) · Killercoda (free browser labs) · killer.sh (exam simulator) · Kubernetes the Hard Way · The Kubebuilder Book · Programming Kubernetes (Hausenblas & Schimanski).

Service mesh (Phase 11)

A mesh moves encryption, retries, traffic control, and per-call telemetry out of the app code and into proxies (or the kernel). Learn it after Kubernetes networking, security, and observability (35, 37, 38).

Level Learn Practice Checkpoint
1 Why meshes exist, sidecar pattern, L4 vs L7, Envoy listeners/routes/clusters, xDS 43, 44 - [ ] Route and retry traffic with an Envoy config you wrote yourself
2 Linkerd and Istio basics: injection, automatic mTLS, golden metrics, Gateway API, ingress gateway 45, 46 - [ ] Show encrypted pod-to-pod traffic and per-route success rates with zero code changes
3 Traffic management (canary, mirroring, fault injection, circuit breaking), zero-trust (SPIFFE, AuthorizationPolicy), tracing 47–49 - [ ] A 90/10 canary with default-deny policies, and one slow request traced across services
4 Sidecarless meshes (Istio ambient, Cilium), overhead, control-plane upgrades, multi-cluster, when not to use a mesh 50 - [ ] A measured comparison and a written recommendation; pass ICA

Resources: Istio docs · Linkerd docs · Envoy docs · Istio in Action (Posta, Maloku) · Solo.io Academy and Buoyant Service Mesh Academy (free) · Isovalent labs for Cilium (free) · Gateway API (GAMMA).

10. Observability

Level Learn Practice Checkpoint
1 Metrics vs logs vs traces, dashboards, basic alerts 11 - [ ] Build a dashboard that answers "is it healthy?" at a glance
2 PromQL, LogQL, RED/USE, cardinality, alert design, SLOs 11, 25 - [ ] Write alerts that fire on user-facing symptoms, with no noise
3 Distributed tracing (OpenTelemetry), profiling, observability at scale 38, 49 - [ ] Trace one slow request across services to its cause

Resources: Prometheus docs · OpenTelemetry docs · Observability Engineering (Majors, Fong-Jones, Miranda) · Google SRE books (free).

11. Security / DevSecOps

Level Learn Practice Checkpoint
1 SSH keys, firewalls, least privilege, secrets out of git, updates 01, 07 - [ ] Explain every secret in this repo: where it lives, who can read it
2 TLS/PKI, vulnerability scanning (Trivy), secrets managers (Vault), OWASP Top 10 21, 37, Phase 13 - [ ] Make CI fail on critical vulnerabilities in your image
3 Supply chain (SBOM, cosign signatures, SLSA), policy as code (OPA/Kyverno), zero-trust service identity, threat modelling 37, 48, Phase 13 - [ ] Only signed images can run in your cluster

Resources: OWASP Top 10 · SLSA · CIS Benchmarks · Container Security (Liz Rice).

12. Data services and messaging (for operators)

Level Learn Practice Checkpoint
1 Running Postgres and Redis in containers, connections, basic SQL; what makes stateful services hard 04, 51 - [ ] Explain for each OpsForge data service how it's deployed, backed up, and monitored
2 Backups and restore tests, connection pooling, indexes, replication; MySQL vs PostgreSQL; Redis persistence and eviction; MongoDB replica sets 03, 24, 52–55 - [ ] Restore production data onto a fresh server, timed, for two different databases
3 Operators and automatic failover, point-in-time recovery, sharding; messaging with RabbitMQ and Kafka (acks, dead letters, partitions, consumer lag) 52–57 - [ ] Kill a primary or a broker under load and show what was (not) lost
4 Event-driven design (outbox, idempotent consumers), zero-downtime migrations, disaster recovery drills 58, 59 - [ ] A DR drill from zero with measured RPO and RTO

Resources: Designing Data-Intensive Applications (Martin Kleppmann): the most valuable book on this list · PostgreSQL docs · PostgreSQL 14 Internals (Egor Rogov, free from Postgres Professional) · CloudNativePG docs · High Performance MySQL · Valkey / Redis docs · MongoDB University (free) · RabbitMQ tutorials · Kafka: The Definitive Guide · Strimzi docs · Enterprise Integration Patterns (Hohpe, Woolf).

13. Scalability, reliability, and SRE

Level Learn Practice Checkpoint
1 Availability, redundancy, health checks, graceful shutdown 04, 08 - [ ] Explain why a deploy can cause errors and how to prevent it
2 Load testing, capacity planning, horizontal scaling, caching, queues 22–24 - [ ] Find your system's breaking point and its bottleneck
3 SLOs and error budgets, chaos engineering, incident response and postmortems 25, 47, Phase 14 - [ ] Lead a (practice) incident and write a blameless postmortem

Resources: Site Reliability Engineering + The SRE Workbook (free) · Release It! (Michael Nygard) · incident.io guide.

14. Ways of working

Level Learn Checkpoint
1 Documentation, clear PRs, asking good questions - [ ] Every lab README lets someone else repeat it
2 DevOps culture, DORA, blameless postmortems, on-call - [ ] Write a runbook someone else can follow at 3 a.m.
3 Platform engineering (internal platforms, "golden paths"), mentoring, technical writing - [ ] Teach a lab to someone, or publish it as a blog post

Resources: The Phoenix Project (novel) · The DevOps Handbook · Team Topologies · platformengineering.org.


Labs still to create (future phases)

Phases 9 (GCP, labs 26–32), 10 (Kubernetes in depth, labs 33–42), 11 (service mesh, labs 43–50), and 12 (data services and messaging, labs 51–59) exist as lab stubs. Still listed here only:

Phase Labs
13 — DevSecOps Image scanning and SBOMs in CI · signing images with cosign · Vault for secrets · supply-chain levels (SLSA) · threat modelling one system
14 — SRE and delivery dev/staging/prod promotion · incident simulation and postmortem · DORA metrics for this repo

Suggested path (about 21 months at 8–10 hours a week)

Stage Months Focus Labs Milestone
A. Foundations 1–3 Linux, networking, Bash, Git, containers 00, 01–06, 13, 17 All Level 1 checkpoints
B. Automation 4–6 CI/CD, IaC, observability, backups, a real VPS online 03, 07–11 The VPS rebuilt from code; alerts on your phone
C. Platforms 7–10 Kubernetes basics, Google Cloud, scaling 12, 22–24, 26–31, 33–36 Associate Cloud Engineer; CKAD
D. Depth 11–15 Kubernetes deep dive, OS internals, security, reliability 14–16, 18–21, 25, 32, 37–42 CKA, then CKS; a public portfolio
E. Data and messaging 16–18 PostgreSQL, MySQL, Redis, MongoDB, RabbitMQ, Kafka; event-driven design; DR 51–59 A DR drill with measured RPO/RTO; optional Kafka admin certification
F. Service mesh 19–21 Envoy, Linkerd, Istio in depth, sidecarless meshes 43–50 ICA (Istio Certified Associate); a measured mesh comparison in your portfolio

A weekly rhythm

Time Activity
~2 h Learn: read the lab's knowledge.md and one resource; answer "Before you start"
~5 h Practice: do the lab yourself; break things on purpose
~1 h Write: "What broke", "Lessons learned", "My notes"; tick checkpoints here
~30 min Review: what's next, and one thing you'd explain differently now

Stages E and F are interchangeable: pick the one your next job needs most. Data services come up in almost every role; service meshes mainly in larger platform teams.

Small and steady beats long and rare: five sessions of 1.5 hours teach more than one 8-hour day.

Certifications (optional, in this order)

Certification When Why
HashiCorp Terraform Associate Any time after lab 10 Quick, validates IaC basics
Google Associate Cloud Engineer After labs 26–31 The entry GCP certification: hands-on cloud operations
CKAD (Certified Kubernetes Application Developer) After labs 33–36 Hands-on, about using Kubernetes; a good first Kubernetes exam
CKA (Certified Kubernetes Administrator) After labs 37–40 Hands-on, about running clusters; highly respected
CKS (Kubernetes Security) After CKA (required) Security depth
Google Professional Cloud DevOps Engineer After Stage D Senior-level: SRE practices on GCP
ICA (Istio Certified Associate) After labs 46–49 Hands-on Istio: traffic, security, observability
CCA (Cilium Certified Associate) Optional, after lab 50 eBPF networking and Cilium's mesh
Confluent Certified Administrator for Apache Kafka Optional, after lab 57 If your work involves Kafka
MongoDB Associate DBA Optional, after lab 55 If your work involves MongoDB

Certificates open doors; the labs and your write-ups are what convince people once the door is open.


Appendix: fundamentals and career

Fundamentals under everything

These aren't tools, but they explain why the tools behave the way they do. Study them alongside the labs, roughly when the "when" column says.

Topic What to learn When Resources
Distributed systems CAP and PACELC, consistency models, consensus (Raft), leader election, idempotency, clocks and ordering, why "exactly once" is hard With labs 39–40 (etcd) and 52–57 Designing Data-Intensive Applications · MIT 6.5840 Distributed Systems (free lectures) · Raft visualisation · Martin Kleppmann's distributed systems lectures (free)
System design Requirements, back-of-the-envelope estimates, trade-offs, diagrams; designing a whole system end to end After Stage C, then ongoing (interviews) System Design Primer (free) · System Design Interview vol. 1–2 (Alex Xu)
Identity for humans OAuth2, OIDC, SSO, sessions vs tokens; a login (Keycloak + oauth2-proxy) in front of Grafana, Argo CD, Portainer With labs 37 and 48 OAuth 2.0 Simplified (free) · Keycloak docs · oauth2-proxy
APIs REST design, gRPC and protobuf, versioning, API gateways, rate limits With labs 43–47 gRPC docs · Google API design guide
Disaster recovery RPO and RTO, backup strategies (3-2-1), DR tiers, multi-region failover, DR drills With labs 03 and 59 Google Cloud DR planning guide
CLI fluency jq, yq, awk, sed, regex, tmux, vim basics, shell history and aliases From day one; 15 minutes a day The Missing Semester (free, MIT) · The Art of Command Line · jq manual

Career skills

Skill How to practise
Interviews Live troubleshooting ("this pod won't start"), system design, and telling incident stories. Every lab's "What broke" section is a ready-made story: symptom, investigation, cause, fix
Portfolio Finished labs with your own notes; a blog post every 2–3 labs; a clean README with the roadmap (this repo)
Technical English Write all docs, commits, and notes in English (you already do); read postmortems and RFCs; explain a lab out loud
Staying current Release notes of the tools you use; the CNCF landscape; one newsletter such as SRE Weekly

Specialisations (choose one or two later)

  • Edge and CDN: Cloudflare, caching, WAF, DDoS protection
  • Compliance: SOC 2, ISO 27001, GDPR basics, audit trails
  • MLOps and LLMOps: GPU workloads on Kubernetes, model serving
  • eBPF in depth: Cilium, Tetragon, kernel-level observability
  • A second cloud: AWS or Azure, mapped from GCP (most concepts transfer one to one)

What "mastery" really takes

  • Run something real, for a long time. Keep the VPS online with real use (even just yours): upgrades, expired certificates, a full disk. Problems you didn't plan are the best teachers.
  • Break things on purpose, then write down what you saw. Every lab does this; keep doing it.
  • Explain it. If you can't explain it simply, you don't know it yet. Blog posts, a talk at a meetup, or helping someone online.
  • Read other people's systems. Open-source Helm charts, Terraform modules, postmortems (danluu/post-mortems).
  • Go general, then deep: be solid across all 14 domains (Level 2), and expert in two or three you enjoy most.

Reference roadmaps