Build an Orchestrator in Go (From Scratch) / Создание оркестратора в Go (с нуля)
Год издания: 2024
Автор: Boring Tim / Боринг Тим
Издательство: Manning Publications Co.
ISBN: 978-1-6172-9975-9
Язык: Английский
Формат: PDF (Not True), EPUB, MOBI
Качество: Издательский макет или текст (eBook)
Интерактивное оглавление: Да
Количество страниц: 410
Описание:
Develop a deep understanding of Kubernetes and other orchestration systems by building your own with Go and the Docker API.
Orchestration systems like Kubernetes can seem like a black box: you deploy to the cloud and it magically handles everything you need. That might seem perfect—until something goes wrong and you don’t know how to find and fix your problems. Build an Orchestrator in Go (From Scratch) reveals the inner workings of orchestration frameworks by guiding you through creating your own.
In Build an Orchestrator in Go (From Scratch) you will learn how to:
Identify the components that make up any orchestration system
Schedule containers on to worker nodes
Start and stop containers using the Docker API
Manage a cluster of worker nodes using a simple API
Work with algorithms pioneered by Google’s Borg
Demystify orchestration systems like Kubernetes and Nomad
Build an Orchestrator in Go (From Scratch) explains each stage of creating an orchestrator with diagrams, step-by-step instructions, and detailed Go code samples. Don’t worry if you’re not a Go expert. The book’s code is optimized for simplicity and readability, and its key concepts are easy to implement in any language. You’ll learn the foundational principles of these frameworks, and even how to manage your orchestrator with a command line interface.
About the Technology:
Orchestration frameworks like Kubernetes and Nomad radically simplify managing containerized applications. Building an orchestrator from the ground up gives you deep insight into deploying and scaling containers, clusters, pods, and other components of modern distributed systems. This book guides you step by step as you create your own orchestrator—from scratch.
About the Book:
Build an Orchestrator in Go (From Scratch) gives you an inside-out perspective on orchestration frameworks and the low-level operation of distributed containerized applications. It takes you on a fascinating journey building a simple-but-useful orchestrator using the Docker API and Go SDK. As you go, you’ll get a guru-level understanding of Kubernetes, along with a pattern you can follow when you need to create your own custom orchestration solutions.
What's Inside:
Schedule containers on worker nodes
Start and stop containers using the Docker API
Manage a cluster of worker nodes using a simple API
Work with algorithms pioneered by Google’s Borg
Who should read this book:
Build an Orchestrator in Go (From Scratch) is for anyone responsible for deploying and operating an orchestration system (i.e., DevOps engineers and SREs) and for anyone responsible for deploying and managing applications that run on an orchestration system (i.e., software engineers). If you want to learn how orchestrators work, you could read the source code for either Kubernetes or Nomad, both open source projects available on GitHub. Kubernetes has 5 million lines of Go code. Nomad has a considerably smaller codebase, but it’s still 500,000-plus lines of Go. I don’t know about you, but I would struggle to get much value from trying to make sense of half a million lines of code, let alone 5 million lines!
Получите глубокое представление о Kubernetes и других системах оркестровки, создав свою собственную с помощью Go и Docker API.
Системы оркестровки, такие как Kubernetes, могут показаться "черным ящиком": вы развертываете их в облаке, и оно волшебным образом обрабатывает все, что вам нужно. Это может показаться идеальным решением — до тех пор, пока что-то не пойдет не так, и вы не будете знать, как найти и устранить свои проблемы. Создание Orchestrator в Go (с нуля) раскрывает внутреннюю работу фреймворков оркестровки, помогая вам создать свой собственный.
В Создание оркестратора в Go (с нуля) вы узнаете, как:
Определять компоненты, из которых состоит любая система оркестрации
Запланируете размещение контейнеров на рабочих узлах
Запускать и останавливать контейнеры с помощью Docker API
Управлять кластером рабочих узлов с помощью простого API
Работать с алгоритмами, впервые разработанными Google Borg
Демистифицируете системы оркестровки, такие как Kubernetes и Nomad
Создание оркестратора в Go (с нуля) объясняет каждый этап создания оркестратора с помощью диаграмм, пошаговых инструкций и подробных примеров кода Go. Не волнуйтесь, если вы не являетесь экспертом в Go. Программный код книги оптимизирован для обеспечения простоты и удобочитаемости, а его ключевые концепции легко реализовать на любом языке. Вы узнаете об основополагающих принципах этих фреймворков и даже о том, как управлять вашим оркестратором с помощью интерфейса командной строки.
О технологии:
Фреймворки оркестрации, такие как Kubernetes и Nomad, радикально упрощают управление контейнеризированными приложениями. Создание оркестратора с нуля дает вам глубокое представление о развертывании и масштабировании контейнеров, кластеров, модулей и других компонентов современных распределенных систем. Эта книга поможет вам шаг за шагом создать свой собственный оркестратор с нуля.
О книге:
Создание оркестратора в Go (с нуля) дает вам представление о фреймворках оркестрации и низкоуровневой работе распределенных контейнерных приложений. Она отправит вас в увлекательное путешествие по созданию простого, но полезного оркестратора с использованием Docker API и Go SDK. По мере продвижения вы получите представление о Kubernetes на уровне гуру, а также схему, которой вы можете следовать, когда вам нужно создавать свои собственные решения для оркестровки.
Что внутри:
Планируйте контейнеры на рабочих узлах
Запускайте и останавливайте контейнеры с помощью Docker API
Управляйте кластером рабочих узлов с помощью простого API
Работайте с алгоритмами, впервые разработанными Borg из Google
Кому стоит прочитать эту книгу:
Создание оркестратора в Go (с нуля) предназначено для всех, кто отвечает за развертывание и эксплуатацию системы оркестрации (например, инженеров DevOps и SREs), а также для всех, кто отвечает за развертывание и управление приложениями, работающими в системе оркестрации (например, инженеров-программистов). Если вы хотите узнать, как работают оркестраторы, вы можете ознакомиться с исходным кодом Kubernetes или Nomad, оба проекта с открытым исходным кодом доступны на GitHub. В Kubernetes 5 миллионов строк кода на Go. У Nomad значительно меньшая кодовая база, но все равно это более 500 000 строк кода Go. Не знаю, как вы, а я бы с трудом извлек какую-то пользу из попыток разобраться в полумиллионе строк кода, не говоря уже о 5 миллионах строк!
Примеры страниц (скриншоты)
Оглавление
Front matter
preface
acknowledgments
about this book
about the author
about the cover illustration
Part 1 Introduction
1 What is an orchestrator?
1.1 Why implement an orchestrator from scratch?
1.2 The (not so) good ol’ days
1.3 What is a container, and how is it different from a virtual
machine?
1.4 What is an orchestrator?
1.5 The components of an orchestration system
The task
The job
The scheduler
The manager
The worker
The cluster
Command-line interface
1.6 Meet Cube
1.7 What tools will we use?
1.8 A word about hardware
1.9 What we won’t be implementing or discussing
Distributed computing
Service discovery
High availability
Load balancing
Security
2 From mental model to skeleton code
2.1 The task skeleton
2.2 The worker skeleton
2.3 The manager skeleton
2.4 The scheduler skeleton
2.5 Other skeletons
2.6 Taking our skeletons for a spin
3 Hanging some flesh on the task skeleton
3.1 Docker: Starting, stopping, and inspecting containers from the
command line
3.2 Docker: Starting, stopping, and inspecting containers from the
API
3.3 Task configuration
3.4 Starting and stopping tasks
Part 2 Worker
4 Workers of the Cube, unite!
4.1 The Cube worker
4.2 Tasks and Docker
4.3 The role of the queue
4.4 The role of the DB
4.5 Counting tasks
4.6 Implementing the worker’s methods
Implementing the StopTask method
Implementing the StartTask method
An interlude on task state
Implementing the RunTask method
4.7 Putting it all together
5 An API for the worker
5.1 Overview of the worker API
5.2 Data format, requests, and responses
5.3 The API struct
5.4 Handling requests
5.5 Serving the API
5.6 Putting it all together
6 Metrics
6.1 What metrics should we collect?
6.2 Metrics available from the /proc filesystem
6.3 Collecting metrics with goprocinfo
6.4 Exposing the metrics on the API
6.5 Putting it all together
Part 3 Manager
7 The manager enters the room
7.1 The Cube manager
The components that make up the manager
7.2 The Manager struct
7.3 Implementing the manager’s methods
Implementing the SelectWorker method
Implementing the SendWork method
Implementing the UpdateTasks method
Adding a task to the manager
Creating a manager
7.4 An interlude on failures and resiliency
7.5 Putting it all together
8 An API for the manager
8.1 Overview of the manager API
8.2 Routes
8.3 Data format, requests, and responses
8.4 The API struct
8.5 Handling requests
8.6 Serving the API
8.7 A few refactorings to make our lives easier
8.8 Putting it all together
9 What could possibly go wrong?
9.1 Overview of our new scenario
9.2 Failure scenarios
Application startup failure
Application bugs
Task startup failures due to resource problems
Task failures due to Docker daemon crashes and restarts
Task failures due to machine crashes and restarts
Worker failures
Manager failures
9.3 Recovery options
Recovery from application failures
Recovering from environmental failures
Recovering from task-level failures
Recovering from worker failures
Recovering from manager failures
9.4 Implementing health checks
Inspecting a task on the worker
Implementing task updates on the worker
Healthchecks and restarts
9.5 Putting it all together
Part 4 Refactorings
10 Implementing a more sophisticated scheduler
10.1 The scheduling problem
10.2 Scheduling considerations
10.3 Scheduler interface
10.4 Adapting the round-robin scheduler to the scheduler interface
10.5 Using the new scheduler interface
Adding new fields to the Manager struct
Modifying the New helper function
10.6 Did you notice the bug?
10.7 Putting it all together
10.8 The E-PVM scheduler
The theory
In practice
10.9 Completing the Node implementation
10.10 Using the E-PVM scheduler
11 Implementing persistent storage for tasks
11.1 The storage problem
11.2 The Store interface
11.3 Implementing an in-memory store for tasks
11.4 Implementing an in-memory store for task events
11.5 Refactoring the manager to use the new in-memory stores
11.6 Refactoring the worker
11.7 Putting it all together
11.8 Introducing BoltDB
11.9 Implementing a persistent task store
11.10 Implementing a persistent task event store
11.11 Switching out the in-memory stores for permanent ones
Part 5 CLI
12 Building a command-line interface
12.1 The core components of CLIs
12.2 Introducing the Cobra framework
12.3 Setting up our Cobra application
12.4 Understanding the new main.go
12.5 Understanding root.go
12.6 Implementing the worker command
12.7 Implementing the manager command
12.8 Implementing the run command
12.9 Implementing the stop command
12.10 Implementing the status command
12.11 Implementing the node command
13 Now what?
13.1 Working on Kubernetes and related tooling
13.2 Manager-worker pattern and workflow systems
13.3 Manager-worker pattern and integration systems
13.4 In closing
appendix Environment setup
index
