Files

120 lines
20 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.
from collections import defaultdict
from datetime import datetime
import json
from pathlib import Path
import statistics
ROOT = Path(__file__).resolve().parents[1]
OUT = ROOT / 'evidence'
SCALING = OUT / 'scaling'
def read(path):
return json.loads(path.read_text(encoding='utf-8-sig'))
def analysis(rows):
selected = [row for row in rows if row['series'] == 'active-window' and row['concurrency'] == 64]
if len(selected) < 4:
return
by_pool = {pool: [row for row in selected if row['pool'] == pool] for pool in (8, 1)}
rates = {pool: statistics.mean(row['successful_rps'] for row in values) for pool, values in by_pool.items()}
p95 = {pool: statistics.mean(row['successful_latency_ms']['p95'] for row in values) for pool, values in by_pool.items()}
growth = 100 * (rates[1] / rates[8] - 1)
latency_change = 100 * (1 - p95[1] / p95[8])
fixed = {count: statistics.mean(row['successful_rps'] for row in rows if row['series'] == 'fixed' and row['replicas'] == count) for count in (1, 2, 4)}
growing = {count: statistics.mean(row['successful_rps'] for row in rows if row['series'] == 'growing' and row['replicas'] == count) for count in (1, 2, 4)}
confirmed = {count: statistics.mean(row['successful_rps'] for row in rows if row['series'] == 'confirmation' and row['replicas'] == count) for count in (2, 4)}
lines = ['# Разбор исследования', '', '## Гипотеза и воспроизводимость', '', 'Гипотеза: репликация без увеличения суммарного CPU/RAM не даёт линейного ускорения; слишком большой пул при жёстком CPU-лимите может увеличивать конкуренцию за CPU и хвостовую задержку. Все запросы синтетические, без вложений, через HAProxy. Каждый POST имеет уникальный Idempotency-Key. Сессии создаются до измерения.', '', 'Команды из корня проекта после запуска стенда: `python scripts/research.py --duration 15 --repeats 2`, `python scripts/confirm.py`, `python scripts/pool_study.py`, `python scripts/summarize.py`. Перед ними установите requirements-research.txt и BASE_URL для выбранного порта. Настройки и порядок прогонов фиксируются в scaling/environment.json.', '', '## Цена масштабирования', '', f'При фиксированных суммарных 1 CPU/512 MiB API: 1/2/4 реплики дали {fixed[1]:.2f}/{fixed[2]:.2f}/{fixed[4]:.2f} RPS. При росте бюджета по 0.5 CPU/256 MiB на реплику: {growing[1]:.2f}/{growing[2]:.2f}/{growing[4]:.2f} RPS. Добавление CPU помогает, но переход 2 → 4 дал лишь {100*(growing[4]/growing[2]-1):.1f}% при удвоении API-ресурсов.', '', f'Контрольный порядок 4 → 2 → 2 → 4 дал для двух реплик {confirmed[2]:.2f}, для четырёх {confirmed[4]:.2f} RPS. Он не подтвердил первоначальный вывод о безусловном преимуществе двух реплик. Одинаковая конфигурация в разные моменты даёт разные RPS: есть дрейф нагрузки host и CPU throttling. Поэтому уменьшение числа реплик не объявляется доказанным улучшением. Две реплики выбраны как обязательный минимум доступности.', '', 'Публичный driver включает создание потоков и SSL contexts в elapsed. При 64 клиентах этот старт значителен. Первые графики показывают именно его end-to-end результат. Сравнение разной конкуренции уточнено отдельным генератором с barrier, 3 секундами прогрева и 15 секундами активной нагрузки; его elapsed включает только активное окно и завершение отправленных запросов.', '', '## Подтверждённое улучшение', '', f'При неизменных четырёх API по 0.5 CPU/256 MiB, PostgreSQL 1 CPU/512 MiB и LB 0.5 CPU/128 MiB выполнен порядок pool=8 → 1 → 1 → 8, 64 клиента. Средний активный throughput: {rates[8]:.3f} → {rates[1]:.3f} RPS ({growth:+.2f}%). Среднее p95 отдельных прогонов: {p95[8]:.3f} → {p95[1]:.3f} ms (снижение {latency_change:.2f}%). Ошибок в этих четырёх прогонах: ' + str(sum(row['failed_requests'] for row in selected)) + '.', '', 'Улучшение — ограничение числа одновременных операций с БД на CPU-ограниченной API-реплике. Изменён DB_POOL_SIZE по умолчанию с 8 на 1 в compose, bootstrap и приложении. Это ограничивает активную конкуренцию и переносит ожидание в контролируемую очередь пула. Настройка подтверждена для этого профиля; при других CPU/SQL/latency её надо измерять заново. Большой пул сам по себе не означает большую пропускную способность.', '', '![Масштабирование](scaling/throughput.png)', '', '![Активное окно и сравнение пула](scaling/active-window.png)', '', '## Насыщение и ресурсы', '', '| Пул, 64 клиента | Компонент | CPU, среднее % одного ядра | CPU, max % | RAM, max MiB | Максимум ожидающих pool на реплике |', '| --- | --- | --- | --- | --- | --- |']
for pool, values in by_pool.items():
collected = defaultdict(list)
waiting = 0
for row in values:
name = f"active-{row['repeat']}-p{pool}-c64"
for sample in read(SCALING / (name + '-resources.json')):
if row['measurement_started_epoch'] <= sample['at'] <= row['measurement_finished_epoch']:
for item in sample['containers']:
service = item['Name'].rsplit('-', 2)[-2]
import re
memory = re.fullmatch(r'([\d.]+)([A-Za-z]+)', item['MemUsage'].split('/')[0].strip())
scale = {'B': 1/1024**2, 'KiB': 1/1024, 'MiB': 1, 'GiB': 1024}
memory_mb = float(memory[1])*scale[memory[2]]
collected[service].append((float(item['CPUPerc'].rstrip('%')), memory_mb))
for sample in read(SCALING / (name + '-pool.json')):
if row['measurement_started_epoch'] <= datetime.fromisoformat(sample['at']).timestamp() <= row['measurement_finished_epoch']:
waiting = max(waiting, sample['stats'].get('requests_waiting', 0))
for service, samples in sorted(collected.items()):
lines.append(f'| {pool} | {service} | {statistics.mean(value[0] for value in samples):.2f} | {max(value[0] for value in samples):.2f} | {max(value[1] for value in samples):.2f} | {waiting if service == "api" else "—"} |')
lines += ['', 'Для API среднее относится к одной реплике; суммарная загрузка — примерно в четыре раза больше. Лимит каждой API — 50% одного ядра. PostgreSQL ограничен 100%, LB — 50%. Снимки показывают приближение API к CPU quota и накопление очередей пула; предела CPU PostgreSQL/LB этот профиль не достиг. При 64 клиентах ожидание пула наблюдается непосредственно в requests_waiting, requests_queued и requests_wait_ms. Увеличение количества соединений на этих CPU-лимитах не устраняет очередь, а ухудшает итоговый throughput.', '', 'Точка насыщения относится к выбранному профилю и очереди синхронного пути, а не к универсальной capacity БД: переход от 4 к 16/64 клиентам с pool=8 уже не даёт роста полезной скорости и увеличивает p95. На 64 клиентах очередь пула зафиксирована напрямую. Чистый аппаратный предел PostgreSQL или HAProxy не измерен; утверждать обратное по этим данным нельзя.', '', '## Отказы, инциденты и ограничения', '', 'Итоговые функциональные проверки и отказы на настроенном стенде приведены в RESULTS.md, исходные выводы — в соседних TXT/JSON. Сохранность проверяется прежним токеном и сравнением подтверждённых сообщений. Rolling replacement фиксирует старые/новые ID и время замены внутри активного окна нагрузки.', '', 'Во время первого запуска активной серии Compose --wait отказался продолжить из-за оставшегося unhealthy после нагрузки состояния одной реплики. Первые два измерения завершились без HTTP-ошибок; третье ещё не начиналось. Hook эксперимента исправлен: явно ожидает восстановления readiness до 90 секунд. Серия продолжена с --resume без удаления завершённых результатов. Подробности: scaling/active-window-incident.txt. Under CPU pressure readiness использует тот же ограниченный pool и тоже может задерживаться; отдельный резерв readiness-подключений не реализован.', '', 'Два повтора сравнения пула и короткие окна не являются статистическим доказательством для любого оборудования. Порядок ABBA снижает влияние временного дрейфа, но не устраняет его полностью. Closed loop сохраняет coordinated omission; клиент, HTTP и Docker Desktop входят в путь. На машине есть соседний учебный стенд, его конфигурация не менялась. Между прогонами растёт набор данных. Один Docker host, единственные БД и LB остаются SPOF.']
(OUT / 'ANALYSIS.md').write_text('\n'.join(lines) + '\n', encoding='utf-8')
def main():
rows = read(SCALING / 'results.json')
from research import graph
graph(rows)
if any(row['series'] == 'active-window' for row in rows):
from pool_study import graph as graph_active
graph_active(rows)
environment = read(SCALING / 'environment.json')
lines = ['# Фактические результаты', '', 'Дата измерений UTC: ' + environment['date_utc'] + '.', '', 'Команды: `python scripts/verify.py`, `python scripts/research.py --duration 15 --repeats 2`. Адрес: ' + environment['base_url'] + '.', '', '## Функциональные проверки', '']
for name in ('contract', 'smoke', 'concurrent', 'persistence', 'public-failover', 'rolling-action', 'smoke-after-rolling'):
path = OUT / (name + '.txt')
lines.append(f'- [{name}]({path.name}): см. фактический вывод.')
lines += ['', '## Отказы', '', '| Остановленный контейнер | Записи / с | Чтения / с | Ошибки | Восстановление, с | Потеря подтверждений |', '| --- | --- | --- | --- | --- | --- |']
for row in read(OUT / 'failover-matrix.json'):
lines.append(f"| {row['container']} | {row['successful_writes']/row['elapsed_seconds']:.2f} | {row['successful_reads']/row['elapsed_seconds']:.2f} | {row['failed_attempts']} | {row['recovery_seconds']:.3f} | {row['lost_confirmations']} |")
rolling = read(OUT / 'rolling-load.json')
lines += ['', f"Rolling replacement: {rolling['successful_requests']} успешных записей, {rolling['failed_requests']} ошибок ({rolling['error_ratio']*100:.2f}%), {rolling['successful_rps']:.2f} RPS, p95={rolling['successful_latency_ms']['p95']:.2f} ms. Это замена без предварительного drain backend; обнаружение отказа допускает краткие ошибки, автоматического retry в этом профиле нет. После замены публичный smoke проходит.", '', '## Среда', '', f"Docker VM: {environment['docker']['NCPU']} CPU, {environment['docker']['MemTotal']/1024**3:.2f} GiB RAM; {environment['docker']['OperatingSystem']}; Engine {environment['docker']['ServerVersion']}. Host: {environment['platform']}.", '', 'Объём данных до: `' + json.dumps(environment['dataset_before']) + '`, после: `' + json.dumps(environment['dataset_after']) + '`.', '', '## Масштабирование', '', 'Фиксированный бюджет: суммарно 1 CPU/512 MiB API. Растущий: по 0.5 CPU/256 MiB каждой API. PostgreSQL 1 CPU/512 MiB, LB 0.5 CPU/128 MiB во всех сериях. Таблица содержит среднее RPS по повторам и диапазон p95 отдельных прогонов; это не объединённый percentile.', '', '| Серия | Реплики | Пул каждой | Клиенты | RPS, среднее | RPS, min–max | p50, ms | p95, ms | p99, ms | Ошибок |', '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |']
groups = defaultdict(list)
for row in rows:
groups[(row['series'], row['replicas'], row['pool'], row['concurrency'])].append(row)
for (series, replicas, pool, concurrency), values in groups.items():
rates = [r['successful_rps'] for r in values]
latencies = {p: [r['successful_latency_ms'][p] for r in values] for p in ('p50', 'p95', 'p99')}
lines.append(f"| {series} | {replicas} | {pool} | {concurrency} | {statistics.mean(rates):.2f} | {min(rates):.2f}–{max(rates):.2f} | {statistics.mean(latencies['p50']):.1f} | {min(latencies['p95']):.1f}–{max(latencies['p95']):.1f} | {statistics.mean(latencies['p99']):.1f} | {sum(r['failed_requests'] for r in values)} |")
lines += ['', '![Графики масштабирования](scaling/throughput.png)', '', 'Публичный driver включает создание клиентских потоков/SSL contexts в elapsed. Его RPS при разной конкуренции содержит заметные расходы старта генератора. Строки active-window измерены после подготовки клиентов и 3 секунд прогрева, включая завершение запросов после дедлайна; эти методики нельзя смешивать.', '']
if any(row['series'] == 'active-window' for row in rows):
lines += ['![Измерения в активном окне](scaling/active-window.png)', '']
lines += ['## Наблюдение ресурсов', '', '| Серия / прогон | Компонент | CPU, среднее % одного ядра | CPU, максимум % | RAM, максимум MiB |', '| --- | --- | --- | --- | --- |']
resources = {}
for path in sorted(SCALING.glob('*-resources.json')):
values = defaultdict(list)
summary = read(path.with_name(path.name.replace('-resources.json', '.json')))
for snapshot in read(path):
if 'measurement_started_epoch' in summary and not summary['measurement_started_epoch'] <= snapshot['at'] <= summary['measurement_finished_epoch']:
continue
for item in snapshot['containers']:
service = item['Name'].rsplit('-', 2)[-2]
memory = item['MemUsage'].split('/')[0].strip()
factors = {'B': 1/1024**2, 'KiB': 1/1024, 'MiB': 1, 'GiB': 1024}
import re
match = re.fullmatch(r'([\d.]+)([A-Za-z]+)', memory)
memory_mb = float(match[1]) * factors[match[2]] if match else 0
values[service].append((float(item['CPUPerc'].rstrip('%')), memory_mb))
for service, samples in sorted(values.items()):
cpu = [c for c, _ in samples]
resources[(path.stem, service)] = statistics.mean(cpu)
lines.append(f'| {path.stem.removesuffix("-resources")} | {service} | {statistics.mean(cpu):.2f} | {max(cpu):.2f} | {max(m for _, m in samples):.2f} |')
lines += ['', 'Для API CPU/RAM в этой таблице относятся к отдельным контейнерам, усреднённым по репликам и снимкам; максимум — отдельный контейнер. Суммарный CPU API вычисляется умножением среднего на число реплик. Docker CPU 100% соответствует одному ядру, независимо от quota.', '', '## Счётчики ожидания пула', '', '| Прогон | Реплик со снимками | Запросы в очереди, прирост | Ожидание, ms, прирост | Максимум ожидающих в снимке |', '| --- | --- | --- | --- | --- |']
for path in sorted(SCALING.glob('*-pool.json')):
by_instance = defaultdict(list)
summary = read(path.with_name(path.name.replace('-pool.json', '.json')))
for sample in read(path):
if 'measurement_started_epoch' in summary and not summary['measurement_started_epoch'] <= datetime.fromisoformat(sample['at']).timestamp() <= summary['measurement_finished_epoch']:
continue
by_instance[sample['instance']].append(sample['stats'])
queued, wait, maximum = 0, 0, 0
for samples in by_instance.values():
queued += samples[-1].get('requests_queued', 0) - samples[0].get('requests_queued', 0)
wait += samples[-1].get('requests_wait_ms', 0) - samples[0].get('requests_wait_ms', 0)
maximum = max(maximum, *(sample.get('requests_waiting', 0) for sample in samples))
lines.append(f'| {path.stem.removesuffix("-pool")} | {len(by_instance)} | {queued} | {wait} | {maximum} |')
lines += ['', 'Счётчики берутся каждые 5 секунд и включают readiness и вспомогательные запросы; прирост между первым и последним снимком покрывает часть измерения. Это диагностический сигнал, а не точный процент запросов измерительного окна.', '', '## Границы вывода', '', 'Короткий closed-loop профиль, два повтора основных серий, фиксированный порядок и растущий набор данных. Percentiles считаются только по успехам. Есть расходы генератора и Docker Desktop, а также соседний учебный стенд; его работа не изменялась. Полученные RPS не являются универсальной production capacity. Данные и графики получены реальным запуском, а не оценены по формуле.']
(OUT / 'RESULTS.md').write_text('\n'.join(lines) + '\n', encoding='utf-8')
analysis(rows)
if __name__ == '__main__':
main()