Skip to main content
🚀

DevOps for Python

L4PRO· 104 lessons

Docker, CI/CD, observability, deploys, incident response

0 / 104 · 0%

104 lessons across 6 modules: Docker + containers, CI/CD + GitHub Actions, Kubernetes + orchestration, observability + logging, cloud + IaC + secrets + cost, plus the modern stack (Helm, ArgoCD GitOps, Vault, Argo Rollouts, chaos engineering, FinOps).

✅ Before you start

  • ·You've shipped at least one Python app (FastAPI, Flask, Django — anything that runs).
  • ·Terminal comfort: cd, ls, grep, ssh. We assume bash basics
  • ·A free-tier account on AWS / GCP / Fly.io / Render — we deploy to one of these in module 5

→ After you finish

ℹ️ Heads-up on the format: These lessons are concept explanations + quizzes + predict-the-output exercises. The code samples don't execute in your browser because Pyodide can't spin up an HTTP server / database / TCP socket. To run them, copy snippets into your own machine — or pair this track with Foundations (which DOES run live in-browser via Skulpt).

⭐0/312 stars· 0% complete

Resume →

What DevOps actually means in 2026

Docker basics for Python

GitHub Actions for Python CI

Secrets management

Environment promotion

Infrastructure as Code (Terraform)

Monitoring and alerting

Feature flags

Database migrations

Logs at scale

Health checks and readiness probes

Backups and disaster recovery

Cost optimization

Incident response

Capstone: ship a Python service to production

Kubernetes basics for Python

Helm charts — packaging k8s apps

Horizontal Pod Autoscaler (HPA)

Ingress controllers

ConfigMaps and Secrets

🎯 Review: DevOps module 1 recap

PersistentVolumes for stateful services

StatefulSets vs Deployments

CronJobs in Kubernetes

Service mesh basics

Distributed tracing with OpenTelemetry

Sentry for error tracking

Datadog APM integration

Prometheus + Grafana

Log aggregation: ELK and Loki

Chaos engineering basics

Blue-green vs canary deploys

Database migrations in production

Zero-downtime deploys with PostgreSQL

Disaster recovery drills

Capstone: design a CI/CD pipeline from scratch

Kubernetes operators and CRDs

GitOps with ArgoCD and Flux

HashiCorp Vault for secrets at scale

AWS IRSA: IAM roles for service accounts

NetworkPolicy: default-deny east-west

🎯 Review: DevOps module 3 recap

PodDisruptionBudgets

Resource requests and limits tuning

NodeSelectors, taints, and affinity

Karpenter vs Cluster Autoscaler

Kubecost / OpenCost dashboards

SLO, SLI, and error budgets

PagerDuty / Opsgenie alert routing

Runbook automation

PgBouncer and connection pooling

CDN edge functions

AWS Lambda cold-start optimization for Python

Modern PaaS comparison: Fly, Render, Railway, Cloud Run

Multi-stage Dockerfile with BuildKit cache mounts

Bazel basics for monorepos

Capstone: zero-downtime monolith to microservices

eBPF basics — kernel observability without sidecars

OpenTelemetry deep — exemplars and sampling

Prometheus federation — multi-cluster metrics

Loki vs ELK — log aggregation tradeoffs

SLI / SLO / error budgets

🎯 Review: DevOps module 4 recap

Chaos engineering — Litmus and Chaos Mesh

Progressive delivery — canary, blue-green, shadow

Argo CD GitOps — app-of-apps and sync waves

Helm vs Kustomize

Image security — Trivy, Cosign, SLSA

Secrets: Vault, External-Secrets, Sealed-Secrets

K8s autoscaling — HPA + VPA + Cluster Autoscaler + Karpenter

Service mesh choice — Istio vs Linkerd vs Cilium

Multi-cluster — when it's actually worth it

DR drills — Velero + etcd backup + RTO measurement

Scenario: prod is 503-ing — incident walkthrough

FinOps + Kubecost — attribution and rightsizing

Platform engineering — IDP / Backstage

Policy-as-code — OPA, Kyverno, Gatekeeper

🏆 Capstone — SRE foundations for a 50-engineer org

Helm: charts, templates, releases

ArgoCD: GitOps for K8s

Vault: dynamic secrets

Terraform: state file is the gold

K8s: liveness vs readiness vs startup

🎯 Review: DevOps module 5 recap

K8s: resource limits + requests

Istio / Linkerd: service mesh

Observability: Prometheus + Grafana

Logs: Loki vs Elasticsearch

Tracing: Jaeger / Tempo

Chaos engineering: deliberate failure

FinOps: tagging and showback

Spot / preemptible instances

Blue/green vs canary vs rolling

Backup strategy: 3-2-1 rule

Container security: distroless images

CI: cache vs parallelism

Image scanning: trivy/grype

Secrets in K8s: never as env vars

Network policy: zero-trust namespaces

GitOps: Argo Rollouts for progressive delivery

DR: multi-region active-passive

Cost: rightsizing autoscalers

Platform engineering: IDP + Backstage

🏆 DevOps capstone: production-ready cluster checklist

Tip: click any lesson to revisit it. After your first attempt, the “Show example” button reveals the full solution.