Learn deployment — from your machine to production

Writing software is only half the job; getting it running reliably somewhere other than your laptop is the other half. This path covers the modern deployment toolkit — build artifacts, containers and Docker, running services with systemd, secrets and configuration, CI/CD pipelines, and cloud hosting — and finishes by deploying a real application, GopherTrunk, end to end.

Start lesson 1 →Jump to glossary

Writing software is only half the job. Getting it running reliably somewhere other than your laptop — where it survives reboots, restarts after a crash, and behaves the same on a server as it did on your machine — is the other half. That second half has its own toolkit, and this path teaches it from the ground up.

Who this is for. Anyone who can build a program but has never shipped one. No prior Docker, Linux administration, or DevOps background is assumed. If you have followed the Go module and know that go build produces a single binary, you already have the one prerequisite that matters. Comfortable with containers but fuzzy on registries, systemd, or CI/CD? Use the unit list to jump straight to the part you need.

How the path works. Five units take you from “what does deploy even mean?” to a real application running on a real server. Unit 1 covers the foundations — environments, configuration, and the build artifacts everything else moves around. Unit 2 is containers and Docker: packaging an app with everything it needs to run anywhere. Unit 3 keeps a service alive and observable in production with systemd, logging, and secrets. Unit 4 automates the whole thing with CI/CD and takes it to the cloud. Unit 5 is the payoff: deploying GopherTrunk — a real software-defined-radio scanner — end to end, using its own Dockerfile, docker-compose stack, and systemd unit. There is also a glossary you can skim any time.

Every concept is grounded in files that actually ship in the GopherTrunk repo, so nothing here is hypothetical. Mark lessons complete as you go — your progress is saved in your browser. New here? Start with lesson 1: What is deployment?

Unit 1 — Foundations

What deployment means, its lifecycle, and the artifacts and config it depends on.

  1. What is deployment? The journey from source code to a running service, what "it works on my machine" really costs, and the moving parts every deployment has to handle. beginner 8 min
  2. The deployment lifecycle Build, test, release, deploy, operate — the repeating cycle every change moves through, and how the rest of this module maps onto its stages. beginner 8 min
  3. Environments & configuration Dev, staging, and production, why the same build must run in all of them, and how environment variables and config files keep settings out of code. beginner 9 min
  4. Build artifacts & versioning What a build produces, why a single reproducible artifact beats rebuilding everywhere, and how version tags let you ship and roll back with confidence. beginner 9 min
  5. Release strategies Rolling, blue-green, and canary releases — the patterns for pushing a new version to users without downtime or a risky big-bang cutover. intermediate 9 min

Unit 2 — Containers

Package an app with everything it needs to run, anywhere — safely.

  1. What is a container? Containers vs virtual machines, the isolation the kernel provides, and why "ship the whole environment" solves the works-on-my-machine problem. beginner 9 min
  2. Writing a Dockerfile Build an image step by step — base images, layers, and multi-stage builds — and how GopherTrunk's own Dockerfile turns Go source into a small runtime image. intermediate 11 min
  3. Optimizing container images Small, fast, secure images — multi-stage builds, minimal and distroless bases, layer-cache ordering, and .dockerignore — and why GopherTrunk's image is tiny. intermediate 9 min
  4. Images & registries How images are named, tagged, stored, and shared through registries, and how a pull-and-run makes deploying somewhere new a one-line operation. intermediate 9 min
  5. Multi-container apps with Compose Describe an app and its dependencies as one file — services, networks, and volumes — and bring the whole stack up with a single command. intermediate 10 min
  6. Container networking & volumes How containers get an IP, talk to each other, publish ports, and persist data — the networking and storage model beneath a Compose file. intermediate 9 min
  7. Container security Running as non-root, dropping capabilities, read-only filesystems, and scanning images — giving a container exactly the access it needs and no more. advanced 10 min

Unit 3 — Running in Production

Keep a service alive, reachable, observable, and configured safely.

  1. Services & systemd Turn a program into a managed service that starts on boot and restarts on failure, using the systemd unit GopherTrunk ships as the example. intermediate 10 min
  2. Reverse proxies & TLS Putting a service behind nginx or Caddy — terminating HTTPS, routing by host, and why the proxy, not the app, usually handles certificates. intermediate 10 min
  3. Logging & health checks How a running service tells you it's healthy — structured logs, health endpoints, and the signals an orchestrator uses to restart what is broken. intermediate 9 min
  4. Secrets & configuration management Keeping API keys and passwords out of images and repos — environment injection, secret stores, and the difference between config and secrets. intermediate 9 min
  5. Backups & persistent data Where a service's data lives, how to back it up and restore it, and why stateful data needs a plan that stateless containers don't. intermediate 9 min
  6. Production hardening Least privilege, firewalls, updates, and the systemd sandboxing GopherTrunk ships — locking a deployment down against the threats a real host faces. advanced 10 min

Unit 4 — Automate & Scale

Ship automatically, describe infrastructure as code, and grow to meet load.

  1. CI/CD pipelines Automating build, test, and release so every commit is shippable — what a pipeline does, and how GopherTrunk uses GitHub Actions to build and publish. intermediate 10 min
  2. Infrastructure as code Describing servers and services declaratively so environments are reproducible — the idea behind tools like Terraform and Ansible, versioned like code. intermediate 9 min
  3. Deploying to the cloud & VPS The hosting spectrum — a VPS you manage, managed platforms, and container services — and how to choose based on control, cost, and effort. intermediate 10 min
  4. Container orchestration What Kubernetes and its cousins actually do — scheduling, self-healing, and scaling many containers — and how to tell when you truly need one. advanced 10 min
  5. Scaling & load balancing Scaling up vs out, stateless vs stateful services, and how a load balancer spreads traffic across instances — the mechanics of handling more users. advanced 10 min
  6. Zero-downtime deploys Health-gated rollouts, draining connections, and rollback — how to replace a running version without dropping a single request. advanced 9 min

Unit 5 — Operate

Keep a live system healthy: monitor it, get alerted, respond, and control cost.

  1. Monitoring & updates Keeping a deployment healthy over time — metrics and alerts, rolling out new versions safely, and rolling back when a release goes wrong. intermediate 9 min
  2. Observability — metrics, logs & traces The three pillars that let you understand a running system — metrics, logs, and traces — and how they answer "is it up?", "what happened?", and "why is it slow?". intermediate 10 min
  3. Alerting & on-call Turning metrics into pages that matter — good alert thresholds, avoiding alert fatigue, and what being on-call for a service actually means. intermediate 9 min
  4. Incident response & runbooks What to do when production breaks — detecting, mitigating, and communicating during an incident, and the runbooks and postmortems that prevent the next one. intermediate 9 min
  5. Cost & resource management Right-sizing CPU and memory, understanding what cloud resources cost, and keeping a deployment affordable without starving it. intermediate 9 min

Unit 6 — Applied

Deploy a real application from start to finish.

  1. Deploying GopherTrunk end to end A complete worked example — container image, docker-compose stack, and a systemd service — taking GopherTrunk from a repo to a running scanner on a server. advanced 12 min
  1. Glossary of deployment terms Plain-language definitions for every deployment term in the path — container, image, registry, Dockerfile, Compose, systemd, CI/CD, artifact, secret, and more — cross-linked to the lessons.