Change Data Capture (CDC): как читать изменения базы через WAL и Debezium

Change Data Capture на примерах: чтение WAL и binlog, Debezium и Kafka, почему dual write ломается, чем CDC отличается от outbox, порядок событий, снапшоты и эволюция схем.

13 мин чтениясистемный дизайн · базы данных · kafka · python

Коротко

ВопросОтвет
Что этоПоток всех вставок, обновлений и удалений из базы, который читают другие системы
Откуда берутся данныеИз журнала транзакций: WAL в Postgres, binlog в MySQL, oplog/change streams в MongoDB
Типичный стекDebezium в Kafka Connect читает журнал и пишет события в Kafka, по топику на таблицу
Какая гарантияAt-least-once и порядок изменений одной строки при ключе сообщения = первичный ключ
Где применяютСинхронизация поиска, кешей и хранилища, миграции между базами, публикация событий через outbox
Главные подводныеСлот репликации копит WAL, первоначальный снапшот, изменения схемы, связь потребителей с внутренней схемой БД

CDC превращает базу в источник событий, не трогая код приложения: всё, что зафиксировано в базе, попадёт в поток, и ничего лишнего.

Задача: данные должны жить в нескольких местах

Сервис каталога хранит товары в Postgres. Те же товары нужны в Elasticsearch для поиска, в Redis для карточки товара, в хранилище для аналитики. Как только у данных больше одного места, возникает вопрос: кто и как поддерживает копии в актуальном состоянии.

Есть три типовых ответа:

  1. Dual write — приложение само пишет и в базу, и во все остальные системы.
  2. Transactional outbox — приложение пишет событие в таблицу той же базы, а отдельный процесс доставляет его дальше. Подробно разобран в статье Transactional Outbox.
  3. Change Data Capture — никто ничего специально не пишет: внешний процесс читает журнал транзакций базы и превращает каждое изменение в событие.

Почему dual write ломается

Первая проблема очевидна: между записью в базу и записью в поиск процесс может упасть. Об этом подробно в статье про outbox. Вторая проблема коварнее и остаётся, даже если ничего не падает, — гонка.

db = {} search = {} # Два запроса меняют цену одного товара почти одновременно. # Планировщик ОС решил выполнить шаги в таком порядке: db['sku-1'] = 100 # A: запись в базу db['sku-1'] = 120 # B: запись в базу search['sku-1'] = 120 # B: запись в поиск search['sku-1'] = 100 # A: запись в поиск (A задержался на GC-паузе) print('база:', db['sku-1'], 'поиск:', search['sku-1']) # база: 120 поиск: 100

База упорядочила две записи одним способом, поиск — другим. Ошибок нет, ретраи не помогут, и расхождение останется навсегда, пока кто-то не поправит товар ещё раз. Порядок записей знает только база, и единственное место, где он зафиксирован, — её журнал.

Откуда CDC берёт изменения

Любая серьёзная СУБД сначала пишет изменение в журнал, а потом в страницы данных — это write-ahead log. Журнал уже существует ради надёжности и репликации, CDC просто становится ещё одной репликой, которая не применяет изменения у себя, а пересылает их дальше.

Существуют и другие способы, но у них серьёзные недостатки:

СпособПлюсыМинусы
Опрос по updated_atПросто, ничего не нужно настраивать в БДНе видит удалений, пропускает промежуточные версии, нагружает базу запросами
Триггеры в таблицу аудитаРаботает везде, видит удаленияУдваивает запись внутри каждой транзакции, триггеры легко забыть или сломать
Чтение журнала (log-based CDC)Все изменения в порядке коммитов, без нагрузки на записьНужны права репликации и настройка БД, свои особенности у каждой СУБД

Дальше речь только о чтении журнала.

Postgres: логическое декодирование

Физический WAL — это байты страниц, сторонней системе он бесполезен. Логическое декодирование переводит его в понятные строки: «в таблице orders вставлена строка с такими колонками». Что нужно включить:

-- postgresql.conf: wal_level = logical (нужен перезапуск) -- какие таблицы публикуем CREATE PUBLICATION debezium_pub FOR TABLE orders, products; -- старые значения всех колонок при UPDATE и DELETE, а не только ключ ALTER TABLE orders REPLICA IDENTITY FULL;

Позицию чтения хранит слот логической репликации. Пока потребитель не подтвердил, что прочитал изменения до какой-то позиции (LSN), Postgres не удаляет этот кусок WAL. Это гарантирует, что ничего не потеряется, и одновременно это главный источник аварий: остановили коннектор на выходные — диск заполнился журналом. Нужен алерт на отставание слота (pg_replication_slots), а с Postgres 13 есть max_slot_wal_keep_size, который жертвует слотом ради диска.

MySQL: binlog

У MySQL журнал для репликации — binlog, отдельный от внутреннего redo log InnoDB. Для CDC его пишут в строковом формате с полными образами строк:

-- my.cnf -- binlog_format = ROW -- binlog_row_image = FULL -- gtid_mode = ON -- позиция переживает переключение на реплику -- enforce_gtid_consistency = ON

Коннектор притворяется ещё одной репликой MySQL и читает binlog по протоколу репликации. Слотов нет: binlog удаляется по сроку хранения (binlog_expire_logs_seconds), и если коннектор отстал сильнее, позиция просто исчезнет — придётся делать снапшот заново.

Debezium и Kafka

Debezium — набор коннекторов для Kafka Connect, по одному на СУБД. Коннектор читает журнал и пишет каждое изменение в Kafka: по топику на таблицу, с именем вида <prefix>.<schema>.<table>. Фрагмент конфигурации для Postgres:

{ "name": "shop-cdc", "config": { "connector.class": "io.debezium.connector.postgresql.PostgresConnector", "plugin.name": "pgoutput", "database.hostname": "shop-db", "database.port": "5432", "database.user": "debezium", "database.dbname": "shop", "topic.prefix": "shop", "slot.name": "debezium_shop", "publication.name": "debezium_pub", "table.include.list": "public.orders,public.products", "snapshot.mode": "initial", "key.converter": "io.confluent.connect.avro.AvroConverter", "value.converter": "io.confluent.connect.avro.AvroConverter", "value.converter.schema.registry.url": "http://schema-registry:8081", "key.converter.schema.registry.url": "http://schema-registry:8081" } }

Событие об изменении — «конверт» со старым и новым состоянием строки и метаданными источника:

{ "before": { "id": 42, "status": "new", "total": 1500 }, "after": { "id": 42, "status": "paid", "total": 1500 }, "source": { "connector": "postgresql", "db": "shop", "schema": "public", "table": "orders", "txId": 90817, "lsn": 24023128, "snapshot": "false", "ts_ms": 1762851600000 }, "op": "u", "ts_ms": 1762851600120 }

Поле op: c — вставка, u — обновление, d — удаление, r — строка из снапшота, t — TRUNCATE. Ключ сообщения — первичный ключ строки. После удаления Debezium по умолчанию отправляет ещё и tombstone — сообщение с тем же ключом и пустым значением, чтобы log compaction в Kafka со временем стёр все версии строки.

Если Kafka в инфраструктуре нет и заводить её не хочется, есть Debezium Server (пишет в Kinesis, Pub/Sub, Redis Streams и другие) и встраиваемый движок для JVM-приложений. Но классическая схема — именно Kafka Connect.

Порядок событий

Kafka гарантирует порядок только внутри партиции. Debezium кладёт изменения одной строки с одним ключом, а значит, в одну партицию. Отсюда главное правило:

  • Порядок изменений одной строки сохраняется. Обновления orders/42 придут в том порядке, в каком их зафиксировала база.
  • Порядок между строками и таблицами — нет. Строка заказа и строки его позиций лежат в разных топиках, потребитель может увидеть позиции раньше заказа.
  • Границы транзакций теряются. Транзакция, изменившая три таблицы, превращается в три независимых события. Если это важно, в Debezium есть отдельный топик с метаданными транзакций (provide.transaction.metadata), но собирать транзакцию обратно придётся самому.

Не менее важно: никогда не меняйте число партиций в топике CDC «на лету». Ключ попадёт в другую партицию, и старые и новые версии строки будут читаться параллельно.

Дубли и идемпотентный потребитель

Kafka Connect сохраняет позицию в журнале (offset) периодически, а не после каждого события. Упал коннектор — после перезапуска часть событий придёт ещё раз. Поэтому стандартная гарантия CDC — at-least-once, и потребитель должен быть идемпотентным.

Для CDC это проще, чем кажется: событие несёт полное новое состояние строки, а не «прибавь 10». Применить его дважды безопасно, если не применять старое поверх нового. Модель в миниатюре:

from dataclasses import dataclass @dataclass class Change: lsn: int # позиция в журнале op: str # 'c' — insert, 'u' — update, 'd' — delete key: str after: dict | None class Database: """Таблица плюс журнал изменений, как WAL в миниатюре.""" def __init__(self): self.rows = {} self.log = [] def commit(self, op, key, value=None): if op == 'd': self.rows.pop(key, None) else: self.rows[key] = value self.log.append(Change(len(self.log) + 1, op, key, value)) class Replica: """Потребитель: поисковый индекс, кеш, хранилище — что угодно.""" def __init__(self): self.rows = {} self.offset = 0 # последний применённый LSN def apply(self, change): if change.lsn <= self.offset: return # дубль после перезапуска — пропускаем if change.op == 'd': self.rows.pop(change.key, None) else: self.rows[change.key] = change.after self.offset = change.lsn def stream(db, replica, crash_after=None): # Коннектор читает журнал с позиции, которую он сохранил раньше. # Сохраняет её не после каждого события, а пачками — отсюда дубли. start = replica.offset - 2 if replica.offset > 2 else 0 for i, change in enumerate(db.log[start:]): if crash_after is not None and i == crash_after: return replica.apply(change) db = Database() db.commit('c', 'sku-1', {'price': 100}) db.commit('c', 'sku-2', {'price': 50}) db.commit('u', 'sku-1', {'price': 120}) replica = Replica() stream(db, replica, crash_after=2) # упали посреди потока db.commit('d', 'sku-2') db.commit('u', 'sku-1', {'price': 90}) stream(db, replica) # перезапуск: часть событий придёт снова print(replica.rows == db.rows, replica.rows, replica.offset) # True {'sku-1': {'price': 90}} 5

В реальной системе потребителей много и партиций много, поэтому «последний LSN» хранят не глобально, а на каждую строку: например, в Elasticsearch через version_type=external с LSN в качестве версии. Тогда опоздавшее старое событие просто отклоняется.

Новые версии Kafka Connect (KIP-618) и Debezium умеют exactly-once на стороне источника, но это касается записи в Kafka, а не вашего индекса или кеша. Идемпотентность потребителя всё равно нужна.

Снапшот: откуда взять то, что было до CDC

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

log = [] # журнал: (lsn, key, value) rows = {} def commit(key, value): rows[key] = value log.append((len(log) + 1, key, value)) for i in range(5): commit(f'user-{i}', 'v1') def bootstrap(consistent): target = {} lsn_at_start = len(log) # позиция журнала на момент начала снапшота keys = sorted(rows) for n, key in enumerate(keys): target[key] = rows[key] # копируем таблицу построчно if n == 1: commit('user-4', 'v2') # пока копируем, приложение пишет commit('user-0', 'v2') start = lsn_at_start if consistent else len(log) for lsn, key, value in log[start:]: target[key] = value # дальше читаем поток с позиции start return target print(bootstrap(consistent=False) == rows) # стартуем поток с «сейчас» rows.clear(); log.clear() for i in range(5): commit(f'user-{i}', 'v1') print(bootstrap(consistent=True) == rows) # стартуем с LSN снапшота # False # True

Если начать поток с «текущего момента» после копирования, изменение user-0 теряется: строка уже скопирована, а событие осталось до точки старта. Правильно — запомнить позицию журнала в начале снапшота и читать поток с неё. Часть изменений при этом придёт дважды (user-4 скопирован уже в версии v2, а затем пришёл ещё раз), но это безопасно для идемпотентного потребителя.

Debezium так и делает в режиме snapshot.mode=initial: создаёт слот, открывает транзакцию с согласованным снимком на позиции слота, выгружает таблицы как события op: r, затем переключается на поток. Проблема классического снапшота — он долгий и непрерывный: таблица на сотни миллионов строк выгружается часами, и если коннектор упал на середине, всё начинается сначала.

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

Схемы и их эволюция

Событие CDC — это строка вашей таблицы. Значит, любая миграция немедленно становится изменением формата событий для всех потребителей.

  • Где хранится схема. В JSON-конвертере Debezium может вкладывать схему в каждое сообщение, что раздувает его в разы. В продакшене обычно используют Avro или Protobuf со Schema Registry: в сообщении только идентификатор схемы, сама схема в реестре.
  • Совместимость. Реестр проверяет новую версию схемы на совместимость (обычно BACKWARD). Добавить nullable-колонку можно. Удалить обязательную или поменять тип — сломать потребителей.
  • История DDL. Postgres передаёт описание таблицы в самом потоке логического декодирования, а коннектору MySQL приходится парсить DDL из binlog и хранить историю схемы в отдельном топике. Потеряли этот топик — коннектор не сможет разобрать старые события.
  • Postgres не реплицирует DDL. Добавили таблицу — её нужно добавить в публикацию, иначе изменения просто не попадут в поток.

Самое неприятное — связность. Как только аналитика и поиск читают таблицу orders напрямую, переименовать колонку становится межкомандным проектом. Внутренняя схема базы превратилась в публичный API.

CDC, outbox и dual write: что выбрать

Это не три конкурента, а скорее два уровня. Outbox — это способ сформировать событие, а CDC — способ его доставить. Самая надёжная схема — outbox, который читает Debezium с EventRouter.

КритерийDual writeOutbox (polling)CDC с бизнес-таблиц
Потеря при паденииВозможнаНетНет
Расхождение из-за гонокВозможноНетНет
Изменения кода приложенияВ каждой точке записиЗапись в outbox в транзакцииНикаких
Видит правки вручную и миграцииНетНетДа
Формат событияЛюбойБизнес-событие, контрактСтрока таблицы, внутренняя схема
ИнфраструктураНетРелейKafka Connect, слоты, реестр схем

Практическое правило:

  • Репликация данных — поисковый индекс, кеш, хранилище, миграция на другую базу: CDC с бизнес-таблиц. Вам нужна точная копия, а не бизнес-смысл, и важно поймать каждое изменение, включая ручные UPDATE.
  • События между сервисами — «заказ оплачен»: outbox (через CDC или polling). Потребителю нужен стабильный контракт, а не внутренние колонки.
  • Dual write — только если расхождение не страшно и есть периодическая сверка.

Отдельный хороший кейс для CDC — инвалидация кеша. Вместо того чтобы помнить про cache.delete в каждой точке записи, слушатель удаляет ключ по событию из журнала. Подробнее о стратегиях в статье про кеширование.

Как рассказывать на собеседовании

CDC всплывает в задачах вида «синхронизировать поиск с базой», «построить ленту», «перенести данные в новую базу без простоя». Хороший ответ укладывается в пять шагов:

  1. Назвать проблему dual write: падения и гонки.
  2. Предложить читать журнал транзакций: Debezium, слот репликации, Kafka.
  3. Сказать про гарантии: at-least-once, порядок по ключу, идемпотентный потребитель с версией по LSN.
  4. Объяснить первоначальную загрузку: согласованный снапшот или инкрементальный.
  5. Назвать риски: рост WAL при остановленном слоте, эволюция схем, связность с внутренней схемой и выбор outbox для доменных событий.

Вопросы, которые спросят дальше

  • Что будет, если коннектор лежал сутки? Postgres копит WAL ради слота — нужен мониторинг и лимит. MySQL может удалить binlog — понадобится новый снапшот.
  • Как переключиться на реплику при падении основной базы? В MySQL помогает GTID. В Postgres логические слоты исторически не переживали failover; в Postgres 17 появилась синхронизация слотов на standby, в старых версиях приходится пересоздавать слот и делать снапшот.
  • Как перенести базу без простоя? Снапшот в новую базу, затем поток CDC, пока отставание не станет близким к нулю, затем переключение записи. Это и есть основа большинства онлайн-миграций.
  • Чем это отличается от Event Sourcing? В Event Sourcing события — первоисточник, состояние вычисляется из них. В CDC первоисточник — таблица, события вторичны и описывают изменения строк, а не намерения пользователя.

Частые ошибки

  • Нет алерта на отставание слота. Классическая авария: коннектор упал в пятницу, к понедельнику на диске базы нет места.
  • Потребитель не идемпотентный. Перезапуск коннектора повторяет события, и счётчики, построенные на +1 за событие, уезжают.
  • Ожидание глобального порядка. Порядок есть только внутри ключа. События разных таблиц нужно уметь применять в любом порядке.
  • REPLICA IDENTITY DEFAULT, а потребителю нужен before. При обновлении и удалении в Postgres придёт только первичный ключ старой строки.
  • Удаления игнорируются. Индекс, который обрабатывает только c и u, со временем заполняется удалёнными товарами.
  • Отдать сырые таблицы другим командам как API. Через полгода любая миграция требует согласования с пятью потребителями. Для межсервисных событий используйте outbox.

Потренироваться в спокойной обстановке

Все задачи