Kubernetes: лучшие практики [1 ed.] 9785446116881, 9781492056478

Table of contents :
Введение
Кому стоит прочесть эту книгу
Почему мы написали ее
Структура книги
Условные обозначения
Использование примеров кода
Благодарности
От издательства
Глава 1. Создание простого сервиса
Обзор приложения
Управление конфигурационными файлами
Создание реплицированного сервиса с помощью ресурса Deployment
Практические рекомендации по управлению образами
Создание реплицированного приложения
Настройка внешнего доступа для HTTP-трафика
Конфигурация приложения с помощью ConfigMap
Управление аутентификацией с помощью объектов Secret
Stateful-развертывание простой базы данных
Создание балансировщика нагрузки для TCP с использованием Service
Направление трафика к серверу статических файлов с помощью Ingress
Параметризация приложения с помощью Helm
Рекомендации по развертыванию сервисов
Резюме
Глава 2. Процесс разработки
Цели
Построение кластера для разработки
Подготовка разделяемого кластера для нескольких разработчиков
Добавление новых пользователей
Создание и защита пространства имен
Управление пространствами имен
Сервисы уровня кластера
Рабочие процессы разработчика
Начальная подготовка
Активная разработка
Тестирование и отладка
Рекомендации по подготовке среды для разработки
Резюме
Глава 3. Мониторинг и ведение журнала в Kubernetes
Метрики и журнальные записи
Разновидности мониторинга
Методы мониторинга
Обзор метрик, доступных в Kubernetes
cAdvisor
Сервер метрик
kube-state-metrics
Какие метрики нужно отслеживать
Средства мониторинга
Мониторинг в Kubernetes с использованием Prometheus
Обзор журналирования
Инструменты для ведения журнала
Журналирование с использованием стека EFK
Уведомления
Рекомендации по мониторингу, журналированию и созданию уведомлений
Мониторинг
Журналирование
Создание уведомлений
Резюме
Глава 4. Конфигурация, Secrets и RBAC
Конфигурация с использованием объектов ConfigMap и Secret
Объекты ConfigMap
Объекты Secret
Общепринятые рекомендации по работе с API ConfigMap и Secret
RBAC
Основные концепции RBAC
Рекомендации по работе с RBAC
Резюме
Глава 5. Непрерывная интеграция, тестирование и развертывание
Управление версиями
Непрерывная интеграция
Тестирование
Сборка контейнеров
Назначение тегов образам контейнеров
Непрерывное развертывание
Стратегии развертывания
Тестирование в промышленных условиях
Подготовка процесса и проведение хаотического эксперимента
Подготовка CI
Подготовка CD
Выполнение плавающего обновления
Простой хаотический эксперимент
Рекомендации относительно CI/CD
Резюме
Глава 6. Версии, релизы и выкатывание обновлений
Ведение версий
Релизы
Развертывание обновлений
Полноценный пример
Рекомендации по ведению версий, созданию релизов и развертыванию обновлений
Резюме
Глава 7. Глобальное распределение приложений и промежуточное тестирование
Распределение вашего образа
Параметризация развертываний
Глобальное распределение трафика
Надежное развертывание программного обеспечения в глобальном масштабе
Проверка перед развертыванием
Канареечный регион
Разные типы регионов
Подготовка к глобальному развертыванию
Когда что-то идет не так
Рекомендации по глобальному развертыванию
Резюме
Глава 8. Управление ресурсами
Планировщик Kubernetes
Предикаты
Приоритеты
Продвинутые методики планирования
Принадлежность и непринадлежность pod
nodeSelector
Ограничения и допуски
Управление ресурсами pod
Запросы ресурсов
Лимиты на ресурсы и качество обслуживания
Объекты PodDisruptionBudget
Управление ресурсами с помощью пространств имен
ResourceQuota
LimitRange
Масштабирование кластера
Масштабирование приложений
Масштабирование с использованием HPA
HPA с применением пользовательских метрик
Масштабирование с использованием VPA
Рекомендации по управлению ресурсами
Резюме
Глава 9. Сетевые возможности, безопасность сети и межсервисное взаимодействие
Принципы работы с сетью в Kubernetes
Сетевые дополнения
Kubenet
Рекомендации по использованию Kubenet
Дополнение CNI
Рекомендации по использованию CNI
Сервисы в Kubernetes
Тип сервисов ClusterIP
Тип сервисов NodePort
Тип сервисов ExternalName
Тип сервисов LoadBalancer
Объекты и контроллеры Ingress
Рекомендации по использованию сервисов и контроллеров Ingress
Сетевые политики безопасности
Рекомендации по применению сетевых политик
Механизмы межсервисного взаимодействия
Рекомендации по применению механизмов межсервисного взаимодействия
Резюме
Глава 10. Безопасность pod и контейнеров
API PodSecurityPolicy
Включение PodSecurityPolicy
Принцип работы PodSecurityPolicy
Трудности при работе с PodSecurityPolicy
Рекомендации по использованию политики PodSecurityPolicy
PodSecurityPolicy: что дальше
Изоляция рабочих заданий и RuntimeClass
Использование RuntimeClass
Реализации сред выполнения
Изоляция рабочих заданий и рекомендации по использованию RuntimeClass
Другие важные аспекты безопасности pod и контейнеров
Контроллеры доступа
Средства обнаружения вторжений и аномалий
Резюме
Глава 11. Политики и принципы управления кластером
Почему политики и принципы управления кластером имеют большое значение
В чем отличие от других политик
Облачно-ориентированная система политик
Введение в Gatekeeper
Примеры политик
Терминология проекта Gatekeeper
Определение шаблона ограничений
Определение ограничений
Репликация данных
Обратная связь
Аудит
Более тесное знакомство с Gatekeeper
Gatekeeper: что дальше?
Рекомендации относительно политик и принципов управления
Резюме
Глава 12. Управление несколькими кластерами
Зачем может понадобиться больше одного кластера
Проблемы многокластерной архитектуры
Развертывание в многокластерной архитектуре
Методики развертывания и администрирования
Администрирование кластера с помощью методики GitOps
Средства управления несколькими кластерами
Kubernetes Federation
Рекомендации по эксплуатации сразу нескольких кластеров
Резюме
Глава 13. Интеграция внешних сервисов с Kubernetes
Импорт сервисов в Kubernetes
Сервисы со стабильными IP-адресами без использования селекторов
Стабильные доменные имена сервисов на основе CNAME
Активный подход с применением контроллеров
Экспорт сервисов из Kubernetes
Экспорт сервисов с помощью внутреннего балансировщика нагрузки
Экспорт сервисов типа NodePort
Интеграция внешних серверов в Kubernetes
Разделение сервисов между кластерами Kubernetes
Сторонние инструменты
Рекомендации по соединению кластеров и внешних сервисов
Резюме
Глава 14. Машинное обучение и Kubernetes
Почему Kubernetes отлично подходит для машинного обучения
Рабочий процесс машинного обучения
Машинное обучение с точки зрения администраторов кластеров Kubernetes
Обучение модели в Kubernetes
Распределенное обучение в Kubernetes
Требования к ресурсам
Специализированное оборудование
Библиотеки, драйверы и модули ядра
Хранение
Организация сети
Узкоспециализированные протоколы
Машинное обучение с точки зрения специалистов по анализу данных
Рекомендации по машинному обучению в Kubernetes
Резюме
Глава 15. Построение высокоуровневых абстракций на базе Kubernetes
Разные подходы к разработке высокоуровневых абстракций
Расширение Kubernetes
Расширение кластеров Kubernetes
Расширение пользовательских аспектов Kubernetes
Архитектурные аспекты построения новых платформ
Поддержка экспорта в образ контейнера
Поддержка существующих механизмов для обнаружения сервисов и работы с ними
Рекомендации по созданию прикладных платформ
Резюме
Глава 16. Управление состоянием
Тома и их подключение
Рекомендации по обращению с томами
Хранение данных в Kubernetes
PersistentVolume
PersistentVolumeClaim
Классы хранилищ
Рекомендации по использованию хранилищ в Kubernetes
Приложения с сохранением состояния
Объекты StatefulSet
Проект Operator
Рекомендации по использованию StatefulSet и Operator
Резюме
Глава 17. Контроль доступа и авторизация
Контроль доступа
Что такое контроллеры доступа?
Почему они важны?
Типы контроллеров доступа
Конфигурация веб-хуков доступа
Рекомендации по использованию контроллеров доступа
Авторизация
Модули авторизации
Практические советы относительно авторизации
Резюме
Глава 18. В заключение
Об авторах
Об изображении на обложке

Citation preview

Kubernetes Best Practices

Blueprints for Building Successful Applications on Kubernetes

Brendan Burns, Eddie Villalba, Dave Strebel, and Lachlan Evenson

Beijing

Boston Farnham Sebastopol

Tokyo

Kubernetes: лучшие практики Раскрой потенциал главного инструмента в отрасли

Брендан Бернс, Эдди Вильяльба Дейв Штребель, Лахлан Эвенсон

2021

ББК 32.973.2-018+32.988.02 УДК 004.4+004.7 К99



Бернс Брендан, Вильяльба Эдди, Штребель Дейв, Эвенсон Лахлан

К99 Kubernetes: лучшие практики. — СПб.: Питер, 2021. — 288 с.: ил. — (Серия «Для профессионалов»).

ISBN 978-5-4461-1688-1 Положитесь на опыт профессионалов, успешно применяющих и развивающих проект Kubernetes. Инженеры Microsoft предлагают лучшие приемы оркестрации контейнеров. Их практики сложились в процессе разработки распределенных систем, на ответственных и нагруженных проектах. Вам останется лишь слегка адаптировать код. Книга идеально подойдет тем, кто уже знаком с Kubernetes, но еще не умеет использовать его максимально эффективно. Вы узнаете все, что необходимо для создания классного Kubernetesприложения, в том числе: • Подготовка окружения и разработка приложений в Kubernetes. • Паттерны мониторинга и защиты ваших систем, управления обновлениями. • Сетевые политики Kubernetes и роли сервисных сетей в экосистеме. • Использование Kubernetes в задачах машинного обучения.

16+ (В соответствии с Федеральным законом от 29 декабря 2010 г. № 436-ФЗ.)

ББК 32.973.2-018+32.988.02 УДК 004.4+004.7

Права на издание получены по соглашению с O’Reilly. Все права защищены. Никакая часть данной книги не может быть воспроизведена в какой бы то ни было форме без письменного разрешения владельцев авторских прав. Информация, содержащаяся в данной книге, получена из источников, рассматриваемых издательством как надежные. Тем не менее, имея в виду возможные человеческие или технические ошибки, издательство не может гарантировать абсолютную точность и полноту приводимых сведений и не несет ответственности за возможные ошибки, связанные с использованием книги. Издательство не несет ответственности за доступность материалов, ссылки на которые вы можете найти в этой книге. На момент подготовки книги к изданию все ссылки на интернет-ресурсы были действующими.

ISBN 978-1492056478 англ. ISBN 978-5-4461-1688-1

Authorized Russian translation of the English edition of Kubernetes Best Practices: ISBN 9781492056478 © 2020 Brendan Burns, Eddie Villalba, Dave Strebel, and Lachlan Evenson This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to publish and sell the same. © Перевод на русский язык ООО Издательство «Питер», 2021 © Издание на русском языке, оформление ООО Издательство «Питер», 2021 © Серия «Для профессионалов», 2021 © Анатолий Павлов, пер. с англ., 2020

Краткое содержание Введение.............................................................................................................. 15 Глава 1. Создание простого сервиса...................................................................... 20 Глава 2. Процесс разработки................................................................................. 42 Глава 3. Мониторинг и ведение журнала в Kubernetes.......................................... 57 Глава 4. Конфигурация, Secrets и RBAC................................................................. 79 Глава 5. Непрерывная интеграция, тестирование и развертывание....................... 94 Глава 6. Версии, релизы и выкатывание обновлений.......................................... 112 Глава 7. Глобальное распределение приложений и промежуточное тестирование............................................................................ 121 Глава 8. Управление ресурсами........................................................................... 135 Глава 9. Сетевые возможности, безопасность сети и межсервисное взаимодействие.......................................................................... 156 Глава 10. Безопасность pod и контейнеров......................................................... 179 Глава 11. Политики и принципы управления кластером...................................... 197 Глава 12. Управление несколькими кластерами.................................................. 208 Глава 13. Интеграция внешних сервисов с Kubernetes......................................... 224 Глава 14. Машинное обучение и Kubernetes........................................................ 236 Глава 15. Построение высокоуровневых абстракций на базе Kubernetes............. 249 Глава 16. Управление состоянием....................................................................... 257 Глава 17. Контроль доступа и авторизация......................................................... 271 Глава 18. В заключение...................................................................................... 283 Об авторах......................................................................................................... 284 Об изображении на обложке.......................................................................... 285

Оглавление

Введение.............................................................................................................. 15 Кому стоит прочесть эту книгу........................................................................... 15 Почему мы написали эту книгу.......................................................................... 15 Структура книги................................................................................................ 16 Условные обозначения...................................................................................... 16 Использование примеров кода.......................................................................... 17 Благодарности................................................................................................... 18 От издательства................................................................................................ 19 Глава 1. Создание простого сервиса...................................................................... 20 Обзор приложения............................................................................................ 20 Управление конфигурационными файлами........................................................ 20 Создание реплицированного сервиса с помощью ресурса Deployment............... 22 Практические рекомендации по управлению образами................................ 23 Создание реплицированного приложения.................................................... 23 Настройка внешнего доступа для HTTP-трафика............................................... 26 Конфигурация приложения с помощью ConfigMap............................................. 27 Управление аутентификацией с помощью объектов Secret................................ 29 Stateful-развертывание простой базы данных.................................................... 32 Создание балансировщика нагрузки для TCP с использованием Service............. 36 Направление трафика к серверу статических файлов с помощью Ingress............................................................................................. 37 Параметризация приложения с помощью Helm.................................................. 39 Рекомендации по развертыванию сервисов....................................................... 41 Резюме.............................................................................................................. 41

Оглавление   7

Глава 2. Процесс разработки................................................................................. 42 Цели.................................................................................................................. 42 Построение кластера для разработки................................................................ 44 Подготовка разделяемого кластера для нескольких разработчиков................... 45 Добавление новых пользователей................................................................ 45 Создание и защита пространства имен......................................................... 48 Управление пространствами имен................................................................ 50 Сервисы уровня кластера............................................................................. 51 Рабочие процессы разработчика....................................................................... 52 Начальная подготовка....................................................................................... 52 Активная разработка......................................................................................... 53 Тестирование и отладка.................................................................................... 54 Рекомендации по подготовке среды для разработки.......................................... 55 Резюме.............................................................................................................. 56 Глава 3. Мониторинг и ведение журнала в Kubernetes.......................................... 57 Метрики и журнальные записи.......................................................................... 57 Разновидности мониторинга.............................................................................. 57 Методы мониторинга......................................................................................... 58 Обзор метрик, доступных в Kubernetes.............................................................. 59 cAdvisor........................................................................................................ 60 Сервер метрик............................................................................................. 60 kube-state-metrics......................................................................................... 61 Какие метрики нужно отслеживать.................................................................... 62 Средства мониторинга....................................................................................... 63 Мониторинг в Kubernetes с использованием Prometheus.................................... 65 Обзор журналирования..................................................................................... 70 Инструменты для ведения журнала................................................................... 72 Журналирование с использованием стека EFK................................................... 72 Уведомления..................................................................................................... 75 Рекомендации по мониторингу, журналированию и созданию уведомлений................................................................................... 77 Мониторинг.................................................................................................. 77

8   

Оглавление

Журналирование.......................................................................................... 77 Создание уведомлений................................................................................. 78 Резюме.............................................................................................................. 78 Глава 4. Конфигурация, Secrets и RBAC................................................................. 79 Конфигурация с использованием объектов ConfigMap и Secret.......................... 79 Объекты ConfigMap....................................................................................... 80 Объекты Secret............................................................................................. 80 Общепринятые рекомендации по работе с API ConfigMap и Secret..................... 81 RBAC................................................................................................................. 88 Основные концепции RBAC........................................................................... 89 Рекомендации по работе с RBAC.................................................................. 91 Резюме.............................................................................................................. 93 Глава 5. Непрерывная интеграция, тестирование и развертывание....................... 94 Управление версиями........................................................................................ 95 Непрерывная интеграция.................................................................................. 95 Тестирование.................................................................................................... 96 Сборка контейнеров.......................................................................................... 96 Назначение тегов образам контейнеров............................................................ 97 Непрерывное развертывание............................................................................. 98 Стратегии развертывания.................................................................................. 99 Тестирование в промышленных условиях........................................................ 104 Подготовка процесса и проведение хаотического эксперимента...................... 105 Подготовка CI............................................................................................ 105 Подготовка CD........................................................................................... 108 Выполнение плавающего обновления........................................................ 109 Простой хаотический эксперимент............................................................. 109 Рекомендации относительно CI/CD.................................................................. 110 Резюме............................................................................................................ 111 Глава 6. Версии, релизы и выкатывание обновлений.......................................... 112 Ведение версий............................................................................................... 113 Релизы............................................................................................................ 113 Развертывание обновлений............................................................................. 114

Оглавление   9

Полноценный пример...................................................................................... 115 Рекомендации по ведению версий, созданию релизов и развертыванию обновлений.................................................................... 119 Резюме............................................................................................................ 120 Глава 7. Глобальное распределение приложений и промежуточное тестирование............................................................................ 121 Распределение вашего образа......................................................................... 122 Параметризация развертываний...................................................................... 123 Глобальное распределение трафика................................................................ 124 Надежное развертывание программного обеспечения в глобальном масштабе................................................................................... 124 Проверка перед развертыванием............................................................... 125 Канареечный регион.................................................................................. 128 Разные типы регионов................................................................................ 129 Подготовка к глобальному развертыванию................................................. 130 Когда что-то идет не так................................................................................. 131 Рекомендации по глобальному развертыванию............................................... 133 Резюме............................................................................................................ 134 Глава 8. Управление ресурсами........................................................................... 135 Планировщик Kubernetes................................................................................. 135 Предикаты................................................................................................. 135 Приоритеты................................................................................................ 136 Продвинутые методики планирования............................................................. 137 Принадлежность и непринадлежность pod................................................. 137 nodeSelector............................................................................................... 138 Ограничения и допуски.............................................................................. 139 Управление ресурсами pod.............................................................................. 141 Запросы ресурсов....................................................................................... 141 Лимиты на ресурсы и качество обслуживания............................................ 142 Объекты PodDisruptionBudget..................................................................... 144 Управление ресурсами с помощью пространств имен................................. 146 ResourceQuota............................................................................................ 147 LimitRange.................................................................................................. 149

10   

Оглавление

Масштабирование кластера........................................................................ 150 Масштабирование приложений.................................................................. 151 Масштабирование с использованием HPA................................................... 152 HPA с применением пользовательских метрик............................................ 153 Масштабирование с использованием VPA................................................... 154 Рекомендации по управлению ресурсами........................................................ 154 Резюме............................................................................................................ 155 Глава 9. Сетевые возможности, безопасность сети и межсервисное взаимодействие.................................................................................................... 156 Принципы работы с сетью в Kubernetes........................................................... 156 Сетевые дополнения....................................................................................... 159 Kubenet...................................................................................................... 160 Рекомендации по использованию Kubenet.................................................. 160 Дополнение CNI......................................................................................... 160 Рекомендации по использованию CNI........................................................ 161 Сервисы в Kubernetes...................................................................................... 162 Тип сервисов ClusterIP................................................................................ 163 Тип сервисов NodePort............................................................................... 164 Тип сервисов ExternalName........................................................................ 165 Тип сервисов LoadBalancer......................................................................... 166 Объекты и контроллеры Ingress................................................................. 168 Рекомендации по использованию сервисов и контроллеров Ingress........... 169 Сетевые политики безопасности...................................................................... 170 Рекомендации по применению сетевых политик......................................... 173 Механизмы межсервисного взаимодействия.................................................... 175 Рекомендации по применению механизмов межсервисного взаимодействия................................................................. 177 Резюме............................................................................................................ 177 Глава 10. Безопасность pod и контейнеров......................................................... 179 API PodSecurityPolicy........................................................................................ 179 Включение PodSecurityPolicy....................................................................... 180 Принцип работы PodSecurityPolicy.............................................................. 181 Трудности при работе с PodSecurityPolicy................................................... 190

Оглавление   11

Рекомендации по использованию политики PodSecurityPolicy..................... 191 PodSecurityPolicy: что дальше?.................................................................... 192 Изоляция рабочих заданий и RuntimeClass...................................................... 192 Использование RuntimeClass...................................................................... 193 Реализации сред выполнения..................................................................... 194 Изоляция рабочих заданий и рекомендации по использованию RuntimeClass................................................................. 194 Другие важные аспекты безопасности pod и контейнеров............................... 195 Контроллеры доступа................................................................................. 195 Средства обнаружения вторжений и аномалий.......................................... 195 Резюме............................................................................................................ 196 Глава 11. Политики и принципы управления кластером...................................... 197 Почему политики и принципы управления кластером имеют большое значение........................................................................................... 197 В чем отличие от других политик.................................................................... 198 Облачно-ориентированная система политик.................................................... 198 Введение в Gatekeeper.................................................................................... 198 Примеры политик....................................................................................... 199 Терминология проекта Gatekeeper.............................................................. 199 Определение шаблона ограничений........................................................... 200 Определение ограничений......................................................................... 201 Репликация данных.................................................................................... 203 Обратная связь.......................................................................................... 203 Аудит.............................................................................................................. 204 Более тесное знакомство с Gatekeeper....................................................... 205 Gatekeeper: что дальше?............................................................................ 205 Рекомендации относительно политик и принципов управления....................... 206 Резюме............................................................................................................ 207 Глава 12. Управление несколькими кластерами.................................................. 208 Зачем может понадобиться больше одного кластера....................................... 208 Проблемы многокластерной архитектуры........................................................ 211 Развертывание в многокластерной архитектуре.............................................. 213 Методики развертывания и администрирования......................................... 213

12   

Оглавление

Администрирование кластера с помощью методики GitOps.............................. 216 Средства управления несколькими кластерами............................................... 218 Kubernetes Federation....................................................................................... 219 Рекомендации по эксплуатации сразу нескольких кластеров........................... 222 Резюме............................................................................................................ 223 Глава 13. Интеграция внешних сервисов с Kubernetes......................................... 224 Импорт сервисов в Kubernetes......................................................................... 224 Сервисы со стабильными IP-адресами без использования селекторов........ 225 Стабильные доменные имена сервисов на основе CNAME........................... 226 Активный подход с применением контроллеров......................................... 228 Экспорт сервисов из Kubernetes....................................................................... 229 Экспорт сервисов с помощью внутреннего балансировщика нагрузки........ 229 Экспорт сервисов типа NodePort................................................................. 230 Интеграция внешних серверов в Kubernetes............................................... 231 Разделение сервисов между кластерами Kubernetes........................................ 232 Сторонние инструменты.................................................................................. 233 Рекомендации по соединению кластеров и внешних сервисов......................... 234 Резюме............................................................................................................ 235 Глава 14. Машинное обучение и Kubernetes........................................................ 236 Почему Kubernetes отлично подходит для машинного обучения...................... 236 Рабочий процесс машинного обучения............................................................ 237 Машинное обучение с точки зрения администраторов кластеров Kubernetes....................................................................................... 238 Обучение модели в Kubernetes................................................................... 239 Распределенное обучение в Kubernetes...................................................... 241 Требования к ресурсам.............................................................................. 242 Специализированное оборудование........................................................... 242 Библиотеки, драйверы и модули ядра........................................................ 244 Хранение.................................................................................................... 244 Организация сети....................................................................................... 245 Узкоспециализированные протоколы......................................................... 246

Оглавление   13

Машинное обучение с точки зрения специалистов по анализу данных............ 246 Рекомендации по машинному обучению в Kubernetes...................................... 247 Резюме............................................................................................................ 248 Глава 15. Построение высокоуровневых абстракций на базе Kubernetes............. 249 Разные подходы к разработке высокоуровневых абстракций........................... 249 Расширение Kubernetes................................................................................... 250 Расширение кластеров Kubernetes.............................................................. 251 Расширение пользовательских аспектов Kubernetes................................... 252 Архитектурные аспекты построения новых платформ...................................... 253 Поддержка экспорта в образ контейнера................................................... 253 Поддержка существующих механизмов для обнаружения сервисов и работы с ними......................................................................................... 254 Рекомендации по созданию прикладных платформ......................................... 255 Резюме............................................................................................................ 256 Глава 16. Управление состоянием....................................................................... 257 Тома и их подключение................................................................................... 258 Рекомендации по обращению с томами...................................................... 259 Хранение данных в Kubernetes........................................................................ 259 PersistentVolume......................................................................................... 260 PersistentVolumeClaim................................................................................. 260 Классы хранилищ....................................................................................... 262 Рекомендации по использованию хранилищ в Kubernetes........................... 263 Приложения с сохранением состояния............................................................ 264 Объекты StatefulSet.................................................................................... 265 Проект Operator......................................................................................... 267 Рекомендации по использованию StatefulSet и Operator............................. 268 Резюме............................................................................................................ 270 Глава 17. Контроль доступа и авторизация......................................................... 271 Контроль доступа............................................................................................ 271 Что такое контроллеры доступа................................................................. 272 Почему они важны..................................................................................... 272

14   

Оглавление

Типы контроллеров доступа....................................................................... 273 Конфигурация веб-хуков доступа............................................................... 274 Рекомендации по использованию контроллеров доступа............................ 276 Авторизация.................................................................................................... 278 Модули авторизации.................................................................................. 279 Практические советы относительно авторизации....................................... 282 Резюме............................................................................................................ 282 Глава 18. В заключение...................................................................................... 283 Об авторах......................................................................................................... 284 Об изображении на обложке.......................................................................... 285

Введение Кому стоит прочесть эту книгу Kubernetes — фактический стандарт для облачно-ориентированной разработки. Это эффективный инструмент, который может упростить создание ваших приложений, ускорить развертывание и сделать его более надежным. Но для раскрытия всего потенциала этой платформы нужно научиться ее корректно использовать. Книга предназначена для всех, кто развертывает реальные приложения в Kubernetes и заинтересован в изучении паттернов проектирования и методик, применимых к этим приложениям. Важно понимать: это не введение в Kubernetes. Мы исходим из того, что вы уже имеете общее представление об API и инструментарии данной платформы и знаете, как создавать и администрировать кластеры на ее основе. Познакомиться с Kubernetes можно, в частности, прочитав книгу Kubernetes: Up and Running (O’Reilly) (https://oreil.ly/ziNRK). Эта книга предназначена для читателей, желающих подробно изучить процесс развертывания конкретных приложений в Kubernetes. Она будет полезной как тем, кто собирается развернуть в Kubernetes свое первое приложение, так и специалистам с многолетним опытом использования данной платформы.

Почему мы написали эту книгу Мы, четыре автора этой книги, многократно помогали развертывать приложения в Kubernetes. Мы видели, какие трудности возникали у разных пользователей, и помогали решать их. Приступая к написанию книги, мы хотели поделиться своим опытом, чтобы еще больше людей могло извлечь пользу из усвоенных нами уроков. Надеемся, таким образом нам удастся сделать наши знания общедоступными и благодаря этому вы сможете самостоятельно развертывать и администрировать свои приложения в Kubernetes.

16   

Введение

Структура книги Эту книгу можно читать последовательно, от первой до последней страницы, однако на самом деле мы задумывали ее как набор независимых глав. В каждой главе дается полноценный обзор определенной задачи, выполнимой с помощью Kubernetes. Мы ожидаем, что вы углубитесь в материал, чтобы узнать о конкретной проблеме или интересующем вас вопросе, а затем будете периодически обращаться к книге при возникновении новых запросов. Несмотря на столь четкое разделение, некоторые темы будут встречаться вам на протяжении всей книги. Разработке приложений в Kubernetes посвящено сразу несколько глав. Глава 2 описывает рабочий процесс. В главе 5 обсуждаются непрерывная интеграция и тестирование. В главе 15 речь идет о построении на основе Kubernetes высокоуровневых платформ, а в главе 16 рассматривается управление stateless- и stateful-приложениями. Управлению сервисами в Kubernetes также отводится несколько глав. Глава 1 посвящена подготовке простого сервиса, а глава 3 — мониторингу и метрикам. В главе 4 вы научитесь управлять конфигурацией, а в главе 6 — версиями и релизами. В главе 7 описывается процесс глобального развертывания приложения. Другая обширная тема — работа с кластерами. Сюда относятся управление ресурсами (глава 8), сетевые возможности (глава 9), безопасность pod (глава 10), политики и управляемость (глава 11), управление несколькими кластерами (глава 12), а также контроль доступа и авторизацию (глава 17). Кроме того, есть полностью самостоятельные главы, посвященные машинному обучению (глава 14) и интеграции с внешними сервисами (глава 13). Прежде чем браться за выполнение реальной задачи, не помешает прочесть соответствующие главы, хотя мы надеемся, что вы будете использовать эту книгу как справочник.

Условные обозначения В этой книге используются следующие условные обозначения: Курсив Курсивом выделены новые термины и важные слова. Моноширинный шрифт

Используется для листингов программ, а также внутри абзацев для обозначения таких элементов, как переменные и функции, базы данных,

Использование примеров кода   17

типы данных, переменные среды, операторы и ключевые слова, имена файлов и их расширения. Моноширинный жирный шрифт

Показывает команды или другой текст, который пользователь должен ввести самостоятельно. Моноширинный курсивный шрифт

Показывает текст, который должен быть заменен значениями, введенными пользователем, или значениями, определяемыми контекстом. Шрифт без засечек

Используется для обозначения URL, адресов электронной почты, названий кнопок, каталогов.

Этот рисунок указывает на совет или предложение.

Такой рисунок указывает на общее замечание.

Этот рисунок указывает на предупреждение.

Использование примеров кода Дополнительный материал (примеры кода, упражнения и т. д.) доступен для скачивания по адресу oreil.ly/KBPsample. Если при использовании примеров кода у вас возникнут технические вопросы или проблемы, то, пожалуйста, обращайтесь к нам по адресу [email protected]. Назначение книги — помочь решить ваши задачи. В ваших программах и документации разрешается использовать предложенный пример кода. Не нужно связываться с нами, если вы не воспроизводите его существенную часть: например, когда включаете в свою программу несколько фрагментов кода,

18   

Введение

приведенного здесь. Однако продажа или распространение компакт-дисков с примерами из книг издательства O’Reilly требует отдельного разрешения. Вы можете свободно цитировать эту книгу с примерами кода, отвечая на вопрос, но если хотите включить существенную часть приведенного здесь кода в документацию своего продукта, то вам следует связаться с нами. Мы приветствуем, но не требуем отсылки на оригинал. Отсылка обычно состоит из названия, имени автора, издательства, ISBN и копирайта. Напри­ мер, «Kubernetes: лучшие практики», Брендан Бернс, Эдди Вильяльба, Дейв Штребель, Лахлан Эвенсон (Питер). Copyright 2020 Brendan Burns, Eddie Villalba, Dave Strebel and Lachlan Evenson. 978-5-4461-1688-1. Если вам кажется, что ваше обращение с примерами кода выходит за рамки добросовестного использования или условий, перечисленных выше, то можете обратиться к нам по адресу [email protected].

Благодарности Брендан хотел бы поблагодарить свою чудесную семью: Робин, Джулию и Итана — за любовь и поддержку всех его действий; сообщество Kubernetes, благодаря которому все это стало возможным; своих потрясающих соавторов — без них книга не появилась бы на свет. Дейв благодарит за поддержку свою прекрасную жену Джен и трех детей: Макса, Мэдди и Мэйсона. Он также хотел бы поблагодарить сообщество Kubernetes за все советы и помощь, полученные на протяжении многих лет. И наконец, он хотел бы выразить признательность своим соавторам, которые помогли воплотить этот проект в жизнь. Лахлан хотел бы поблагодарить свою жену и троих детей за их любовь и поддержку. Он также хотел бы сказать спасибо всем участникам сообщества Kubernetes, в том числе замечательным людям, на протяжении этих лет находившим время, чтобы поделиться с ним знаниями. Он хотел бы выразить особую признательность Джозефу Сандовалу за наставничество. И наконец, Лахлан не может не поблагодарить своих фантастических соавторов, благодаря которым появилась эта книга. Эдди хотел бы поблагодарить свою жену Сандру за моральную поддержку и возможность заниматься этим изданием часами напролет, в то время как она сама была в последнем триместре первой беременности. Он также хотел бы сказать спасибо своей дочери Джованне за дополнительную моти-

От издательства   19

вацию. В завершение Эдди хотел бы выразить признательность сообществу Kubernetes и своим соавторам, на которых он всегда равнялся при работе с облачно-ориентированными технологиями. Мы хотели бы поблагодарить Вирджинию Уилсон за ее помощь в работе над рукописью и объединении всех наших идей, а также Бриджет Кромхаут, Билгина Ибряма, Роланда Хуса и Джастина Домингуса за их внимание к деталям.

От издательства Ваши замечания, предложения, вопросы отправляйте по электронному адресу [email protected] (издательство «Питер», компьютерная редакция). Мы будем рады узнать ваше мнение! На веб-сайте издательства www.piter.com вы найдете подробную информацию о наших книгах.

Глава 1

Создание простого сервиса В этой главе описываются приемы создания простого многоуровневого приложения в Kubernetes, представляющего собой веб-сервис и базу данных. Это далеко не самый сложный пример, однако он послужит хорошей отправной точкой, на которую следует ориентироваться при управлении приложениями в Kubernetes.

Обзор приложения Приложение, которое мы будем использовать в данном примере, не отличается особой сложностью. Это простой журнальный сервис, хранящий свои данные в Redis. Он также содержит отдельный сервер статических файлов на основе NGINX и предоставляет единый URL с двумя веб-путями. Первый путь, https://my-host.io, предназначен для файлового сервера, а второй, https:// my-host.io/api, — для программного интерфейса приложения (application programming interface, API) в формате REST. Мы будем использовать SSLсертификаты от Let’s Encrypt (https://letsencrypt.org). На рис. 1.1 показана схема приложения. Для его построения мы воспользуемся сначала конфигурационными файлами YAML, а затем Heml-чартами.

Управление конфигурационными файлами Прежде чем погружаться в подробности развертывания данного приложения в Kubernetes, следует поговорить о том, как управлять конфигурацией. В Kubernetes все представлено в декларативном виде. Это значит, что для определения всех аспектов своего приложения вы сначала описываете, каким должно быть его состояние в кластере (обычно в формате YAML или JSON). Декларативный подход куда более предпочтителен по сравнению с императивным, в котором состояние кластера представляет собой совокупность внесенных в него изменений. В случае императивной конфигурации очень сложно понять и воспроизвести состояние, в котором находится

Управление конфигурационными файлами   21

Рис. 1.1. Схема приложения

кластер. Это существенно затрудняет диагностику и исправление проблем, возникающих в приложении. Предпочтительный формат для объявления состояния приложения — YAML, хотя Kubernetes поддерживает и JSON. Дело в том, что YAML выглядит несколько более компактно и лучше подходит для редактирования вручную. Однако стоит отметить: этот формат чувствителен к отступам, из-за чего многие ошибки в конфигурационных файлах связаны с некорректными пробельными символами. Если что-то идет не так, то имеет смысл проверить отступы. Поскольку декларативное состояние, хранящееся в этих YAML-файлах, служит источником истины, из которого ваше приложение черпает информацию, правильная работа с состоянием — залог успеха. В ходе его редактирования вы должны иметь возможность управлять изменениями, проверять их корректность, проводить аудит их авторов и откатывать изменения в случае неполадок. К счастью, в контексте разработки ПО для всего этого уже есть подходящие инструменты. В частности, практические рекомендации, относящиеся к управлению версиями и аудиту изменений кода, можно смело использовать в работе с декларативным состоянием приложения.

22   

Глава 1. Создание простого сервиса

В наши дни большинство людей хранят конфигурацию для Kubernetes в Git. И хотя выбор той или иной системы контроля версий непринципиален, многие инструменты в экосистеме Kubernetes рассчитаны на хранение файлов в Git-репозитории. В сфере аудита изменения кода все не так однозначно: многие используют локальные инструменты и сервисы, хотя платформа GitHub, несомненно, довольно популярна. Независимо от того, как вы реализуете процесс аудита изменения кода для конфигурации своего приложения, относиться к нему следует с тем же вниманием, что и к системе контроля версий. Для организации компонентов приложения обычно стоит использовать структуру папок файлов системы. Сервис приложения (какой бы смысл ни вкладывала ваша команда в это понятие) обычно хранится в отдельном каталоге, а его компоненты — в подкаталогах. В этом примере мы структурируем файлы таким образом: journal/ frontend/ redis/ fileserver/

Внутри каждого каталога находятся конкретные YAML-файлы, необходимые для определения сервиса. Как вы позже сами увидите, по мере развертывания нашего приложения в разных регионах или кластерах эта структура каталогов будет все более усложняться.

Создание реплицированного сервиса с помощью ресурса Deployment Мы начнем описание нашего приложения с клиентской части и будем продвигаться вниз. В качестве этой части журнала будет выступать приложение для Node.js, написанное на языке TypeScript. Его код (https://oreil.ly/70kFT) слишком велик, чтобы приводить его здесь целиком. На порте 8080 работает HTTP-сервис, который обслуживает запросы к /api/* и использует сервер Redis для добавления, удаления и вывода актуальных записей журнала. Вы можете собрать это приложение в виде образа контейнера, используя включенный в его код файл Dockerfile, и загрузить его в собственный репозиторий образов. Затем вы сможете подставить его имя в YAML-файлы, приведенные ниже.

Создание реплицированного сервиса с помощью ресурса Deployment   23

Практические рекомендации по управлению образами В целом сборка и обслуживание образов контейнеров выходит за рамки этой книги, но все же будет уместно перечислить некоторые рекомендации. Процесс сборки образов как таковой уязвим к «атакам на поставщиков». В ходе подобных атак злоумышленник внедряет код или двоичные файлы в одну из зависимостей, которая хранится в доверенном источнике и участвует в сборке вашего приложения. Поскольку это создает слишком высокий риск, в сборке должны участвовать только хорошо известные и доверенные провайдеры образов. В качестве альтернативы все образы можно собирать с нуля; для некоторых языков (например, Go) это не составляет труда, поскольку они могут создавать статические исполняемые файлы, но в интерпретируемых языках, таких как Python, JavaScript и Ruby, это может быть большой проблемой. Некоторые рекомендации касаются выбора имен для образов. Теоретически тег с версией образа контейнера в реестре можно изменить, но вы никогда не должны этого делать. Хороший пример системы именования — сочетание семантической версии и SHA-хеша фиксации кода, из которой собирается образ (например, v1.0.1-bfeda01f). Если версию не указать, то по умолчанию используется значение latest. Оно может быть удобно в процессе разработки, но в промышленных условиях данного значения лучше избегать, так как оно явно изменяется при создании каждого нового образа.

Создание реплицированного приложения Наше клиентское приложение является stateless (не хранит свое состояние), делегируя данную функцию серверу Redis. Благодаря этому его можно реплицировать произвольным образом без воздействия на трафик. И хотя наш пример вряд ли будет испытывать серьезные нагрузки, все же неплохо использовать как минимум две реплики (копии): это позволяет справляться с неожиданными сбоями и выкатывать новые версии без простоя. В Kubernetes есть объект ReplicaSet, отвечающий за репликацию контейнеризованных приложений, но его лучше не использовать напрямую. Для наших задач подойдет объект Deployment, который сочетает в себе возможности объекта ReplicaSet, систему управления версиями и поддержку поэтапного развертывания обновлений. Объект Deployment позволяет применять встроенные в Kubernetes механизмы для перехода от одной версии к другой.

24   

Глава 1. Создание простого сервиса

Ресурс Deployment нашего приложения выглядит следующим образом: apiVersion: extensions/v1beta1 kind: Deployment metadata: labels: app: frontend name: frontend namespace: default spec: replicas: 2 selector: matchLabels: app: frontend template: metadata: labels: app: frontend spec: containers: - image: my-repo/journal-server:v1-abcde imagePullPolicy: IfNotPresent name: frontend resources: requests: cpu: "1.0" memory: "1G" limits: cpu: "1.0" memory: "1G"

В этом ресурсе следует обратить внимание на несколько деталей. Так, для идентификации экземпляров ReplicaSet, объекта Deployment и создаваемых им pod используются метки (labels). Мы добавили метку layer: frontend для всех этих объектов, благодаря чему они теперь находятся в общем слое (layer) и их можно просматривать вместе с помощью одного запроса. Как вы увидите позже, мы будем применять данный подход и при добавлении других ресурсов. Помимо этого, мы добавили комментарии в разные участки YAML-файла. Как и комментарии в программном коде, они не попадут в итоговый ресурс, хранящийся на сервере; их задача — сделать конфигурацию более понятной для тех, кто не видел ее раньше. Обратите внимание и на то, что для контейнеров в ресурсе Deployment установлены запросы ресурсов Request и Limit с одинаковыми значениями.

Создание реплицированного сервиса с помощью ресурса Deployment   25

Request гарантирует выделение определенного объема ресурсов на сервере,

на котором запущено приложение. Limit  — максимальное потребление ресурсов, разрешенное к использованию контейнером. На первых порах установка одинаковых значений для этих двух запросов обеспечивает наиболее предсказуемое поведение приложения. Но за это приходится платить неоптимальным использованием ресурсов. С одной стороны, когда Request и  Limit равны, ваше приложение не тратит слишком много процессорного времени и не потребляет лишние ресурсы при бездействии. С другой — если не проявить крайнюю осторожность при подборе этих значений, то вы не можете в полной мере использовать ресурсы сервера. Начав лучше ориентироваться в модели управления ресурсами Kubernetes, вы сможете попробовать откорректировать параметры Request и Limit своего приложения по отдельности, но в целом большинство пользователей предпочитают пожертвовать эффективностью в угоду стабильности, получаемой в результате предсказуемости. Итак, мы определили ресурс Deployment. Теперь сохраним его в системе контроля версий и развернем в Kubernetes: git add frontend/deployment.yaml git commit -m "Added deployment" frontend/deployment.yaml kubectl apply -f frontend/deployment.yaml

Рекомендуется также следить за тем, чтобы содержимое вашего кластера в точности соответствовало содержимому репозитория. Для этого лучше всего использовать методику GitOps и брать код для промышленной среды только из определенной ветки системы контроля версий. Данный процесс можно автоматизировать с помощью непрерывной интеграции (Conti­ nuous Integration, CI) и непрерывной доставки (Continuous Delivery, CD). Это позволяет гарантировать соответствие между репозиторием и промышленной системой. Для простого приложения полноценный процесс CI/CD может показаться избыточным, но автоматизация как таковая, даже если не брать во внимание повышение надежности, которое она обеспечивает, обычно стоит затраченных усилий. Внедрение CI/CD в уже существующий проект с императивным развертыванием — чрезвычайно сложная задача. В следующих разделах мы обсудим другие фрагменты этого YAML-файла (например, ConfigMap и секретные тома) и качество обслуживания (Quality of Service) pod-оболочки.

26   

Глава 1. Создание простого сервиса

Настройка внешнего доступа для HTTP-трафика Контейнеры нашего приложения уже развернуты, но к нему все еще нельзя обратиться. Ресурсы кластера по умолчанию недоступны снаружи. Чтобы с ними мог работать кто угодно, нам нужно создать объект Service и балансировщик нагрузки; это позволит присвоить контейнерам внешний IP-адрес и направить к ним трафик. Для этого мы воспользуемся двумя ресурсами. Первый — это Service, который распределяет (балансирует) трафик, поступающий по TCP или UDP. В нашем примере мы задействуем протокол TCP. Второй ресурс — объект Ingress , обеспечивающий балансировку нагрузки с гибкой маршрутизацией запросов в зависимости от доменных имен и HTTP-путей. Вам, наверное, интересно, зачем такому простому приложению, как наше, настолько сложный ресурс, коим является Ingress. Но в последующих главах вы увидите, что даже в этом незамысловатом примере обслуживаются HTTP-запросы из двух разных сервисов. Более того, наличие Ingress на границе кластера обеспечивает гибкость, необходимую для дальнейшего расширения нашего сервиса. Прежде чем определять ресурс Ingress, следует создать Kubernetes Service, на который он будет указывать. А чтобы связать этот Service с pod, созданными в предыдущем разделе, мы воспользуемся метками. Определение Service выглядит намного проще, чем ресурс Deployment: apiVersion: v1 kind: Service metadata: labels: app: frontend name: frontend namespace: default spec: ports: - port: 8080 protocol: TCP targetPort: 8080 selector: app: frontend type: ClusterIP

Теперь можно определить ресурс Ingress. Он, в отличие от Service, требует наличия в кластере контейнера с подходящим контроллером. Контроллеры бывают разные: одни из них предоставляются облачными провайдерами, а другие основываются на серверах с открытым исходным кодом. Если вы выбрали открытую реализацию Ingress, то для ее установки и обслужива-

Конфигурация приложения с помощью ConfigMap   27

ния лучше использовать диспетчер пакетов Helm (helm.sh). Популярностью пользуются такие реализации, как nginx и haproxy: apiVersion: extensions/v1beta1 kind: Ingress metadata: name: frontend-ingress spec: rules: - http: paths: - path: /api backend: serviceName: frontend servicePort: 8080

Конфигурация приложения с помощью ConfigMap Любое приложение должно быть в той или иной степени настраиваемым. Это может касаться количества отображаемых журнальных записей на странице, цвета фона, специального праздничного представления и многих других параметров. Обычно такую конфигурационную информацию лучше всего хранить отдельно от самого приложения. У такого разделения есть несколько причин. Прежде всего, у вас может быть несколько одинаковых исполняемых файлов с разными настройками, зависящими от определенных условий. Например, вы можете предусмотреть две отдельные страницы, где будут поздравления с Пасхой в Европе и китайским Новым годом в Китае. Помимо региональной специфики, разделение вызвано еще одной причиной — гибкостью. Двоичные релизы, как правило, содержат некоторый новый функционал; если включать их непосредственно в коде, то это потребует выпуска нового двоичного файла, что может быть затратным и медленным процессом. Конфигурация позволяет быстро (и даже динамически) активизировать и деактивизировать возможности в зависимости от потребностей пользователей или программных сбоев. Вы можете выкатывать и откатывать каждую отдельную функцию. Такая гибкость позволяет непрерывно развивать приложение, даже если некоторые из его возможностей приходится выключать из-за плохой производительности или некорректного поведения. В Kubernetes такого рода конфигурация представлена ресурсом под названием ConfigMap. Данный ресурс содержит пары типа «ключ — значение»,

28   

Глава 1. Создание простого сервиса

описывающие конфигурационную информацию или файл. Эта информация предоставляется pod с помощью файлов или переменных среды. Представьте, что вам нужно сделать настраиваемым количество журнальных записей, отображаемых на каждой странице. Для этого можно создать ресурс ConfigMap: kubectl create configmap frontend-config --from-literal=journalEntries=10

Затем вы должны предоставить конфигурационную информацию в виде переменной среды в самом приложении. Для этого в раздел containers ресурса Deployment, который вы определили ранее, можно добавить следующий код: ... # Массив контейнеров в PodTemplate внутри Deployment. containers: - name: frontend ... env: - name: JOURNAL_ENTRIES valueFrom: configMapKeyRef: name: frontend-config key: journalEntries ...

Это один из примеров использования ConfigMap для конфигурации приложения, но в реальных условиях изменения в данный ресурс можно вносить на регулярной основе: еженедельно или еще чаще. У вас может возникнуть соблазн делать это напрямую, редактируя сам файл ConfigMap, но это не самый удачный подход. Тому есть несколько причин: прежде всего, изменение конфигурации само по себе не инициирует обновление существующих pod. Чтобы применить настройки, pod нужно перезапустить. В связи с этим развертывание не зависит от работоспособности приложения и может происходить по мере необходимости или произвольным образом. Вместо этого номер версии лучше указывать и в имени самого ресурса ConfigMap. Например, frontend-config-v1, а не frontend-config. Если вам нужно внести изменение, то не обновляйте существующую конфигурацию, а создайте новый экземпляр ConfigMap с версией v2 и затем отредактируйте Deployment так, чтобы он его использовал. Благодаря этому развертывание происходит автоматически, с использованием соответствующих проверок работоспособности и пауз между изменениями. Более того, если вам нужно откатить обновление, то конфигурация v1 по-прежнему находится в кластере и, чтобы переключиться на нее, достаточно еще раз отредактировать Deployment.

Управление аутентификацией с помощью объектов Secret    29

Управление аутентификацией с помощью объектов Secret До сих пор мы обходили вниманием сервис Redis, к которому подключена клиентская часть нашего приложения. Но в любом реальном проекте соединение между сервисами должно быть защищенным. Это отчасти делается в целях повышения безопасности пользователей и их данных, но в то же время необходимо для предотвращения ошибок, таких как подключение клиентской части к промышленной базе данных. Для аутентификации в сервере Redis используется обычный пароль, который было бы удобно хранить в исходном коде приложения или в одном из файлов вашего образа. Однако оба варианта являются плохими по целому ряду причин. Для начала это раскрывает ваши секретные данные (пароль) в среде, в которой может не быть никакой системы контроля доступа. Если пароль находится в исходном коде, то доступ к вашему репозиторию эквивалентен доступу ко всем секретным данным. Это, скорее всего, плохое решение. Обычно доступ к исходному коду имеет более широкий круг пользователей, чем к серверу Redis. Точно так же не всех пользователей, имеющих доступ к образу контейнера, следует допускать к промышленной базе данных. Помимо проблем с контролем доступа, есть еще одна причина, почему не стоит привязывать секретные данные к исходному коду и/или образам: параметризация. Вы должны иметь возможность использовать одни и те же образы и код в разных средах (отладочной, канареечной или промышленной). Если секретные данные привязаны к исходному коду или образу, то вам придется собирать новый образ (или код) для каждой отдельной среды. В прошлом разделе вы познакомились с ресурсом ConfigMap и, наверное, думаете, что пароль можно было бы хранить в качестве конфигурации и затем передавать его приложению. Действительно, конфигурация и секретные данные отделяются от приложения по тому же принципу. Но дело в том, что последние сами по себе являются важной концепцией. Вам вряд ли захочется управлять контролем доступа, администрированием и обновлением секретных данных так, как вы это делаете с конфигурацией. Что еще важнее, ваши разработчики должны по-разному воспринимать доступ к конфигурации и секретным данным. В связи с этим Kubernetes располагает встроенным ресурсом Secret, предназначенным специально для этих целей.

30   

Глава 1. Создание простого сервиса

Вы можете создать секретный пароль для своей базы данных Redis следующим образом: kubectl create secret generic redis-passwd --from-literal=passwd=${RANDOM}

Очевидно, что в качестве пароля лучше не использовать просто случайные числа. К тому же вам, вероятно, захочется подключить сервис для управления секретными данными или ключами; это может быть решение вашего облачного провайдера, такое как Microsoft Azure Key Vault, или открытый проект наподобие HashiCorp Vault. Обычно сервисы по управлению ключами имеют более тесную интеграцию с ресурсами Secret в Kubernetes. По умолчанию секретные данные в Kubernetes хранятся в незашифрованном виде. Если вам нужно шифрование, то можете воспользоваться интеграцией с  провайдером ключей; вы получите ключ, с  помощью которого будут шифроваться все секретные данные в кластере. Это защищает от непосредственных атак на базу данных etcd, но вам все равно необходимо позаботиться о безопасном доступе через API-сервер Kubernetes.

Сохранив пароль к Redis в виде объекта Secret, вы должны привязать его к приложению, которое развертывается в Kubernetes. Для этого можно использовать ресурс Volume (том). Том — это, в сущности, файл или каталог с возможностью подключения к запущенному контейнеру по заданному пользователем пути. В случае с секретными данными том создается в виде файловой системы tmpfs, размещенной в оперативной памяти, и затем подключается к контейнеру. Благодаря этому, даже если злоумышленник имеет физический доступ к серверу (что маловероятно в облаке, но может случиться в вычислительном центре), ему будет намного сложнее заполучить секретные данные. Чтобы добавить секретный том в объект Deployment, вам нужно указать в YAML-файле последнего два дополнительных раздела. Первый раздел, volumes, добавляет том в pod: ... volumes: - name: passwd-volume secret: secretName: redis-passwd

Управление аутентификацией с помощью объектов Secret    31

Затем том нужно подключить к определенному контейнеру. Для этого в описании контейнера следует указать поле volumeMounts: ... volumeMounts: - name: passwd-volume readOnly: true mountPath: "/etc/redis-passwd" ...

Благодаря этому том становится доступным для клиентского кода в каталоге redis-passwd. Итоговый объект Deployment будет выглядеть следующим образом: apiVersion: extensions/v1beta1 kind: Deployment metadata: labels: app: frontend name: frontend namespace: default spec: replicas: 2 selector: matchLabels: app: frontend template: metadata: labels: app: frontend spec: containers: - image: my-repo/journal-server:v1-abcde imagePullPolicy: IfNotPresent name: frontend volumeMounts: - name: passwd-volume readOnly: true mountPath: "/etc/redis-passwd" resources: requests: cpu: "1.0" memory: "1G" limits: cpu: "1.0" memory: "1G" volumes: - name: passwd-volume secret: secretName: redis-passwd

32   

Глава 1. Создание простого сервиса

Благодаря этой конфигурации наше клиентское приложение имеет доступ к паролю, который позволяет ему войти в сервис Redis. Аналогичным образом использование пароля настраивается и в самом сервисе; мы подключаем секретный том к Redis pod и загружаем пароль из файла.

Stateful-развертывание простой базы данных Развертывание stateful принципиально не отличается от развертывания клиентского приложения, которое мы рассматривали в предыдущих разделах, однако наличие состояния вносит дополнительные сложности. Прежде всего, планирование функционирования pod в Kubernetes зависит от ряда факторов, таких как работоспособность узла, обновление или перебалансировка. Если данные экземпляра Redis хранятся на каком-то конкретном сервере или в самом контейнере, то будут потеряны при миграции или перезапуске данного контейнера. Чтобы этого избежать, при выполнении в Kubernetes stateful-приложений нужно обязательно использовать удаленные постоянные тома (PersistentVolumes). Kubernetes поддерживает различные реализации объекта PersistentVolume, но все они имеют общие свойства. Как и секретные тома, описанные ранее, они привязываются к pod и подключаются к контейнеру по определенному пути. Их особенностью является то, что они обычно представляют собой удаленные хранилища, которые подключаются по некоему сетевому протоколу: или файловому (как в случае с NFS и SMB), или блочному (как в случае с iSCSI, облачными дисками и т. д.). В целом для таких приложений, как базы данных, предпочтительны блочные диски, поскольку обеспечивают лучшую производительность. Но если скорость работы не настолько важна, то файловые диски могут быть более гибкими.

Управление состоянием, как в  Kubernetes, так и  в  целом,  — сложная задача. Если среда, в которой вы работаете, поддерживает сервисы с сохранением состояния (stateful) (например, MySQL или Redis), то обычно лучше использовать именно их. Сначала тарифы на SaaS (Software as a Service — программное обеспечение как услуга) могут показаться высокими, но если учесть все операционные требования к поддержанию состояния (резервное копирование, обеспечение локальности и избыточности данных и т. д.) и тот факт, что наличие состояния осложняет перемещение приложений между кластерами Kubernetes, то становится

Stateful-развертывание простой базы данных   33

очевидно, что в большинстве случаев высокая цена SaaS себя оправдывает. В средах с локальным размещением, где сервисы SaaS недоступны, имеет смысл организовать отдельную команду специалистов, которая будет предоставлять услугу хранения данных в рамках всей организации. Это, несомненно, лучше, чем позволять каждой команде выкатывать собственное решение.

Для развертывания сервиса Redis мы воспользуемся ресурсом StatefulSet. Это дополнение к ReplicaSet, которое появилось уже после выхода первой версии Kubernetes и предоставляет более строгие гарантии, такие как согласованные имена (никаких случайных хешей!) и определенный порядок увеличения и уменьшения количества pod (scale-up, scale-down). Это не так важно, когда развертывается одноэлементное приложение, но если вам нужно развернуть состояние с репликацией, то данные характеристики придутся очень кстати. Чтобы запросить постоянный том для нашего сервиса Redis, мы воспользуемся PersistentVolumeClaim. Это своеобразный запрос ресурсов. Наш сервис объявляет, что ему нужно хранилище размером 50 Гбайт, а кластер Kubernetes определяет, как выделить подходящий постоянный том. Данный механизм нужен по двум причинам. Во-первых, он позволяет создать ресурс StatefulSet, который можно переносить между разными облаками и размещать локально, не заботясь о конкретных физических дисках. Во-вторых, несмотря на то, что том типа PersistentVolume можно подключить лишь к одному pod, запрос тома позволяет написать шаблон, доступный для реплицирования, но при этом каждому pod будет назначен отдельный постоянный том. Ниже показан пример ресурса StatefulSet для Redis с постоянными томами: apiVersion: apps/v1 kind: StatefulSet metadata: name: redis spec: serviceName: "redis" replicas: 1 selector: matchLabels: app: redis template: metadata: labels: app: redis

34   

Глава 1. Создание простого сервиса

spec: containers: - name: redis image: redis:5-alpine ports: - containerPort: 6379 name: redis volumeMounts: - name: data mountPath: /data volumeClaimTemplates: - metadata: name: data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 10Gi

В результате будет развернут один экземпляр сервиса Redis. Но, допустим, вам нужно реплицировать кластер Redis, чтобы масштабировать запросы на чтение и повысить устойчивость к сбоям. Для этого, очевидно, следует довести количество реплик до трех, но в то же время сделать так, чтобы для выполнения записи новые реплики подключались к ведущему экземпляру Redis. Когда мы добавляем в объект StatefulSet новый неуправляемый (headless) сервис, для него автоматически создается DNS-запись redis-0.redis; это IP-адрес первой реплики. Вы можете воспользоваться этим для написания сценария, пригодного для запуска во всех контейнерах: #!/bin/sh PASSWORD=$(cat /etc/redis-passwd/passwd) if [[ "${HOSTNAME}" == "redis-0" ]]; then redis-server --requirepass ${PASSWORD} else redis-server --slaveof redis-0.redis 6379 --masterauth ${PASSWORD} --requirepass ${PASSWORD} fi

Этот сценарий можно оформить в виде ConfigMap: kubectl create configmap redis-config --from-file=launch.sh=launch.sh

Затем объект ConfigMap нужно добавить в StatefulSet и использовать его как команду для управления контейнером. Добавим также пароль для аутентификации, который создали ранее.

Stateful-развертывание простой базы данных   35

Полное определение сервиса Redis с тремя репликами выглядит следующим образом: apiVersion: apps/v1 kind: StatefulSet metadata: name: redis spec: serviceName: "redis" replicas: 3 selector: matchLabels: app: redis template: metadata: labels: app: redis spec: containers: - name: redis image: redis:5-alpine ports: - containerPort: 6379 name: redis volumeMounts: - name: data mountPath: /data - name: script mountPath: /script/launch.sh subPath: launch.sh - name: passwd-volume mountPath: /etc/redis-passwd command: - sh - -c - /script/launch.sh volumes: - name: script configMap: name: redis-config defaultMode: 0777 - name: passwd-volume secret: secretName: redis-passwd volumeClaimTemplates: - metadata: name: data spec: accessModes: [ "ReadWriteOnce" ] resources: requests: storage: 10Gi

36   

Глава 1. Создание простого сервиса

Создание балансировщика нагрузки для TCP с использованием Service Итак, мы развернули stateful-сервис Redis; теперь его нужно сделать доступным для нашего клиентского приложения. Для этого создадим два разных Service Kubernetes. Первый будет читать данные из Redis. Поскольку они реплицируются между всеми тремя участниками StatefulSet, для нас несущественно, к какому из них будут направляться наши запросы на чтение. Следовательно, для этой задачи подойдет простой Service: apiVersion: v1 kind: Service metadata: labels: app: redis name: redis namespace: default spec: ports: - port: 6379 protocol: TCP targetPort: 6379 selector: app: redis sessionAffinity: None type: ClusterIP

Выполнение записи потребует обращения к ведущей реплике Redis (под номером 0). Создайте для этого неуправляемый (headless) Service. У него нет IP-адреса внутри кластера; вместо этого он задает отдельную DNS-запись для каждого pod в StatefulSet. То есть мы можем обратиться к нашей ведущей реплике по доменному имени redis-0.redis: apiVersion: v1 kind: Service metadata: labels: app: redis-write name: redis-write spec: clusterIP: None ports: - port: 6379 selector: app: redis

Таким образом, если нам нужно подключиться к Redis для сохранения каких-либо данных или выполнения транзакции с чтением/записью, то мы

Направление трафика к серверу статических файлов с помощью Ingress   37

можем собрать отдельный клиент, который будет подключаться к серверу redis-0.redis-write.

Направление трафика к серверу статических файлов с помощью Ingress Заключительный компонент нашего приложения — сервер статических файлов, который отвечает за раздачу HTML-, CSS-, JavaScript-файлов и изображений. Отделение сервера статических файлов от нашего клиентского приложения, предоставляющего API, делает нашу работу более эффективной и целе­направленной. Для раздачи файлов можно воспользоваться готовым высокопроизводительным файловым сервером наподобие NGINX; при этом команда разработчиков может сосредоточиться на реализации нашего API. К счастью, ресурс Ingress позволяет очень легко организовать такую архитектуру в стиле мини/микросервисов. Как и в случае с клиентским приложением, мы можем описать реплицируемый сервер NGINX с помощью ресурса Deployment. Соберем статические образы в контейнер NGINX и развернем их в каждой реплике. Ресурс Deployment будет выглядеть следующим образом: apiVersion: extensions/v1beta1 kind: Deployment metadata: labels: app: fileserver name: fileserver namespace: default spec: replicas: 2 selector: matchLabels: app: fileserver template: metadata: labels: app: fileserver spec: containers: - image: my-repo/static-files:v1-abcde imagePullPolicy: Always name: fileserver terminationMessagePath: /dev/termination-log terminationMessagePolicy: File resources: requests: cpu: "1.0"

38   

Глава 1. Создание простого сервиса

memory: "1G" limits: cpu: "1.0" memory: "1G" dnsPolicy: ClusterFirst restartPolicy: Always

Теперь, запустив реплицируемый статический веб-сервер, вы можете аналогичным образом создать ресурс Service, который будет играть роль балансировщика нагрузки: apiVersion: v1 kind: Service metadata: labels: app: fileserver name: fileserver namespace: default spec: ports: - port: 80 protocol: TCP targetPort: 80 selector: app: fileserver sessionAffinity: None type: ClusterIP

Итак, у вас есть Service для сервера статических файлов. Добавим в ресурс Ingress новый путь. Необходимо отметить, что путь / должен идти после /api, иначе запросы API станут направляться серверу статических файлов. Обновленный ресурс Ingress будет выглядеть следующим образом: apiVersion: extensions/v1beta1 kind: Ingress metadata: name: frontend-ingress spec: rules: - http: paths: - path: /api backend: serviceName: frontend servicePort: 8080 # Примечание: этот раздел должен идти после /api, # иначе он будет перехватывать запросы. - path: / backend: serviceName: fileserver servicePort: 80

Параметризация приложения с помощью Helm   39

Параметризация приложения с помощью Helm Все, что мы обсуждали до сих пор, было направлено на развертывание одного экземпляра нашего сервиса в одном кластере. Но в реальности сервисы почти всегда приходится развертывать в нескольких разных средах (даже при условии, что они находятся в общем кластере). Вы можете быть разработчиком-одиночкой, который занимается всего одним приложением, но если хотите, чтобы внесение изменений не мешало пользователям работать, то вам понадобится как минимум две версии: отладочная и промышленная. И прибавив к этому интеграционное тестирование и CI/CD, мы получим следующее: даже при работе с одним сервисом и наличии лишь пары разработчиков нужно выполнять развертывание по меньшей мере в трех разных средах, и это далеко не предел, если приложение должно справляться со сбоями на уровне вычислительного центра. Начальная стратегия для борьбы со сбоями у многих команд заключается в тривиальном копировании файлов из одного кластера в другой. Вместо одного каталога frontend/ они используют два: frontend-production/ и  frontenddevelopment/. Такой способ опасен, поскольку разработчикам приходится следить за тем, чтобы файлы оставались синхронизированными. Этого можно было бы легко добиться, если бы эти каталоги должны были быть идентичными. Но некоторые расхождения между отладочной и промышленной версиями нормальны, так как вы будете разрабатывать новые возможности; крайне важно, чтобы эти расхождения были намеренными и простыми в управлении. Еще один подход состоит в использовании веток и системы контроля версий; центральный репозиторий разделяется на промышленную и отладочную ветки, разница между которыми видна невооруженным глазом. Это может быть хорошим вариантом для некоторых команд, но если вы хотите развертывать ПО сразу в нескольких средах (например, система CI/CD может выполнять развертывание в разных регионах облака), то переключение между ветками будет проблематичным. В связи с этим большинство людей в итоге выбирают систему шаблонов. Идея в том, что централизованный каркас конфигурации приложения образуют шаблоны, которые подставляются для той или иной среды на основе параметров. Таким образом, вы можете иметь одну общую конфигурацию, при необходимости легко подгоняемую под определенные условия. Для Kubernetes есть множество разных систем шаблонов, но наиболее популярна, безусловно, Helm (helm.sh).

40   

Глава 1. Создание простого сервиса

В Helm приложения распространяются в виде так называемых чартов с файлами внутри. В основе чарта лежит файл chart.yaml, в котором определяются его метаданные: apiVersion: v1 appVersion: "1.0" description: A Helm chart for our frontend journal server. name: frontend version: 0.1.0

Этот файл размещается в корневом каталоге чарта (например, в  frontend/). Там же находится каталог templates, внутри которого хранятся шаблоны. Шаблон, в сущности, представляет собой YAML-файл, похожий на приводимые в предыдущих примерах; разница лишь в том, что отдельные его значения заменены ссылками на параметры. Скажем, представьте, будто хотите параметризировать количество реплик в своем клиентском приложении. Вот что содержал наш исходный объект Deployment: ... spec: replicas: 2 ...

В файле шаблона (frontend-deployment.tmpl) данный раздел выглядит следующим образом: ... spec: replicas: {{ .replicaCount }} ...

Это значит, что при развертывании чарта для поля replicas будет подставлен подходящий параметр. Сами параметры определены в файле values.yaml, предназначенном для конкретной среды, в котором развертывается приложение. Для этого простого чарта файл values.yaml выглядел бы так: replicaCount: 2

Теперь, чтобы собрать все указанное вместе, вы можете развернуть данный чарт с помощью утилиты helm, как показано ниже: helm install path/to/chart --values path/to/environment/values.yaml

Эта команда параметризирует ваше приложение и развернет его в Kubernetes. Со временем параметризация будет расширяться, охватывая все разнообразие сред выполнения вашего приложения.

Резюме   41

Рекомендации по развертыванию сервисов Kubernetes — эффективная система, которая может показаться сложной. Однако процесс развертывания обычного приложения легко упростить, если следовать общепринятым рекомендациям. ‰‰ Большинство сервисов нужно развертывать в виде ресурса Deployment. Объекты Deployment создают идентичные реплики для масштабирования и обеспечения избыточности. ‰‰ Для доступа к объектам Deployment можно использовать объект Service, который, в сущности, является балансировщиком нагрузки. Service может быть доступен как изнутри (по умолчанию), так и снаружи. Если вы хотите, чтобы к вашему HTTP-приложению можно было обращаться, то используйте контроллер Ingress для добавления таких возможностей, как маршрутизация запросов и SSL. ‰‰ Рано или поздно ваше приложение нужно будет параметризировать, чтобы сделать его конфигурацию более пригодной к использованию в разных средах. Для этого лучше всего подходят диспетчеры пакетов, такие как Helm (helm.sh).

Резюме Несмотря на свою простоту, приложение, созданное нами в этой главе, охватывает практически все концепции, которые могут понадобиться вам в более крупных и сложных проектах. Понимание того, как сочетаются эти фундаментальные компоненты, и умение их использовать — залог успешного применения Kubernetes. Использование системы контроля версий, аудита изменений кода и непрерывной доставки ваших сервисов позволит любым проектам, которые вы создаете, иметь прочный фундамент. Эта основополагающая информация пригодится вам при изучении более сложных тем, представленных в других главах.

Глава 2

Процесс разработки Платформа Kubernetes была создана для надежной эксплуатации программного обеспечения. Она упрощает развертывание и администрирование приложений за счет API, ориентированного на управление программами, свойств самовосстановления и таких ценных инструментов, как объекты Deployment, которые позволяют развертывать ПО с нулевым временем простоя. И хотя все эти средства полезны, они не слишком помогают в разработке приложений для Kubernetes. Многие кластеры предназначены для выполнения промышленных приложений, поэтому редко участвуют в процессе разработки. Тем не менее крайне важно, чтобы разработчики имели возможность писать код с расчетом на Kubernetes, а это обычно подразумевает выделение кластера или как минимум некой его части под разработку. Это один из ключевых моментов в создании успешных приложений для данной платформы. Очевидно, что сам по себе кластер, для которого не собрано никакого кода, довольно бесполезен.

Цели Прежде чем переходить к описанию лучших подходов к построению кластеров для разработки, следует обозначить цели, которые мы ставим перед собой. Очевидно, что основная цель — дать возможность разработчикам быстро и легко собирать приложения для Kubernetes, но что это означает на самом деле и какие практические требования к кластеру для разработки влечет за собой? Определим этапы взаимодействия разработчика с кластером. Все начинается с подготовки. Это когда к команде присоединяется новый разработчик. На данном этапе ему выдают учетную запись для доступа к кластеру и показывают, как производится развертывание. Цель этапа — за минимальные сроки подготовить разработчика к выполнению его обязанностей. Для этого следует определить ключевые показатели эффективно-

Цели   43

сти (key performance indicator, KPI), на которые нужно ориентироваться. Например, если пользователю удастся развернуть с нуля приложение из текущей ветки в течение получаса, то это можно считать успехом. Проверяйте эффективность данного этапа каждый раз, когда к команде присоединяется новый человек. Второй этап — разработка. Это ежедневные обязанности разработчика. Цель этапа — быстрое развитие и отладка проекта. Разработчикам нужно быстро и по многу раз в день доставлять код в кластер. Они также должны иметь возможность легко тестировать свой код и отлаживать его в случае некорректной работы. Показатели эффективности данного этапа не так-то просто измерить, но вы можете их оценить, посчитав время, уходящее на развертывание в кластере PR (pull request — запрос на включение внесенных изменений) или изменения. Вместо этого (или в дополнение) уместно провести исследование субъективной производительности пользователей, которую также можно измерить в контексте общей производительности вашей команды. Третий этап — тестирование. Он переплетается с разработкой и используется для проверки кода перед его загрузкой и слиянием. Цель этапа состоит из двух частей. Во-первых, разработчик должен иметь возможность выполнить все тесты для своей среды, прежде чем отправлять PR. Во-вторых, перед слиянием кода в репозитории все тесты должны запускаться автоматически. Вдобавок следует установить KPI для продолжительности выполнения тестов. Вполне естественно, что по мере того, как ваш проект усложняется, увеличивается количество его тестов и, следовательно, время их работы. В этом случае имеет смысл выделить некую часть тестов, которые разработчик может использовать для начальной проверки перед отправкой PR. Кроме того, следует определить очень жесткий KPI для стабильности тестов. Нестабильным называют тест, который изредка (или сравнительно часто) дает сбой. В любом относительно активном проекте нестабильность, выражающаяся в одном сбое на каждые тысячу запусков, приводит к разногласиям между разработчиками. Вы должны убедиться в том, что среда выполнения вашего кластера не является причиной нестабильности тестов. Тесты могут становиться нестабильными как из-за проблем в коде, так и вследствие некорректного функционирования среды разработки (например, при нехватке ресурсов или слишком активном поведении других тестов на том же оборудовании). Вам следует позаботиться о том, чтобы в среде разработки не было подобных проблем; для этого нужно отслеживать нестабильные тесты и быстро принимать соответствующие меры.

44   

Глава 2. Процесс разработки

Построение кластера для разработки Когда люди начинают задумываться о разработке для Kubernetes, одно из первых решений, которые им приходится принимать, заключается в выборе между созданием одного большого кластера для разработки и выделением отдельных кластеров для каждого разработчика. Стоит отметить, что этот выбор встает только в средах, позволяющих легко и динамически создавать новые кластеры (например, в публичных облаках). В физических окружениях один большой кластер может быть единственным вариантом. Если у вас все же есть выбор, то вы должны подумать о преимуществах и недостатках каждого из двух решений. Можно выделить по одному кластеру для каждого разработчика, но существенным минусом этого подхода будут его высокая цена и низкая эффективность; к тому же вам придется управлять большим количеством разных сред для разработки. Дополнительные денежные расходы обусловлены тем, что существенная часть ресурсов каждого кластера будет простаивать. Кроме того, большое количество разных кластеров затруднит отслеживание и освобождение ненужных ресурсов. Преимущество этого подхода состоит в его простоте: каждый разработчик может самостоятельно заниматься обслуживанием своего кластера, а благодаря изоляции разные члены команды не будут мешать друг другу. С другой стороны, единый кластер для разработки будет намного эффективней; цена обслуживания того же количества разработчиков, вероятно, будет как минимум втрое ниже. Кроме того, это значительно упрощает установку общих кластерных сервисов, таких как мониторинг и ведение журнала, благодаря чему намного легче сделать кластер удобным для разработки. Недостатки разделяемого кластера — процесс управления пользователями и недостаточная изоляция между разработчиками. В настоящее время процедуру добавления в Kubernetes новых пользователей и пространств имен нельзя назвать слишком простой. Механизмы для взаимодействия с ресурсами и управления доступом на основе ролей (Role-Based Access Control, RBAC), встроенные в Kubernetes, могут уменьшить риск возникновения конфликтов между двумя разработчиками. Однако всегда существует вероятность того, что пользователь займет слишком много ресурсов и заблокирует работу других приложений, в результате чего нарушится функционирование кластера. Кроме того, вам нужно следить за тем, чтобы разработчики не забывали освобождать выделенные им ресурсы, хотя по сравнению с подходом, в котором они создают собственные кластеры, это не так уж сложно.

Подготовка разделяемого кластера для нескольких разработчиков   45

Оба описанных варианта приемлемы, но в целом мы рекомендуем использовать единый большой кластер. Потенциальные конфликты между разными разработчиками устранимы, а экономичность и возможность легко добавлять в кластер новые функции в масштабах всей организации перевешивают вероятные риски. Но при этом необходимо позаботиться о подготовке условий для новых сотрудников, об управлении ресурсами и удалении ненужных сред. Мы считаем, что сначала следует попробовать один большой кластер. По мере роста вашей организации (или если она уже большая) можно будет подумать о выделении отдельных кластеров для каждой команды или группы (размером 10–20 человек), чтобы не сосредотачивать сотни пользователей в одной системе. Это может помочь как с планированием расходов, так и с управлением.

Подготовка разделяемого кластера для нескольких разработчиков Крупный кластер создается для того, чтобы в нем могли работать сразу несколько пользователей, не мешая друг другу. Очевидным средством разделения разработчиков в Kubernetes служат пространства имен — на их основе можно создавать отдельные среды для развертывания, чтобы клиентские сервисы разных пользователей не конфликтовали между собой. Пространства имен также играют роль областей доступа для RBAC, благодаря которым разработчик не может случайно удалить чужие контейнеры. Таким образом, в разделяемом кластере пространства имен логично использовать в качестве рабочих областей. Процедуры добавления новых пользователей и создания/ защиты пространств имен описываются в следующих подразделах.

Добавление новых пользователей Прежде чем назначить пользователю пространство имен, вы должны дать доступ к самому кластеру Kubernetes. Вы можете создать для пользователя новый сертификат и предоставить ему файл kubeconfig, который позволит входить в систему; вы также можете настроить свой кластер в целях применения внешней системы идентификации (такой как Microsoft Azure Active Directory или AWS Identity and Access Management, IAM). В целом применение внешней системы идентификации — предпочтительный вариант, поскольку она не требует поддержания двух разных источников

46   

Глава 2. Процесс разработки

идентичности. Однако в случаях, когда она неприменима, приходится использовать сертификаты. К счастью, для создания и администрирования таких сертификатов в Kubernetes есть специальный API. Ниже описана процедура добавления нового пользователя в существующий кластер. Первым делом нужно выполнить запрос для создания нового сертификата. Ниже представлена простая программа на Go, которая делает это: package main import ( "crypto/rand" "crypto/rsa" "crypto/x509" "crypto/x509/pkix" "encoding/asn1" "encoding/pem" "os" ) func main() { name := os.Args[1] user := os.Args[2] key, err := rsa.GenerateKey(rand.Reader, 1024) if err != nil { panic(err) } keyDer := x509.MarshalPKCS1PrivateKey(key) keyBlock := pem.Block{ Type: "RSA PRIVATE KEY", Bytes: keyDer, } keyFile, err := os.Create(name + "-key.pem") if err != nil { panic(err) } pem.Encode(keyFile, &keyBlock) keyFile.Close() commonName := user // подставьте сюда свои данные emailAddress := "[email protected]" org := "My Co, Inc." orgUnit := "Widget Farmers" city := "Seattle" state := "WA" country := "US"

Подготовка разделяемого кластера для нескольких разработчиков   47

subject := pkix.Name{ CommonName: Country: Locality: Organization: OrganizationalUnit: Province: }

commonName, []string{country}, []string{city}, []string{org}, []string{orgUnit}, []string{state},

asn1, err := asn1.Marshal(subject.ToRDNSequence()) if err != nil { panic(err) } csr := x509.CertificateRequest{ RawSubject: asn1, EmailAddresses: []string{emailAddress}, SignatureAlgorithm: x509.SHA256WithRSA, } bytes, err := x509.CreateCertificateRequest(rand.Reader, &csr, key) if err != nil { panic(err) } csrFile, err := os.Create(name + ".csr") if err != nil { panic(err) }

}

pem.Encode(csrFile, &pem.Block{Type: "CERTIFICATE REQUEST", Bytes: bytes}) csrFile.Close()

Вы можете запустить ее следующим образом: go run csr-gen.go client ;

В результате будут созданы файлы с названиями client-key.pem и client.csr. Затем можно запустить следующий сценарий, чтобы создать и загрузить новый сертификат: #!/bin/sh csr_name="my-client-csr" name="${1:-my-user}" csr="${2}" cat