Build an Orchestrator in Go (From Scratch) (Tim Boring) (Z-Library)

# Build an Orchestrator in Go (From Scratch) ## 【One-Line Pitch】 A hands-on, project-based guide that walks you through building a container orchestration system (named "Cube") from the ground up using Go, teaching you the core concepts behind systems like Kubernetes by implementing them yourself. Ideal for Go developers and backend engineers who want to understand orchestration internals rather than just using them. ## 【Book Arc】 - **Opening (~0%–10%)**: Introduces the motivation for orchestration through a relatable scenario (managing diverse applications with different deployment processes) and lays out the mental model of an orchestrator's components—task, job, scheduler, manager, worker, cluster, and CLI. Sets the design constraints: use Go with minimal external libraries, run workers in a high-availability manner but only a single manager instance for simplicity. - **Early (~10%–23%)**: Fleshes out the foundational objects. Starts with the Task struct, then builds the Worker skeleton with a queue for FIFO task handling and a database (map) for tracking tasks. Introduces the Node concept as the physical aspect of a worker. Implements the Docker integration layer—pulling images, creating containers, and stopping/removing them via the Docker client. - **Early (~23%–32%)**: Completes the Worker implementation and builds its HTTP API using the chi router. Implements handlers for starting tasks (POST /tasks), listing tasks (GET /tasks), and stopping tasks (DELETE /tasks/{taskID}). Demonstrates testing the API with curl commands and observing log output. - **Middle (~32%–42%)**: Adds a metrics collection system to the worker. Implements functions to gather CPU stats from /proc/stat, memory stats, and load averages. Exposes these metrics via a /stats API endpoint, with a CollectStats method that refreshes data every 15 seconds (an arbitrary interval for observability). - **Middle (~42%–48%)**: Introduces the Manager component, which handles administrative concerns (user requests, scheduling, state tracking, restarting failed tasks) separately from execution concerns. Implements a naive round-robin scheduling algorithm to assign tasks to workers. Uses goroutines with anonymous functions to run continuous update loops that refresh task states from workers. - **Late (~48%–100%)**: Covers the remaining components: the Manager API, failure handling and recovery scenarios, a scheduler interface with more sophisticated algorithms, a storage interface supporting both in-memory and persistent database backends, and finally a CLI with commands for starting the manager/worker, running/stopping tasks, checking status, and managing nodes. The book closes with guidance on next steps for working with Kubernetes and related tooling. ## 【Key Takeaways】 - **Orchestration is about separation of concerns** (Early): The manager handles administrative tasks (scheduling, state tracking, failure recovery) while workers handle execution. This architectural split is fundamental to understanding systems like Kubernetes and Borg. - **Tasks are the atomic unit of orchestration** (Early): Everything revolves around the Task object, which runs as a Docker container. Understanding task lifecycle—from submission to running to stopping—is the foundation for everything else. - **Composition over inheritance in Go** (Early): The Worker struct embeds a Queue from an external package, demonstrating Go's composition model. This pattern—building higher-level objects from smaller, reusable structs—recurs throughout the book. - **Docker is the execution substrate** (Early): The orchestrator interacts with Docker through its client library for pulling images, creating containers, and stopping/removing them. The Docker abstraction provides the "kitchen" where tasks get their CPU, memory, and networking resources. - **Metrics drive scheduling decisions** (Middle): The worker collects CPU, memory, and load statistics from the system (including parsing /proc/stat) and exposes them via an API. These metrics are what enable the manager to make informed scheduling choices. - **Scheduling starts simple, then evolves** (Middle): The initial implementation uses naive round-robin, but the book later introduces a scheduler interface with a Score() method, allowing for more sophisticated algorithms that consider worker capabilities and metrics. - **Observability is built-in, not bolted on** (Middle): The use of goroutines with infinite loops to continuously update task states and collect metrics reflects a design philosophy where monitoring is integral to the system, not an afterthought. - **Persistence is pluggable** (Late): The storage interface allows tasks to be stored in-memory or in a database, showing how to design for flexibility when requirements change. ## 【Reading Tips】 - **Skim the opening scenario** (~0%–3%): The Michelle example is motivational but not technical. Move quickly to the component breakdown and design decisions. - **Deep-read the Task and Worker chapters** (~10%–23%): These establish the core data structures and Docker integration that everything else builds on. Type out the code as you go—the listings are meant to be followed along. - **Pay special attention to the Manager chapter** (~42%–48%): The round-robin scheduler and the goroutine-based update loops are the heart of the system. Understanding these patterns will make the later scheduler interface and failure-handling chapters much easier. - **Treat the CLI chapter as a capstone** (Late): Rather than reading it in isolation, use it as a way to review and operate the entire system you've built. Run the commands to see the full orchestrator working end-to-end. - **Don't skip the "Now what?" chapter** (Ending): It provides valuable context on how Cube's architecture maps to real-world systems like Kubernetes, which helps solidify the concepts you've learned. ## 【Coverage Limits】 The excerpts cover the book's structure and the implementation details through roughly the middle of the Manager chapter (~48%). The later chapters on failure handling, the scheduler interface, storage abstraction, and the CLI are described in the table of contents but their implementation details are not covered in the provided material. ##