Change Data Capture (CDC): как читать изменения базы через WAL и Debezium
Change Data Capture на примерах: чтение WAL и binlog, Debezium и Kafka, почему dual write ломается, чем CDC отличается от outbox, порядок событий, снапшоты и эволюция схем.
Коротко
| Вопрос | Ответ |
|---|---|
| Что это | Поток всех вставок, обновлений и удалений из базы, который читают другие системы |
| Откуда берутся данные | Из журнала транзакций: WAL в Postgres, binlog в MySQL, oplog/change streams в MongoDB |
| Типичный стек | Debezium в Kafka Connect читает журнал и пишет события в Kafka, по топику на таблицу |
| Какая гарантия | At-least-once и порядок изменений одной строки при ключе сообщения = первичный ключ |
| Где применяют | Синхронизация поиска, кешей и хранилища, миграции между базами, публикация событий через outbox |
| Главные подводные | Слот репликации копит WAL, первоначальный снапшот, изменения схемы, связь потребителей с внутренней схемой БД |
CDC превращает базу в источник событий, не трогая код приложения: всё, что зафиксировано в базе, попадёт в поток, и ничего лишнего.
Задача: данные должны жить в нескольких местах
Сервис каталога хранит товары в Postgres. Те же товары нужны в Elasticsearch для поиска, в Redis для карточки товара, в хранилище для аналитики. Как только у данных больше одного места, возникает вопрос: кто и как поддерживает копии в актуальном состоянии.
Есть три типовых ответа:
- Dual write — приложение само пишет и в базу, и во все остальные системы.
- Transactional outbox — приложение пишет событие в таблицу той же базы, а отдельный процесс доставляет его дальше. Подробно разобран в статье Transactional Outbox.
- 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 write | Outbox (polling) | CDC с бизнес-таблиц |
|---|---|---|---|
| Потеря при падении | Возможна | Нет | Нет |
| Расхождение из-за гонок | Возможно | Нет | Нет |
| Изменения кода приложения | В каждой точке записи | Запись в outbox в транзакции | Никаких |
| Видит правки вручную и миграции | Нет | Нет | Да |
| Формат события | Любой | Бизнес-событие, контракт | Строка таблицы, внутренняя схема |
| Инфраструктура | Нет | Релей | Kafka Connect, слоты, реестр схем |
Практическое правило:
- Репликация данных — поисковый индекс, кеш, хранилище, миграция на другую базу: CDC с бизнес-таблиц. Вам нужна точная копия, а не бизнес-смысл, и важно поймать каждое изменение, включая ручные
UPDATE. - События между сервисами — «заказ оплачен»: outbox (через CDC или polling). Потребителю нужен стабильный контракт, а не внутренние колонки.
- Dual write — только если расхождение не страшно и есть периодическая сверка.
Отдельный хороший кейс для CDC — инвалидация кеша. Вместо того чтобы помнить про cache.delete в каждой точке записи, слушатель удаляет ключ по событию из журнала. Подробнее о стратегиях в статье про кеширование.
Как рассказывать на собеседовании
CDC всплывает в задачах вида «синхронизировать поиск с базой», «построить ленту», «перенести данные в новую базу без простоя». Хороший ответ укладывается в пять шагов:
- Назвать проблему dual write: падения и гонки.
- Предложить читать журнал транзакций: Debezium, слот репликации, Kafka.
- Сказать про гарантии: at-least-once, порядок по ключу, идемпотентный потребитель с версией по LSN.
- Объяснить первоначальную загрузку: согласованный снапшот или инкрементальный.
- Назвать риски: рост 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.