The databasePart 5 of 6

Деплой — это перевод ветки в продакшн, а не миграция

Выкатка в продакшн обычно означает перенос данных: снять дамп с dev, восстановить его в отдельной прод-базе, прогнать миграции и надеяться, что окружения не разошлись. На таймлайнах Postgres с копированием при записи всё устроено иначе: продакшн — это ветка, а выпуск — её перевод в продакшн. Когда продакшн форкается от head ветки dev, не перемещается ни байта (а по умолчанию продакшн получает только схему); повторные деплои сохраняют данные продакшна и применяют только ещё не применённые миграции; откат заново деплоит закреплённый коммит и при желании восстанавливает данные на нужный момент; каждое окружение масштабируется до нуля независимо от другого. Вот модель и её механика.

Деплой — это перевод ветки в продакшн, а не миграция

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

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

Он опирается на два примитива, разобранных в других постах: ветвление с копированием при записи на LSN и compute с масштабированием до нуля. Если они вам в новинку, сначала пробегитесь по ним — этот пост их объединяет.


Модель: продакшн — это устойчивая ветка, форкнутая от dev

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

Первый деплой форкает текущий head ветки dev в новый, устойчивый прод-таймлайн. С этого момента продакшн — это собственный таймлайн, на котором будут жить данные реальных пользователей, а dev продолжает работать на своём таймлайне, оставаясь нетронутым. Поскольку ветвление — это O(1)-копирование при записи, форк не копирует данные. Работа с базой при деплое стоит одинаково, держит ли база килобайт или сто гигабайт.

С чем продакшн стартует — отдельный вопрос. База dev полна демо- и faker-строк, которым не место в живом приложении, поэтому по умолчанию продакшн стартует только со схемой. Форк с копированием при записи нельзя создать пустым, поэтому релиз форкает базу, а когда прод-compute поднят, очищает таблицы приложения. Тот, кто деплоит, может вместо этого сохранить строки dev (copyDevData). Служебные аккаунты, которыми платформа проверяет приложение, удаляются в любом случае — до того, как приложение откроется пользователям.

first deploy: fork dev head → prod

shared history up to the fork

dev timeline
agent builds here · keeps running

prod timeline
durable · customer traffic

Из того, что продакшн и dev — один и тот же движок и разделяет их всего одна ветка, напрямую следует: никакого расхождения окружений. Продакшн — не отдельно поднятая база, куда данные переносят через дамп и восстановление, а форк, который в момент разделения унаследовал журнал миграций dev. Деплой применяет только те миграции, которых продакшн действительно ещё не видел (DDL, который dev уже выполнил, а продакшн — нет), поэтому не бывает ситуации «на dev работает, на проде ломается» из-за двух баз, которые поднимали и мигрировали по отдельности.


Механика перевода в продакшн

Первый перевод в продакшн — это единственный сдвиг метаданных: форкнуть head ветки dev в устойчивый прод-таймлайн. Решение чистое — по текущим веткам определить, что станет продакшном, — а выполнение это операция ветвления без копирования данных:

pageserverneon-conn-proxybackend (promotion)deploy triggerpageserverneon-conn-proxybackend (promotion)deploy triggerpromoteToProduction(project)planPromotion(branches) %% pick the dev-serving timelinefork dev head → prod timeline (O(1), CoW)create_timeline(ancestor=dev head)record prod branchprovision prod compute credentials (Vault + proxy cache)setServingBranch("prod")release flip step: neon-compute-prod in proj-{id}-prod

Логика перевода в продакшн — это маленькая чистая функция, planPromotion: она смотрит на ветки проекта и решает, какой таймлайн станет продакшном (и ничего не делает, если dev уже совпадает с продакшном). Слой выполнения, promoteToProduction, форкает head ветки dev, записывает новую прод-ветку, выпускает для неё учётные данные прод-compute и только после этого назначает её веткой, обслуживающей prod, — так продакшн никогда не обслуживает таймлайн, к которому ничто не может подключиться. Сам прод-compute живёт в собственном пространстве имён proj-{id}-prod: это пространство имён и его квоту создаёт шаг переключения (flip) релиза, и он же разворачивает там neon-compute-prod.

Это первый перевод в продакшн. Повторный деплой не форкает заново: он сохраняет действующий прод-таймлайн, так что данные реальных пользователей переживают смену релизов. Он ставит на head продакшна контрольную точку LSN перед деплоем как якорь для отката (anchorProdRedeploy; повторный деплой без якоря отклоняется), закрепляет только что выпущенный коммит и применяет к продакшну ещё не применённые db/migrations каждого приложения как DDL «только вперёд» (migrateProduction → runPendingMigrations(…, { env: "prod" })). То есть миграции схемы на продакшне деплой действительно прогоняет — но данные не копирует никогда. Данные продакшна заменяются данными dev только по явному решению владельца и никогда — как побочный эффект выкатки. Таких решений два: сброс данных и, если продакшн снимали с публикации с сохранением старых данных, повторный деплой «с чистого листа» на данных dev. Перед заменой каждое из них создаёт точку восстановления для заменяемых данных.

Откат неудачного деплоя заново деплоит закреплённый коммит одного из прошлых релизов. Журнал релизов только дописывается, и каждый релиз закреплён за git-коммитом, так что старый код восстанавливается в точности. Восстановление данных необязательно и опирается на тот же примитив «ветка на LSN», что и путешествие во времени. Точка восстановления — контрольная точка, поставленная перед деплоем релиза, который сменил целевой. Откат форкает продакшн от этой точки и переключает прод-compute на форк. Никакого восстановления из бэкапа; при этом данные возвращаются раньше старого кода, так что старый код никогда не работает с данными из более позднего периода.


Отдельный compute на каждое окружение — и оба масштабируются до нуля

Продакшн и dev должны быть активны одновременно: клиенты идут в продакшн, пока агент продолжает итерации на dev. Один процесс Postgres привязан к одному таймлайну на момент запуска, поэтому окружения получают отдельные compute — neon-compute для dev и neon-compute-prod для продакшна — каждый нацелен на свой таймлайн.

Звучит как двойная стоимость, так бы и было, если бы оба compute не масштабировались до нуля независимо (прокси для масштабирования до нуля маршрутизирует по окружениям на основе имени базы данных и будит каждое по запросу):

  • Приложение без посетителей, и никто ничего не собирает → оба на нуле.
  • Заходит клиент → просыпается продакшн; dev остаётся на нуле.
  • Агент итерирует → просыпается dev; продакшн остаётся на нуле.

Вы платите за используемое окружение, а не за поднятое. Манифесты генерируются для каждого окружения из единого шаблона (generateNeonComputeManifests(projectId, { env })), поэтому прод-compute — это тот же набор ресурсов, что и у dev, лишь с другим именем, пространством имён и таймлайном.

Материализация ленивая: у проекта, который ещё не деплоился, ровно один compute (dev). Прод-таймлайн и его compute возникают при первом переводе в продакшн — так что длинный хвост никогда не деплоившихся экспериментов не несёт вообще никаких накладных расходов на продакшн.


Что это вам даёт

  • Работа с базой при деплое мгновенна и не зависит от размера данных. Это форк плюс сдвиг указателя, а не дамп/восстановление. База на 50 ГБ переходит в продакшн так же быстро, как и пустая.
  • Данные продакшна не теряются. Первый деплой по умолчанию запускает продакшн с чистой базой; повторные деплои сохраняют данные и только применяют к ним новые миграции. Данные dev попадают в живой продакшн только по явному решению владельца, и перед этим всегда создаётся точка восстановления.
  • Никакого расхождения окружений. Движок тот же, и разделяет окружения всего одна ветка: продакшн форкнут от dev и унаследовал его журнал миграций, поэтому деплой применяет только недостающий DDL, а не прогоняет вслепую все миграции заново на отдельно собранной базе.
  • Откат точен, а по запросу — вместе с данными. Закреплённый коммит деплоится заново; при желании данные продакшна возвращаются к состоянию времён этого релиза той же операцией «ветка на LSN», что и путешествие во времени для кода и данных, — только применённой к продакшну.
  • Простой ничего не стоит — в каждом окружении по отдельности. Каждый compute масштабируется до нуля, поэтому второе окружение не становится постоянной статьёй расходов: оно поднимается, когда к нему обращаются, и гаснет, когда не нужно.

Суть в двух словах

Перестаньте думать о продакшне как о месте, куда вы копируете свою базу данных, и начните думать о нём как о ветке, которую вы переводите в продакшн. На Postgres с разделёнными хранилищем и compute «деплой» перестаёт быть событием миграции данных с шагом копирования и риском расхождения и становится тем, чем должен быть: сдвигом указателя, который говорит «вот эту версию получают клиенты». Хранилище для этого уже есть — общее, с копированием при записи, и до любого окружения от него всего одна ветка.

Создавай на той самой платформе, о которой эти посты.

Опиши своё приложение простыми словами — igentik напишет код, настроит базу данных и выкатит его в онлайн.

Начать бесплатно