Files
mtusi2026lab2/scripts/track2_backup_restore.py
vest1ter ac1317d22e ЛР2 на 5: Redis-кэш сессий, отказоустойчивость, трек 2 (индексы и восстановление)
Уровень 4:
- Redis как кэш сессий (cache-aside, источник истины — PostgreSQL): TTL <= остатка сессии,
  метка revoked при logout + SET NX против гонки, при отказе Redis — работа через базу
  и фоновая проверка доступности
- тесты: гонка регистрации, откат посреди транзакции, недоступность БД и Redis (44 теста)
- EXPLAIN (ANALYZE, BUFFERS) на 22 000 сообщений, history_query общий для API и скрипта
- эксперименты отказа Redis/PostgreSQL под нагрузкой; dns_opt у API, чтобы отказ БД
  давал быстрый 503, а не зависание на поиске имени остановленного контейнера

Уровень 5, трек 2:
- 105 000 сообщений в неравномерных чатах, 4 варианта индекса + OFFSET против keyset,
  стоимость записи (время, WAL), два независимых прогона
- pg_dump -> pg_restore в новый контейнер -> сверка md5 всех таблиц и выборки сообщений,
  RTO 14 с, демонстрация RPO
2026-10-29 15:42:37 +03:00

216 lines
13 KiB
Python

#!/usr/bin/env python3
"""Трек 2 (оценка «5»), часть 2: backup -> восстановление в НОВОЕ хранилище -> сверка.
Источник — база messenger_bench (≈105 000 сообщений, см. scripts/track2_indexes.py) в контейнере
postgres из compose.yaml.
1. «Отпечаток» источника: число строк и md5 содержимого каждой таблицы (строки по PK),
плюс выборка сообщений: первые/последние в чате каждого класса и 20 псевдослучайных.
2. pg_dump -Fc (согласованный снимок в одной транзакции) -> backups/ (вне Git); время, размер, sha256.
3. Граница потери данных (RPO): после дампа в источник пишутся ещё 100 сообщений — их в бэкапе нет.
4. Новое хранилище: отдельный контейнер postgres того же образа со своим пустым volume, без портов
наружу; pg_restore -j 4. Замеряются запуск, восстановление и общее время (RTO).
5. Сверка восстановленной базы с отпечатком: счётчики, md5 таблиц, выборка сообщений по полям,
версия миграций, индексы и план запроса истории.
6. Временный контейнер и его volume удаляются (--keep оставляет), 100 «поздних» сообщений
из источника удаляются.
Запуск (стенд lab2 поднят, данные бенчмарка есть):
python scripts/track2_backup_restore.py
Результаты: evidence/track2-backup-restore.json и .md
"""
import argparse
import hashlib
import json
import secrets
import subprocess
import time
from datetime import datetime, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
DB = 'messenger_bench'
IMAGE = 'postgres:17.10-alpine@sha256:979c4379dd698aba0b890599a6104e082035f98ef31d9b9291ec22f2b13059ca'
RESTORE_CONTAINER = 'mtusi-lab2-restore-check'
RESTORE_VOLUME = 'mtusi-lab2-restore-check-data'
# Таблица -> порядок строк для контрольной суммы (первичный ключ).
TABLES = {
'alembic_version': 'version_num',
'users': 'id',
'sessions': 'token_hash',
'chats': 'id',
'chat_members': 'chat_id, user_id',
'messages': 'id',
}
CLASSES = ['huge', 'medium', 'small', 'tiny']
def run(args, timeout=600, **kwargs):
proc = subprocess.run(args, cwd=ROOT, capture_output=True, timeout=timeout, **kwargs)
if proc.returncode != 0:
raise SystemExit('FAIL: ' + ' '.join(args[:4]) + ': ' + proc.stderr.decode('utf-8', 'replace')[-400:])
return proc.stdout
def source_container():
return run(['docker', 'compose', 'ps', '-q', 'postgres']).decode().strip()
def psql(container, user, sql):
"""Выполнить SQL внутри контейнера (локальный сокет, без пароля); строки с разделителем |."""
out = run(['docker', 'exec', '-i', container, 'psql', '-U', user, '-d', DB, '-v', 'ON_ERROR_STOP=1',
'-At', '-F', '|', '-c', sql])
return [line.split('|') for line in out.decode('utf-8').splitlines() if line]
def fingerprint(container, user, sample_ids):
counts = {t: int(psql(container, user, f'SELECT count(*) FROM {t}')[0][0]) for t in TABLES}
sums = {t: psql(container, user, f"SELECT coalesce(md5(string_agg(md5(x::text), '' ORDER BY {order})), 'empty')"
f" FROM {t} x")[0][0] for t, order in TABLES.items()}
ids = ",".join(f"'{i}'" for i in sample_ids)
rows = psql(container, user, "SELECT id, chat_id, sender_id, created_at, length(text), md5(text) "
f"FROM messages WHERE id IN ({ids}) ORDER BY id")
return {'counts': counts, 'md5': sums, 'sample': {r[0]: r[1:] for r in rows}}
def pick_sample(container, user):
ids = []
for cls in CLASSES:
chat = psql(container, user, "SELECT c.id FROM chats c JOIN messages m ON m.chat_id = c.id "
f"WHERE c.title LIKE '{cls} %' GROUP BY c.id ORDER BY count(*) DESC LIMIT 1")[0][0]
for direction in ('ASC', 'DESC'):
ids += [r[0] for r in psql(container, user, f"SELECT id FROM messages WHERE chat_id = '{chat}' "
f"ORDER BY created_at {direction}, id {direction} LIMIT 2")]
ids += [r[0] for r in psql(container, user, "SELECT id FROM messages ORDER BY md5(id::text) LIMIT 20")]
return sorted(set(ids))
def wait_ready(container, timeout=120):
"""Официальный образ при первом старте поднимает временный сервер для init и перезапускается:
ждём сообщения об окончании init и затем pg_isready."""
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
proc = subprocess.run(['docker', 'logs', container], capture_output=True)
logs = (proc.stdout + proc.stderr).decode('utf-8', 'replace')
if 'PostgreSQL init process complete' in logs and subprocess.run(
['docker', 'exec', container, 'pg_isready', '-U', 'postgres'], capture_output=True).returncode == 0:
return
time.sleep(0.5)
raise SystemExit('FAIL: restore container did not become ready')
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument('--keep', action='store_true', help='не удалять временный контейнер восстановления')
p.add_argument('--late-writes', type=int, default=100, help='сообщений, записанных после бэкапа')
p.add_argument('--output', default=str(ROOT / 'evidence'))
args = p.parse_args()
src = source_container()
if not src:
raise SystemExit('FAIL: postgres from compose.yaml is not running')
sample_ids = pick_sample(src, 'messenger')
before = fingerprint(src, 'messenger', sample_ids)
if before['counts']['messages'] < 100000:
raise SystemExit('FAIL: run scripts/track2_indexes.py first (need ≥100 000 messages)')
# 1. Backup.
backups = ROOT / 'backups'
backups.mkdir(exist_ok=True)
dump = backups / f'{DB}.dump'
t = time.perf_counter()
with dump.open('wb') as out:
proc = subprocess.run(['docker', 'exec', src, 'pg_dump', '-U', 'messenger', '-d', DB, '-Fc'],
stdout=out, stderr=subprocess.PIPE, timeout=600)
if proc.returncode != 0:
raise SystemExit('FAIL: pg_dump: ' + proc.stderr.decode('utf-8', 'replace')[-400:])
dump_seconds = time.perf_counter() - t
dump_sha = hashlib.sha256(dump.read_bytes()).hexdigest()
# 2. Запись после бэкапа: эти сообщения при восстановлении из дампа будут потеряны (RPO).
chat, sender = psql(src, 'messenger', "SELECT chat_id, user_id FROM chat_members LIMIT 1")[0]
psql(src, 'messenger', f"INSERT INTO messages (chat_id, sender_id, text) SELECT '{chat}', '{sender}', "
f"'after-backup ' || g FROM generate_series(1, {args.late_writes}) g")
source_after = int(psql(src, 'messenger', "SELECT count(*) FROM messages")[0][0])
# 3. Новое хранилище и восстановление.
subprocess.run(['docker', 'rm', '-f', '-v', RESTORE_CONTAINER], capture_output=True)
subprocess.run(['docker', 'volume', 'rm', RESTORE_VOLUME], capture_output=True)
t_rto = time.perf_counter()
run(['docker', 'run', '-d', '--name', RESTORE_CONTAINER, '-v', f'{RESTORE_VOLUME}:/var/lib/postgresql/data',
'-e', 'POSTGRES_PASSWORD=' + secrets.token_urlsafe(24), IMAGE])
wait_ready(RESTORE_CONTAINER)
start_seconds = time.perf_counter() - t_rto
t = time.perf_counter()
run(['docker', 'cp', str(dump), f'{RESTORE_CONTAINER}:/tmp/restore.dump'])
run(['docker', 'exec', RESTORE_CONTAINER, 'createdb', '-U', 'postgres', DB])
run(['docker', 'exec', RESTORE_CONTAINER, 'pg_restore', '-U', 'postgres', '-d', DB, '-j', '4',
'--no-owner', '--no-privileges', '/tmp/restore.dump'])
run(['docker', 'exec', RESTORE_CONTAINER, 'psql', '-U', 'postgres', '-d', DB, '-c', 'ANALYZE'])
restore_seconds = time.perf_counter() - t
rto_seconds = time.perf_counter() - t_rto
# 4. Сверка.
after = fingerprint(RESTORE_CONTAINER, 'postgres', sample_ids)
count_ok = before['counts'] == after['counts']
md5_ok = before['md5'] == after['md5']
sample_ok = before['sample'] == after['sample'] and len(after['sample']) == len(sample_ids)
indexes = [r[0] for r in psql(RESTORE_CONTAINER, 'postgres',
"SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY 1")]
huge = psql(RESTORE_CONTAINER, 'postgres', "SELECT c.id FROM chats c WHERE c.title = 'huge 0'")[0][0]
plan = "\n".join(r[0] for r in psql(RESTORE_CONTAINER, 'postgres',
"EXPLAIN (ANALYZE, BUFFERS) SELECT id, chat_id, sender_id, created_at, text "
f"FROM messages WHERE chat_id = '{huge}' ORDER BY created_at, id LIMIT 51"))
late_in_restore = int(psql(RESTORE_CONTAINER, 'postgres',
"SELECT count(*) FROM messages WHERE text LIKE 'after-backup %'")[0][0])
restored_size = psql(RESTORE_CONTAINER, 'postgres', f"SELECT pg_size_pretty(pg_database_size('{DB}'))")[0][0]
source_version = psql(src, 'messenger', 'SELECT version_num FROM alembic_version')[0][0]
restored_version = psql(RESTORE_CONTAINER, 'postgres', 'SELECT version_num FROM alembic_version')[0][0]
# 5. Уборка.
psql(src, 'messenger', "DELETE FROM messages WHERE text LIKE 'after-backup %'")
if not args.keep:
subprocess.run(['docker', 'rm', '-f', '-v', RESTORE_CONTAINER], capture_output=True)
subprocess.run(['docker', 'volume', 'rm', RESTORE_VOLUME], capture_output=True)
report = {
'generated_at': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'),
'source': f'compose service postgres, database {DB}', 'target': f'new container {RESTORE_CONTAINER} '
f'(same image, empty volume {RESTORE_VOLUME}, no published ports)',
'backup': {'tool': 'pg_dump -Fc (one consistent snapshot)', 'seconds': round(dump_seconds, 2),
'bytes': dump.stat().st_size, 'sha256': dump_sha},
'restore': {'tool': 'pg_restore -j 4 --no-owner --no-privileges + ANALYZE',
'container_start_seconds': round(start_seconds, 2), 'restore_seconds': round(restore_seconds, 2),
'rto_seconds': round(rto_seconds, 2), 'restored_database_size': restored_size},
'verification': {
'row_counts_equal': count_ok, 'table_md5_equal': md5_ok, 'sample_messages_equal': sample_ok,
'sample_size': len(sample_ids), 'counts': after['counts'],
'md5_source': before['md5'], 'md5_restored': after['md5'],
'alembic_version_source': source_version,
'alembic_version_restored': restored_version,
'indexes_on_messages': indexes,
'history_query_plan_on_restored': plan,
},
'data_loss_boundary': {
'messages_in_backup': before['counts']['messages'],
'messages_written_after_backup': args.late_writes,
'messages_in_source_at_failure_time': source_after,
'late_messages_present_in_restore': late_in_restore,
'lost_if_restored_from_this_backup': source_after - after['counts']['messages'],
},
}
out = Path(args.output)
out.mkdir(parents=True, exist_ok=True)
(out / 'track2-backup-restore.json').write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n',
encoding='utf-8')
print(json.dumps({k: report[k] for k in ('backup', 'restore', 'data_loss_boundary')}, ensure_ascii=False, indent=2))
v = report['verification']
print('verification:', {k: v[k] for k in ('row_counts_equal', 'table_md5_equal', 'sample_messages_equal',
'sample_size', 'indexes_on_messages')})
if not (count_ok and md5_ok and sample_ok):
raise SystemExit('FAIL: restored data differs from the source snapshot')
print('PASS: backup restored into a new storage and verified')
if __name__ == '__main__':
main()