#!/usr/bin/env python3 """Track 2, часть 2: backup → восстановление в новое хранилище → сверка. 1. В служебный чат track2-rpo пишутся K сообщений «до backup». 2. Снимается отпечаток исходной БД (счётчики, md5 таблиц, страницы чатов). 3. pg_dump -Fc из сервиса db в backups/ (каталог в .gitignore). 4. В исходную БД пишутся N сообщений «после backup» — их не должно быть в восстановленной копии (граница потери данных логического backup). 5. Новый контейнер postgres:16-alpine с новым пустым volume, pg_restore по секциям pre-data / data / post-data с замером каждой. 6. Сверка отпечатков, страниц, RPO-маркеров и плана запроса на копии. 7. Контейнер и volume копии удаляются (если не указан --keep). Результат: evidence/track2_restore.md. python3 scripts/track2_restore.py python3 scripts/track2_restore.py --jobs 4 --keep """ import argparse import secrets import subprocess import time from pathlib import Path from track2_common import (ENV, MESSAGE_COLS, PERF_USER_ID, ROOT, Pg, dataset_lines, environment_lines, pick_chats, write_evidence) IMAGE = "postgres:16-alpine" RPO_CHAT_TITLE = "track2-rpo" PAGE = 50 src = Pg.compose() FINGERPRINT_SQL = """ SELECT 'count.users', count(*)::text FROM users UNION ALL SELECT 'count.chats', count(*)::text FROM chats UNION ALL SELECT 'count.chat_members', count(*)::text FROM chat_members UNION ALL SELECT 'count.messages', count(*)::text FROM messages UNION ALL SELECT 'count.sessions', count(*)::text FROM sessions UNION ALL SELECT 'schema_migrations', string_agg(version::text, ',' ORDER BY version) FROM schema_migrations UNION ALL SELECT 'md5.users', md5(coalesce(string_agg( id::text || '|' || username || '|' || display_name || '|' || password_hash || '|' || extract(epoch FROM created_at)::text, E'\\n' ORDER BY id), '')) FROM users UNION ALL SELECT 'md5.chats', md5(coalesce(string_agg( id::text || '|' || title || '|' || extract(epoch FROM created_at)::text, E'\\n' ORDER BY id), '')) FROM chats UNION ALL SELECT 'md5.chat_members', md5(coalesce(string_agg( chat_id::text || '|' || user_id::text, E'\\n' ORDER BY chat_id, user_id), '')) FROM chat_members UNION ALL SELECT 'md5.messages', md5(coalesce(string_agg( id::text || '|' || chat_id::text || '|' || sender_id::text || '|' || text || '|' || extract(epoch FROM created_at)::text, E'\\n' ORDER BY id), '')) FROM messages UNION ALL SELECT 'md5.sessions', md5(coalesce(string_agg( token || '|' || user_id::text || '|' || extract(epoch FROM expires_at)::text, E'\\n' ORDER BY token), '')) FROM sessions UNION ALL SELECT 'md5.messages_per_chat', md5(coalesce(string_agg( chat_id::text || ':' || n::text, ',' ORDER BY chat_id), '')) FROM (SELECT chat_id, count(*) AS n FROM messages GROUP BY chat_id) s; """ def fingerprint(db): return {k: v for k, v in db.rows(FINGERPRINT_SQL)} def page_queries(chats): """Страницы теми же запросами, что у приложения: первая, keyset из середины, последняя.""" qs = {} for label, (cid, _, n) in chats: ts, mid = src.rows(f""" SELECT created_at::text, id FROM messages WHERE chat_id = '{cid}' ORDER BY created_at, id OFFSET {n // 2} LIMIT 1; """)[0] base = f"SELECT {MESSAGE_COLS} FROM messages WHERE chat_id = '{cid}'" qs[f"{label}.first"] = f"{base} ORDER BY created_at ASC, id ASC LIMIT {PAGE}" qs[f"{label}.middle"] = (f"{base} AND (created_at, id) > ('{ts}'::timestamptz, '{mid}'::uuid) " f"ORDER BY created_at ASC, id ASC LIMIT {PAGE}") qs[f"{label}.last"] = (f"SELECT * FROM ({base} ORDER BY created_at DESC, id DESC " f"LIMIT {PAGE}) t ORDER BY created_at_epoch, id") return qs def fetch_pages(db, qs): return {k: db.rows(q + ";") for k, q in qs.items()} def ensure_rpo_chat(): cid = src.scalar(f"SELECT id FROM chats WHERE title = '{RPO_CHAT_TITLE}' LIMIT 1;") if cid: return cid return src.scalar(f""" WITH c AS ( INSERT INTO chats (id, title, created_at) VALUES (gen_random_uuid(), '{RPO_CHAT_TITLE}', now()) RETURNING id ), m AS ( INSERT INTO chat_members (chat_id, user_id) SELECT id, '{PERF_USER_ID}' FROM c ) SELECT id FROM c; """) def insert_marker(cid, tag, n): src.psql(f""" INSERT INTO messages (id, chat_id, sender_id, text, created_at) SELECT gen_random_uuid(), '{cid}', '{PERF_USER_ID}', '{tag}-' || g, date_trunc('second', clock_timestamp()) FROM generate_series(1, {n}) AS g; """) def count_marker(db, tag): return int(db.scalar(f"SELECT count(*) FROM messages WHERE text LIKE '{tag}-%';")) def sh(cmd, **kw): return subprocess.run(cmd, check=True, capture_output=True, text=True, cwd=ROOT, **kw) def timed(fn): t0 = time.perf_counter() result = fn() return result, time.perf_counter() - t0 def start_restore_storage(name, volume): sh(["docker", "volume", "create", volume]) sh(["docker", "run", "-d", "--name", name, "-e", f"POSTGRES_USER={ENV['POSTGRES_USER']}", "-e", f"POSTGRES_PASSWORD={secrets.token_hex(16)}", "-e", f"POSTGRES_DB={ENV['POSTGRES_DB']}", "-v", f"{volume}:/var/lib/postgresql/data", IMAGE]) # Во время initdb сервер слушает только unix-socket; TCP-готовность # означает, что поднят окончательный сервер. for _ in range(120): r = subprocess.run(["docker", "exec", name, "pg_isready", "-h", "127.0.0.1", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"]], capture_output=True) if r.returncode == 0: return time.sleep(0.25) raise SystemExit("восстановительный PostgreSQL не поднялся за 30 с") def main(): p = argparse.ArgumentParser(description=__doc__.split("\n")[0]) p.add_argument("--before", type=int, default=100, help="маркеров до backup") p.add_argument("--after", type=int, default=37, help="маркеров после backup") p.add_argument("--jobs", type=int, default=1, help="pg_restore -j для data/post-data") p.add_argument("--keep", action="store_true", help="не удалять контейнер и volume копии") args = p.parse_args() run_id = time.strftime("%Y%m%d%H%M%S") tag_before, tag_after = f"track2-rpo-before-{run_id}", f"track2-rpo-after-{run_id}" name, volume = f"track2-restore-{run_id}", f"track2_restore_{run_id}" backups = ROOT / "backups" backups.mkdir(exist_ok=True) dump_path = backups / f"track2_{run_id}.dump" chats = pick_chats(src) rpo_chat = ensure_rpo_chat() insert_marker(rpo_chat, tag_before, args.before) env, dataset = environment_lines(src), dataset_lines(src) print("\n".join(env + dataset)) print(f"\n[1] записано {args.before} сообщений до backup") qs = page_queries(chats) fp_src = fingerprint(src) pages_src = fetch_pages(src, qs) db_size = int(src.scalar(f"SELECT pg_database_size('{ENV['POSTGRES_DB']}');")) print(f"[2] отпечаток исходной БД: {fp_src['count.messages']} сообщений") with open(dump_path, "wb") as f: _, t_dump = timed(lambda: src.run( ["pg_dump", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"], "-Fc"], binary=True, stdout=f)) dump_size = dump_path.stat().st_size print(f"[3] pg_dump: {t_dump:.2f} s, {dump_size / 1048576:.1f} MiB → {dump_path.relative_to(ROOT)}") insert_marker(rpo_chat, tag_after, args.after) print(f"[4] записано {args.after} сообщений после backup") dst = Pg.container(name) timings = {} try: _, timings["storage"] = timed(lambda: start_restore_storage(name, volume)) print(f"[5] новое хранилище {name} (volume {volume}): {timings['storage']:.2f} s") _, timings["copy"] = timed(lambda: sh(["docker", "cp", str(dump_path), f"{name}:/tmp/db.dump"])) for section in ("pre-data", "data", "post-data"): cmd = ["pg_restore", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"], "--no-owner", "--exit-on-error", f"--section={section}"] if section != "pre-data" and args.jobs > 1: cmd += ["-j", str(args.jobs)] _, timings[section] = timed(lambda: dst.run(cmd + ["/tmp/db.dump"])) print(f" pg_restore --section={section}: {timings[section]:.2f} s") dst.psql("ANALYZE;") fp_dst, t_verify = timed(lambda: fingerprint(dst)) pages_dst = fetch_pages(dst, qs) fp_src_now = fingerprint(src) rpo = { "before_dst": count_marker(dst, tag_before), "after_dst": count_marker(dst, tag_after), "after_src": count_marker(src, tag_after), } plan_dst = dst.psql(f"EXPLAIN (ANALYZE, BUFFERS) {qs['large.middle']};", tuples=False).strip() indexes_dst = dst.scalar( "SELECT string_agg(indexname, ', ' ORDER BY indexname) FROM pg_indexes " "WHERE schemaname = 'public';") version_dst = dst.scalar("SHOW server_version;") sample = pages_src["large.middle"][:3] finally: if args.keep: print(f"\nкопия оставлена: docker exec -it {name} psql -U {ENV['POSTGRES_USER']} {ENV['POSTGRES_DB']}") else: subprocess.run(["docker", "rm", "-f", name], capture_output=True) subprocess.run(["docker", "volume", "rm", volume], capture_output=True) print(f"\nконтейнер {name} и volume {volume} удалены") # ---------- сверка ---------- checks = [] for key in sorted(fp_src): checks.append((key, fp_src[key], fp_dst.get(key), fp_src[key] == fp_dst.get(key))) pages_ok = {k: pages_src[k] == pages_dst[k] for k in qs} rpo_ok = (rpo["before_dst"] == args.before and rpo["after_dst"] == 0 and rpo["after_src"] == args.after) plan_ok = "messages_chat_keyset_idx" in plan_dst diverged = sorted(k for k in fp_src_now if fp_src_now[k] != fp_dst.get(k)) all_ok = all(c[3] for c in checks) and all(pages_ok.values()) and rpo_ok and plan_ok print("\nPASS: копия совпадает со снимком" if all_ok else "\nFAIL: есть расхождения") rto = timings["storage"] + timings["copy"] + timings["pre-data"] + timings["data"] + timings["post-data"] restore_only = timings["pre-data"] + timings["data"] + timings["post-data"] post_share = timings["post-data"] / restore_only * 100 throughput = db_size / 1048576 / restore_only md = ["# Track 2. Backup → восстановление в новое хранилище → сверка", "", f"Сгенерировано `python3 scripts/track2_restore.py --before {args.before} " f"--after {args.after} --jobs {args.jobs}`. Итог: **{'PASS' if all_ok else 'FAIL'}**.", "", "## Окружение и данные", "", *env, *dataset, f"- Размер БД `pg_database_size`: {db_size / 1048576:.1f} MiB; " f"восстановлено в PostgreSQL {version_dst} (`{IMAGE}`, новый пустой volume)", "", "## Гипотезы", "", "- **H4.** Логический backup (`pg_dump -Fc`) восстанавливается в пустое хранилище без " "потерь: совпадают счётчики, содержимое всех таблиц и страницы истории.", "- **H5.** Время восстановления заметно определяется построением индексов и " "ограничений (секция post-data), а не только загрузкой строк.", "- **H6.** Граница потери данных (RPO) логического backup — момент его снимка: всё, что " "подтверждено COMMIT после начала `pg_dump`, в копии отсутствует.", "", "## Методика", "", f"1. В служебный чат `{RPO_CHAT_TITLE}` записано {args.before} сообщений с меткой «до».", "2. Снят отпечаток исходной БД: `count(*)` и md5 упорядоченного содержимого каждой " "таблицы, md5 числа сообщений по чатам, страницы истории (первая, keyset из середины, " "последняя) для чатов small/medium/large/burst — теми же запросами, что у приложения.", "3. `pg_dump -Fc` из работающего сервиса `db` в `backups/` (не в Git).", f"4. В исходную БД записано {args.after} сообщений с меткой «после».", "5. `docker volume create` + `docker run postgres:16-alpine`: новое хранилище; " "`pg_restore --section=pre-data|data|post-data` с замером каждой секции.", "6. Сверка отпечатков, страниц, маркеров и плана запроса на копии; копия удаляется.", "", "## Время", "", "| Этап | Время, s |", "|---|---|", f"| pg_dump (backup) | {t_dump:.2f} |", f"| Запуск нового хранилища (initdb + старт) | {timings['storage']:.2f} |", f"| Копирование дампа в контейнер | {timings['copy']:.2f} |", f"| pg_restore pre-data (схема) | {timings['pre-data']:.2f} |", f"| pg_restore data (COPY строк) | {timings['data']:.2f} |", f"| pg_restore post-data (PK, FK, индексы) | {timings['post-data']:.2f} |", f"| **RTO: от пустого хоста до готовой БД** | **{rto:.2f}** |", f"| Сверка отпечатков (вне RTO) | {t_verify:.2f} |", "", f"Размер дампа: {dump_size / 1048576:.1f} MiB (сжатие custom-формата, " f"{db_size / max(dump_size, 1):.1f}× меньше БД).", "", "## Сверка", "", "| Проверка | Исходная (снимок) | Копия | Совпадает |", "|---|---|---|---|"] for key, a, b, ok in checks: short = (lambda v: v if v is None or len(v) <= 20 else v[:12] + "…") md.append(f"| {key} | `{short(a)}` | `{short(b)}` | {'да' if ok else '**НЕТ**'} |") for key, ok in pages_ok.items(): md.append(f"| страница {key} ({len(pages_src[key])} строк) | — | — | {'да' if ok else '**НЕТ**'} |") md += [f"| план Q2 на копии использует messages_chat_keyset_idx | — | — | {'да' if plan_ok else '**НЕТ**'} |", "", "Пример выбранных сообщений (large, keyset из середины), одинаковы в обеих БД:", "", "| id | chat_id | created_at (epoch) | text |", "|---|---|---|---|"] for row in sample: md.append(f"| `{row[0]}` | `{row[1][:8]}…` | {row[4]} | {row[3]} |") md += ["", "Индексы на копии: " + indexes_dst, "", "## Граница потери данных", "", "| Маркер | В исходной БД | В копии | Ожидание |", "|---|---|---|---|", f"| до backup | {args.before} | {rpo['before_dst']} | все есть |", f"| после backup | {rpo['after_src']} | {rpo['after_dst']} | нет ни одного |", "", "После записи маркеров «после» исходная БД разошлась с копией по: " + (", ".join(f"`{k}`" for k in diverged) or "—") + ".", "", "## Выводы", "", f"**H4 — {'подтверждена' if all(c[3] for c in checks) and all(pages_ok.values()) else 'НЕ подтверждена'}.** " f"Все {len(checks)} отпечатков (счётчики и md5 содержимого users, chats, chat_members, " f"messages, sessions, schema_migrations, распределение по чатам) и {len(pages_ok)} страниц " f"истории совпали. На копии восстановлены индексы, и тот же keyset-запрос идёт через " f"`messages_chat_keyset_idx`. Таблица `schema_migrations` восстановлена, поэтому API, " f"направленный на копию, не будет повторно применять миграции.", "", f"**H5 — {'подтверждена' if post_share >= 25 else 'частично'}.** " f"post-data заняла {timings['post-data']:.2f} s из {restore_only:.2f} s pg_restore " f"({post_share:.0f}%): PK и вторичные индексы строятся заново после загрузки строк. " f"Полный RTO {rto:.1f} s, из них {timings['storage']:.1f} s — запуск пустого PostgreSQL. " f"Скорость восстановления ≈ {throughput:.0f} MiB/s БД; при линейной экстраполяции " f"10× данных ≈ {restore_only * 10:.0f} s только на pg_restore (оценка: построение " f"индексов растёт как n·log n, а при данных больше RAM появится дисковый I/O). " f"Ускорение — `pg_restore -j N` для data/post-data или физический backup " f"(`pg_basebackup`), который не перестраивает индексы.", "", f"**H6 — {'подтверждена' if rpo_ok else 'НЕ подтверждена'}.** " f"Все {args.before} сообщений до backup есть в копии, ни одного из {args.after} после — нет, " f"хотя они подтверждены COMMIT в исходной БД. `pg_dump` читает один согласованный снимок " f"(REPEATABLE READ) на момент старта, поэтому RPO = время с начала последнего backup. " f"При backup раз в сутки можно потерять до суток сообщений; чтобы уменьшить RPO до секунд, " f"нужен непрерывный архив WAL (`archive_mode` + pgBackRest/wal-g) и PITR " f"или потоковая реплика.", "", "**Сессии.** " + ("Сессии хранятся в Valkey (`SESSION_STORE=redis`) и в дамп PostgreSQL не входят. " "Если Valkey цел, старые токены работают и с восстановленной БД: `user_id` сохранились. " "Если потерян и Valkey, пользователи логинятся заново; при AOF `appendfsync everysec` " "можно потерять до ~1 s новых сессий. Таблица `sessions` в PostgreSQL (резервный " "режим `SESSION_STORE=postgres`) восстанавливается вместе с дампом." if ENV.get("SESSION_STORE", "redis") == "redis" else "Сессии хранятся в PostgreSQL и восстанавливаются вместе с дампом; сессии, созданные " "после backup, теряются, а logout после backup «воскрешает» отозванный токен до его expiry."), "", "**COMMIT и durability.** При `synchronous_commit=on` подтверждённая транзакция уже " "записана в WAL на диск и переживает рестарт контейнера, но не потерю volume/диска: " "от этого защищает только копия на другом носителе. Здесь дамп лежит на том же хосте, " "поэтому эксперимент доказывает процедуру восстановления, а не защиту от потери хоста.", "", "## Ограничения", "", "- Один хост, тёплый page cache; дамп и копия на том же диске.", "- Во время backup не было внешней нагрузки; при нагрузке pg_dump длится дольше, но " "снимок остаётся согласованным.", "- RTO не включает переключение API на новую БД (смена секрета `database_url` и рестарт api).", "- Сверка md5 упорядоченного содержимого требует чтения всех таблиц; на больших объёмах " "её заменяют выборочной сверкой и счётчиками.", "", "## План keyset-запроса на восстановленной копии", "", "```", plan_dst, "```", ""] write_evidence("track2_restore.md", "\n".join(md)) if not all_ok: raise SystemExit(1) if __name__ == "__main__": main()