Write-Ahead Log (WAL): как базы данных не теряют записи при сбое
Что такое журнал упреждающей записи (WAL): правило write-ahead, fsync и group commit, восстановление после сбоя, checkpoint и репликация через WAL в PostgreSQL. С рабочим кодом на Python.
Коротко
| Вопрос | Ответ |
|---|---|
| Что это | Файл, куда каждое изменение дописывается в конец до того, как оно попадёт в основные данные |
| Какую задачу решает | Durability из ACID: подтверждённая транзакция переживает падение процесса и выключение питания |
| Главное правило | Сначала запись в журнал надёжно на диске (fsync), потом ответ клиенту, потом — когда угодно — данные |
| Что ещё даёт | Репликацию (реплика проигрывает тот же журнал), point-in-time recovery, CDC |
| Цена | fsync на каждый коммит — это миллисекунды; лечится group commit |
| Где встречается | PostgreSQL, MySQL InnoDB (redo log), SQLite в режиме WAL, RocksDB, etcd, Kafka |
- Журнал — это последовательная запись в конец файла. Она намного дешевле, чем обновление разбросанных по диску страниц таблиц и индексов.
- После сбоя база читает журнал от последнего checkpoint и заново применяет изменения. Так данные приводятся к последнему подтверждённому состоянию.
write()ещё не значит «на диске». Данные лежат в кэше ОС, пока не вызванfsync.- Журнал, который уже нужен для восстановления, удобно отдавать репликам: так работает потоковая репликация в PostgreSQL.
Проблема: изменение — это много записей в разные места
Возьмём простую транзакцию: перевести 100 рублей с одного счёта на другой. Физически базе нужно поменять две строки в таблице, возможно, пару страниц индекса и служебные структуры. Это несколько страниц по 8 КБ в разных частях файлов.
Если писать страницы на диск прямо во время коммита, возникают две проблемы:
- Медленно. Каждая страница — случайная запись в своё место, а коммит ждёт их все.
- Неатомарно. Если питание пропадёт между записью первой и второй страницы, деньги спишутся, но не зачислятся. Хуже того, сама страница может записаться наполовину (torn page): диск гарантирует атомарность обычно только для сектора, а страница больше.
Держать изменения только в памяти тоже нельзя: при падении процесса подтверждённая транзакция пропадёт, а это нарушает букву D в ACID. Об остальных буквах — в статье об уровнях изоляции транзакций.
Идея WAL
Решение — завести отдельный журнал и соблюдать одно правило:
Прежде чем изменённая страница данных попадёт на диск, на диске уже должна лежать запись журнала, описывающая это изменение.
Отсюда название: write-ahead — «пишем заранее». На практике цикл коммита выглядит так:
- Транзакция меняет страницы в памяти (в буферном кэше базы) и для каждого изменения формирует запись журнала.
- При
COMMITзаписи журнала дописываются в конец WAL-файла и вызываетсяfsync. - Только после успешного
fsyncклиент получает «OK». - Изменённые («грязные») страницы данных записываются на диск позже, в фоне, в удобном порядке.
Если сервер упадёт между шагами 3 и 4, ничего не потеряно: при старте база прочитает журнал и повторит изменения. Если упадёт до шага 3 — клиент не получил подтверждения, и транзакция считается неслучившейся.
Каждая запись журнала получает LSN (log sequence number) — монотонно растущую позицию в журнале. На каждой странице данных хранится LSN последнего изменения, которое в неё попало. При восстановлении это позволяет не применять запись повторно, если страница уже новее.
Классическое описание этого подхода — алгоритм ARIES (IBM, 1992). Современные СУБД устроены сложнее, но базовая логика та же.
fsync: где на самом деле лежат ваши данные
Самая частая ошибка в понимании WAL — считать, что write() что-то записал на диск. Путь байтов выглядит так:
буфер приложения → (write) → page cache ядра → (fsync) → кэш диска → носитель
write()копирует данные в кэш операционной системы и сразу возвращается. При падении процесса данные переживут: ядро их всё равно допишет. При падении ОС или питания — пропадут.fsync(fd)ждёт, пока ядро отправит данные на устройство и устройство подтвердит, что они на носителе.fdatasyncделает то же, но не обязательно сбрасывает метаданные вроде времени изменения.- Если файл создан или переименован, нужно сделать
fsyncи для каталога: иначе после сбоя файла может «не оказаться», хотя его содержимое записано.
fsync дорогой: на SSD это от десятков микросекунд до единиц миллисекунд, на HDD — до 10 мс. Если делать его на каждую транзакцию, пропускная способность упрётся в число fsync в секунду.
Group commit
Решение — group commit: пока идёт один fsync, другие транзакции успевают дописать свои записи в буфер журнала, и следующий fsync подтверждает их все разом. При высокой конкуренции один fsync закрывает десятки коммитов. PostgreSQL, MySQL и RocksDB делают это автоматически.
Ещё один рычаг — ослабить гарантию. В PostgreSQL synchronous_commit = off позволяет отвечать клиенту, не дожидаясь fsync. Целостность базы сохраняется, но при падении можно потерять последние доли секунды подтверждённых транзакций. Для логов и метрик это часто разумно, для платежей — нет.
Когда fsync возвращает ошибку
В 2018 году выяснилось, что после ошибки fsync Linux мог пометить грязные страницы как чистые, и повторный fsync возвращал успех, хотя данные так и не записались. PostgreSQL до этого просто повторял fsync и мог тихо потерять данные. Исправление было радикальным: теперь при ошибке fsync PostgreSQL аварийно останавливается и восстанавливается из WAL. Урок: ошибку fsync нельзя «повторить» — состояние кэша после неё неизвестно.
Реализация на Python
Минимальный журнал: каждая запись — заголовок с длиной и CRC32, затем JSON. Контрольная сумма нужна, чтобы при восстановлении отличить целую запись от недописанной в момент сбоя.
import json import os import struct import zlib HEADER = struct.Struct("<II") # длина payload, CRC32 payload class WAL: def __init__(self, path): self.path = path self.file = open(path, "ab") def append(self, record): payload = json.dumps(record).encode() self.file.write(HEADER.pack(len(payload), zlib.crc32(payload))) self.file.write(payload) def sync(self): self.file.flush() # из буфера Python в ядро os.fsync(self.file.fileno()) # из page cache ядра на диск def close(self): self.file.close() def replay(path): """Читает записи по порядку и останавливается на первой битой.""" records = [] with open(path, "rb") as f: while True: header = f.read(HEADER.size) if len(header) < HEADER.size: break # конец файла или оборванный заголовок length, crc = HEADER.unpack(header) payload = f.read(length) if len(payload) < length or zlib.crc32(payload) != crc: break # «хвост» недописанной записи records.append(json.loads(payload)) return records def apply(state, record): if record["op"] == "set": state[record["key"]] = record["value"] elif record["op"] == "del": state.pop(record["key"], None) path = "demo.wal" if os.path.exists(path): os.remove(path) wal = WAL(path) for rec in [ {"op": "set", "key": "alice", "value": 100}, {"op": "set", "key": "bob", "value": 50}, {"op": "del", "key": "alice"}, ]: wal.append(rec) wal.sync() # group commit: одна fsync на пачку записей wal.close() # Имитируем сбой посреди записи: дописываем половину записи with open(path, "ab") as f: f.write(HEADER.pack(100, 12345) + b'{"op": "se') state = {} for rec in replay(path): apply(state, rec) print(state) # {'bob': 50}
Обратите внимание на три вещи:
flush()иfsync()— разные шаги. Первый перекладывает данные из буфера Python в ядро, второй — из ядра на носитель.- Три записи подтверждены одним
fsync— это и есть group commit в миниатюре. - Битый хвост журнала — нормальная ситуация после сбоя, а не повреждение базы. Всё, что после него, клиенту не подтверждалось, поэтому восстановление просто останавливается на последней целой записи.
Операции в журнале должны быть идемпотентными при повторном применении, либо нужно знать, какие из них уже применены (для этого и нужен LSN). set и del из примера идемпотентны, а вот increment — нет. О том, почему это важно и за пределами баз данных, — в статье об идемпотентности.
Checkpoint: чтобы журнал не рос бесконечно
Если никогда не чистить журнал, он займёт весь диск, а восстановление будет проигрывать всю историю базы. Checkpoint решает обе проблемы:
- Записать на диск все грязные страницы (или, как в примере ниже, снимок состояния) и сделать
fsync. - Зафиксировать, до какого LSN данные теперь гарантированно на диске.
- Сегменты журнала до этой точки больше не нужны для восстановления — их можно удалить или переиспользовать.
import json import os def checkpoint(state, snapshot_path, wal_path): tmp = snapshot_path + ".tmp" with open(tmp, "w") as f: json.dump(state, f) f.flush() os.fsync(f.fileno()) os.replace(tmp, snapshot_path) # атомарная подмена файла dir_fd = os.open(os.path.dirname(os.path.abspath(snapshot_path)), os.O_RDONLY) os.fsync(dir_fd) # фиксируем саму операцию rename в каталоге os.close(dir_fd) open(wal_path, "wb").close() # снимок надёжен — старый журнал можно обнулить def recover(snapshot_path, wal_path): state = {} if os.path.exists(snapshot_path): with open(snapshot_path) as f: state = json.load(f) if os.path.exists(wal_path): for rec in replay(wal_path): apply(state, rec) return state
Порядок здесь принципиален: сначала новый снимок надёжно на диске, и только потом журнал обнуляется. Если поменять шаги местами и упасть между ними, данные пропадут. Запись во временный файл и os.replace нужны, чтобы при сбое посреди записи снимка не остаться с полуфайлом.
В PostgreSQL checkpoint выполняется по таймеру (checkpoint_timeout, по умолчанию 5 минут) или когда журнал вырос до max_wal_size (по умолчанию 1 ГБ). Компромисс понятный: частые checkpoint — быстрое восстановление, но больше фоновой записи; редкие — меньше нагрузки, но дольше подниматься после сбоя.
Отсюда же решение проблемы torn page: после каждого checkpoint PostgreSQL при первом изменении страницы пишет в журнал её полную копию (full_page_writes). Если страница при сбое записалась наполовину, её восстановят из этой копии.
Репликация через WAL
Журнал — это упорядоченный список всех изменений базы. Если отправить его другому серверу и там проиграть, получится реплика. Именно так работает потоковая (физическая) репликация в PostgreSQL:
- Основной сервер пишет WAL как обычно.
- Процесс
walsenderотправляет записи журнала репликам по мере появления. - На реплике
walreceiverсохраняет их, а процесс восстановления применяет, как после сбоя. Реплика фактически находится в вечном recovery.
Отсюда же синхронная и асинхронная репликация. При асинхронной мастер подтверждает коммит после локального fsync, и при его гибели последние транзакции могут не доехать до реплики. При синхронной (synchronous_standby_names) мастер ждёт подтверждения от реплики, и это добавляет сетевую задержку к каждому коммиту. Подробнее о компромиссах — в статье о шардировании и репликации.
Другие варианты того же принципа:
- Логическая репликация и CDC. Физический WAL описывает изменения байтов в страницах. Logical decoding превращает его в поток «вставлена строка, обновлена строка». Его читают Debezium и аналоги, чтобы отправлять изменения в Kafka. На этом построен паттерн transactional outbox.
- Point-in-time recovery. Если архивировать все сегменты WAL и иметь базовый бэкап, можно восстановить базу на любой момент, например за минуту до случайного
DROP TABLE. - Консенсус. В Raft реплицируется именно лог команд, и каждый узел обязан сделать
fsyncсвоей копии, прежде чем подтвердить запись лидеру. - Журнал как основа системы. Kafka — по сути распределённый WAL, доступный приложениям напрямую. С той же идеей связан event sourcing: журнал событий — источник правды, а состояние — производная.
Где ещё встречается WAL
- MySQL InnoDB — redo log для восстановления после сбоя. Для репликации MySQL использует отдельный журнал — binlog, и согласование двух журналов при коммите — отдельная интересная история.
- SQLite — режим
PRAGMA journal_mode=WAL: изменения пишутся в файл-wal, читатели не блокируют писателя. - LSM-хранилища — RocksDB и Cassandra пишут в WAL перед вставкой в memtable. Как это сочетается с остальной структурой, описано в статье про LSM-дерево.
- Файловые системы — ext4 и XFS ведут журнал метаданных по той же схеме.
Типичные ошибки и вопросы на собеседовании
«WAL — это лог для отладки». Нет, это не текстовый лог приложения. Это двоичная, строго упорядоченная запись изменений, без которой база не восстановится.
«Достаточно write() в журнал». Без fsync (или O_DSYNC) запись переживёт падение процесса, но не падение машины.
«Записи в журнале можно применять в любом порядке». Порядок и есть смысл журнала. Реплика, применившая изменения в другом порядке, придёт к другому состоянию.
«Чем больше реплик, тем надёжнее синхронный коммит». Да, но задержка коммита равна задержке самой медленной из реплик, которых ждёт мастер. Обычно ждут одну или кворум.
Частые вопросы:
- Почему писать в журнал и потом в таблицу быстрее, чем сразу в таблицу? — Журнал пишется последовательно, а страницы таблиц можно сбрасывать в фоне крупными пачками и объединять многократные изменения одной страницы.
- Что происходит при старте после сбоя? — Чтение журнала от последнего checkpoint, повтор изменений (redo), откат незавершённых транзакций.
- Зачем нужен checkpoint? — Ограничить размер журнала и время восстановления.
- Как сделать реплику базы? — Отдавать ей поток WAL и проигрывать его.
Итог
WAL — простая идея с большими последствиями: сначала надёжно записать намерение в конец журнала, а уже потом спокойно применять изменения. Она даёт атомарность и durability, превращает случайные записи в последовательные, а заодно бесплатно открывает дорогу к репликации, бэкапам на любой момент и CDC. На собеседовании достаточно уверенно объяснить правило write-ahead, роль fsync и group commit, зачем нужен checkpoint и как WAL превращается в репликацию.