devops-курс Все курсы

✻ Урок 9.5 · Тема 9: Секреты и GitOps

CloudNativePG: PostgreSQL-оператор

⏱ 3 ч

Как работать с кодом и когда идти дальше

Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:

  • Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
  • Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
  • Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.

Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.

Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.

Зачем это нужно

Ты уже гонял PostgreSQL (популярная база данных: программа, которая хранит таблицы с данными приложения, как электронный архив с картотекой) в StatefulSet и делал pg_dump (команду, которая выгружает всю базу в один файл-копию) по крону (урок 5.5). У такой схемы три дыры:

  • Если под с primary (главным экземпляром базы, куда пишут) умрёт, никто не поднимет второй экземпляр и не назначит его главным. База лежит, пока ты не вмешаешься руками.
  • Восстановление из бэкапа придётся вспоминать по памяти: какой файл, какой командой, в какую базу.
  • Бэкапы лежат в том же кластере, что и база. Умер кластер, умерли и бэкапы.

Вот как первая дыра выглядит в логе приложения, когда под с базой упал:

ERROR db: connection refused (postgres:5432)

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

Оператор (operator) закрывает эти дыры. Технически это программа, которая работает внутри Kubernetes и знает, как эксплуатировать конкретную систему: как настроить репликацию, как переключиться на запасной экземпляр, как снять бэкап и восстановиться. Ты описываешь желаемое в YAML («хочу две копии базы и бэкап каждую ночь»), а оператор приводит систему к этому виду и держит её такой.

Два слова, которые будут везде. Репликация (replication) это когда база постоянно копирует свои изменения на второй экземпляр. Запасная копия при этом почти всегда свежая, и если главный сломался, её можно назначить главным. Бэкап (backup) это отдельная копия на случай ошибок людей и потери всего сразу, подробно разберём ниже.

Внимание, путаница в словах: у CNPG ресурс называется Cluster, и это не кластер Kubernetes, а одна база с её копиями (главная и запасные машины вместе). Слово «кластер» в уроке будет значить обе вещи: по контексту и написанию Cluster с большой буквы в коде отличай.

Вот где это нужно на дежурстве. Ночью упал узел, на котором жил primary, или кто-то по ошибке удалил PVC (диск) с данными. Бизнес спрашивает, сколько простоя допустимо и сколько данных можно потерять, а ты должен ответить цифрами и подтвердить их: какой под сейчас главный, свежа ли реплика, лежит ли бэкап и восстанавливался ли из него хоть раз кто-нибудь. Оператор делает большую часть сам, но проверять итог придётся тебе.

Шаг проекта (версия приложения 0.7.0):

  • В notes-gitops появляется Cluster notes-db (CloudNativePG), приложение ходит в notes-db-rw.notes.svc:5432, и оператор сам следит, кто сейчас главный.
  • Пароль к базе приходит из Vault через ESO (урок 9.2).
  • Бэкапы уходят в MinIO, отдельное хранилище файлов.
  • StatefulSet postgres и CronJob pg-backup удалены.

Что нужно знать

Картина целиком

Представь дежурного инженера в серверной. Ему оставили инструкцию: «Всегда держи два работающих сервера базы: главный и запасной. Каждую ночь делай копию. Если главный сломался, сделай главным запасной и заведи новый запасной». Инженер не спит, постоянно смотрит на серверы и, как только видит расхождение с инструкцией, исправляет его. Оператор это такой дежурный инженер, только программа. Инструкция это ресурс Cluster в YAML.

Вот как это выглядит в нашем проекте:

flowchart LR
    subgraph G["git notes-gitops"]
        G1["cnpg-cluster.yaml<br>cnpg-secret.yaml<br>cnpg-backup.yaml"]
    end
    G1 -->|"Flux"| OP["оператор CNPG<br>следит за базой"]
    OP -->|"создаёт и чинит"| DB["база notes-db<br>главная и запасная копия"]
    APP["приложение notes"] -->|"notes-db-rw"| DB
    DB -->|"копии"| M["хранилище копий<br>MinIO"]

Части схемы связаны так. Git хранит желаемое, Flux кладёт это в кластер. Оператор читает Cluster и создаёт поды с базой, диски и Service. Приложение знает один адрес, notes-db-rw, и не знает, какой именно под сейчас главный. Копии уезжают в MinIO, то есть за пределы подов с базой. Пароль приходит отдельной дорогой, через Vault и ESO. Полную схему с бэкапами увидишь ниже, в разделе про бэкапы. Дальше каждая часть разбирается по очереди.

Теория

Почему базу в Kubernetes нельзя просто «запустить»

Kubernetes отлично управляет приложениями без памяти (stateless): убил под, запустил такой же, ничего не потерялось. База данных приложение с памятью (stateful): её данные лежат на диске, и потерять их нельзя. Плюс у базы есть роли: один экземпляр главный, остальные копии.

В уроке 5.5 ты использовал StatefulSet: он даёт поду постоянное имя (postgres-0) и постоянный диск (PVC, PersistentVolumeClaim, «заявка на диск»). Это решает «не потерять данные при перезапуске». Но StatefulSet ничего не знает про PostgreSQL. Он не знает, что такое главный и запасной, что реплика отстаёт от главного на сколько-то записей, что перед переключением надо убедиться, что старый главный точно перестал писать. Всё это в лучшем случае делает скрипт, который кто-то написал и поддерживает.

Разберём на примере. В StatefulSet из урока 5.5 один под, postgres-0, он и есть база. Он умер ночью в 03:10. StatefulSet послушно создаст postgres-0 заново с тем же диском. Пока он стартует (полминуты), запись невозможна. Но допустим, диск повреждён и под не стартует. StatefulSet будет бесконечно пытаться. Добавь ты рядом ещё два пода, postgres-1 и postgres-2, как копии, ничего бы не изменилось: никто не скажет одному из них «теперь ты главный». В 03:10 у тебя простой, и он продлится до момента, пока человек не проснётся и не выполнит команду повышения руками.

Помнишь ошибку connection refused из начала урока? Вот как та же ночь выглядит в выводе команд. kubectl get pods показывает поды и их состояние, kubectl logs ... --tail=1 печатает последнюю строку лога пода:

$ kubectl get pods -n notes
NAME                     READY   STATUS             RESTARTS      AGE
notes-6d8f7b9c4-x2k7p    1/1     Running            0             2d
notes-6d8f7b9c4-q9wlz    0/1     Running            14 (30s ago)  2d
postgres-0               0/1     CrashLoopBackOff   6 (45s ago)   10m

$ kubectl logs notes-6d8f7b9c4-q9wlz -n notes --tail=1
ERROR db: connection refused (postgres:5432)

Как читать вывод: единственный под postgres-0 в состоянии CrashLoopBackOff (падает и перезапускается по кругу), 0/1 в READY значит «не готов». Второго экземпляра нет, и под приложения q9wlz перезапускается (колонка RESTARTS: 14), потому что не может достучаться до базы, а x2k7p пока держится (0). Так будет, пока человек не вмешается руками.

Осторожно: «Kubernetes сам следит за подами, значит и за базой». Нет: он следит за тем, что под жив, а не за тем, что база правильно устроена. Под может быть Running, а база внутри в режиме «только чтение».

Главное: StatefulSet возвращает под и диск, но не знает про роли, отставание реплик и безопасное переключение.

Проверь понимание: StatefulSet возвращает упавший под с тем же диском. Почему этого мало, чтобы сказать «база отказоустойчива»?

Ответ

Диск сохранится, но StatefulSet не умеет повышать реплику до главного, не следит за отставанием реплик и не переключает клиентов. Если главный под не может стартовать, простой не заканчивается сам.

Чтобы всё это делалось само, нужен оператор.

Оператор: CRD плюс контроллер

Знания «как эксплуатировать PostgreSQL» есть у людей. Оператор кладёт эти знания в программу, которая работает круглосуточно и реагирует быстрее человека.

Два кусочка.

  1. CRD (Custom Resource Definition, «описание собственного типа ресурса»). Kubernetes из коробки знает Pod, Service, Deployment. CRD добавляет в его API новый тип, например Cluster в группе postgresql.cnpg.io. После установки CRD команда kubectl get cluster начинает работать. Ты паттерн уже видел в уроке 9.4: там Certificate и ClusterIssuer.
  2. Контроллер (controller): программа-под, которая в бесконечном цикле согласования (reconcile loop) делает три шага: прочитать желаемое из spec объекта, посмотреть фактическое (какие поды, диски, роли есть), устранить разницу.
flowchart LR
    SP["spec: instances: 2"] --> CMP["сравнить"]
    CMP --> FACT["фактически 1 под"]
    FACT --> ACT["создать notes-db-2"]
    ACT --> EV["событие: под умер,<br>изменился spec"]
    EV --> CMP

Разберём на примере. В spec написано instances: 2. Контроллер смотрит: под notes-db-1 есть, второго нет. Создаёт диск и под notes-db-2, настраивает его как реплику. Через минуту смотрит снова: оба есть, разницы нет, ничего не делает. Ты удалил notes-db-2. Контроллер видит событие «под исчез», снова видит разницу «нужно 2, есть 1» и создаёт его заново. Ты изменил instances: 3, разница появилась снова, третий под создан. Заметь, что ты никогда не говорил «создай под», ты говорил только, что должно быть.

CloudNativePG (CNPG) не использует StatefulSet. Он сам управляет подами и дисками напрямую, поэтому может выбрать, какую реплику повысить, и не должен ждать упорядоченного старта. Каждый инстанс (instance, отдельный экземпляр базы) это свой под notes-db-1, notes-db-2 со своим PVC. Сам оператор ставится один раз на кластер (Helm-чарт cloudnative-pg, у нас через HelmRelease из 9.3) и живёт в своём namespace, а базы описываются ресурсами Cluster в тех namespace, где они нужны приложениям.

Осторожно: «Оператор это продвинутый Helm». Helm один раз превращает шаблоны в манифесты и уходит. Оператор остаётся в кластере и работает всё время.

Главное: оператор это CRD плюс контроллер в бесконечном цикле согласования, а не Helm, который отработал и ушёл.

Проверь понимание: чем оператор отличается от Helm-чарта, который просто рисует StatefulSet?

Ответ

Helm один раз рендерит манифесты и уходит. Оператор живёт в кластере постоянно: замечает смерть primary, повышает реплику, перенастраивает Service, запускает бэкапы по расписанию. Helm описывает начальное состояние, оператор поддерживает и меняет его в ходе жизни.

Первая обязанность оператора: держать копию данных.

Репликация и WAL: откуда у запасного экземпляра данные

Если данные есть только в одном месте, смерть этого места равна потере данных. Значит, нужна копия, причём свежая: копия недельной давности не спасёт вчерашние заказы.

Аналогия: бухгалтер ведёт журнал, а помощник в соседней комнате слушает по громкой связи, как тот диктует каждую новую запись, и переписывает её в свою копию. Если бухгалтер упал в обморок, у помощника почти всё уже есть. «Почти», потому что последнюю фразу он мог не дослушать. Так работает асинхронная репликация.

PostgreSQL перед тем как изменить таблицу, записывает описание изменения в специальный журнал: WAL (write-ahead log, «журнал упреждающей записи»: сначала запись в журнал, потом в таблицы). Это нужно, чтобы после аварии базу можно было довести до согласованного состояния, проиграв журнал. Реплика (replica, копия базы, доступная только для чтения) подключена к главному экземпляру (primary) и получает WAL потоком: это потоковая репликация (streaming replication). Полученные записи она применяет к своим данным. Так её данные почти всегда совпадают с главными, отставая на доли секунды.

Слово «асинхронная» значит: primary подтверждает клиенту «записано», не дожидаясь, пока реплика получит запись. Это быстро, но есть цена.

Разберём на примере. В 10:31:12.400 клиент вставил заметку номер 4, primary ответил «ок». Запись 4 отправилась в сторону реплики по сети. В 10:31:12.401 primary умер, а запись не успела дойти. Реплика повышена до главного, но записи 4 у неё нет: клиент получил «ок», а данных нет. Величина этой потери называется RPO (recovery point objective, допустимая потеря данных, измеряется в секундах или записях). У асинхронной репликации RPO не строго ноль. Как понятие RPO и RTO (время восстановления) разбираются в уроке 10.3, здесь только механика.

Прикинь сам: primary умер, повышена реплика, у которой записи 4 нет. Что увидит клиент, который уже получил «ок» на запись 4, если прочитает заметки?

Заметки 4 в списке не будет, хотя «ок» он уже получил. Это и есть ненулевой RPO у асинхронной репликации.

Что делает оператор, когда primary пропал:

  1. Через пробы и своё соединение замечает, что primary не отвечает.
  2. Смотрит, какая из реплик получила больше всего WAL (наименьшее отставание).
  3. Повышает её до primary (promote, «повысить»).
  4. Переставляет Service notes-db-rw на новый под.
  5. Старый под, когда вернётся, перенастраивает в реплику нового главного.

Весь путь занимает обычно от нескольких секунд до полуминуты.

Отдельный термин: switchover это плановое переключение, когда ты сам просишь «переставь главного» (например, перед обновлением узла). Тогда оператор сначала дожидается, пока реплика получит всё, и потери нет. Failover это аварийное переключение, когда главный умер сам.

Осторожно: «Реплика заменяет бэкап». Нет: если кто-то по ошибке выполнил DROP TABLE, это удаление тоже честно доедет до реплики за доли секунды. Реплика защищает от смерти машины, бэкап от ошибок людей.

Для любопытных: как получить RPO ноль и не потерять всё вместе с узлом

Чтобы потери записей не было, репликацию делают синхронной: primary отвечает клиенту «записано» только после того, как запись подтвердила хотя бы одна реплика. В CNPG это блок spec.postgresql.synchronous (например, method: any и number: 1; в старых версиях те же настройки назывались minSyncReplicas и maxSyncReplicas). Цена двойная: каждая запись ждёт сеть до реплики, то есть задержка записи растёт, а если подтверждать некому (все реплики недоступны), запись останавливается. Поэтому синхронную репликацию включают там, где потеря даже одной записи дороже простоя.

Второе: экземпляры базы должны жить на разных узлах (а в проде и в разных зонах). Если оба инстанса оказались на одной машине, смерть узла забирает и primary, и реплику. CNPG по умолчанию просит планировщик разнести поды (мягкое правило podAntiAffinity по имени узла), а строгое или по зонам задаётся в spec.affinity и topologySpreadConstraints. Для продакшена обычно берут минимум 3 инстанса: тогда при потере одного останется и главный, и запасной, а при синхронной репликации остаётся кворум. В нашем kind один узел, поэтому разнесение подов там проверить нельзя.

Главное: реплика получает WAL потоком и защищает от смерти машины, но не от ошибки человека, и RPO у асинхронной репликации не ноль.

Проверь понимание: почему после failover может пропасть заметка, на которую приложение уже получило ответ «создана»?

Ответ

Репликация асинхронная: primary подтвердил запись, не дожидаясь реплики. Если он умер до отправки записи, повышенная реплика её не содержит. Это ненулевой RPO.

Как приложение находит главный под?

Сервисы rw, ro и r: один адрес вместо имён подов

Приложению нужен постоянный адрес базы, а главный под может переехать с notes-db-1 на notes-db-2. Если прописать имя пода, после failover приложение будет стучаться в реплику.

Service (стабильный адрес и балансировщик внутри кластера, урок 5.3) выбирает поды по меткам (селектор). CNPG вешает на каждый под метку с его ролью и создаёт три Service:

Service Куда ведёт Для чего
notes-db-rw только primary запись и чтение, его использует приложение
notes-db-ro только реплики тяжёлые запросы «только чтение», отчёты
notes-db-r любой инстанс чтение, когда всё равно откуда

rw расшифровывается read-write, ro read-only, r read.

flowchart LR
    APP["приложение"] --> SVC["notes-db-rw<br>ClusterIP 10.96.201.33 (постоянный<br>внутренний адрес Service)<br>селектор: роль = primary"]
    SVC -->|"до failover"| A["notes-db-1 [primary]<br>notes-db-2 [replica]"]
    SVC -.->|"после failover"| B["notes-db-2 [primary]<br>notes-db-1 [replica]"]

Разберём на примере. До сбоя за notes-db-rw стоит один endpoint (адрес пода, куда реально идёт трафик), скажем 10.244.1.12:5432 (это notes-db-1). После failover оператор переставляет метку роли, и endpoint становится 10.244.2.9:5432 (notes-db-2). ClusterIP 10.96.201.33 (постоянный внутренний адрес Service) не изменился, приложение шлёт запросы туда же. Изменилось только то, за кем стоит этот адрес.

Что видит приложение: текущие открытые соединения рвутся (старый сервер исчез), поэтому оно должно переподключиться. Хороший клиент делает это сам, с повторами.

Осторожно: что достаточно «любого» сервиса. Запись в notes-db-ro завершится ошибкой cannot execute INSERT in a read-only transaction: реплика не принимает запись.

Главное: приложение ходит в notes-db-rw, а оператор сам переставляет, кто за ним стоит.

Проверь понимание: почему приложение должно ходить в notes-db-rw, а не в notes-db-1?

Ответ

Имя пода привязано к конкретному инстансу, а primary может переехать на notes-db-2. Service notes-db-rw всегда указывает на текущий primary, оператор переставляет селектор сам.

Теперь о защите от ошибок людей.

Бэкапы: базовая копия плюс WAL в объектное хранилище

Реплика не спасает от ошибки человека («удалил таблицу», «выкатил миграцию, которая испортила данные»). Нужны копии, из которых можно вернуться в прошлое, причём хранящиеся отдельно от самой базы.

Есть два вида бэкапа PostgreSQL.

  • Логический (pg_dump): выгрузка содержимого таблиц в SQL-файл. Просто и переносимо между версиями, но он показывает базу на один момент: всё, что изменилось после дампа, в копии нет, и откатиться на другое время нельзя. На больших базах он ещё и медленный. Твой CronJob pg-backup из урока 5.8 делал именно так.
  • Физический: копия самих файлов базы (base backup, базовая копия) плюс непрерывная архивация WAL. CNPG использует инструмент Barman (в виде плагина Barman Cloud). Он периодически делает базовую копию, а каждый готовый сегмент WAL сразу отправляет в S3-совместимое объектное хранилище (S3 это стандарт API для хранения файлов-«объектов» в бакетах, «корзинах»; в облаке это, например, Yandex Object Storage, у нас MinIO).

Из базовой копии плюс WAL можно восстановить состояние на любой момент между копией и последним архивным сегментом. Это PITR (point-in-time recovery, восстановление на момент времени).

Ресурсы, которыми это описывается:

  • ObjectStore плагина Barman Cloud: куда складывать (destinationPath, endpointURL, ключи) и как долго хранить (retentionPolicy); Cluster подключает его в разделе plugins;
  • ScheduledBackup: расписание базовых копий, как cron (планировщик задач по расписанию, урок 1.7);
  • Backup: разовая копия по запросу.

WAL при этом архивируется непрерывно, вне расписания. Поэтому RPO бэкапа измеряется секундами и минутами, а не «раз в сутки», как у ночного CronJob.

Разберём на примере. Сегодня 14:03 кто-то выполнил DROP TABLE notes. Последняя базовая копия сделана в 03:00. Восстановление в новый кластер на 14:02:59: оператор берёт копию 03:00 и проигрывает WAL с 03:00 до 14:02:59, удаление в WAL идёт следующим, и до него проигрывание не доходит. Таблица на месте. Ночной pg_dump в той же ситуации вернул бы состояние 03:00 и потерял бы 11 часов работы.

Расписание "0 0 3 * * *" в ScheduledBackup читается слева направо: секунда 0, минута 0, час 3, любой день месяца, любой месяц, любой день недели, то есть каждый день в 03:00:00. Обрати внимание: у CNPG шесть полей, первое секунды, в отличие от классического cron с пятью.

Прикинь сам: что значит "0 30 2 * * 1" в ScheduledBackup?

Секунды 0, минуты 30, час 2, любой день месяца, любой месяц, понедельник: каждый понедельник в 02:30:00.

Осторожно: нельзя хранить бэкапы там же, где живёт база. Бэкап на диске рядом с базой умирает вместе с машиной. В учебном kind MinIO стоит в том же кластере, поэтому это защита от логических ошибок, но не от потери машины или всего кластера: мы сознательно упростили стенд. В продакшене бакет находится в другом ЦОДе или облаке.

Осторожно: бэкап, который никогда не восстанавливали, это гипотеза, а не бэкап.

Бэкапы в CNPG делает плагин Barman Cloud (плагин это дополнение к оператору, которое ставится отдельно). Хранилище описывается отдельным объектом ObjectStore (куда класть, какими ключами, как долго хранить), а Cluster, Backup и ScheduledBackup только ссылаются на него по имени:

apiVersion: barmancloud.cnpg.io/v1
kind: ObjectStore
metadata:
  name: minio-store
  namespace: notes
spec:
  # хранить бэкапы 7 дней
  retentionPolicy: "7d"
  configuration:
    destinationPath: s3://cnpg-backups/
    endpointURL: http://minio.minio.svc:9000
    s3Credentials:
      accessKeyId: {name: minio-creds, key: ACCESS_KEY_ID}
      secretAccessKey: {name: minio-creds, key: ACCESS_SECRET_KEY}
    wal:
      compression: gzip

В Cluster добавляется ссылка на плагин (spec.plugins), а в Backup и ScheduledBackup метод plugin. Всё это ты напишешь целиком в практике. Остальное в этом разделе (базовая копия плюс WAL, PITR) от способа не зависит.

Главное: базовая копия плюс непрерывный WAL дают восстановление на любой момент, а бэкап рядом с базой умирает вместе с ней.

Проверь понимание: что лучше для восстановления после случайного DROP TABLE в 14:03: ночной pg_dump или базовая копия плюс WAL?

Ответ

Базовая копия плюс WAL: восстанавливаешь новый кластер на 14:02:59 (PITR). С ночным дампом потеряешь всё, что произошло после ночи.

Если увидишь в чужом кластере: старый способ бэкапа

В кластерах со старыми версиями оператора бэкап описан прямо в Cluster, блоком barmanObjectStore, без ObjectStore и plugins. Этот способ объявлен устаревшим, поэтому в наших манифестах его нет.

spec:
  backup:
    retentionPolicy: "7d"
    barmanObjectStore:
      destinationPath: s3://cnpg-backups/notes-db
      endpointURL: http://minio.minio.svc:9000
      s3Credentials:
        accessKeyId: {name: minio-creds, key: ACCESS_KEY_ID}
        secretAccessKey: {name: minio-creds, key: ACCESS_SECRET_KEY}

Переезд на плагин делается правкой манифестов: ObjectStore с теми же адресом и ключами, plugins в Cluster, метод plugin в бэкапах.

Куда именно уезжают копии?

Объектное хранилище S3: куда уезжают копии

Бэкапы надо хранить отдельно от базы и дёшево, а файлов накапливается много: копия каждую ночь и непрерывный поток WAL. Обычный диск под подом, который исчезнет вместе с подом, не подходит. Нужно место, которое живёт само по себе и принимает файлы по сети.

Аналогия: автоматическая камера хранения на вокзале. Ты приносишь вещь (файл), получаешь ячейку с номером (адрес), потом по номеру забираешь обратно. Камера только хранит. Отличие в том, что вещь в ней нельзя «дописать с краю»: объект кладут и заменяют целиком.

Объектное хранилище (object storage) работает так: есть бакеты (bucket, «корзины»: верхнеуровневые контейнеры вроде cnpg-backups), а внутри бакета лежат объекты (файлы с именем-путём). S3 (Simple Storage Service) это протокол, придуманный Amazon: по нему программы общаются с хранилищем через HTTP (создать бакет, положить объект, скачать объект). Сегодня S3-совместимыми называют любые хранилища, которые понимают тот же протокол: Yandex Object Storage, AWS S3, MinIO. Поэтому CNPG, научившись разговаривать с S3, работает с любым из них, и меняется только адрес (endpointURL) и ключи доступа (ACCESS_KEY_ID как логин, ACCESS_SECRET_KEY как пароль).

flowchart LR
    B["CNPG (Barman)<br>базовая копия<br>файл WAL"] -->|"HTTP PUT, ключи доступа"| M["S3-хранилище (MinIO)<br>бакет cnpg-backups/<br>notes-db/base/2026...<br>notes-db/wals/0000000100..."]

Разберём на примере. Адрес записи в манифесте: destinationPath: s3://cnpg-backups/ и endpointURL: http://minio.minio.svc:9000. Читаем: «бакет называется cnpg-backups, искать его нужно не у Amazon, а у нашего MinIO по адресу minio.minio.svc:9000». Если убрать endpointURL, программа пойдёт в настоящий AWS, не найдёт такого бакета и получит ошибку доступа. Поэтому в лаборатории адрес MinIO указывается явно.

Осторожно: «бакет это папка на диске, её можно смонтировать как каталог». Нет: это не файловая система, доступ идёт только по HTTP и по ключам. И «MinIO это база данных»: MinIO лишь хранит файлы.

Главное: S3 это протокол по HTTP, поэтому CNPG работает с любым совместимым хранилищем, а endpointURL выбирает сервер.

Проверь понимание: зачем CNPG нужен endpointURL, если протокол S3 один и тот же?

Ответ

Протокол один, а серверов много. Без endpointURL клиент по умолчанию идёт в облачный AWS S3. Адрес указывает, к какому именно S3-совместимому серверу обращаться, в нашем случае к MinIO внутри кластера.

Теперь вернёмся к приложению.

Как приложение подключается к базе: из чего состоит адрес

Когда приложение «не может подключиться к базе», причина почти всегда в одной из пяти частей адреса. Если знаешь части, ищешь точно.

Данные для подключения к PostgreSQL складываются в строку подключения (connection string, DSN): postgresql://пользователь:пароль@хост:порт/база. Части:

  • хост: где база. У нас notes-db-rw.notes.svc (имя Service, namespace и svc, схема имён из урока 5.3);
  • порт: 5432, стандартный порт PostgreSQL;
  • база: notes, название базы внутри сервера (на одном сервере PostgreSQL может быть много баз);
  • пользователь и пароль: кто подключается. CNPG создаёт их при запуске и кладёт в Secret (notes-db-app).
flowchart LR
    D["postgresql://notes:пароль@notes-db-rw.notes.svc:5432/notes"] --> U["пользователь: notes"]
    D --> PW["пароль: из Secret"]
    D --> H["хост: notes-db-rw.notes.svc"]
    D --> PO["порт: 5432"]
    D --> DB["база: notes"]

Разберём на примере. Приложение пишет could not translate host name (не удалось найти хост): ошибка в части «хост», например опечатка в имени Service или другой namespace. Connection refused (отказ в соединении): хост найден, но на порту никто не слушает (под не готов, нет главного). password authentication failed: хост и порт верны, не подходит пароль (Secret устарел или пароль в Vault сменили). database "notes" does not exist: сервер жив, а такой базы нет. Каждая фраза указывает на свою часть адреса, и поиск сразу сужается.

Осторожно: «пароль в строке подключения надо зашить в код». Нет: он приходит из Secret переменной окружения (урок 5.6), в git его нет.

Главное: ошибка подключения почти всегда в одной из пяти частей адреса, и каждая даёт свой текст ошибки.

Проверь понимание: приложение пишет password authentication failed. Чей пароль проверять в первую очередь и какую часть адреса можно не трогать?

Ответ

Проверь пароль в Secret, который читает приложение, и совпадает ли он с тем, что знает база (и с тем, что в Vault). Хост и порт можно не трогать: соединение дошло до сервера, иначе ошибка была бы про хост или отказ в соединении.

Как проверить состояние самой базы?

Как читать состояние кластера: kubectl cnpg status

Когда что-то идёт не так, ты открываешь одну команду и за минуту понимаешь, где проблема: нет главного, отстаёт реплика, не идёт архивация WAL. Без умения читать её остаётся гадать.

kubectl cnpg status notes-db -n notes (плагин CNPG) собирает данные с разных мест и печатает блоками. Ниже сокращённый вывод: настоящий длиннее (есть ещё версия образа, время старта, сертификаты и другие блоки), а значения у тебя будут другие. Справа мои пояснения, в реальном выводе их нет:

Cluster Summary
  Name:              notes-db          кто это
  Namespace:         notes             где лежит
  Primary instance:  notes-db-1        кто сейчас главный
  Status:            Cluster in healthy state   общий итог
  Instances:         2                 сколько должно быть
  Ready instances:   2                 сколько готово

Continuous Backup status
  First Point of Recoverability: ...   самый ранний момент, на который можно откатить
  Working WAL archiving: OK            WAL уезжает в S3

Instances status
  notes-db-1  primary  ...             роль каждого пода
  notes-db-2  replica  ...  lag        отставание реплики

Разберём на примере. Смотри сверху вниз. Primary instance подтверждает, куда смотрит -rw. Instances 2 / Ready 2 значит, что запасной есть. Working WAL archiving: OK значит, что бэкапы действительно уезжают. Если вместо OK стоит Failing (или Starting Up, если ни один сегмент ещё не отправлен, а так сидит долго), а диск primary растёт, ищи проблему с адресом S3 или ключами: WAL копится, потому что отправить его некуда. First Point of Recoverability: Not Available значит, что ни одной базовой копии нет и восстанавливаться не из чего.

Осторожно: «Ready instances равно числу инстансов, значит бэкапы в порядке». Это разные блоки: живость подов и работоспособность архивации проверяются отдельно.

Главное: живость подов и работа архивации WAL проверяются в разных блоках, смотри оба.

Проверь понимание: в блоке Cluster Summary всё зелёное, а Working WAL archiving не OK. Что под угрозой?

Ответ

Восстановление и место на диске. Новые WAL не попадают в хранилище, значит откат на недавний момент невозможен, а локальные WAL копятся на диске primary и со временем могут его заполнить.

Откуда в кластере берутся пароль и стартовые данные?

Секреты и bootstrap: как база получает пароль и стартовые данные

Новая база должна на старте получить имя базы, владельца и пароль. Пароль нельзя класть в git (урок 9.1).

bootstrap в Cluster описывает, как появляется первый инстанс. Вариант initdb создаёт пустую базу (database: notes) и роль-владельца (owner: notes). Пароль владельца берётся из Secret типа kubernetes.io/basic-auth с ключами username и password. Мы порождаем этот Secret через ExternalSecret из Vault (урок 9.2), поэтому в git пароля нет. Если Secret не задать, CNPG сам сгенерирует пароль и положит в Secret notes-db-app: это допустимо, но тогда источник правды не Vault.

Вариант recovery создаёт кластер не пустым, а из бэкапа: так делается восстановление. Есть и initdb.import для миграции данных из другого сервера, но мы сделаем ручной pg_dump и psql: так виден каждый шаг.

Разберём на примере. Порядок при первом создании: ESO читает пароль из Vault и создаёт Secret notes-db-app. Оператор видит Cluster, запускает короткоживущий Job notes-db-1-initdb: он создаёт файлы базы, роль notes с паролем из Secret и базу notes. Потом стартует под notes-db-1, и после него, копируя данные с primary, notes-db-2.

Осторожно: «Сменил пароль в Vault, значит сменился пароль в базе». Нет: ESO обновит Secret, но пароль роли внутри PostgreSQL остаётся старым, пока его не поменяют командой ALTER ROLE или средствами оператора.

Главное: initdb создаёт пустую базу, recovery поднимает из бэкапа, а смена пароля в Vault не меняет роль в PostgreSQL.

Проверь понимание: что будет, если Cluster применился раньше, чем ESO создал notes-db-app?

Ответ

Инициализация не сможет прочитать Secret и будет ждать: под не стартует, а в событиях появится ошибка про отсутствующий Secret. Когда ESO создаст Secret, оператор при следующем цикле согласования продолжит. Порядка внутри одной Kustomization Flux не задаёт: ExternalSecret и Cluster у нас лежат вместе в apps/notes, поэтому оператор просто повторяет попытку, пока Secret не появится. dependsOn нужен для другого: чтобы CRD оператора и Vault были готовы раньше ступени apps.

Что из этого создаёт оператор?

Что оператор создаёт внутри: под, диск, Secret, Service

Зачем это знать. Когда что-то сломается, ты должен понимать, какие объекты появились из одного Cluster, и искать причину в нужном.

Из одного Cluster notes-db с instances: 2 оператор создаёт:

flowchart TD
    C["Cluster notes-db, instances: 2"] --> P1["Pod notes-db-1"] --> D1["PVC notes-db-1<br>диск 2Gi, данные PostgreSQL"]
    C --> P2["Pod notes-db-2"] --> D2["PVC notes-db-2"]
    C --> SV["Service notes-db-rw, -ro, -r"]
    C --> SE["Secret notes-db-app<br>пароль владельца, через ESO"]
    C --> CE["Secret notes-db-ca, notes-db-server<br>сертификаты для шифрования соединений"]
    C --> PDB["PodDisruptionBudget<br>не выключать оба инстанса разом"]

Внутри каждого пода работает не «голый» PostgreSQL, а программа оператора instance manager (менеджер экземпляра), которая запускает PostgreSQL как дочерний процесс. Она отвечает на пробы Kubernetes (проверки «жив ли ты», урок 5.7), сообщает оператору о состоянии базы, отправляет WAL в хранилище и по команде оператора повышает или понижает роль. Поэтому оператору не нужно заходить в под по ssh и запускать команды, он говорит с менеджером по внутреннему API.

Разберём на примере. Ты удалил PVC notes-db-2 вместе с подом. Оператор видит, что инстанса нет, создаёт новый диск, разворачивает на него копию с primary (это называется клонированием реплики) и запускает под. Данные на новом диске получены от primary по сети, а не восстановлены из бэкапа. Если бы ты удалил PVC primary, реплика стала бы главным, а на месте потерянного создался бы новый инстанс-реплика.

Осторожно: что данные лежат в поде. Данные лежат на PVC, под лишь запускает PostgreSQL с этим диском. Удаление пода безопасно, удаление PVC уничтожает данные этого инстанса.

Главное: данные лежат на PVC, а не в поде: удаление пода безопасно, удаление PVC уничтожает данные инстанса.

Проверь понимание: ты удалил под notes-db-2, но не PVC. Данные пропали?

Ответ

Нет. Оператор создаст под заново и подключит к нему тот же PVC. Реплика лишь догонит WAL за время, пока пода не было.

Как база живёт дальше, годами?

Обновления и размер диска

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

Вот как это устроено.

  • Минорное обновление (18.5 на 18.6): меняешь imageName в Cluster. Оператор делает rolling update (поочерёдную замену): сначала реплики по одной, потом primary. По умолчанию (primaryUpdateMethod: restart) primary перезапускается на месте, а с primaryUpdateMethod: switchover оператор сначала переключает роль на уже обновлённую реплику и обновляет бывший primary. Клиенты видят короткий разрыв соединений в любом случае.
  • Мажорное обновление (17 на 18): формат файлов на диске меняется, простой заменой образа не обойтись. Нужен отдельный план, и его всегда репетируют на копии из бэкапа.
  • Расширение диска: увеличиваешь storage.size. Если класс хранилища разрешает расширение томов (allowVolumeExpansion), оператор расширит PVC без остановки базы. Уменьшить диск нельзя.

Разберём на примере с primaryUpdateMethod: switchover. У Cluster два инстанса. Меняем 18.5 на 18.6. Шаг 1: остановлена и перезапущена notes-db-2 (реплика), primary работает. Шаг 2: оператор ждёт, пока реплика догонит WAL, и делает switchover: notes-db-2 стала primary. Шаг 3: перезапущена notes-db-1, теперь она реплика. Итог: на каждом этапе есть работающий primary, разрыв только на момент switchover.

Осторожно: «Поменяю тег и посмотрю» на боевой базе. Без свежего бэкапа и без репетиции на копии любое обновление это ставка.

Главное: минорное обновление идёт с реплик, а primary обновляется последним (перезапуском или через switchover), диск можно расширять, но не уменьшать.

Всё это бесполезно, если бэкап не проверен.

Как проверить, что бэкап настоящий

Есть старая шутка: «бэкапа нет, пока ты не восстановился из него». Причины сломанных бэкапов скучные: истёк ключ доступа, переполнился бакет, изменился endpoint, а тревоги нет. Узнать об этом в день аварии слишком поздно.

Три уровня проверки.

  1. Статус. kubectl get backup показывает completed или failed. kubectl cnpg status notes-db показывает, что архивация WAL работает (нет Failing) и когда была последняя успешная копия.
  2. Алерты. Метрики CNPG сообщают возраст последнего бэкапа и последней архивации WAL. Алерт «бэкап старше 26 часов» ловит тихую поломку расписания.
  3. Учебное восстановление (restore drill): раз в квартал поднять отдельный кластер из бэкапа, сверить количество строк и записать, сколько это заняло. Это ты делаешь в задании 4.

Правило хранения «3-2-1»: минимум 3 копии данных, на 2 разных носителях, 1 из них в другом месте. У нас primary и реплика (две копии на одном кластере) плюс MinIO: копия в другом месте пока условная: MinIO стоит в том же кластере, и мы это сознательно упростили.

Разберём на примере. MinIO переехал на новый адрес, а в endpointURL остался старый. С этого момента WAL копится на диске primary, потому что отправить его некуда (PostgreSQL не удаляет сегменты, пока они не заархивированы). Через сутки диск на 2Gi заполнен, primary останавливается. Без алерта на возраст архивации ты узнаешь об этом по отвалившемуся приложению. Если у primary заполняется диск, первым делом смотри, не сломана ли архивация WAL.

Осторожно: Статус completed для базовой копии не гарантирует, что работает и архивация WAL: это два независимых процесса, проверяй оба.

Главное: бэкап настоящий, когда проверены статус, алерты на возраст и учебное восстановление, и это два независимых процесса: копия и WAL.

Что в этот момент видит приложение?

Поведение приложения при failover

Failover это событие, в котором участвует не только база, но и клиент. Половина «ложных» инцидентов после переключения это клиент, который не умеет переподключаться.

При failover открытые соединения обрываются. Клиент, который держал их в пуле (наборе заранее открытых соединений), обнаружит это при следующем запросе и получит ошибку. Правильный клиент выкидывает «мёртвое» соединение, открывает новое к notes-db-rw (адрес тот же) и повторяет запрос с паузой. Неправильный держит мёртвые соединения и отвечает 500 до перезапуска.

Отдельная ловушка: проба готовности /readyz в приложении (урок 5.7), которая заглядывает в базу. Напомню три пробы. Liveness отвечает «процесс жив?», при «нет» Kubernetes перезапускает контейнер. Readiness отвечает «готов принять запрос прямо сейчас?», при «нет» под убирают из Service, но не перезапускают. Startup даёт медленному приложению время на старт. Если /readyz зависит от базы, то во время failover она падает у всех подов сразу, Kubernetes убирает их все из Service, и снаружи вместо коротких ошибок на часть запросов получается 502 или 503 на все. Поведение объяснимо, но обычно вредно: приложение могло бы отдавать то, что не требует базы (страницы, кеш), а заодно лишняя проверка вызывает лавину переподключений, когда база возвращается.

Правило: в readiness кладут то, без чего этот под не может обслужить запрос сам, а внешние зависимости обычно нет (или кладут осознанно, понимая цену). Поэтому делают две ручки: /readyz без обращения к базе для Kubernetes и отдельную глубокую проверку, например /health/deep с запросом select 1, для мониторинга и алертов.

Разберём на примере. Время t0: primary умер. t0+2 секунды: запросы в notes падают с connection reset. t0+10: реплика повышена, endpoints notes-db-rw обновлены. t0+11: новые соединения работают. Приложение с ретраями теряет запросы за 10 секунд и восстанавливается само. Приложение без ретраев с пулом остаётся в ошибках до рестарта, и его RTO определяет не база, а время, за которое кто-то заметит и перезапустит под.

Прикинь сам: primary умер в 10:00:00, реплика повышена к 10:00:10. Когда восстановится приложение без ретраев с пулом соединений?

Само оно не восстановится: мёртвые соединения остаются в пуле до рестарта пода. Время восстановления зависит от того, когда кто-то заметит.

Осторожно: «Failover прошёл, значит приложение восстановилось». Проверять нужно и базу, и клиента.

Главное: после failover восстанавливается не только база, но и клиент, поэтому приложение должно уметь переподключаться.

Проверь понимание: что происходит с пулом соединений приложения без логики переподключения после failover?

Ответ

В пуле остаются соединения к умершему primary. Каждый запрос на них падает с ошибкой, пока приложение не пересоздаст соединения или его не перезапустят.

Остался вопрос, нужна ли такая схема вообще.

Миграция и вопрос «стоит ли БД в Kubernetes»

Как мигрировать. Самый простой способ (его мы и сделаем): остановить запись, снять дамп из старой базы, залить в новую, проверить количество строк, переключить приложение, и только потом удалять старое. Запись останавливают первой: всё, что приложение запишет после дампа, в новую базу не попадёт и пропадёт. Поэтому такая миграция требует окна простоя (приложение масштабируют в 0 реплик). Если простоя допустить нельзя, есть два других пути: bootstrap.initdb.import, где CNPG сам копирует данные из работающего сервера при создании Cluster (это тоже логическая копия на момент старта, запись всё равно надо остановить на время импорта), и логическая репликация PostgreSQL (публикация и подписка), когда новая база догоняет старую на ходу, а приложение переключают за секунды. Если удалить старое раньше проверки, ошибка в любом из шагов станет необратимой. Флаг --no-owner у pg_dump говорит «не записывай в дамп, кто владелец объектов»: в новой базе владельцем будет та роль, от которой ты заливаешь.

Стоит ли вообще. Плюсы: единый подход с остальным, GitOps, автоматизация, нет отдельной платформы. Минусы: ты сам отвечаешь за хранилище, обновления и бэкапы, а качество зависит от дисков и сети кластера. Управляемая облачная БД (урок 6.4) снимает эту ответственность за деньги. Если в команде нет людей на эксплуатацию БД, надёжнее управляемый сервис. С оператором и проверенными бэкапами вариант рабочий.

Главное: мигрируют в порядке остановка записи, дамп, заливка, проверка, переключение, удаление, а решение «база в Kubernetes» зависит от людей на эксплуатацию.

Дальше в уроке 10.3 те же понятия RPO и RTO разобраны на уровне всей системы.

Практика

Конфигурации оператора, хранилища бэкапов и Cluster возьми за основу из примеров. В своей схеме найди, где приложение получает адрес и пароль БД, где хранятся данные и куда уходит резервная копия. Внутренности оператора можно отложить; проверь переключение primary и восстановление в новый кластер, не ограничиваясь статусом Ready.

Предполагается кластер kind-notes из урока 9.3 с Flux, Vault, ESO и cert-manager. Репозиторий notes-gitops склонирован в ~/notes-gitops.

Все задания, кроме первого шага с MinIO, выполняются в kubectl и в git-репозитории notes-gitops. Ещё нужен плагин CNPG для kubectl (команда kubectl cnpg ..., без него не будет kubectl cnpg status). На Ubuntu проще всего через krew, менеджер плагинов kubectl (если krew не стоит, установка описана на krew.sigs.k8s.io, после неё каталог ~/.krew/bin должен быть в PATH). На macOS можно через Homebrew: brew install kubectl-cnpg.

kubectl krew install cnpg
kubectl cnpg version

Команда version печатает версию плагина (строка с Version) и, когда оператор уже стоит в кластере, его версию тоже. Если версия напечатана, плагин работает; точный вид строк зависит от релиза.

Если у тебя 8 ГБ

Два инстанса PostgreSQL плюс MinIO лишние. Поставь instances: 1 в cnpg-cluster.yaml. Failover в задании 3 не получится, вместо него убей под и посмотри, как оператор его пересоздаёт и подключает тот же PVC. Остальные задания не меняются.

Задание 1. Оператор через Flux и MinIO для бэкапов

Цель: поставить CNPG v1.30.1 как HelmRelease и поднять MinIO в namespace minio под бэкапы.

Предскажи: сколько новых CRD появится после установки оператора: 0, 1 или больше? И в каком namespace они видны?

Ответ

Больше одного: clusters, backups, scheduledbackups, poolers и другие. CRD кластерные, namespace у типа нет, у объектов есть.

Шаги:

  1. Добавь оператор в инфраструктуру. Файл описывает три объекта: namespace cnpg-system (отдельный, чтобы оператор жил отдельно от приложений), HelmRepository (откуда Flux берёт чарты, раз в час interval: 1h проверяет обновления индекса) и HelmRelease (что и с какими настройками поставить, урок 9.3):
cd ~/notes-gitops
mkdir -p infrastructure/controllers/cnpg
cat > infrastructure/controllers/cnpg/release.yaml <<'YAML'
apiVersion: v1
kind: Namespace
metadata:
  name: cnpg-system
---
apiVersion: source.toolkit.fluxcd.io/v1
kind: HelmRepository
metadata:
  name: cnpg
  namespace: cnpg-system
spec:
  interval: 1h
  url: https://cloudnative-pg.github.io/charts
---
apiVersion: helm.toolkit.fluxcd.io/v2
kind: HelmRelease
metadata:
  name: cnpg
  namespace: cnpg-system
spec:
  interval: 10m
  chart:
    spec:
      chart: cloudnative-pg
      # чарт 0.29.1 ставит оператор v1.30.1
      version: "0.29.1"
      sourceRef:
        kind: HelmRepository
        name: cnpg
  install:
    crds: CreateReplace
  upgrade:
    crds: CreateReplace
YAML
cat > infrastructure/controllers/cnpg/kustomization.yaml <<'YAML'
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
  - release.yaml
YAML

Разбор ключевого: chart.spec.version: "0.29.1" закрепляет версию чарта (она ставит оператор v1.30.1; соответствие чарта и оператора сверь на странице проекта при обновлении). install.crds: CreateReplace и upgrade.crds: CreateReplace - явная страховка: у многих чартов CRD лежат в каталоге crds/, и Helm при обновлении их не трогает (новый оператор упирается в старую схему ресурсов), а Flux по этой политике заменяет. У чарта CNPG CRD лежат в templates и обновляются обычным апгрейдом, но явная политика ничего не портит. Оператор при этом ставится в cnpg-system, а базы будут в notes.

  1. Подключи каталог в infrastructure/controllers/kustomization.yaml (добавь строку - cnpg в resources).
  2. Поднимай MinIO для бэкапов. MinIO это S3-совместимое хранилище, которое можно запустить одним подом. Сначала namespace и Secret с паролем администратора: $(openssl rand -base64 24) подставляет в команду 24 случайных байта в base64, это пароль; --from-literal кладёт значение в Secret без файла. Это допущение стенда: пароль MinIO создан руками и в git не попадает. В проде такой Secret ведут через ESO из Vault, как пароль базы в задании 2. Версию образа закрепляем тегом, не latest: quay.io/minio/minio:RELEASE.2025-09-07T16-13-09Z. Честная пометка: репозиторий сообщества MinIO больше не развивается (статус проверь на GitHub), образы не обновляются; для лаборатории это годится, в продакшене нужен S3 облака или поддерживаемый аналог (Garage, SeaweedFS, форк). Если образа на quay.io у тебя нет, возьми другой тег этого образа со страницы quay.io/minio/minio.
kubectl create namespace minio
kubectl -n minio create secret generic minio-creds \
  --from-literal=rootUser=minio \
  --from-literal=rootPassword="$(openssl rand -base64 24)"
  1. Манифест MinIO: диск (PVC 2Gi), Deployment с одним подом и Service minio. Разбор: strategy: Recreate не запускает новый под, пока не остановлен старый (диск ReadWriteOnce нельзя подключить к двум подам сразу); args: ["server", "/data"] запускает сервер MinIO с каталогом данных /data; MINIO_ROOT_USER и MINIO_ROOT_PASSWORD берутся из Secret minio-creds; readinessProbe не пускает трафик, пока MinIO не готов. Применяем руками, не через git: это допущение стенда, как и пароль:
kubectl apply -f - <<'YAML'
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: minio-data
  namespace: minio
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 2Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: minio
  namespace: minio
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: minio
  template:
    metadata:
      labels:
        app: minio
    spec:
      containers:
        - name: minio
          image: quay.io/minio/minio:RELEASE.2025-09-07T16-13-09Z
          args: ["server", "/data"]
          ports:
            - containerPort: 9000
          env:
            - name: MINIO_ROOT_USER
              valueFrom:
                secretKeyRef:
                  name: minio-creds
                  key: rootUser
            - name: MINIO_ROOT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: minio-creds
                  key: rootPassword
          readinessProbe:
            httpGet:
              path: /minio/health/ready
              port: 9000
          volumeMounts:
            - name: data
              mountPath: /data
      volumes:
        - name: data
          persistentVolumeClaim:
            claimName: minio-data
---
apiVersion: v1
kind: Service
metadata:
  name: minio
  namespace: minio
spec:
  selector:
    app: minio
  ports:
    - port: 9000
      targetPort: 9000
YAML
kubectl -n minio rollout status deploy/minio

Ожидаемо: deployment "minio" successfully rolled out.

Теперь бакет cnpg-backups (бакет это верхнеуровневая «папка» в S3). Его создаёт клиент mc (командная утилита MinIO): временный под выполняет две команды и удаляется. mc alias set запоминает адрес и логин под именем local, mc mb (make bucket) создаёт бакет. Пароль берётся из Secret и передаётся в переменную пода, поэтому в команде его нет. Тег mc закреплён так же, как у сервера:

kubectl -n minio run mc --rm -it --restart=Never \
  --image=quay.io/minio/mc:RELEASE.2025-08-13T08-35-41Z \
  --env="MINIO_PW=$(kubectl -n minio get secret minio-creds -o jsonpath='{.data.rootPassword}' | base64 -d)" \
  --command -- sh -c 'mc alias set local http://minio.minio.svc:9000 minio "$MINIO_PW" && mc mb local/cnpg-backups'

Ожидаемо в конце: Bucket created successfully с именем local/cnpg-backups. Если тега mc нет, возьми любой другой со страницы quay.io/minio/mc.

Секрет для CNPG в namespace notes нужен отдельный, потому что Secret из одного namespace нельзя использовать в другом. Ключи в нём названы так, как их ждёт CNPG (ACCESS_KEY_ID, ACCESS_SECRET_KEY). Namespace notes уже есть с прошлых уроков:

kubectl -n notes create secret generic minio-creds \
  --from-literal=ACCESS_KEY_ID=minio \
  --from-literal=ACCESS_SECRET_KEY="$(kubectl -n minio get secret minio-creds -o jsonpath='{.data.rootPassword}' | base64 -d)"
  1. Закоммить и запушь, дождись Flux. flux reconcile ... --with-source просит Flux не ждать интервала, а сразу забрать свежий коммит и применить; rollout status ждёт, пока Deployment оператора полностью готов; grep cnpg.io оставляет из списка CRD только наши:
git add -A && git commit -m "cnpg: оператор" && git push
flux reconcile kustomization infrastructure --with-source
kubectl -n cnpg-system rollout status deploy/cnpg-cloudnative-pg
kubectl get crd | grep cnpg.io
  1. Плагин Barman Cloud (он делает бэкапы, раздел «Бэкапы» выше) ставится отдельным манифестом из релизов проекта cloudnative-pg/plugin-barman-cloud. Ему нужен cert-manager из урока 9.4 и оператор в cnpg-system, поэтому ставим его последним, когда оператор уже работает. Версию узнаём со страницы релизов (запиши её в раздел «Проверено на версиях»). Разбор: curl -s тянет JSON последнего релиза с GitHub, grep tag_name оставляет строку с тегом, cut вырезает из неё значение между кавычками; kubectl apply -f ставит всё, что описано в манифесте релиза:
V=$(curl -s https://api.github.com/repos/cloudnative-pg/plugin-barman-cloud/releases/latest | grep tag_name | cut -d'"' -f4)
echo "$V"
kubectl apply -f "https://github.com/cloudnative-pg/plugin-barman-cloud/releases/download/${V}/manifest.yaml"
kubectl -n cnpg-system rollout status deploy/barman-cloud

Проверка: объект deployment "barman-cloud" successfully rolled out, а kubectl get crd | grep barmancloud показывает objectstores.barmancloud.cnpg.io.

Что должно получиться:

deployment "cnpg-cloudnative-pg" successfully rolled out
backups.postgresql.cnpg.io                 2026-09-29T10:12:04Z
clusters.postgresql.cnpg.io                2026-09-29T10:12:04Z
poolers.postgresql.cnpg.io                 2026-09-29T10:12:04Z
scheduledbackups.postgresql.cnpg.io        2026-09-29T10:12:04Z

Как читать вывод: первая строка говорит, что под оператора запущен и готов. Дальше список CRD: слева имя типа (clusters.postgresql.cnpg.io это Cluster в группе postgresql.cnpg.io), справа время создания. Даты у тебя будут свои. Полный набор CRD может быть больше четырёх (в нём есть и другие типы, например для публикаций и подписок), важно, что четыре главных на месте. CRD видны без указания namespace: это кластерные объекты.

Объясни себе:

  • Зачем явно указывать политику CRD в HelmRelease, если у этого чарта CRD лежат в templates?
  • Почему оператор в отдельном namespace, а базы в notes?

Типичные ошибки:

  • no matches for kind "Cluster" in version "postgresql.cnpg.io/v1": CRD ещё не установлены, приложение применилось раньше оператора: проверь dependsOn из 9.3, оператор в controllers, кластер в apps.
  • Error: chart "cloudnative-pg" version "0.29.1" not found: такой версии нет: helm search repo cnpg/cloudnative-pg --versions и укажи реальную.
  • pod has unbound immediate PersistentVolumeClaims: у kind нет свободного PV на MinIO: проверь kubectl get sc, должен быть standard.

Задание 2. Cluster с паролем из Vault

Цель: описать Cluster notes-db, пароль взять из Vault через ESO и увидеть три Service.

Предскажи: сколько подов появится при instances: 2 и чем они отличаются в kubectl get pods -L cnpg.io/instanceRole?

Ответ

Два: notes-db-1 с ролью primary и notes-db-2 с ролью replica. Также сначала появится короткоживущий Job notes-db-1-initdb.

Шаги:

  1. Пароль уже лежит в Vault по пути secret/notes/db (урок 9.1), поле password. Опиши ExternalSecret (объект ESO, который читает значение из Vault и создаёт из него обычный Secret, урок 9.2), создающий Secret notes-db-app. Разбор: refreshInterval: 1h значит сверять с Vault раз в час; secretStoreRef указывает на хранилище vault-backend; в data описано, какое поле брать из Vault (property: password); в template заготовка итогового Secret: тип kubernetes.io/basic-auth и два ключа. Выражение с точкой в двойных фигурных скобках подставляет значение password.
cd ~/notes-gitops
cat > apps/notes/cnpg-secret.yaml <<'YAML'
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: notes-db-app
  namespace: notes
spec:
  refreshInterval: 1h
  secretStoreRef:
    kind: ClusterSecretStore
    name: vault-backend
  target:
    name: notes-db-app
    template:
      type: kubernetes.io/basic-auth
      data:
        username: notes
        password: "{{ .password }}"
  data:
    - secretKey: password
      remoteRef:
        key: notes/db
        property: password
YAML
  1. Опиши хранилище бэкапов и кластер. Сначала ObjectStore (раздел «Бэкапы» выше): retentionPolicy: "7d" хранить бэкапы 7 дней; destinationPath бакет в S3; endpointURL адрес MinIO внутри кластера (minio это Service, minio второй раз namespace); s3Credentials откуда брать ключи (имя Secret и ключи в нём); wal.compression: gzip сжимать WAL перед отправкой. Потом Cluster: instances: 2 это два инстанса; imageName образ PostgreSQL от проекта CNPG (версия закреплена); storage.size размер PVC на каждый инстанс; bootstrap.initdb создаёт базу notes и владельца notes с паролем из Secret; plugins подключает плагин Barman Cloud, isWALArchiver: true значит «этот плагин отправляет WAL», а barmanObjectName ссылается на ObjectStore по имени:
cat > apps/notes/cnpg-objectstore.yaml <<'YAML'
apiVersion: barmancloud.cnpg.io/v1
kind: ObjectStore
metadata:
  name: minio-store
  namespace: notes
spec:
  retentionPolicy: "7d"
  configuration:
    destinationPath: s3://cnpg-backups/
    endpointURL: http://minio.minio.svc:9000
    s3Credentials:
      accessKeyId:
        name: minio-creds
        key: ACCESS_KEY_ID
      secretAccessKey:
        name: minio-creds
        key: ACCESS_SECRET_KEY
    wal:
      compression: gzip
YAML
cat > apps/notes/cnpg-cluster.yaml <<'YAML'
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: notes-db
  namespace: notes
spec:
  # 2 инстанса: primary и реплика (в режиме 8 ГБ поставь 1)
  instances: 2
  imageName: ghcr.io/cloudnative-pg/postgresql:18.6
  storage:
    size: 2Gi
  bootstrap:
    initdb:
      database: notes
      owner: notes
      secret:
        name: notes-db-app
  plugins:
    - name: barman-cloud.cloudnative-pg.io
      isWALArchiver: true
      parameters:
        barmanObjectName: minio-store
YAML
  1. Добавь все три файла (cnpg-secret.yaml, cnpg-objectstore.yaml, cnpg-cluster.yaml) в resources файла apps/notes/kustomization.yaml, закоммить, запушь и дождись. kubectl wait --for=condition=Ready блокируется, пока у объекта не появится условие «готов» (или не пройдут 300 секунд); -L cnpg.io/instanceRole добавляет колонку со значением метки роли; grep notes-db оставляет только наши Service:
git add -A && git commit -m "cnpg: cluster notes-db" && git push
flux reconcile kustomization apps --with-source
kubectl -n notes wait cluster/notes-db --for=condition=Ready --timeout=300s
kubectl -n notes get pods -L cnpg.io/instanceRole
kubectl -n notes get svc | grep notes-db

Что должно получиться:

cluster.postgresql.cnpg.io/notes-db condition met
NAME         READY   STATUS    RESTARTS   AGE   INSTANCEROLE
notes-db-1   1/1     Running   0          2m    primary
notes-db-2   1/1     Running   0          80s   replica
notes-db-r    ClusterIP   10.96.41.7     <none>   5432/TCP   2m
notes-db-ro   ClusterIP   10.96.12.90    <none>   5432/TCP   2m
notes-db-rw   ClusterIP   10.96.201.33   <none>   5432/TCP   2m

Как читать вывод: condition met значит, что кластер готов. В таблице подов колонка READY 1/1 говорит, что единственный контейнер работает; в последней колонке роль: primary пишет, replica копирует. Возраст 80s у второго пода показывает, что реплика создаётся после primary. Три строки Service это -r, -ro, -rw, у каждого свой ClusterIP (внутренний адрес, у тебя будут другие) и порт 5432, стандартный порт PostgreSQL.

Объясни себе:

  • Почему пароля нет в git, но кластер его получает?
  • Что случится, если ESO ещё не создал notes-db-app, а Cluster уже применился? (подсказка: оператор повторяет попытки, пока Secret не появится)

Типичные ошибки:

  • secret "notes-db-app" not found: ExternalSecret не синхронизировался: kubectl -n notes get externalsecret, смотри статус и путь в Vault.
  • Error: cannot fetch secret ... permission denied: политика notes-read не покрывает путь: поправь политику Vault из 9.1.
  • unable to create pod: exceeded quota или Pending у notes-db-2: на kind не хватает памяти: режим 8 ГБ, instances: 1.

Перед убийством primary попроси нейросеть составить список того, что ты ожидаешь увидеть в kubectl cnpg status до и после. Сверь с реальным выводом: расхождение укажет, чего ты не понял.

Задание 3. Failover: убей primary

Цель: увидеть переключение и замерить, сколько записей приложение не смогло сделать.

Предскажи: после kubectl delete pod notes-db-1 какой под станет primary и сменится ли адрес notes-db-rw?

Ответ

Primary станет notes-db-2. ClusterIP сервиса notes-db-rw останется прежним, изменится только endpoint за ним. Удалённый notes-db-1 вернётся как реплика.

Шаги:

  1. Выясни, кто сейчас primary: kubectl -n notes get pods -L cnpg.io/instanceRole, в колонке INSTANCEROLE ищи primary. Дальше в тексте это notes-db-1; если у тебя главный notes-db-2, подставляй его имя.
  2. В первом терминале запусти запись раз в секунду через временный под (пароль берём из Secret). Разбор: kubectl run writer запускает под writer; --rm -it --restart=Never удалит его после выхода и подключит терминал; --env=PGPASSWORD=... передаёт пароль клиенту psql через переменную окружения, а $(... | base64 -d) достаёт пароль из Secret (в Secret всё хранится в base64, -d декодирует). psql -h notes-db-rw -U notes notes -tAc "...": -h хост, -U пользователь, следующее notes имя базы, -t без заголовков, -A без выравнивания, -c выполнить запрос. Сам запрос выводит текущее время (now()::timestamp(0) округляет его до секунды) и признак pg_is_in_recovery() (t значит «я реплика», f «я primary»). Весь запрос в двойных кавычках, а внешняя команда bash -c в одинарных, поэтому внутри запроса нет строковых литералов в одинарных кавычках: они бы закрыли внешние. 2>&1 | head -1 сводит ошибки и вывод в поток и оставляет первую строку, sleep 1 пауза секунду:
kubectl -n notes run writer --rm -it --restart=Never \
  --image=ghcr.io/cloudnative-pg/postgresql:18.6 \
  --env="PGPASSWORD=$(kubectl -n notes get secret notes-db-app -o jsonpath='{.data.password}' | base64 -d)" \
  --command -- bash -c 'while true; do psql -h notes-db-rw -U notes notes -tAc "select now()::timestamp(0), pg_is_in_recovery()" 2>&1 | head -1; sleep 1; done'
  1. Во втором терминале удали primary и смотри роли (-w держит команду и печатает изменения; остановить по Ctrl+C):
kubectl -n notes delete pod notes-db-1 --wait=false
kubectl -n notes get pods -L cnpg.io/instanceRole -w

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

2026-09-29 10:31:12|f
2026-09-29 10:31:13|f
psql: error: connection to server at "notes-db-rw" (10.96.201.33), port 5432 failed: Connection refused
psql: error: connection to server at "notes-db-rw" (10.96.201.33), port 5432 failed: Connection refused
... (ещё около пяти таких же строк)
2026-09-29 10:31:21|f

Как читать вывод: строки с временем и f это успешные записи на primary. Строки Connection refused это секунды, когда за notes-db-rw не было ни одного работающего endpoint; при паузе в 1 секунду их набирается примерно по одной на секунду простоя. Потом снова время и f: теперь отвечает новый primary. Между 10:31:13 и 10:31:21 прошло 8 секунд: это окно недоступности. Твои числа и количество ошибок будут другими. Когда всё посмотрел, останови цикл в первом терминале по Ctrl+C: временный под удалится сам (из-за --rm).

Окно недоступности обычно от нескольких секунд до полуминуты. Это твой измеренный RTO для сбоя primary, запиши его в docs/ для урока 10.3.

Объясни себе:

  • Почему ошибки были, если реплика уже стояла?
  • Что бы произошло, если бы приложение держало пул соединений без переподключения?

Типичные ошибки:

  • Команда прошла без ошибки, а primary не сменился: ты удалил реплику, и оператор просто пересоздал её под. Определи primary по kubectl -n notes get pods -L cnpg.io/instanceRole и удаляй того, у кого primary.
  • FATAL: the database system is not yet accepting connections: соединился с только что поднявшимся инстансом: подожди и проверь kubectl cnpg status notes-db -n notes.

Вставь в нейросеть вывод цикла записи и вывод kubectl get pods -L cnpg.io/instanceRole -w и спроси, в какую секунду пропал primary и когда запись вернулась. Сверь ответ с метками времени сам.

Задание 4. Бэкап и восстановление в новый Cluster

Цель: снять бэкап в MinIO и поднять из него отдельный кластер.

Предскажи: можно ли восстановить в кластер с тем же именем notes-db, пока старый жив?

Ответ

Нет: имена конфликтуют, поды и PVC уже существуют. Восстанавливаем в новый Cluster с другим именем, например notes-db-restore, проверяем данные и потом решаем, что с ним делать.

Шаги:

  1. Сначала положи в базу данные, по которым потом проверишь восстановление. Таблицу notes не трогаем: она понадобится в задании 5. Заведём отдельную таблицу restore_check с тремя строками. Primary определяем по роли, а не по имени: после задания 3 он мог переехать. P=$(...) кладёт имя пода в переменную, -o name печатает его в виде pod/имя, ${P#pod/} отрезает приставку:
P=$(kubectl -n notes get pod -l cnpg.io/cluster=notes-db,cnpg.io/instanceRole=primary -o name)
kubectl -n notes exec ${P#pod/} -c postgres -- psql -U postgres notes -c "create table restore_check as select generate_series(1,3) as n"

Ожидаемо: SELECT 3.

  1. Расписание и ручной бэкап. method: plugin и pluginConfiguration.name говорят оператору делать копию через плагин Barman Cloud, а в какое хранилище писать, плагин узнаёт из Cluster (раздел plugins). backupOwnerReference: self значит, что созданные по расписанию объекты Backup принадлежат самому ScheduledBackup и удаляются вместе с ним. kubectl apply -f - <<'YAML' применяет манифест, который идёт сразу за командой (а -f - значит «читать из стандартного ввода»), get backup -w показывает изменения на лету, выход по Ctrl+C. Расписание идёт через git, ручной бэкап применяем сразу:
cat > apps/notes/cnpg-backup.yaml <<'YAML'
apiVersion: postgresql.cnpg.io/v1
kind: ScheduledBackup
metadata:
  name: notes-db-daily
  namespace: notes
spec:
  # формат с секундами: каждый день в 03:00
  schedule: "0 0 3 * * *"
  method: plugin
  pluginConfiguration:
    name: barman-cloud.cloudnative-pg.io
  cluster:
    name: notes-db
  backupOwnerReference: self
YAML
# дописываем файл в resources: sed вставляет строку сразу после "resources:"
sed -i.bak '/^resources:/a\
  - cnpg-backup.yaml
' apps/notes/kustomization.yaml
rm apps/notes/kustomization.yaml.bak
# проверка: строка должна найтись, иначе Flux расписание не применит
grep cnpg-backup apps/notes/kustomization.yaml
git add -A && git commit -m "cnpg: расписание бэкапов" && git push
flux reconcile kustomization apps --with-source
kubectl -n notes get scheduledbackup
kubectl -n notes apply -f - <<'YAML'
apiVersion: postgresql.cnpg.io/v1
kind: Backup
metadata:
  name: notes-db-manual
  namespace: notes
spec:
  method: plugin
  pluginConfiguration:
    name: barman-cloud.cloudnative-pg.io
  cluster:
    name: notes-db
YAML
kubectl -n notes get backup -w
  1. Когда PHASE станет completed, создай кластер для проверки (не коммить, это временный эксперимент). Восстановление тоже идёт через плагин: в externalClusters кластер-источник описан как plugin, где barmanObjectName это наш ObjectStore, а serverName имя кластера, чьи бэкапы лежат в бакете. bootstrap.recovery.source указывает на эту запись:
kubectl -n notes apply -f - <<'YAML'
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: notes-db-restore
  namespace: notes
spec:
  instances: 1
  imageName: ghcr.io/cloudnative-pg/postgresql:18.6
  storage:
    size: 2Gi
  bootstrap:
    recovery:
      source: notes-db
  externalClusters:
    - name: notes-db
      plugin:
        name: barman-cloud.cloudnative-pg.io
        parameters:
          barmanObjectName: minio-store
          serverName: notes-db
YAML
kubectl -n notes wait cluster/notes-db-restore --for=condition=Ready --timeout=300s
kubectl -n notes exec notes-db-restore-1 -c postgres -- psql -U postgres notes -tAc "select count(*) from restore_check"
  1. Убери эксперимент и временную таблицу (она нужна была только для проверки, а в задании 5 не должна мешать):
kubectl -n notes delete cluster notes-db-restore
kubectl -n notes exec ${P#pod/} -c postgres -- psql -U postgres notes -c "drop table restore_check"

Что должно получиться:

NAME             AGE   CLUSTER    LAST BACKUP
notes-db-daily   12s   notes-db
NAME              AGE   CLUSTER    METHOD   PHASE       ERROR
notes-db-manual   40s   notes-db   plugin   completed
cluster.postgresql.cnpg.io/notes-db-restore condition met
3

Как читать вывод: METHOD plugin это способ бэкапа (через плагин Barman Cloud), PHASE completed значит копия готова и лежит в бакете. condition met у второго кластера значит, что он поднялся из бэкапа. Последняя строка это результат select count(*) по restore_check: 3 строки, те самые, что мы создали до бэкапа. Если пришло 3, данные доехали через бэкап. Ключ -c postgres выбирает контейнер: в поде CNPG может быть несколько. Строка notes-db-daily в самом начале показывает, что расписание применилось; если там No resources found, строка про cnpg-backup.yaml не попала в kustomization.yaml.

Вставь в нейросеть вывод kubectl describe backup notes-db-manual и спроси, на каком шаге остановилась копия. Сверь ответ с блоком Events сам.

Полноценный учебный restore drill с замером RTO проводится один раз в уроке 10.3, здесь только механика.

Объясни себе:

  • Чем Backup отличается от ScheduledBackup?
  • Почему бэкап в MinIO внутри того же kind защищает только от логических ошибок, а не от потери машины?

Типичные ошибки:

  • Error: The specified bucket does not exist: бакет cnpg-backups не создан в MinIO: создай его командой mc mb из задания 1.
  • PHASE failed ... Access Denied: неверные ключи в minio-creds namespace notes: сверь с секретом в minio.
  • WAL archiving failed в kubectl cnpg status: неверный endpointURL в cnpg-objectstore.yaml (нужен http://, не https://, без TLS в MinIO): исправь адрес.

Задание 5. Шаг проекта: «Заметки» переезжают на CNPG

Цель: перенести данные из StatefulSet postgres, переключить приложение на notes-db-rw и удалить старое.

Предскажи: что произойдёт с приложением, если сначала удалить StatefulSet, а потом делать дамп?

Ответ

Дамп сделать будет не из чего, если удалён и PVC (у StatefulSet PVC остаётся, но проще ошибиться). Порядок всегда: остановить запись, дамп, восстановление, проверка, переключение, и только потом удаление старого.

Шаги:

  1. Останови запись в старую базу, иначе заметки, добавленные во время дампа, потеряются. flux suspend kustomization apps ставит синхронизацию apps на паузу (иначе Flux вернёт Deployment на место, пока мы его гасим), scale --replicas=0 останавливает приложение. Это короткий простой: допустимо на стенде, в проде окно согласуют заранее. Потом дамп из старой БД (postgres-0 из урока 5.5) и заливка в новую. Разбор: kubectl exec postgres-0 -- pg_dump ... запускает pg_dump внутри старого пода; > /tmp/notes-dump.sql (перенаправление вывода, урок 1.2) сохраняет SQL в файл у тебя на машине; exec -i ... < файл подаёт файл на вход psql в новом поде. Строка SET ROLE notes; перед дампом делает так, что все таблицы создаются от имени notes, а не суперпользователя postgres: иначе приложение не получит прав на таблицы. Новую базу определяем по роли primary, как в задании 3, а не по имени notes-db-1: после failover он мог стать репликой, а в реплику писать нельзя:
flux suspend kustomization apps
kubectl -n notes scale deploy/notes --replicas=0
kubectl -n notes exec postgres-0 -- pg_dump -U notes --no-owner notes > /tmp/notes-dump.sql
P=$(kubectl -n notes get pod -l cnpg.io/cluster=notes-db,cnpg.io/instanceRole=primary -o name)
(echo "SET ROLE notes;"; cat /tmp/notes-dump.sql) | kubectl -n notes exec -i ${P#pod/} -c postgres -- psql -U postgres notes
kubectl -n notes exec ${P#pod/} -c postgres -- psql -U postgres notes -tAc "select count(*) from notes"
  1. В проекте теперь два разных Secret, и их легко перепутать. notes-db-app из задания 2 хранит пароль владельца базы для CNPG (тип basic-auth, поля username и password). Secret notes-db из урока 9.2 хранит то, что читает приложение: DATABASE_URL и POSTGRES_PASSWORD. Меняем второй: поменяй хост db на notes-db-rw в шаблоне чарта, откуда собирается DATABASE_URL (helm/notes/templates/externalsecret.yaml, хост зашит там, в gitops-репозитории из 9.3 в apps/notes/ лежат только release.yaml и kustomization.yaml), подними version в Chart.yaml, запушь чарт и укажи новую версию в spec.chart.spec.version файла apps/notes/release.yaml. Значение станет postgresql://notes:<пароль>@notes-db-rw.notes.svc:5432/notes. Пароль в обоих Secret идёт из одного поля Vault secret/notes/db, поэтому совпадает. Закоммить и запушь, потом верни синхронизацию: flux resume снимает паузу, и Flux сам вернёт число реплик из git (мы их обнулили руками). Приложение стартует уже с новым Secret:
git add -A && git commit -m "notes: БД на CNPG (notes-db-rw)" && git push
flux resume kustomization apps
flux reconcile kustomization apps --with-source
kubectl -n notes rollout restart deploy/notes
kubectl -n notes rollout status deploy/notes
curl -s --cacert /tmp/notes-ca.crt --resolve notes.lab:443:127.0.0.1 https://notes.lab/notes
  1. Убедись, что заметки на месте, и только потом удали старое из git (apps/notes/: файлы StatefulSet postgres, Service db, CronJob pg-backup, PVC pg-backups), закоммить и запушь. Flux с prune: true удалит объекты. PVC data-postgres-0 удали вручную после проверки: kubectl -n notes delete pvc data-postgres-0.
  2. Сохрани /tmp/notes-dump.sql как последнюю страховку до конца урока, потом удали файл.

Что должно получиться:

3
deployment "notes" successfully rolled out
[{"id":1,"text":"первая","created_at":"2026-09-29T09:01:11Z"},{"id":2,"text":"вторая","created_at":"2026-09-29T09:02:03Z"},{"id":3,"text":"третья","created_at":"2026-09-29T09:02:40Z"}]

Проверь, что старого нет:

kubectl -n notes get sts,cronjob
No resources found in notes namespace.

Состояние проекта: версия 0.7.0, Cluster notes-db, Service notes-db-rw, бэкапы в MinIO. Долг: MinIO без репликации.

Как читать вывод: 3 это число строк в новой базе, оно должно совпасть с тем, что было в старой. Строка rolled out подтверждает, что новые поды приложения запущены с новым DATABASE_URL. JSON последней строкой это ответ приложения: три заметки на месте. Даты у тебя будут свои. No resources found после проверки значит, что StatefulSet и CronJob удалены.

Объясни себе:

  • Почему pg_dump с --no-owner?
  • Как убедиться, что в новой БД не меньше строк, чем в старой?

Типичные ошибки:

  • psql: error: connection to server ... FATAL: password authentication failed for user "notes": в Vault и в notes-db-app разные пароли, либо в DATABASE_URL остался старый: сравни kubectl get secret обоих и обнови из Vault.
  • ERROR: permission denied for table notes в логах приложения после переключения: таблицы созданы от имени postgres, потому что залили без SET ROLE notes;. Выдай права ALTER TABLE notes OWNER TO notes; или повтори заливку в чистую базу.
  • ERROR: role "old_owner" does not exist при заливке: дамп снят без --no-owner и ссылается на роль старой базы, которой в новой нет: сними дамп заново с флагом.
  • pg_dump: error: connection to server on socket ... failed: пода postgres-0 нет, StatefulSet уже удалён: восстанови из последнего pg-backup (PVC pg-backups) или из /tmp/notes-dump.sql.

Сломай и почини

Скрипта поломки для этого урока нет: ты ломаешь сам, руками, через git. Выбери один из трёх сценариев и попроси коллегу (или себя завтрашнего) не подглядывать в разбор ниже.

  1. Запись в реплику. В шаблоне чарта helm/notes/templates/externalsecret.yaml поменяй хост в DATABASE_URL с notes-db-rw на notes-db-ro, подними версию чарта и укажи её в apps/notes/release.yaml, закоммить, запушь, перезапусти Deployment notes.
  2. Бэкап падает. В apps/notes/cnpg-objectstore.yaml замени endpointURL на https://minio.minio.svc:9000 (у нашего MinIO нет TLS), закоммить, запушь, создай новый Backup.
  3. Primary удалён и не возвращается. Поставь instances: 1 (закоммить, запушь, дождись), узнай имя primary командой P=$(kubectl -n notes get pod -l cnpg.io/cluster=notes-db,cnpg.io/instanceRole=primary -o name) (после задания 3 это уже не notes-db-1), затем kubectl -n notes delete $P --wait=false и удали его PVC командой kubectl -n notes delete pvc ${P#pod/}. Это учебный кластер, данные учебные. Перед этим убедись, что есть свежий Backup.

Чини через git (Flux откатит ручные правки), не через kubectl edit.

Симптом

Приложение отвечает 500 на POST /notes, в логах cannot execute INSERT in a read-only transaction, либо kubectl get backup показывает failed, либо в kubectl get pods подов notes-db нет или один из них не в Running.

Гипотезы

  • Приложение ходит в notes-db-ro или в имя реплики, а не в -rw.
  • Бэкап: неверный endpoint, ключи или нет бакета.
  • Primary недоступен: под не стартует, PVC потерян, нет места, отсутствует реплика для повышения.

Проверки

kubectl cnpg status notes-db -n notes
kubectl -n notes get cluster notes-db -o wide
kubectl -n notes describe backup "<имя>"
kubectl -n notes logs deploy/notes --tail=20
kubectl -n notes get endpoints notes-db-rw

cnpg status сводит состояние кластера, репликации и архивации WAL в один экран. get endpoints notes-db-rw показывает, есть ли за адресом записи живой primary: пустой список значит, что писать некуда. Подумай, какая проверка сужает поиск быстрее всего.

Исправление

Разбор сценариев
  1. Запись в реплику: DATABASE_URL указывает на notes-db-ro или notes-db-2. Проверь psql -c "select pg_is_in_recovery()" через этот хост, t значит реплика. Исправь хост на notes-db-rw в helm/notes/templates/externalsecret.yaml, подними версию чарта и в apps/notes/release.yaml, закоммить, запушь, перезапусти Deployment.
  2. Бэкап failed: kubectl describe backup и логи пода primary в контейнере postgres покажут Access Denied, bucket does not exist или ошибку соединения. Поправь endpointURL в cnpg-objectstore.yaml или ключи в minio-creds, создай бакет, запусти новый Backup. Убедись, что WAL идёт: kubectl cnpg status без Failing в блоке WAL archiving.
  3. Primary удалён и не возвращается: если есть реплика, оператор повысит её сам, дождись; если реплики нет (instances: 1), нужен restore из бэкапа в новый Cluster (задание 4). Смотри события kubectl -n notes get events --sort-by=.lastTimestamp. Профилактика: instances не меньше 2 и рабочий бэкап.

ИИ в помощь

Нейросеть хорошо объясняет вывод kubectl cnpg status и пишет черновики манифестов, но путает поля CNPG между версиями. Общие правила: ИИ-помощник. Настоящие значения секретов в запрос не вставляй: заменяй их на CHANGE_ME.

Задача: разобрать состояние кластера.

Вот вывод `kubectl cnpg status notes-db -n notes`:
<вставь вывод>.
Скажи по блокам: кто primary, сколько реплик готово, работает ли архивация WAL и какое отставание. Что в этом выводе настораживает?

Проверь ответ: каждое утверждение найди в самом выводе. Типичная ошибка: нейросеть объявляет кластер здоровым по блоку Cluster Summary и пропускает Working WAL archiving.

Задача: написать ScheduledBackup.

Напиши `ScheduledBackup` CloudNativePG для кластера `notes-db`, чтобы копия делалась каждый день в 03:00. Объясни каждое поле расписания.

Проверь ответ: расписание должно быть из шести полей, первое секунды: "0 0 3 * * *". Типичная ошибка: расписание из пяти полей, как в обычном cron.

Задача: найти причину ошибки подключения.

Приложение пишет: <вставь ошибку>. Строка подключения: postgresql://notes:пароль@notes-db-rw.notes.svc:5432/notes. Укажи, какая из пяти частей адреса виновата, и дай команду проверки.

Проверь ответ: сверь с таблицей из теории: хост, порт, база, пользователь, пароль. Типичная ошибка: совет «перезапусти базу» вместо проверки Secret или имени Service.

Словарик урока

Термин Простыми словами
Оператор (operator) Программа в кластере, которая знает, как эксплуатировать конкретную систему, и постоянно приводит её к описанному состоянию
CRD Описание нового типа ресурса, который добавляют в API Kubernetes (Cluster, Backup)
Контроллер, reconcile loop Программа и её цикл «прочитать желаемое, сравнить с фактическим, исправить разницу»
Instance (инстанс) Один экземпляр базы: под и его диск
Primary Главный инстанс, принимает запись
Replica (реплика) Копия primary только для чтения, получает изменения потоком
WAL Журнал изменений PostgreSQL, по которому реплика догоняет, а бэкап восстанавливается
Streaming replication Реплика получает WAL от primary непрерывным потоком
Асинхронная репликация Primary подтверждает запись, не дожидаясь реплики: быстро, но возможна потеря последних записей
Failover / switchover Аварийное или плановое переключение роли primary на другую реплику
RPO / RTO Допустимая потеря данных и допустимое время простоя (урок 10.3)
Base backup Физическая копия файлов базы на момент времени
PITR Восстановление на выбранный момент: базовая копия плюс проигрывание WAL
Barman Инструмент, который CNPG использует для бэкапов и архивации WAL
S3, бакет Стандарт хранения файлов-объектов по HTTP и «корзина» верхнего уровня; MinIO это S3 у нас в кластере
ScheduledBackup / Backup Бэкап по расписанию / разовый бэкап
bootstrap.initdb / recovery Создать пустую базу / поднять кластер из бэкапа
notes-db-rw, -ro, -r Service на primary / на реплики / на любой инстанс
строка подключения (DSN) адрес базы одной строкой: пользователь, пароль, хост, порт, имя базы
объектное хранилище хранилище файлов-объектов в бакетах, доступ по HTTP (S3 и совместимые)
endpointURL адрес S3-совместимого сервера (у нас MinIO); без него CNPG идёт в AWS
kubectl cnpg status сводка по кластеру: главный, реплики, отставание, работа архивации WAL
репликация постоянное копирование изменений главной базы на запасной экземпляр
Cluster (CNPG) ресурс: одна база с её копиями, не кластер Kubernetes

Вопросы с собеседований

Раздел для повторения: ответь вслух, потом открой ответ. Короткие вопросы с пометкой [на скорость] тренируй на время: ответ за 30 секунд.

1. [junior] [часто] Что такое оператор в Kubernetes и чем он отличается от Helm-чарта?

Ответ

Оператор это CRD плюс контроллер, который постоянно сверяет желаемое состояние с фактическим и знает, как эксплуатировать конкретную систему. Helm один раз рисует манифесты. Оператор реагирует на события: упал primary, пора сделать бэкап, надо обновить версию.

Что хотят услышать: reconcile loop, CRD, эксплуатационные знания в коде, пример (CNPG, cert-manager, Prometheus Operator).

Красный флаг: «это такой продвинутый Helm» или «это про установку».

2. [middle] [часто] Как в CNPG устроены бэкапы и восстановление на момент времени?

Ответ

Базовая копия плюс непрерывная архивация WAL в объектное хранилище. Сейчас это делает плагин Barman Cloud: объект ObjectStore описывает хранилище, в Cluster.spec.plugins включается архивация, а Backup и ScheduledBackup идут с method: plugin. Для PITR создаётся новый Cluster с bootstrap.recovery и recoveryTarget.targetTime, источник описан в externalClusters. Восстанавливаем в новое имя, проверяем и переключаем приложение. Старый встроенный barmanObjectStore устарел.

Что хотят услышать: Barman Cloud, WAL, ObjectStore, ScheduledBackup, восстановление в новый кластер, проверка бэкапов (restore drill).

Красный флаг: «делаю pg_dump раз в сутки» как единственный вариант, или бэкапы в том же кластере и не проверены.

3. [middle] [часто] Стоит ли держать PostgreSQL в Kubernetes?

Ответ

Зависит от требований, и вот по каким критериям решаю. Есть ли SLA, который выдержит самостоятельная эксплуатация. Какие диски: локальные привязывают базу к узлу, сетевые проще. Какого размера база: на сотнях гигабайт восстановление и обновления становятся долгими. Есть ли в команде человек, который понимает PostgreSQL (DBA или SRE с опытом). Если людей нет, а требования строгие, надёжнее управляемый сервис. С оператором, проверенными бэкапами и опытной командой вариант рабочий.

Что хотят услышать: взвешенный ответ с критериями (SLA, диски, размер данных, наличие DBA, стоимость), не догма, упоминание управляемых сервисов.

Красный флаг: категоричное «никогда» или «всегда» без аргументов.

4. [middle] Прод: приложение пишет в БД, primary в CNPG умер. Что происходит и что ты делаешь?

Ответ

Оператор обнаруживает потерю primary, повышает реплику с наименьшим отставанием и переключает Service -rw. Я смотрю kubectl cnpg status, роли подов, endpoints -rw, и что приложение переподключается. Если реплики не было, иду в восстановление из бэкапа.

Что хотят услышать: Service -rw, окно недоступности, переподключение пула, асинхронная репликация и возможная потеря последних транзакций, проверка после.

Красный флаг: «зайду в под и вручную сделаю pg_promote» без проверки состояния оператора.

5. [junior] [на скорость] Через какой Service приложение должно подключаться к CNPG и почему?

Ответ

К notes-db-rw: он всегда указывает на текущий primary. -ro ведёт на реплики, поэтому запись там завершится ошибкой read-only. Имена подов использовать нельзя, primary переезжает.

Что хотят услышать: три сервиса, назначение каждого, отличие от имени пода.

Красный флаг: «хожу на IP пода» или «на любой сервис, они одинаковые».

7. [middle] Нужно поднять новую версию PostgreSQL в CNPG с минимальным простоем. Как?

Ответ

Минорное обновление: меняю imageName, оператор делает rolling update: сначала реплики, потом primary (по умолчанию перезапуск на месте, с primaryUpdateMethod: switchover через переключение на обновлённую реплику). Для мажорного апгрейда нужен отдельный план (импорт в новый кластер или поддерживаемый in-place механизм), делаю сначала на копии из бэкапа. Перед этим свежий бэкап.

Что хотят услышать: rolling по репликам, primary последним (restart или switchover), свежий бэкап, репетиция на копии, различие минорных и мажорных версий.

Красный флаг: «просто поменяю тег и посмотрю».

8. [middle] Пароль БД в Vault сменили, а приложение не может подключиться. Что не так и как правильно менять пароль?

Ответ

Смена в Vault не меняет пароль роли в самой PostgreSQL: ESO обновит Secret, но пользователь notes в БД остался со старым. Нужно синхронно сменить роль, например ALTER ROLE notes PASSWORD '…' (значение берут из Secret, не печатая его), либо управлять ролью через оператор: managed.roles с passwordSecret, тогда оператор сам применит новый пароль. После этого перезапускаю приложение. Проверяю refreshInterval ESO и статус ExternalSecret.

Что хотят услышать: источник правды один, порядок смены, ESO обновляет Secret, но не БД, managed.roles, перечитывание в приложении.

Красный флаг: «сменил в Vault, значит всё обновится».

9. [middle] Диск primary заполняется WAL, что делать?

Ответ

Смотрю, не застрял ли архив WAL (kubectl cnpg status, метрики), не отвалился ли MinIO или ключи: пока архив не работает, WAL копятся на диске. Чиню архивацию, WAL уйдёт и очистится. Срочно: расширяю PVC (storage.size, если класс позволяет), но причину чиню всегда.

Что хотят услышать: связь архива WAL и диска, kubectl cnpg status, расширение тома, алерты на место и на возраст архивации.

Красный флаг: «удалю файлы WAL из pg_wal руками».

10. [middle] Прод отвечает 502 после failover в БД. Как разбираешься?

Ответ

Иду по цепочке: логи приложения, endpoints notes-db-rw, роли подов, readiness-пробы. Частая причина: пул не переподключился или проба readyz ходит в БД, и при failover все поды выпали из Service. Readiness не должна зависеть от внешних систем: проверка БД в ней делает из сбоя базы полный простой, а работающий под мог бы отдать хотя бы то, что не требует базы. Смотрю время сбоя, перезапускаю проблемные поды, потом чиню переподключение и таймауты.

Что хотят услышать: цепочка проверок, readiness без внешних зависимостей, поведение пула, метрики и логи вместо догадок.

Красный флаг: «увеличу реплики nginx».

11. [junior] Что такое WAL в PostgreSQL и зачем он нужен?

Ответ

WAL (write-ahead log) - журнал, в который Postgres сначала записывает изменения, а потом уже применяет к файлам данных. Благодаря ему база переживает падение: после старта повторяет журнал. Реплики получают тот же поток WAL и применяют его, а для восстановления на момент времени архивирую сегменты WAL в объектное хранилище. Если WAL не успевают архивироваться или реплика отстала, журнал копится на диске primary и может его заполнить.

Что хотят услышать: журнал до записи данных, восстановление после сбоя, репликация, PITR, риск заполнения диска.

Красный флаг: путает WAL с логами приложения.

13. [middle] Как обновить ноду Kubernetes с кластером CNPG так, чтобы БД не упала?

Ответ

Кластер должен быть минимум из двух экземпляров, лучше трёх, с PodDisruptionBudget, который оператор создаёт сам. При kubectl drain с ноды выселяют под. Если это primary, оператор делает switchover на реплику, а потом выселяется бывший primary. Перед работой смотрю kubectl cnpg status <кластер>: реплики должны быть в синхроне. Если хранилище привязано к ноде (local PV), под будет ждать именно её, об этом нужно знать заранее.

Что хотят услышать: несколько экземпляров, PDB, switchover, проверка репликации до работ, особенность локальных дисков.

Красный флаг: дренит все ноды подряд и не проверяет реплики.

14. [middle] Как получить RPO равное нулю в PostgreSQL и чем за это платишь?

Ответ

Нужна синхронная репликация: primary подтверждает запись клиенту только после того, как её получила хотя бы одна реплика, поэтому при падении primary подтверждённые записи не пропадают. Цена: каждая запись ждёт сеть и реплику, растёт задержка. Если реплики недоступны, запись может встать совсем (или приходится ослаблять гарантию). В CNPG это включают настройками синхронной репликации в Cluster. Асинхронная репликация быстрее, но даёт ненулевой RPO.

Что хотят услышать: синхронная против асинхронной репликации, задержка записи, риск остановки записи, выбор по требованию бизнеса.

Красный флаг: «RPO ноль даёт бэкап раз в минуту» или «включу и ничего не потеряю без последствий».

Проверено на версиях

Кластер Kubernetes для этого урока не запускался. Вывод команд показан как образец формата, у тебя он будет другим: имена, адреса, время и число строк отличаются. Манифесты и версии сверены с документацией проекта, а не прогнаны.

  • CloudNativePG: v1.30.1 (не прогонялось)
  • PostgreSQL: 18.6 (не прогонялось)
  • Flux: v2.9.5
  • External Secrets Operator: v2.11.0
  • Vault: v2.1.1
  • MinIO: тег RELEASE.2025-09-07T16-13-09Z (проект больше не развивается, образы не обновляются, статус проверь в репозитории MinIO; только для лаборатории), mc с тегом той же поры
  • Helm-чарт cloudnative-pg: 0.29.1 (appVersion CNPG 1.30.1)
  • Плагин Barman Cloud: версия «последний релиз» на момент установки (шаг 6 задания 1), запиши свою; в этом тексте он не прогонялся, имя Deployment barman-cloud сверь по kubectl -n cnpg-system get deploy
  • Встроенный barmanObjectStore не используем: он устарел с 1.26, помечен устаревшим, сроки удаления смотри в документации cloudnative-pg.io

Итог урока: ты умеешь

  • умею объяснить, чем оператор отличается от Helm-чарта
  • умею установить CloudNativePG через HelmRelease и увидеть его CRD
  • умею описать Cluster с паролем из Vault через ESO
  • умею назвать, какой Service для записи, а какой для чтения
  • умею вызвать failover и замерить окно недоступности
  • умею настроить ScheduledBackup в S3-совместимое хранилище и восстановить в новый Cluster
  • умею перенести данные pg_dump и psql и удалить старый StatefulSet
  • умею диагностировать запись в реплику и упавший бэкап

Дальше: Урок 9.6: прогрессивная доставка

Проверь себя

Короткий тест по уроку: 5 вопросов из банка в 30. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.

Тест работает с включённым JavaScript.

тема 9 урок 9.5 3 ч курс 0/0 ← → уроки

Помоги улучшить курс

Что нужно изменить?