# Mission — Helm

## Why this course exists

**Course 3 of 7** in the deployment/infra track. Course 2 (Kubernetes) taught the *objects* —
Pods, Deployments, StatefulSets, Services, KEDA, PDBs — and kept saying one thing: *"this repo
doesn't hand-write these; it generates them from Helm templates."* This course is where that
promise is paid off. **Helm is the single largest topic in the whole `deployments/` domain** —
~106 charts, all built on one shared library chart — and it's how every Kubernetes object the
learner just studied actually comes into being.

If Course 2 was "what are the objects," Course 3 is "how does this codebase *produce* them,
per environment and per customer, without copy-pasting YAML 106 times."

## Who the learner is

- Backend engineer on the **conversationmgmt / notification / spike** team — strong Go, gRPC,
  Kafka, Postgres, Airflow; now solid on containers/local-dev and Kubernetes (eight courses in).
- **Newer to Helm and templating-as-infrastructure.** Charts, templates, values, releases,
  named templates, library charts are new. Assume strong backend maturity, NOT Helm fluency.
- Directly relevant: their services (`spike` = Deployment; `conversationmgmt` = StatefulSet)
  are each *tiny* charts that call one library macro — the perfect worked example.

## What "success" looks like

By the end, the learner can, from memory:

1. Explain what Helm is (a package manager + templating engine for Kubernetes) and the
   chart / release / values triad.
2. Read a chart's anatomy — `Chart.yaml`, `templates/`, `values.yaml`, `_helpers.tpl` — and
   the Go template engine (`.Values`, `.Release`, `.Chart`, functions, `include`/`tpl`).
3. Explain values **precedence** (`values.yaml` → `-f` files → `--set`) and this repo's
   env×org values layering (`{env}-{org}-values.yaml`).
4. Explain **named templates** and **library charts** — and this repo's unusual
   copy-not-dependency model (`update_deps.sh`) — and *why* it's done that way.
5. Explain Helm **hooks** (the DB-migration hook), **releases** (install/upgrade/rollback),
   and how **Skaffold** drives Helm (tying back to Course 1's `render`).
6. Explain **SOPS secret** integration, values **at scale** (~106 charts), and chart
   **operations/quality** (lint, template/dry-run, versioning, the CI drift check).

## Grounding

Every concept lands on a real chart in `deployments/helm/` — the `libs/util` library chart, a
service chart like `spike`/`conversationmgmt`, the `{env}-{org}-values.yaml` files, the SOPS
`*.encrypted.yaml`, and the Skaffold `deploy.helm` blocks — mapped in
[reference/repo-helm-map.md](./reference/repo-helm-map.md). External claims cite the official
Helm docs ([RESOURCES.md](./RESOURCES.md)) — never my memory.

## The seven-course plan (this track)

1. Containers & Local Dev ✅
2. Kubernetes ✅
3. **Helm** ← *you are here* (how the repo templates the objects from Course 2)
4. Istio & Service Mesh — the networking layer, also Helm-deployed
5. CI/CD & Delivery — how these charts reach real clusters
6. Observability & Monitoring
7. Infrastructure as Code — Terraform/GCP/GKE/Workload Identity (the KMS behind SOPS)