Когда контейнеров в инфраструктуре становится больше пары десятков, ручное управление превращается в фабрику инцидентов. Контейнеры падают, узлы перезагружаются, трафик перекашивается, обновление занимает вечер выкатки и три ночи отката. Оркестрация забирает эту работу у людей: администратор описывает желаемое состояние в манифестах, а система непрерывно приводит реальность к этой декларации. Kubernetes стал самым распространённым инструментом такой работы, и его устройство полезно понимать каждому, кто отвечает за продакшн-кластеры. Смысл модели не в красивых абстракциях, а в воспроизводимости: описание состояния в git, выкатка через CI, одинаковые окружения на тесте и в проде. Ниже - архитектура кластера, обязанности каждого компонента и практические выводы для ежедневной эксплуатации.

Архитектура control plane и роль kube-apiserver в каждом запросе

Управляющий слой кластера, control plane, собирает несколько процессов, которые на собственных установках обычно живут на выделенных узлах. Центральная фигура здесь - kube-apiserver. Это единственная точка входа в кластер: kubectl, дашборды, операторы и сами компоненты control plane общаются друг с другом только через его REST API. Любое изменение - создание пода, правка ConfigMap, масштабирование Deployment - проходит один и тот же путь: аутентификация, авторизация через RBAC, валидация схемы, admission-контроллеры и лишь затем запись в хранилище. Ни один объект не появляется в кластере в обход этой цепочки.

Такой дизайн даёт два практических следствия. Первое - безопасность: достаточно закрыть доступ к apiserver и настроить политики, чтобы контролировать всё происходящее внутри. Второе - наблюдаемость: каждая мутация фиксируется в журналах API, и по ним можно восстановить, кто и когда изменил объект. Сам apiserver не хранит состояние, поэтому масштабируется горизонтально: несколько реплик за балансировщиком выдерживают заметно больший поток запросов, чем одна.

API кластера версионирован: объекты описываются в группах вроде apps/v1 или batch/v1, и при обновлении кластера устаревшие версии исчезают. Отсюда привычка держать манифесты в репозитории и обновлять их заранее, а не ловить несовместимости на выкатке.

Полезно помнить, что kubectl - обычный HTTP-клиент. Команда kubectl apply -f manifest.yaml отправляет в API манифест, сервер сохраняет объект, а дальше система сама решает, что с ним делать. Любой инструмент с сетевым доступом и валидным токеном управляет кластером теми же запросами, а компоненты читают API не по кругу, а подписываются на события через механизм watch и реагируют на изменения в реальном времени. Поэтому контроллеры замечают сбой узла за секунды, а не по окончании длинного цикла опроса.

Отдельно стоит сказать про установку через kubeadm: компоненты control plane там запускаются как static pods. kubelet на управляющих узлах читает манифесты из каталога /etc/kubernetes/manifests и держит эти контейнеры живыми даже при недоступном API. Логика проста: сломанный apiserver не может перезапустить сам себя, поэтому его жизненный цикл выведен из-под его же контроля. При разборе проблем управляющего слоя журналы этих статических контейнеров дают больше информации, чем внешние сигналы.

etcd как единый источник правды и требования к его сохранности

etcd - распределённое key-value хранилище, где лежит всё состояние кластера: объекты рабочей нагрузки, секреты, конфигурация, членство узлов. Компонент построен на консенсусе Raft, поэтому разворачивается нечётным числом узлов, обычно три или пять: кластер переживает отказ меньшинства без потери записи. Кворум обязателен. Если большинство узлов etcd недоступно, apiserver перестаёт принимать изменения, и весь кластер переходит в режим, где нельзя создать или обновить ни один объект.

Топологию выбирают при установке. В stacked-варианте etcd живёт на тех же узлах, что и остальные компоненты control plane, что экономит железо; отдельное размещение повышает устойчивость, но требует больше серверов. При любом варианте дискам нужна быстрая запись с низкими задержками: apiserver отвечает на каждый запрос к ресурсам и болезненно реагирует на просевшую латентность хранилища. Сначала это выглядит как медленный kubectl, потом превращается в таймауты по всему кластеру.

Резервные копии снимают регулярно утилитой etcdctl snapshot save и обязательно проверяют восстановлением на отдельном стенде: копия, которую ни разу не разворачивали, при инциденте обычно не разворачивается вовсе. Доступ к etcd закрывают сетью и шифруют TLS, потому что тот, кто читает это хранилище, читает и все секреты кластера. Складывать туда данные приложений не стоит: объём растёт, compaction спасает лишь частично, а деградация хранилища бьёт сразу по всему кластеру.

Планировщик и controller manager, которые сверяют желаемое состояние с фактическим

kube-scheduler решает, на каком узле запустится каждый новый под. Работа идёт в два прохода: сначала фильтрация узлов, где под физически поместится с учётом requests, портов и volumes, затем оценка кандидатов по нагрузке, affinity-правилам и политикам раскладки. taints и tolerations позволяют резервировать узлы под специальные задачи, например под базы данных или GPU. Приоритеты подов и preemption добавляют ещё один слой: при нехватке ресурсов планировщик выселяет менее важные поды, освобождая место критичным. Если под висит в статусе Pending, искать причину стоит именно здесь - нехватка ресурсов, несработавшие affinity-правила или taints на всех подходящих узлах.

kube-controller-manager собирает набор контроллеров, каждый из которых отвечает за свой тип объектов. ReplicaSet-контроллер держит нужное число подов, Node-контроллер следит за доступностью узлов и помечает отвалившиеся, EndpointSlice-контроллер обновляет списки адресов за Service, Job-контроллер завершает разовые задачи. Логика у всех одна: наблюдать фактическое состояние, сравнивать с желаемым и выполнять действие по расхождению. Сбой контроллера коварен тем, что снаружи незаметен: поды продолжают работать, но перезапустившийся узел так и остаётся без нагрузки, а сломавшаяся реплика - без замены. Поэтому мониторинг нужен не только рабочим подам, но и самим компонентам control plane.

Из принципа сверения следует и другое: ручные правки живого объекта живут до ближайшей сверки с манифестом, после чего контроллер возвращает всё на место. Поэтому любое изменение рабочего состояния оформляют правкой манифеста в репозитории, а не быстрым исправлением через консоль.

kubelet и kube-proxy как агенты на каждом узле кластера

На каждом рабочем узле живёт пара агентов. kubelet получает от apiserver спецификации подов, привязанных к этому узлу, запускает контейнеры через CRI-совместимый рантайм, чаще всего containerd, следит за их состоянием и выполняет проверки liveness и readiness. Для тяжёлых приложений, которым нужно время на инициализацию, существует startupProbe: пока она не прошла, остальные проверки не стартуют. kubelet перезапускает упавший контейнер и рапортует статус пода обратно в API. Он же следит за давлением ресурсов: при заполнении диска или памяти узел начинает выселять поды по собственным порогам, и эти eviction-события видны в describe пода. Если контейнер ведёт себя странно только на одной машине, первой гипотезой становится kubelet и его журналы.

kube-proxy отвечает на узле за сетевую часть сервисов: он программирует правила iptables или IPVS так, чтобы трафик на виртуальный IP Service попадал на реальные поды за ним. В свежих установках эту роль всё чаще берут на себя eBPF-решения вроде Cilium, которые делают ту же работу без промежуточных правил и дают более тонкие сетевые политики. Для администратора важно одно: между Service и трафиком всегда стоит конкретный механизм, и при странных сетевых сбоях его настройки проверяют первыми.

Pod, Deployment и Service как базовые абстракции повседневной работы

Pod - минимальная единица развертывания в Kubernetes: один или несколько контейнеров, которые разделяют сетевое пространство имён и тома. Sidecar-контейнер с прокси или сборщиком логов живёт рядом с приложением и общается с ним через localhost. Поды эфемерны: при пересоздании они получают новый IP и новое имя, поэтому привязываться к конкретному поду из клиентского кода нельзя.

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
        - name: api
          image: registry.example.com/api:1.42.0
          resources:
            requests:
              cpu: 250m
              memory: 256Mi
            limits:
              memory: 512Mi
          readinessProbe:
            httpGet:
              path: /healthz
              port: 8080

Service даёт группе подов стабильный виртуальный IP и DNS-имя: приложение обращается к api-service.internal и не заботится, какие конкретно поды сейчас живы. Внутри кластера DNS автоматически создаёт записи вида service.namespace.svc.cluster.local. Тип ClusterIP подходит для внутреннего трафика, NodePort открывает порт на каждом узле, LoadBalancer запрашивает у облака внешний балансировщик, а Ingress и Gateway API маршрутизируют HTTP-трафик по хостам и путям. Связка label и selector склеивает объекты: Deployment находит свои поды по меткам, Service направляет трафик по тому же принципу, и рассинхрон меток в шаблоне с селектором - классическая причина, по которой Service внезапно теряет поды. Конфигурацию и чувствительные данные выносят из образов в ConfigMap и Secret: они монтируются файлами или приходят переменными окружения, и один и тот же образ едет из теста в прод без пересборки.

kubectl и повседневные команды администратора кластера

Большая часть работы проходит через kubectl, и уверенное владение им экономит больше времени, чем любые дашборды. Стартовый набор покрывает просмотр, диагностику и правку объектов:

kubectl get pods -n prod
kubectl describe pod web-7d9c8b6f5-x2vql -n prod
kubectl logs -f deploy/api -n prod --since=10m
kubectl rollout status deployment/api -n prod
kubectl rollout undo deployment/api -n prod
kubectl scale deployment api --replicas=5 -n prod
kubectl top pods -n prod
kubectl get events -A --sort-by=.lastTimestamp

Диагностика сбойного пода обычно укладывается в короткую цепочку проверок:

  1. убедиться, что под создан и находится в ожидаемом namespace;
  2. посмотреть события через describe и найти ошибки планирования или загрузки образа;
  3. проверить логи текущего и предыдущего контейнера, если он перезапускался;
  4. сверить probes и лимиты ресурсов с фактическим потреблением приложения;
  5. при повторяющихся сбоях откатить Deployment к предыдущей ревизии.

Пара привычек заметно ускоряет работу. Флаг -o wide добавляет к выводу get узел и IP пода, а -o yaml отдаёт полный объект для разбора. Команда kubectl explain описывает поля любого ресурса прямо в терминале, kubectl auth can-i --list показывает, что разрешено текущему пользователю, и это первый вопрос при подозрении на ограничение прав. Контексты переключают kubectl между кластерами, а namespaces разделяют окружения внутри одного кластера, поэтому -n в командах - не украшение, а способ не перепутать среду.

Практики эксплуатации, которые экономят ночи дежурному инженеру

Компоненты кластера прощают небрежность ровно до первого серьёзного инцидента, поэтому несколько привычек стоит выстроить заранее. Для каждой рабочей нагрузки прописывают requests и limits: без них планировщик раскладывает поды вслепую, а один прожорливый контейнер душит соседей по узлу. Liveness и readiness probes настраивают под реальное время старта приложения, иначе циклы перезапусков при медленной инициализации гарантированы. Доступ разграничивают через RBAC с отдельными ролями для людей и CI, а сетевые политики в кластере с несколькими командами - не опция, а базовая гигиена.

Масштабирование под трафик доверяют HPA, а PodDisruptionBudget удерживает выкатки и эвакуации узлов от массового выселения реплик: без них рутинное обновление узла оставляет половину сервиса без инстансов. Обновления control plane и узлов планируют регулярными окнами и отрабатывают на стенде: кластер, который не обновлялся два года, при вынужденном апгрейде превращается в проект на месяц. Манифесты держат в git и применяют через kubectl apply или Helm: шаблонизатор снимает копипаст между окружениями, но не отменяет понимания того, что именно попадёт в кластер.

Состояние самих компонентов - apiserver, etcd, scheduler, kubelet - выносят в мониторинг наравне с рабочими метриками, а не ищут их деградацию постфактум. Аудит-логи API включают до инцидента: по ним видно, кто и что менял, и это первая линия расследования. В управляемых облачных Kubernetes часть этой работы берёт на себя провайдер, но ответственность за бэкапы etcd, настройки RBAC и поведение рабочих узлов остаётся на команде.

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