Skip to content
Projects

snowops-oss/snowopslabs has 136 GitHub stars and 24 forks. GitHot measured +3 stars in 24 hours and +7 in 7 days. Last checked 2026-11-16 18:57 UTC. Last push 2026-11-15.

How these counts are measured

What you can do

  • Observability - observability-sre: wire traces through a collector, follow one request across logs, metrics and traces, fire an SLO alert
  • Scaling and cost - autoscaling-under-load (KEDA on Prometheus RPS) · cost-right-sizing (OpenCost, requests sized to measured peak)
  • Delivery - gitops-cicd (Argo CD against a repo you push to) · env-promotion (dev to staging to prod) · mesh-traffic-management (Istio canary, fault injection, mTLS)
  • Security - security-compliance (Kyverno audit to enforce, cert-manager) · secrets-management (Vault rotation through External Secrets)

Measured star growth

in 24h
+3
in 7 days
+7
in 15 days
Collecting history
in 1 month
Collecting history

Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.

About

Learn platform engineering by breaking and fixing real Kubernetes clusters.

Self-hosted

README.md

Original

SnowOps Labs

A flight simulator for platform engineers: a real Kubernetes platform on your laptop, broken on purpose, with your fix graded.

License: Apache-2.0 CI Release Open in GitHub Codespaces

SnowOps Labs is a Kubernetes platform-engineering simulator. One command builds a production-shaped cluster on your laptop: real Prometheus, Grafana, Loki, Tempo, Argo CD, Istio, Kafka and Vault, not mocks. Then it breaks that cluster in ways you will meet on call, and grades how you fix it against the live cluster.

Practise what production never lets you practise: finding why every pod is Ready while a third of requests fail, draining a node under load without breaking the SLO, or picking a service mesh with evidence instead of opinion. It runs on macOS (Apple Silicon and Intel), Linux and Windows via WSL2, or in your browser through GitHub Codespaces.

labctl walking the scenario catalog, listing the built-in incident library, and validating every declarative file - real command output.

Try it

git clone --branch stable https://github.com/sagar2395/snowopslabs.git
cd snowopslabs && ./install.sh
labctl init                                              # cluster + platform, 5 to 10 minutes
labctl incident inject crashloop-bad-config --deploy-prereqs
labctl incident status                                   # hints, and whether you fixed it

No Docker on this machine? Open it in GitHub Codespaces and skip to Your first lab.

Status: stable releases ship on the stable branch, with every fault checked against a live cluster each night. What comes next is on the roadmap; bugs and ideas go in issues.

The four loops

Loop What you do Command
Build Stand up a cluster and install a real platform stack from swappable providers labctl init
Simulate Activate a scenario with objectives and checks that grade your work labctl scenario up <name>
Break Inject a reversible fault while traffic flows and alerts fire labctl incident inject <name>
Measure Grade the outcome: checks passed, time to resolve, hints used labctl scenario verify <name>

Failures are injected into the real systems, so the signal you debug is the signal you would see in production.

Who it is for

You are You use it to
An engineer learning Kubernetes operations Work through a learning path, then debug each class of failure without help
A platform team choosing a tool Swap a provider, run the same scenario on both, and compare the results
An SRE running a game day Inject faults, unnamed if you like, and measure time to resolve across sessions
A lead assessing skills Run timed challenges with the same faults, grading and par time for everyone

What you can practise

Every scenario and fault below ships today and is graded by checks against the live cluster.

13 scenarios (catalog):

Area Scenarios
Observability observability-sre: wire traces through a collector, follow one request across logs, metrics and traces, fire an SLO alert
Scaling and cost autoscaling-under-load (KEDA on Prometheus RPS) · cost-right-sizing (OpenCost, requests sized to measured peak)
Delivery gitops-cicd (Argo CD against a repo you push to) · env-promotion (dev to staging to prod) · mesh-traffic-management (Istio canary, fault injection, mTLS)
Security security-compliance (Kyverno audit to enforce, cert-manager) · secrets-management (Vault rotation through External Secrets)
Reliability chaos-engineering (Chaos Mesh experiments with a hypothesis)
Data event-driven-arch (a Kafka consumer group falling behind)
Day-2 operations node-drain-drill · cluster-upgrade-drill · backup-restore-drill, each graded on live traffic

12 faults (library), for example:

Fault What you walk into
dns-egress-blocked A security policy forgot port 53. Every pod is Ready, /health answers, and requests that call the upstream fail.
stray-pod-behind-service A steady fraction of requests fails. Every pod is Ready, and the app's own error panel is flat.
cpu-throttling p99 latency is in seconds, with no restarts, no errors and a nearly idle node.
missing-secret-key After a credential rotation, no pod starts and there are no logs to read.

4 timed challenges (on-call-shift lands two unnamed faults at once) and the kubernetes-foundations learning path tie these together into a curriculum.

See it in action

Every asset below is real labctl output and the actual embedded UI.

Inspect a scenario before you run it. labctl scenario info shows what a scenario installs: its stages, objectives, the checks that grade you, and commands to explore with:

labctl scenario info observability-sre: prerequisites, staged installs, objectives, checks, and explore commands.

Drive it from a browser. labctl ui serves a web dashboard at http://localhost:3939, built into the same binary:

SnowOps Labs web dashboard - the scenario catalog, with category tags and one-click activation.

More of the dashboard (click a thumbnail for full size):

Fault library Platform components Operate hub
Incident library - reversible faults with severity and verified badges Platform components grouped by category, each installable with one click Dashboard: cluster status, platform components, and app controls (shown before labctl init, so the cluster reads Disconnected)

Watch the setup. A video walkthrough on YouTube explains what the lab is and sets it up on a Mac, following the same steps as Install.

How it compares

Option What it leaves out
Browser-based labs Small clusters with no observability stack and no realistic failures
Certification courses (CKA/CKAD) They test what you know, not how you respond to an incident under time pressure
Internal game days Setup costs so much that they happen once or twice a year

What's inside

Layer What it does
Runtimes k3d (the default), kind (headless, used in CI), incluster (a shared team server)
Platform Ingress (Traefik/Nginx), monitoring (Prometheus + Grafana), logging (Loki), tracing (Tempo), GitOps (Argo CD), mesh (Istio/Linkerd), data (Kafka/Postgres), secrets (Vault/ESO), autoscaling (KEDA), cost (OpenCost), security (Kyverno, cert-manager), chaos (Chaos Mesh)
Scenarios Declarative labs with objectives and checks that grade your work
Incidents Reversible production faults with progressive hints and time-to-resolve measurement
Learn Ordered paths that chain scenarios and incidents into a curriculum
Challenges Timed, graded runs scored on par time and hints used
Apps go-api (HTTP, metrics, tracing), java-api (the same contract on the JVM), echo-server (HTTP + Redis), or your own
CLI + UI labctl: one binary with the web dashboard built in

What you need

  • macOS, Linux, or Windows with WSL2.
  • Docker with at least 2 CPUs and 4 GB of memory. On macOS you don't need to install anything: labctl init installs colima (a lightweight Docker VM) with Homebrew and starts it at that size. Docker Desktop works too.
  • About 10 GB of free disk for the VM, images and cluster.

labctl init installs everything else (kubectl, helm, k3d) for you, without sudo (Homebrew on macOS, ~/.local/bin on Linux and WSL).

2 CPU / 4 GB runs one scenario at a time, including the observability and autoscaling ones. 4 CPU / 6 GB runs a couple together, or the heavier ones (Kafka, service mesh, GitOps), and 8 GB runs several. Before a scenario starts, labctl checks it fits and, if not, tells you which scenario to stop or how to give Docker more memory. Per-scenario figures: Resources.

Your OS in detail: macOS · Linux · Windows (WSL2) · GitHub Codespaces.

Install

Your lab is a clone of this repository: every manifest, Helm values file, scenario and fault is a file you can open, read and change. Clone the latest release anywhere you like, then run its installer:

git clone --branch stable https://github.com/sagar2395/snowopslabs.git
cd snowopslabs
./install.sh

stable always points at the latest release; to pin one, clone with --branch vX.Y.Z (see releases). install.sh downloads the labctl binary that matches your clone into ~/.local/bin, verifies its checksum and needs no sudo. It also records where your clone is, so labctl works from any directory. If ~/.local/bin is not on your PATH yet, it prints one command that adds it to the right startup file for your shell.

On Windows, clone inside WSL2, in your Linux home (cd ~), not under /mnt/c.

To skip installing anything, open the lab in GitHub Codespaces. It builds the lab in a 4-core codespace on your GitHub account with the same install.sh and labctl init (details).

Your first lab

labctl init

init checks your machine, installs what is missing, starts Docker at the right size, creates a local Kubernetes cluster and installs the platform (Traefik, Prometheus, Grafana). The first run downloads a few hundred MB and takes about five to ten minutes; it ends with the lab's URLs. If anything is wrong (Docker too small, a stalled download, a pod that won't start), it stops and says how to fix it.

Open the dashboard:

labctl ui          # http://localhost:3939

Run a scenario. --deploy-prereqs builds and deploys the app it runs against and installs any platform component it needs:

labctl scenario list
labctl scenario info observability-sre       # what it installs, its objectives and checks
labctl scenario up observability-sre --deploy-prereqs
labctl scenario verify observability-sre     # how you're doing
labctl scenario down observability-sre       # when you're done

Break something and fix it:

labctl incident inject crashloop-bad-config --deploy-prereqs
labctl incident status                       # whether it is resolved
labctl incident hint                         # the next hint, when you are stuck

The cluster is yours: kubectl and helm work against it directly. Lab URLs look like http://grafana.snowops.localhost and need no hosts-file edits.

Next: Using the lab covers changing what the lab installs, bringing it back after a reboot, upgrading, configuration and uninstalling.

When something goes wrong

The errors say what to do. The most common:

You see Do this
docker is too small for the lab Resize Docker with the command printed, then labctl init.
The dashboard or labctl status says the cluster is unreachable Docker or colima is stopped, usually after a reboot. Run labctl init.
Not enough memory for <scenario> Run the commands it prints to free memory, or resize Docker as printed.
could not find your lab Run ./install.sh in your clone once, or cd into it.

Everything else, by symptom: Troubleshooting.

Documentation

Getting started: macOS · Linux · WSL2 · Codespaces Installing and running on your OS, or in the browser
Using the lab Everyday commands, changing the lab, upgrading, configuration, uninstalling
Scenario catalog Every scenario, what it teaches and what it needs
Fault library Every fault, what breaks and the challenges built on them
Running a game day A team session on one shared lab: setup, rounds, rescue and review
Learning paths · Challenges Guided modules, and timed graded runs
CLI reference Every labctl command and flag
Resources How much CPU and memory each scenario needs
Troubleshooting Fixes by symptom
Product · Roadmap What SnowOps Labs is for, and what comes next
Setup video What SnowOps Labs is and how to set it up locally, on YouTube

Contributing

The easiest first contribution is content: a new fault or scenario is YAML plus a shell script, with no Go to write. Start with your first scenario, pick up a good first issue, and read CONTRIBUTING for working on labctl itself.

License

Apache-2.0 - see LICENSE, NOTICE and TRADEMARKS.md.