Files
mtusi2026lab2/scripts/track2_restore.py
2026-10-16 05:27:13 +03:00

342 lines
22 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/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()