POST   /api/v1/auth/register        # Регистрация пользователя
POST   /api/v1/auth/login           # Аутентификация
POST   /api/v1/auth/refresh         # Обновление токенов
POST   /api/v1/auth/logout          # Выход из системы
GET    /api/v1/users/me             # Получение профиля
PUT    /api/v1/users/me             # Обновление профиля
POST   /api/v1/identifiers/verify   # Верификация email/phone

POST /api/v1/auth/register HTTP/2
Host: api.aiops.io
Content-Type: application/json
User-Agent: AIOps-Web/1.0

{
  "username": "john_doe",
  "email": "john@example.com",
  "password": "SecureP@ssw0rd!"
}

HTTP/2 201 Created
Content-Type: application/json

{
  "user": {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "username": "john_doe",
    "status": "active",
    "created_at": "2024-03-09T10:30:00Z"
  },
  "tokens": {
    "access_token": "eyJhbGciOiJSUzI1NiIs...",
    "refresh_token": "eyJhbGciOiJSUzI1NiIs...",
    "expires_in": 900
  }
}

// identity.proto
service IdentityService {
  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
  rpc GetUser(GetUserRequest) returns (GetUserResponse);
  rpc GetUserByUsername(GetUserByUsernameRequest) returns (GetUserResponse);
  rpc GetUserByIdentifier(GetUserByIdentifierRequest) returns (GetUserResponse);
}

// credential.proto
service CredentialService {
  rpc SetPassword(SetPasswordRequest) returns (SetPasswordResponse);
  rpc VerifyPassword(VerifyPasswordRequest) returns (VerifyPasswordResponse);
  rpc ChangePassword(ChangePasswordRequest) returns (ChangePasswordResponse);
}

import grpc
from aiops.identity.v1 import identity_pb2, identity_pb2_grpc

async with grpc.aio.insecure_channel('identity-service:50051') as channel:
    stub = identity_pb2_grpc.IdentityServiceStub(channel)

    response = await stub.GetUser(
        identity_pb2.GetUserRequest(user_id=user_id)
    )

    print(f"User: {response.user.username}")

# sqlalchemy-postgres-kit
async_engine = create_async_engine(
    DATABASE_URL,
    pool_size=20,              # Max connections per pod
    max_overflow=10,           # Burst capacity
    pool_pre_ping=True,        # Health check before use
    pool_recycle=3600,         # Recycle connections after 1h
)

# redis-client-kit
redis_client = AsyncRedisClient(
    host="redis-master",
    port=6379,
    max_connections=50,
    socket_keepalive=True,
    health_check_interval=30,
)

@cache(ttl=300, key_prefix="user")
async def get_user_by_id(user_id: UUID) -> User | None:
    """
    1. Check Redis cache
    2. If miss, query PostgreSQL
    3. Store result in Redis
    """
    cached = await redis.get(f"user:{user_id}")
    if cached:
        return User.parse_raw(cached)

    user = await db.query(UserDB).filter_by(id=user_id).first()
    if user:
        await redis.setex(
            f"user:{user_id}",
            ttl=300,
            value=user.to_domain().json()
        )

    return user.to_domain() if user else None

from aiodataloader import DataLoader

class UserLoader(DataLoader):
    async def batch_load_fn(self, user_ids: list[UUID]) -> list[User | None]:
        """Load multiple users in single query"""
        users = await db.query(UserDB).filter(
            UserDB.id.in_(user_ids)
        ).all()

        user_map = {u.id: u for u in users}
        return [user_map.get(uid) for uid in user_ids]

# Usage in single request
user_loader = UserLoader()

# These calls are batched into single DB query
user1 = await user_loader.load(user_id_1)
user2 = await user_loader.load(user_id_2)
user3 = await user_loader.load(user_id_3)

from opentelemetry import trace

tracer = trace.get_tracer(__name__)

@tracer.start_as_current_span("get_user")
async def get_user(user_id: UUID) -> User:
    with tracer.start_as_current_span("cache.get"):
        cached = await redis.get(f"user:{user_id}")

    if not cached:
        with tracer.start_as_current_span("db.query"):
            user = await db.query(UserDB).get(user_id)

        with tracer.start_as_current_span("cache.set"):
            await redis.setex(f"user:{user_id}", 300, user.json())

    return user

from prometheus_client import Histogram, Counter

request_duration = Histogram(
    'http_request_duration_seconds',
    'HTTP request latency',
    ['method', 'endpoint', 'status']
)

cache_hits = Counter(
    'cache_hits_total',
    'Number of cache hits',
    ['cache_type', 'key_prefix']
)

cache_misses = Counter(
    'cache_misses_total',
    'Number of cache misses',
    ['cache_type', 'key_prefix']
)

from circuitbreaker import circuit

@circuit(failure_threshold=5, recovery_timeout=60)
async def call_external_service():
    """Auto-open circuit after 5 failures"""
    response = await http_client.post(...)
    return response

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=1, max=10)
)
async def query_database():
    """Retry DB query up to 3 times"""
    return await db.query(...)