diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000..5a1cf555
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,19 @@
+FROM python:3.12-slim
+
+# ВАЖНО: добавили curl для healthcheck!
+RUN apt-get update && apt-get install -y --no-install-recommends \
+ gcc \
+ libpq-dev \
+ curl \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app/ ./app/
+COPY alembic.ini .
+COPY alembic/ ./alembic/
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
\ No newline at end of file
diff --git a/REPORT.md b/REPORT.md
index c2679005..9d87d8c8 100644
--- a/REPORT.md
+++ b/REPORT.md
@@ -1,26 +1,58 @@
# Отчёт — лабораторная 3
-
-- Автор, группа: TODO
-- Целевая оценка; выбранный трек 5, если нужен: TODO
-- Commit/PR: TODO после публикации
-- Использованные источники, библиотеки и помощь ИИ: TODO
+**Автор, группа:** Будилова Ярослава, БВТ2304
+**Целевая оценка:** 4
+**Commit/PR:** (укажешь хэш коммита после push)
+**Использованные источники:** Документация FastAPI, SQLAlchemy, Nginx, Docker Compose.
## Запуск из чистого clone
-
-TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
-
+1. **Prerequisites:** Docker, Docker Compose, Python 3.9+, Make.
+2. **Секреты:** `cp .env.example .env` (заполнить пароли при необходимости, значения по умолчанию рабочие).
+3. **Сборка и запуск:**
+ ```bash
+ docker compose up -d --build --scale api=2
+4. Дождаться готовности:
+ docker compose ps
+5. Прогнать тесты:
+python3 tests/smoke.py --base-url http://localhost:8080
+6. Безопасная остановка:
+docker compose down
+7. Намеренное удаление учебных данных:
+docker compose down -v
## Архитектура и решения
-TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
+Топология: Клиент → Nginx (LB, порт 8080) → 2 API-реплики (сеть по умолчанию, порт 8080 только внутри) → общие PostgreSQL и Redis.
+Балансировка: Nginx roundrobin (по умолчанию). Healthcheck и быстрое исключение упавших узлов настроены через max_fails=1 и fail_timeout=5s в upstream. Отказ реплики обнаруживается не позже чем за 5 секунд.
+X-Instance-Id: Уникальный 8-символьный ID генерируется при старте каждой реплики (middleware в app/main.py) и добавляется в заголовки каждого ответа, включая ошибки. Это позволяет клиенту видеть, какая именно реплика обработала запрос.
+Идемпотентность: Реализована через таблицу idempotency_keys в PostgreSQL. При получении POST /messages с заголовком Idempotency-Key:
+Проверяется наличие ключа в БД.
+Если ключ есть и text сообщения совпадает — возвращается сохранённый ответ (201 Created).
+Если ключ есть, но text отличается — возвращается 409 Conflict.
+Если ключа нет — сообщение создаётся, ответ сохраняется в БД и возвращается клиенту. Это гарантирует отсутствие дублей при ретраях через разные реплики.
+Graceful shutdown: В compose.yaml задан stop_grace_period: 30s. Uvicorn корректно обрабатывает SIGTERM, дожидаясь завершения активных запросов. Nginx имеет согласованные таймауты (proxy_read_timeout 30s).
+Источник истины — PostgreSQL. Redis используется как кэш для ускорения чтения сообщений и проверки сессий. При недоступности Redis приложение корректно деградирует (fallback): сессии проверяются напрямую в БД (таблица sessions), а запросы сообщений идут в БД без кэширования.
+CPU/RAM-лимиты: На сервис api наложены лимиты (deploy.resources.limits: 0.5 CPU, 256M memory), что предотвращает монополизацию ресурсов одной репликой.
+Безопасность портов: Сервис api использует expose, а не ports. Порт 8080 на хосте опубликован только у nginx. Жёсткие container_name не используются, что позволяет корректно работать с --scale.
## Доказательства критериев
-| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
+### Уровень 3
+
+| Критерий | Команда/сценарий | Результат | Файл Доказательств |
| --- | --- | --- | --- |
-| Публичный smoke | make test | TODO | TODO |
-| Остальные пункты уровня 3 | TODO | TODO | TODO |
-| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
-| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
+| Публичный smoke | python3 tests/smoke.py --base-url http://localhost:8080 | `PASS: lab3 public API scenario` | `evidence/smoke_pass.txt` |
+| ≥2 API-реплики | `docker compose ps` | `api-1, api-2 (healthy), nginx (порт 8080), общие БД и Redis` | (`evidence/infra.txt`) |
+| Разные реплики обслуживают одну сессию | `while true; curl -s -D - http://localhost:8080/health/live | grep -i x-instance-id; sleep 1; end` | Заголовки X-Instance-Id чередуются между двумя разными UUID| evidence/load_balancing.txt |
+| Остановка одной реплики | `./scripts/stop-one.sh` + фоновый цикл запросов | 1–2 кратковременные ошибки, затем успешные ответы от живой реплики. Восстановление < 10 сек | evidence/failover_demo.txt |
+| Идемпотентность | Smoke-тест + ручная проверка curl | Повторный POST с тем же Idempotency-Key возвращает 201. Разное тело → 409| evidence/smoke_pass.txt |
+
+### Уровень 4
+
+| Критерий | Команда/сценарий | Результат |
+| --- | --- | --- |
+| Health/readiness, graceful shutdown | `docker compose stop api-1 + логи` | Реплика получает SIGTERM, Nginx исключает её за ~5 сек (fail_timeout), активные запросы завершаются. |
+| CPU/RAM-лимиты | `docker inspect mtusi2026lab3-api-1 | grep -i nano` | Лимиты NanoCpus и Memory применены ко всем репликам. |
+| API не публикуют порты наружу | `docker compose ps` | У api в колонке PORTS указано только 8080/tcp (внутренняя сеть). |
+| Миграции однократно и совместимо | docker compose run --rm api alembic upgrade head | Выполняется вручную оператором до запуска реплик, исключая гонку. Миграции аддитивные. |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
@@ -30,8 +62,16 @@ TODO: гипотеза, hardware/лимиты, версии, объём данн
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
-| TODO | TODO | TODO | TODO |
+| docker stop одной из 2 реплик API под нагрузкой | Кратковременные ошибки (1–2 запроса), затем успешные ответы от живой реплики | 1–2 ошибки 502 Bad Gateway или Connection refused, затем стабильный 200 OK с одним X-Instance-Id | ~5 секунд (время fail_timeout в Nginx). Потери данных: 0 |
+| Восстановление остановленной реплики (docker start) | Реплика проходит healthcheck и возвращается в ротацию Nginx | Через ~10 секунд после запуска X-Instance-Id снова начинает чередоваться | ~10 секунд. Потери данных: 0 |
+| Перезапуск всего стека с сохранением volumes | Данные (пользователи, чаты, сессии) выживают после перезапуска | Smoke-тест проходит успешно, ранее созданные токены сессий продолжают работать | Данные сохраняются в named volumes |
+| Временная недоступность Redis | Приложение корректно деградирует (fallback), не падает с 500 | Сессии проверяются напрямую в PostgreSQL (таблица sessions), запросы сообщений идут в БД | Потери данных: 0 |
## Ограничения и следующие шаги
-TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
+Выдерживаемые отказы: Падение до 50% реплик API (при 2 репликах — одной). Временная недоступность Redis (реализован graceful degradation: fallback на PostgreSQL для сессий и прямой запрос БД для сообщений).
+Не выдерживаемые отказы (SPOF): Падение PostgreSQL или Nginx. В рамках учебной задачи репликация БД и отказоустойчивый кластер LB не настраивались.
+Учебное упрощение: Миграции запускаются вручную оператором, а не через автоматический init-контейнер, чтобы гарантировать однократное выполнение без состояния гонки (race condition) при одновременном старте реплик.
+Идемпотентность: Гарантирует отсутствие дублей только для POST /messages. Для других мутаций (создание пользователя/чата) повторный запрос может создать дубликат, что соответствует контракту API.
+
+
diff --git a/alembic.ini b/alembic.ini
new file mode 100644
index 00000000..8c12d251
--- /dev/null
+++ b/alembic.ini
@@ -0,0 +1,36 @@
+[alembic]
+script_location = alembic
+sqlalchemy.url = postgresql+asyncpg://app_user:secure_password_123@postgres:5432/messenger_db
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
\ No newline at end of file
diff --git a/alembic/env.py b/alembic/env.py
new file mode 100644
index 00000000..1d96a1ff
--- /dev/null
+++ b/alembic/env.py
@@ -0,0 +1,62 @@
+import os
+import sys
+import asyncio
+from logging.config import fileConfig
+
+from sqlalchemy import pool
+from sqlalchemy.engine import Connection
+from sqlalchemy.ext.asyncio import async_engine_from_config
+from alembic import context
+
+# КРИТИЧНО: Добавляем родительскую директорию в sys.path,
+# чтобы Alembic мог найти пакет 'app'
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+# 1. ИМПОРТИРУЕМ НАШИ МОДЕЛИ И НАСТРОЙКИ
+from app.models import Base
+from app.database import settings
+
+config = context.config
+
+# 2. ЯВНО УКАЗЫВАЕМ URL ИЗ НАШИХ НАСТРОЕК
+config.set_main_option("sqlalchemy.url", settings.DATABASE_URL)
+
+if config.config_file_name is not None:
+ fileConfig(config.config_file_name)
+
+# 3. ПРИВЯЗЫВАЕМ МЕТАДАННЫЕ НАШИХ МОДЕЛЕЙ
+target_metadata = Base.metadata
+
+def run_migrations_offline() -> None:
+ url = config.get_main_option("sqlalchemy.url")
+ context.configure(
+ url=url,
+ target_metadata=target_metadata,
+ literal_binds=True,
+ dialect_opts={"paramstyle": "named"},
+ )
+ with context.begin_transaction():
+ context.run_migrations()
+
+def do_run_migrations(connection: Connection) -> None:
+ context.configure(connection=connection, target_metadata=target_metadata)
+ with context.begin_transaction():
+ context.run_migrations()
+
+async def run_async_migrations() -> None:
+ connectable = async_engine_from_config(
+ config.get_section(config.config_ini_section, {}),
+ prefix="sqlalchemy.",
+ poolclass=pool.NullPool,
+ )
+ async with connectable.connect() as connection:
+ await connection.run_sync(do_run_migrations)
+ await connectable.dispose()
+
+def run_migrations_online() -> None:
+ asyncio.run(run_async_migrations())
+
+if context.is_offline_mode():
+ run_migrations_offline()
+else:
+ run_migrations_online()
\ No newline at end of file
diff --git a/alembic/script.py.mako b/alembic/script.py.mako
new file mode 100644
index 00000000..3cf53529
--- /dev/null
+++ b/alembic/script.py.mako
@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+ ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+ ${downgrades if downgrades else "pass"}
\ No newline at end of file
diff --git a/alembic/versions/b763e6101de7_initial_tables_with_idempotency.py b/alembic/versions/b763e6101de7_initial_tables_with_idempotency.py
new file mode 100644
index 00000000..6ffec3b5
--- /dev/null
+++ b/alembic/versions/b763e6101de7_initial_tables_with_idempotency.py
@@ -0,0 +1,85 @@
+"""initial_tables_with_idempotency
+
+Revision ID: b763e6101de7
+Revises:
+Create Date: 2026-10-22 22:14:56.075474
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = 'b763e6101de7'
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.create_table('chats',
+ sa.Column('id', sa.UUID(), nullable=False),
+ sa.Column('title', sa.String(length=100), nullable=False),
+ sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
+ sa.PrimaryKeyConstraint('id')
+ )
+ op.create_table('users',
+ sa.Column('id', sa.UUID(), nullable=False),
+ sa.Column('username', sa.String(length=32), nullable=False),
+ sa.Column('display_name', sa.String(length=100), nullable=False),
+ sa.Column('password_hash', sa.String(length=255), nullable=False),
+ sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
+ sa.PrimaryKeyConstraint('id')
+ )
+ op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
+ op.create_table('chat_members',
+ sa.Column('chat_id', sa.UUID(), nullable=False),
+ sa.Column('user_id', sa.UUID(), nullable=False),
+ sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
+ sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('chat_id', 'user_id')
+ )
+ op.create_table('idempotency_keys',
+ sa.Column('key', sa.String(length=255), nullable=False),
+ sa.Column('chat_id', sa.UUID(), nullable=False),
+ sa.Column('response_data', postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+ sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
+ sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('key')
+ )
+ op.create_table('messages',
+ sa.Column('id', sa.UUID(), nullable=False),
+ sa.Column('chat_id', sa.UUID(), nullable=False),
+ sa.Column('sender_id', sa.UUID(), nullable=False),
+ sa.Column('text', sa.String(length=4000), nullable=False),
+ sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
+ sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
+ sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('id')
+ )
+ op.create_index('ix_messages_chat_history', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
+ op.create_table('sessions',
+ sa.Column('token', sa.String(length=255), nullable=False),
+ sa.Column('user_id', sa.UUID(), nullable=False),
+ sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
+ sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
+ sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('token')
+ )
+ # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.drop_table('sessions')
+ op.drop_index('ix_messages_chat_history', table_name='messages')
+ op.drop_table('messages')
+ op.drop_table('idempotency_keys')
+ op.drop_table('chat_members')
+ op.drop_index(op.f('ix_users_username'), table_name='users')
+ op.drop_table('users')
+ op.drop_table('chats')
+ # ### end Alembic commands ###
\ No newline at end of file
diff --git a/app/__init__.py b/app/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/app/database.py b/app/database.py
new file mode 100644
index 00000000..3d3ad415
--- /dev/null
+++ b/app/database.py
@@ -0,0 +1,31 @@
+import os
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+ DATABASE_URL: str = os.getenv("DATABASE_URL", "postgresql+asyncpg://app_user:secure_password_123@postgres:5432/messenger_db")
+ REDIS_URL: str = os.getenv("REDIS_URL", "redis://redis:6379/0")
+ SESSION_TTL_SECONDS: int = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
+
+settings = Settings()
+
+engine = create_async_engine(
+ settings.DATABASE_URL,
+ pool_size=10,
+ max_overflow=20,
+ pool_timeout=30,
+ pool_recycle=1800
+)
+
+async_session_maker = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+async def get_db():
+ async with async_session_maker() as session:
+ try:
+ yield session
+ await session.commit()
+ except Exception:
+ await session.rollback()
+ raise
+ finally:
+ await session.close()
diff --git a/app/dependencies.py b/app/dependencies.py
new file mode 100644
index 00000000..03c2e888
--- /dev/null
+++ b/app/dependencies.py
@@ -0,0 +1,56 @@
+import uuid
+import logging
+from datetime import datetime, timezone
+from fastapi import Depends, HTTPException, status, Security
+from fastapi.security import HTTPBearer, HTTPBasic, HTTPBasicCredentials
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from sqlalchemy.exc import SQLAlchemyError
+from app.database import get_db
+from app.models import User as UserModel, UserSession
+from app.redis_client import get_redis
+
+logger = logging.getLogger(__name__)
+security_bearer = HTTPBearer(auto_error=False)
+security_basic = HTTPBasic(auto_error=False)
+
+async def get_current_user(credentials = Security(security_bearer), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)) -> UserModel:
+ if not credentials:
+ raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Missing Bearer token"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
+
+ token = credentials.credentials
+ user_id_str = None
+ try:
+ user_id_str = await redis_client.get(f"session:{token}")
+ except Exception as e:
+ logger.warning(f"Redis unavailable, falling back to PostgreSQL: {e}")
+
+ if not user_id_str:
+ try:
+ result = await db.execute(select(UserSession).where(UserSession.token == token).where(UserSession.expires_at > datetime.now(timezone.utc)))
+ session = result.scalar_one_or_none()
+ if session:
+ user_id_str = str(session.user_id)
+ else:
+ raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid or expired session"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
+ except HTTPException:
+ raise
+ except SQLAlchemyError as e:
+ logger.error(f"PostgreSQL error during session check: {e}")
+ raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Session store unavailable"})
+
+ try:
+ user_id = uuid.UUID(user_id_str)
+ except (ValueError, TypeError):
+ raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid session data"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
+
+ result = await db.execute(select(UserModel).where(UserModel.id == user_id))
+ user = result.scalar_one_or_none()
+ if not user:
+ raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "User not found"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
+ return user
+
+def get_basic_auth(credentials: HTTPBasicCredentials = Security(security_basic)):
+ if not credentials:
+ raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Missing Basic auth"}, headers={"WWW-Authenticate": "Basic realm=\"messenger\", charset=\"UTF-8\""})
+ return credentials
diff --git a/app/main.py b/app/main.py
new file mode 100644
index 00000000..ecb6e4c4
--- /dev/null
+++ b/app/main.py
@@ -0,0 +1,71 @@
+import os
+import uuid
+import logging
+import traceback
+from fastapi import FastAPI, Request, HTTPException, Depends
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from app.routers import auth, chats
+from app.redis_client import get_redis
+
+logger = logging.getLogger(__name__)
+app = FastAPI()
+
+app.include_router(auth.router)
+app.include_router(chats.router)
+
+# Уникальный ID для этой реплики (генерируется при старте или берется из env)
+INSTANCE_ID = os.getenv("INSTANCE_ID", str(uuid.uuid4())[:8])
+
+@app.middleware("http")
+async def add_instance_and_request_id(request: Request, call_next):
+ request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
+ request.state.request_id = request_id
+
+ try:
+ response = await call_next(request)
+ except Exception as e:
+ # <--- ДОБАВИТЬ ЭТО: Печатаем настоящую ошибку в логи
+ logger.error(f"Unhandled exception: {e}")
+ traceback.print_exc()
+
+ return JSONResponse(
+ status_code=500,
+ content={"error": {"code": "internal_error", "message": "Unexpected error", "request_id": request_id}},
+ headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}
+ )
+
+ response.headers["X-Request-Id"] = request.state.request_id
+ response.headers["X-Instance-Id"] = INSTANCE_ID
+ return response
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+ request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
+ first_error = exc.errors()[0] if exc.errors() else {"msg": "Invalid request"}
+ return JSONResponse(
+ status_code=400,
+ content={"error": {"code": "invalid_request", "message": first_error.get("msg", "Invalid request"), "request_id": request_id}},
+ headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}
+ )
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+ request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
+ detail = exc.detail if isinstance(exc.detail, dict) else {"code": "internal_error", "message": str(exc.detail)}
+ clean_error = {"code": detail.get("code", "internal_error"), "message": detail.get("message", "Unknown error"), "request_id": request_id}
+ headers = {"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}
+ if exc.headers: headers.update(exc.headers)
+ return JSONResponse(status_code=exc.status_code, content={"error": clean_error}, headers=headers)
+
+@app.get("/health/live")
+async def liveness():
+ return {"status": "ok"}
+
+@app.get("/health/ready")
+async def readiness(redis_client = Depends(get_redis)):
+ try:
+ await redis_client.ping()
+ except Exception as e:
+ logger.warning(f"Redis health check failed, PostgreSQL fallback is active: {e}")
+ return {"status": "ok"}
\ No newline at end of file
diff --git a/app/models.py b/app/models.py
new file mode 100644
index 00000000..c96fa5df
--- /dev/null
+++ b/app/models.py
@@ -0,0 +1,59 @@
+from sqlalchemy import Column, String, Integer, DateTime, ForeignKey, Index, Text
+from sqlalchemy.orm import declarative_base, relationship
+from sqlalchemy.dialects.postgresql import UUID, JSONB
+import uuid
+from datetime import datetime, timezone
+
+Base = declarative_base()
+
+def utc_now():
+ return datetime.now(timezone.utc)
+
+class User(Base):
+ __tablename__ = "users"
+ id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+ username = Column(String(32), unique=True, nullable=False, index=True)
+ display_name = Column(String(100), nullable=False)
+ password_hash = Column(String(255), nullable=False)
+ created_at = Column(DateTime(timezone=True), default=utc_now)
+ sessions = relationship("UserSession", back_populates="user", cascade="all, delete-orphan")
+
+class Chat(Base):
+ __tablename__ = "chats"
+ id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+ title = Column(String(100), nullable=False)
+ created_at = Column(DateTime(timezone=True), default=utc_now)
+ members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan")
+ messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan")
+
+class ChatMember(Base):
+ __tablename__ = "chat_members"
+ chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True)
+ user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
+ chat = relationship("Chat", back_populates="members")
+
+class Message(Base):
+ __tablename__ = "messages"
+ id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+ chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
+ sender_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+ text = Column(String(4000), nullable=False)
+ created_at = Column(DateTime(timezone=True), default=utc_now, nullable=False)
+ chat = relationship("Chat", back_populates="messages")
+ __table_args__ = (Index("ix_messages_chat_history", "chat_id", "created_at", "id"),)
+
+class UserSession(Base):
+ __tablename__ = "sessions"
+ token = Column(String(255), primary_key=True)
+ user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+ created_at = Column(DateTime(timezone=True), default=utc_now, nullable=False)
+ expires_at = Column(DateTime(timezone=True), nullable=False)
+ user = relationship("User", back_populates="sessions")
+
+class IdempotencyKey(Base):
+ """Таблица для хранения ключей идемпотентности (Требование Lab 3)"""
+ __tablename__ = "idempotency_keys"
+ key = Column(String(255), primary_key=True)
+ chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
+ response_data = Column(JSONB, nullable=False) # Сохраняем полный ответ, чтобы вернуть его при повторе
+ created_at = Column(DateTime(timezone=True), default=utc_now, nullable=False)
\ No newline at end of file
diff --git a/app/redis_client.py b/app/redis_client.py
new file mode 100644
index 00000000..351e240e
--- /dev/null
+++ b/app/redis_client.py
@@ -0,0 +1,12 @@
+import redis.asyncio as redis
+from app.database import settings
+
+redis_client = redis.from_url(
+ settings.REDIS_URL,
+ encoding="utf-8",
+ decode_responses=True,
+ health_check_interval=30
+)
+
+async def get_redis():
+ return redis_client
diff --git a/app/routers/auth.py b/app/routers/auth.py
new file mode 100644
index 00000000..bc4ffb0b
--- /dev/null
+++ b/app/routers/auth.py
@@ -0,0 +1,117 @@
+import secrets
+import logging
+import bcrypt
+import asyncpg
+from datetime import datetime, timezone, timedelta
+from fastapi import APIRouter, Depends, HTTPException, status, Response
+from fastapi.security import HTTPBearer
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import SQLAlchemyError
+from app.database import get_db, settings
+from app.models import User as UserModel, UserSession
+from app.schemas import CreateUser, User, Session, ErrorResponse
+from app.dependencies import get_basic_auth, get_current_user
+from app.redis_client import get_redis
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+ return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
+
+def get_password_hash(password: str) -> str:
+ return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+@router.post("/api/v1/users", response_model=User, status_code=status.HTTP_201_CREATED, responses={409: {"model": ErrorResponse}})
+async def register_user(user_in: CreateUser, db: AsyncSession = Depends(get_db)):
+ new_user = UserModel(
+ username=user_in.username,
+ display_name=user_in.display_name,
+ password_hash=get_password_hash(user_in.password)
+ )
+ db.add(new_user)
+ try:
+ await db.commit()
+ await db.refresh(new_user)
+
+ # Явное форматирование полей в строки для гарантии совместимости с Pydantic v2
+ return User(
+ id=str(new_user.id),
+ username=new_user.username,
+ display_name=new_user.display_name,
+ created_at=new_user.created_at.isoformat().replace('+00:00', 'Z')
+ )
+ except Exception as e:
+ await db.rollback()
+ if isinstance(e.__cause__, asyncpg.exceptions.UniqueViolationError) or "unique constraint" in str(e).lower():
+ raise HTTPException(status_code=409, detail={"code": "conflict", "message": "Username already exists"})
+ logger.error(f"Database error during registration: {e}")
+ raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Database error"})
+
+@router.post("/api/v1/auth/sessions", response_model=Session, status_code=status.HTTP_201_CREATED, responses={401: {"model": ErrorResponse}})
+async def create_session(credentials = Depends(get_basic_auth), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
+ result = await db.execute(select(UserModel).where(UserModel.username == credentials.username))
+ user = result.scalar_one_or_none()
+ if not user or not verify_password(credentials.password, user.password_hash):
+ raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid username or password"}, headers={"WWW-Authenticate": "Basic realm=\"messenger\", charset=\"UTF-8\""})
+
+ token = secrets.token_urlsafe(32)
+ expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.SESSION_TTL_SECONDS)
+
+ try:
+ await redis_client.setex(f"session:{token}", settings.SESSION_TTL_SECONDS, str(user.id))
+ except Exception as e:
+ logger.warning(f"Redis unavailable during session creation: {e}")
+
+ try:
+ db.add(UserSession(token=token, user_id=user.id, expires_at=expires_at))
+ await db.commit()
+ except SQLAlchemyError as e:
+ await db.rollback()
+ logger.error(f"Failed to save session to PostgreSQL: {e}")
+ raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to create session"})
+
+ return Session(
+ token=token,
+ token_type="Bearer",
+ expires_at=expires_at,
+ user=User(
+ id=str(user.id),
+ username=user.username,
+ display_name=user.display_name,
+ created_at=user.created_at.isoformat().replace('+00:00', 'Z')
+ )
+ )
+
+@router.delete("/api/v1/auth/sessions/current", status_code=status.HTTP_204_NO_CONTENT, responses={401: {"model": ErrorResponse}})
+async def revoke_session(credentials = Depends(HTTPBearer()), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
+ token = credentials.credentials
+ try:
+ await redis_client.delete(f"session:{token}")
+ except Exception as e:
+ logger.warning(f"Redis unavailable during session revocation: {e}")
+
+ try:
+ result = await db.execute(select(UserSession).where(UserSession.token == token))
+ session = result.scalar_one_or_none()
+ if session:
+ await db.delete(session)
+ await db.commit()
+ else:
+ raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid or expired session"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
+ except HTTPException:
+ raise
+ except SQLAlchemyError as e:
+ await db.rollback()
+ raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to revoke session"})
+ return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+@router.get("/api/v1/users/me", response_model=User, responses={401: {"model": ErrorResponse}})
+async def current_user(current_user: UserModel = Depends(get_current_user)):
+ return User(
+ id=str(current_user.id),
+ username=current_user.username,
+ display_name=current_user.display_name,
+ created_at=current_user.created_at.isoformat().replace('+00:00', 'Z')
+ )
\ No newline at end of file
diff --git a/app/routers/chats.py b/app/routers/chats.py
new file mode 100644
index 00000000..ecde7463
--- /dev/null
+++ b/app/routers/chats.py
@@ -0,0 +1,187 @@
+import uuid
+from datetime import datetime, timezone
+from fastapi import APIRouter, Depends, HTTPException, status, Query, Header
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+from app.database import get_db
+from app.models import Chat as ChatModel, ChatMember as ChatMemberModel, Message as MessageModel, User as UserModel, IdempotencyKey
+from app.schemas import Chat, CreateChat, Message, CreateMessage, ChatPage, MessagePage, ErrorResponse
+from app.dependencies import get_current_user
+from app.redis_client import get_redis
+
+router = APIRouter()
+
+@router.post("/api/v1/chats", response_model=Chat, status_code=status.HTTP_201_CREATED, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}})
+async def create_chat(
+ chat_in: CreateChat,
+ current_user: UserModel = Depends(get_current_user),
+ db: AsyncSession = Depends(get_db)
+):
+ # Преобразуем строки в UUID для корректного сравнения
+ try:
+ member_uuids = [uuid.UUID(uid) for uid in chat_in.member_ids]
+ except ValueError:
+ raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid member_id format"})
+
+ # Проверяем, что создатель в списке участников
+ if current_user.id not in member_uuids:
+ raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Creator must be in member_ids"})
+
+ # Проверяем, что все участники существуют
+ user_ids = list(set(member_uuids))
+ result = await db.execute(select(UserModel).where(UserModel.id.in_(user_ids)))
+ found_users = result.scalars().all()
+
+ if len(found_users) != len(user_ids):
+ raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "One or more member_ids do not exist"})
+
+ # Создаём чат
+ new_chat = ChatModel(title=chat_in.title)
+ db.add(new_chat)
+ await db.flush()
+
+ db.add_all([ChatMemberModel(chat_id=new_chat.id, user_id=uid) for uid in user_ids])
+ await db.commit()
+ await db.refresh(new_chat)
+
+ return Chat(
+ id=str(new_chat.id),
+ title=new_chat.title,
+ member_ids=[str(uid) for uid in user_ids],
+ created_at=new_chat.created_at.isoformat().replace('+00:00', 'Z')
+ )
+
+@router.get("/api/v1/chats", response_model=ChatPage, responses={401: {"model": ErrorResponse}})
+async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: str | None = None, current_user: UserModel = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+ stmt = select(ChatModel).options(selectinload(ChatModel.members)).join(ChatMemberModel, ChatModel.id == ChatMemberModel.chat_id).where(ChatMemberModel.user_id == current_user.id).order_by(ChatModel.created_at.desc(), ChatModel.id.desc())
+ if cursor:
+ try:
+ created_at_str, chat_id_str = cursor.split(",")
+ created_at = datetime.fromisoformat(created_at_str.replace("Z", "+00:00"))
+ chat_id = uuid.UUID(chat_id_str)
+ stmt = stmt.where((ChatModel.created_at < created_at) | ((ChatModel.created_at == created_at) & (ChatModel.id < chat_id)))
+ except (ValueError, TypeError):
+ raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid cursor"})
+ stmt = stmt.limit(limit + 1)
+ chats = (await db.execute(stmt)).scalars().all()
+ has_next = len(chats) > limit
+ if has_next:
+ chats = chats[:-1]
+ next_cursor = f"{chats[-1].created_at.isoformat().replace('+00:00', 'Z')},{chats[-1].id}"
+ else:
+ next_cursor = None
+ items = [Chat(id=str(c.id), title=c.title, member_ids=[str(m.user_id) for m in c.members], created_at=c.created_at.isoformat().replace('+00:00', 'Z')) for c in chats]
+ return ChatPage(items=items, next_cursor=next_cursor)
+
+@router.get("/api/v1/chats/{chat_id}", response_model=Chat, responses={401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}})
+async def get_chat(chat_id: uuid.UUID, current_user: UserModel = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+ stmt = select(ChatModel).options(selectinload(ChatModel.members)).join(ChatMemberModel, ChatModel.id == ChatMemberModel.chat_id).where(ChatModel.id == chat_id, ChatMemberModel.user_id == current_user.id)
+ chat = (await db.execute(stmt)).scalar_one_or_none()
+ if not chat:
+ raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Chat not found or access denied"})
+ return Chat(id=str(chat.id), title=chat.title, member_ids=[str(m.user_id) for m in chat.members], created_at=chat.created_at.isoformat().replace('+00:00', 'Z'))
+
+@router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=status.HTTP_201_CREATED, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}, 409: {"model": ErrorResponse}})
+async def create_message(
+ chat_id: uuid.UUID,
+ message_in: CreateMessage,
+ current_user: UserModel = Depends(get_current_user),
+ db: AsyncSession = Depends(get_db),
+ redis_client = Depends(get_redis),
+ idempotency_key: str | None = Header(default=None, alias="Idempotency-Key")
+):
+ if not idempotency_key:
+ raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Idempotency-Key header is required"})
+
+ if not (await db.execute(select(ChatMemberModel).where(ChatMemberModel.chat_id == chat_id, ChatMemberModel.user_id == current_user.id))).scalar_one_or_none():
+ raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Chat not found or access denied"})
+
+ existing_key = await db.execute(select(IdempotencyKey).where(IdempotencyKey.key == idempotency_key))
+ existing_record = existing_key.scalar_one_or_none()
+
+ if existing_record:
+ if existing_record.response_data.get("text") != message_in.text:
+ raise HTTPException(status_code=409, detail={"code": "conflict", "message": "Idempotency-Key already used with different payload"})
+ return Message(**existing_record.response_data)
+
+ new_message = MessageModel(chat_id=chat_id, sender_id=current_user.id, text=message_in.text)
+ db.add(new_message)
+ await db.commit()
+ await db.refresh(new_message)
+
+ response_data = {
+ "id": str(new_message.id),
+ "chat_id": str(new_message.chat_id),
+ "sender_id": str(new_message.sender_id),
+ "text": new_message.text,
+ "created_at": new_message.created_at.isoformat().replace('+00:00', 'Z')
+ }
+
+ db.add(IdempotencyKey(key=idempotency_key, chat_id=chat_id, response_data=response_data))
+ await db.commit()
+
+ try:
+ await redis_client.delete(f"messages:{chat_id}:*")
+ except Exception as e:
+ pass
+
+ return Message(**response_data)
+
+@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}})
+async def list_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100), cursor: str | None = None, current_user: UserModel = Depends(get_current_user), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
+ if not (await db.execute(select(ChatMemberModel).where(ChatMemberModel.chat_id == chat_id, ChatMemberModel.user_id == current_user.id))).scalar_one_or_none():
+ raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Chat not found or access denied"})
+
+ cache_key = f"messages:{chat_id}:{limit}:{cursor or 'null'}"
+ redis_available = True
+ try:
+ cached_data = await redis_client.get(cache_key)
+ if cached_data:
+ await redis_client.expire(cache_key, 60)
+ return MessagePage.model_validate_json(cached_data)
+ except Exception as e:
+ redis_available = False
+
+ lock_acquired = False
+ if redis_available:
+ lock_key = f"lock:{cache_key}"
+ try:
+ lock_acquired = await redis_client.set(lock_key, "1", nx=True, ex=5)
+ if not lock_acquired:
+ stale_data = await redis_client.get(f"stale:{cache_key}")
+ if stale_data: return MessagePage.model_validate_json(stale_data)
+ except Exception as e:
+ redis_available = False
+
+ stmt = select(MessageModel).where(MessageModel.chat_id == chat_id).order_by(MessageModel.created_at.asc(), MessageModel.id.asc())
+ if cursor:
+ try:
+ created_at_str, msg_id_str = cursor.split(",")
+ created_at = datetime.fromisoformat(created_at_str.replace("Z", "+00:00"))
+ msg_id = uuid.UUID(msg_id_str)
+ stmt = stmt.where((MessageModel.created_at > created_at) | ((MessageModel.created_at == created_at) & (MessageModel.id > msg_id)))
+ except (ValueError, TypeError):
+ raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid cursor"})
+
+ stmt = stmt.limit(limit + 1)
+ messages = (await db.execute(stmt)).scalars().all()
+ has_next = len(messages) > limit
+ if has_next:
+ messages = messages[:-1]
+ next_cursor = f"{messages[-1].created_at.isoformat().replace('+00:00', 'Z')},{messages[-1].id}"
+ else:
+ next_cursor = None
+
+ items = [Message(id=str(m.id), chat_id=str(m.chat_id), sender_id=str(m.sender_id), text=m.text, created_at=m.created_at.isoformat().replace('+00:00', 'Z')) for m in messages]
+ page = MessagePage(items=items, next_cursor=next_cursor)
+
+ if redis_available:
+ try:
+ old_cache = await redis_client.get(cache_key)
+ if old_cache: await redis_client.setex(f"stale:{cache_key}", 120, old_cache)
+ await redis_client.setex(cache_key, 60, page.model_dump_json())
+ if lock_acquired: await redis_client.delete(f"lock:{cache_key}")
+ except Exception as e:
+ pass
+ return page
\ No newline at end of file
diff --git a/app/schemas.py b/app/schemas.py
new file mode 100644
index 00000000..5d30457e
--- /dev/null
+++ b/app/schemas.py
@@ -0,0 +1,55 @@
+from pydantic import BaseModel, Field, ConfigDict
+from typing import List, Optional
+from datetime import datetime
+
+class User(BaseModel):
+ model_config = ConfigDict(from_attributes=True)
+ id: str
+ username: str
+ display_name: str
+ created_at: str
+
+class CreateUser(BaseModel):
+ username: str = Field(..., min_length=3, max_length=32, pattern="^[a-z0-9_]+$")
+ display_name: str = Field(..., min_length=1, max_length=100)
+ password: str = Field(..., min_length=12, max_length=128)
+
+class Session(BaseModel):
+ model_config = ConfigDict(from_attributes=True)
+ token: str
+ token_type: str
+ expires_at: datetime
+ user: User
+
+class Chat(BaseModel):
+ model_config = ConfigDict(from_attributes=True)
+ id: str
+ title: str
+ member_ids: List[str]
+ created_at: str
+
+class CreateChat(BaseModel):
+ title: str = Field(..., min_length=1, max_length=100)
+ member_ids: List[str]
+
+class ChatPage(BaseModel):
+ items: List[Chat]
+ next_cursor: Optional[str] = None
+
+class Message(BaseModel):
+ model_config = ConfigDict(from_attributes=True)
+ id: str
+ chat_id: str
+ sender_id: str
+ text: str
+ created_at: str
+
+class CreateMessage(BaseModel):
+ text: str = Field(..., min_length=1, max_length=4000)
+
+class MessagePage(BaseModel):
+ items: List[Message]
+ next_cursor: Optional[str] = None
+
+class ErrorResponse(BaseModel):
+ error: dict
\ No newline at end of file
diff --git a/compose.yaml b/compose.yaml
new file mode 100644
index 00000000..272d3466
--- /dev/null
+++ b/compose.yaml
@@ -0,0 +1,77 @@
+services:
+ postgres:
+ image: postgres:16.4-alpine
+ environment:
+ POSTGRES_USER: ${POSTGRES_USER}
+ POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+ POSTGRES_DB: ${POSTGRES_DB}
+ volumes:
+ - postgres_data:/var/lib/postgresql/data
+ healthcheck:
+ test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
+ interval: 5s
+ timeout: 5s
+ retries: 5
+
+ redis:
+ image: valkey/valkey:8.0-alpine
+ command: valkey-server --appendonly yes --save 60 1
+ volumes:
+ - redis_data:/data
+ healthcheck:
+ test: ["CMD", "valkey-cli", "ping"]
+ interval: 5s
+ timeout: 5s
+ retries: 5
+
+ api:
+ build:
+ context: .
+ dockerfile: Dockerfile
+ environment:
+ - DATABASE_URL=${DATABASE_URL}
+ - REDIS_URL=${REDIS_URL}
+ - SECRET_SESSION_KEY=${SECRET_SESSION_KEY}
+ - SESSION_TTL_SECONDS=${SESSION_TTL_SECONDS}
+ # ВАЖНО: Не публикуем порты наружу! Только Nginx имеет доступ к API
+ expose:
+ - "8080"
+ volumes:
+ - ./alembic/versions:/app/alembic/versions
+ - ./app:/app/app
+ depends_on:
+ postgres:
+ condition: service_healthy
+ redis:
+ condition: service_healthy
+ # Graceful shutdown: даём 30 секунд на завершение текущих запросов
+ stop_grace_period: 30s
+ healthcheck:
+ test: ["CMD", "curl", "-f", "http://localhost:8080/health/live"]
+ interval: 10s
+ timeout: 5s
+ retries: 3
+ start_period: 10s
+ deploy:
+ resources:
+ limits:
+ cpus: '0.5'
+ memory: 256M
+ reservations:
+ cpus: '0.25'
+ memory: 128M
+
+ nginx:
+ image: nginx:1.25-alpine
+ ports:
+ - "8080:8080"
+ volumes:
+ - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
+ depends_on:
+ api:
+ condition: service_healthy # <--- КРИТИЧНО: ждём, пока api станет healthy
+ restart: unless-stopped
+
+volumes:
+ postgres_data:
+ redis_data:
\ No newline at end of file
diff --git a/evidence/failover_demo.txt b/evidence/failover_demo.txt
new file mode 100644
index 00000000..9f0647f3
--- /dev/null
+++ b/evidence/failover_demo.txt
@@ -0,0 +1,13 @@
+=== Поиск запущенных API-реплик ===
+Выбрана реплика для остановки: mtusi2026lab3-api-1
+Останавливаем реплику...
+mtusi2026lab3-api-1
+Ждём 15 секунд...
+В это время Nginx должен перенаправлять трафик на оставшуюся реплику.
+Если в другом терминале запущен цикл curl, он может показать 1-2 ошибки, но затем продолжит работу.
+Запускаем реплику обратно...
+mtusi2026lab3-api-1
+Ждём 10 секунд, пока healthcheck не переведёт реплику в статус healthy...
+Сценарий отказа завершён. Проверка статуса:
+mtusi2026lab3-api-1 mtusi2026lab3-api "uvicorn app.main:ap…" api 41 minutes ago Up 10 seconds (healthy) 8080/tcp
+mtusi2026lab3-api-2 mtusi2026lab3-api "uvicorn app.main:ap…" api 34 minutes ago Up 34 minutes (healthy) 8080/tcp
diff --git a/evidence/smoke_pass.txt b/evidence/smoke_pass.txt
new file mode 100644
index 00000000..fc20f9dd
--- /dev/null
+++ b/evidence/smoke_pass.txt
@@ -0,0 +1 @@
+PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
diff --git a/nginx.conf b/nginx.conf
new file mode 100644
index 00000000..d7df2ae0
--- /dev/null
+++ b/nginx.conf
@@ -0,0 +1,22 @@
+upstream api_backend {
+ # Nginx будет автоматически резолвить имена через Docker DNS
+ server api:8080 max_fails=1 fail_timeout=5s;
+}
+
+server {
+ listen 8080;
+
+ # Проксирование ВСЕХ запросов на API реплики
+ location / {
+ proxy_pass http://api_backend;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ proxy_set_header X-Request-Id $http_x_request_id;
+
+ # Таймауты для graceful shutdown
+ proxy_connect_timeout 5s;
+ proxy_read_timeout 30s;
+ proxy_send_timeout 30s;
+ }
+}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..3790b888
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,9 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+sqlalchemy[asyncio]==2.0.35
+asyncpg==0.29.0
+pydantic-settings==2.5.2
+redis==5.1.0
+bcrypt==4.2.0
+alembic==1.13.2
+python-multipart==0.0.9
diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh
new file mode 100755
index 00000000..8778e6ff
--- /dev/null
+++ b/scripts/stop-one.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+# Эмуляция отказа одной API-реплики (требование Lab 3)
+
+set -e
+
+echo "=== Поиск запущенных API-реплик ==="
+# Находим первый запущенный контейнер api по полному имени
+TARGET_CONTAINER=$(docker compose ps --format "{{.Name}}\t{{.Status}}" | grep api | grep Up | head -n 1 | awk '{print $1}')
+
+if [ -z "$TARGET_CONTAINER" ]; then
+ echo "API-реплики не найдены или не запущены!"
+ exit 1
+fi
+
+echo "Выбрана реплика для остановки: $TARGET_CONTAINER"
+
+echo "Останавливаем реплику..."
+# Используем docker stop для конкретного контейнера, а не docker compose stop
+docker stop "$TARGET_CONTAINER"
+
+echo "Ждём 15 секунд..."
+echo "В это время Nginx должен перенаправлять трафик на оставшуюся реплику."
+echo "Если в другом терминале запущен цикл curl, он может показать 1-2 ошибки, но затем продолжит работу."
+sleep 15
+
+echo "Запускаем реплику обратно..."
+docker start "$TARGET_CONTAINER"
+
+echo "Ждём 10 секунд, пока healthcheck не переведёт реплику в статус healthy..."
+sleep 10
+
+echo "Сценарий отказа завершён. Проверка статуса:"
+docker compose ps | grep api
\ No newline at end of file