forked from mtusi2026/mtusi2026lab2
Уровень 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
216 lines
13 KiB
Python
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()
|