The engineering notebook
Beacon: give it somewhere to live
You can run Beacon on a local Kubernetes cluster, explain the controllers that keep it alive, expose it safely, preserve its SQLite state, and debug the common failure modes without guessing.
Before you begin
Prerequisites and setup
Prior knowledge: Basic terminal use and a general idea of containers are helpful. Docker, Kubernetes resources, networking, storage, and troubleshooting are introduced step by step; you do not need to complete earlier Vault courses.
Tools, accounts, and cost: You need Docker, kind and kubectl. Everything runs on a local kind cluster and is free: no AWS account, no cloud load balancer, no credit card and no public DNS zone are required.
- Required course tool
- kind and kubectl
- Installation guide
- Check it with
kind version && kubectl version --client. - Starting project
- At `course-4-start` you already have a signed, non-root, multi-stage Beacon container image published to `registry.gitlab.com`, plus a Docker Compose file that runs Beacon locally with a volume for its SQLite database. You may use the provided published image reference at the tag; you do not need to have taken course 3.
- Estimated study time
- about 15 hr 45 min across 10 stages.
- Estimate sums each stage’s reading, implementation, and debugging time; your pace will vary.
- Entry point
- You may start here without completing earlier Vault paths. This prepared project snapshot includes the code described above; the listed knowledge, tools, and any cost notes still apply.
Your learning trail
A verified submission confirms the project runs and prints the expected output. It does not grade code quality or award a credential. Course progress is saved in this browser, so it does not automatically transfer to another device.
System design
What you are building
Beacon moves from a signed image to a locally orchestrated service. Kubernetes stores desired state, schedules Pods, rolls workloads, injects configuration, gives Pods stable service discovery, asks health questions, budgets machine resources, preserves SQLite data with a StatefulSet, narrows identity and network access, and finally exposes HTTPS through Ingress and cert-manager.
Stages
10 stages, in order
All lesson pages are readable, including locked stages. Locks apply only to verified project work: complete the previous stage before submitting the next one. Time labels are estimates for reading, implementation, and debugging; your pace will vary.
Phase 1 — Learn the control plane
Understand reconciliation, create a local cluster and run Beacon under a Deployment.
Trust the loop60 minutes (locked)
What changes when software is run by a control loop instead of a person?
You will be able to create a deploy/k8s directory to hold all Kubernetes manifests for Beacon.
Fork the project repository to start working through the stages.
Read what this stage coversMake a cluster local75 minutes (locked)
How can a real Kubernetes cluster run on a laptop without renting cloud infrastructure?
You will be able to create a kind cluster named beacon using a checked-in config file.
Fork the project repository to start working through the stages.
Read what this stage coversRun the image90 minutes (locked)
How does Kubernetes keep Beacon running and roll it forward without hand-starting containers?
You will be able to create a Deployment for Beacon in deploy/k8s/10-deployment.yaml.
Fork the project repository to start working through the stages.
Read what this stage covers
Phase 2 — Define the runtime contract
Move configuration outside the image, wire stable service discovery, and let Kubernetes probe Beacon correctly.
Move knobs outside90 minutes (locked)
How does Beacon receive configuration without baking it into the image?
You will be able to create 20-config.yaml with a ConfigMap for Beacon runtime settings.
Fork the project repository to start working through the stages.
Read what this stage coversGive pods a name90 minutes (locked)
How does traffic find the right Beacon Pods when Pod IPs are disposable?
You will be able to create 30-service.yaml defining a ClusterIP Service named beacon.
Fork the project repository to start working through the stages.
Read what this stage coversLet the cluster ask90 minutes (locked)
How should Kubernetes decide whether Beacon is alive, ready and finished starting?
You will be able to add HTTP startup, readiness and liveness probes to the Beacon container.
Fork the project repository to start working through the stages.
Read what this stage covers
Phase 3 — Share machines and keep state
Set resource expectations and move SQLite onto stable StatefulSet storage.
Budget the machine90 minutes (locked)
How does Kubernetes decide where Beacon fits and what happens when it uses too much?
You will be able to add resource requests for Beacon's container: small CPU, realistic memory.
Fork the project repository to start working through the stages.
Read what this stage coversKeep the database2 hours (locked)
How can Beacon keep SQLite data when Pods are disposable?
You will be able to replace the Beacon Deployment with a StatefulSet for the SQLite-backed local version.
Fork the project repository to start working through the stages.
Read what this stage covers
Phase 4 — Lock down and expose
Apply least privilege, restrict network paths, and publish Beacon through local HTTPS it can monitor itself.
Limit two blast radii2 hours (locked)
How do RBAC and NetworkPolicy give Beacon only the access it needs?
You will be able to create a named ServiceAccount beacon and attach it to the workload.
Fork the project repository to start working through the stages.
Read what this stage coversExpose it safely2 hours (locked)
How does Beacon become reachable from outside the cluster with a certificate it can monitor itself?
You will be able to install or enable ingress-nginx on the kind cluster before applying the Ingress.
Fork the project repository to start working through the stages.
Read what this stage covers
Course overview
A container image is a package, not a platform. Beacon still needs placement, restarts, stable networking, configuration, storage, policy and a safe edge before it behaves like a service someone can rely on.
What you will learn: Kubernetes Deployments and rollouts, Liveness and readiness probes, Requests, limits and QoS classes, Kubernetes RBAC and NetworkPolicy, Ingress and cert-manager TLS. Build the project through cumulative challenges with beginner explanations and local verification.
- Level
- Complete beginner to independently building and operating the project
- Format
- 10 cumulative stages. Every stage teaches the concept in full before any code, then gives you the thing to build and the run that proves it works
