🚀 Deploy e Operacao

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Dependencias de sistema
RUN apt-get update && apt-get install -y \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# Dependencias Python
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Codigo da aplicacao
COPY app/ ./app/
COPY templates/ ./templates/
COPY static/ ./static/

# Variaveis de ambiente
ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1

# Porta
EXPOSE 8000

# Comando
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=sqlite:///./data/notebooklmx.db
      - GEMINI_API_KEY=${GEMINI_API_KEY}
      - LOG_LEVEL=INFO
    volumes:
      - ./data:/app/data
      - ./artifacts:/app/artifacts
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Opcional: Redis para cache
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

volumes:
  redis_data:

# app/config.py
from pydantic_settings import BaseSettings
from functools import lru_cache

class Settings(BaseSettings):
    # Database
    DATABASE_URL: str = "sqlite:///./notebooklmx.db"

    # API Keys
    GEMINI_API_KEY: str

    # Limites GIPM
    MAX_TOKENS_PER_REQUEST: int = 30000
    MAX_COST_PER_DAY_USD: float = 50.0
    MAX_FILE_SIZE_MB: int = 10

    # Logging
    LOG_LEVEL: str = "INFO"
    LOG_FORMAT: str = "json"

    # Ambiente
    ENVIRONMENT: str = "development"

    class Config:
        env_file = ".env"

@lru_cache()
def get_settings() -> Settings:
    return Settings()

# app/routers/health.py
from fastapi import APIRouter, Depends
from app.database import get_db

router = APIRouter()

@router.get("/health")
async def health_check(db: Session = Depends(get_db)):
    """Health check para load balancers"""
    try:
        # Verifica conexao com banco
        db.execute("SELECT 1")
        db_status = "healthy"
    except Exception:
        db_status = "unhealthy"

    return {
        "status": "healthy" if db_status == "healthy" else "degraded",
        "checks": {
            "database": db_status,
            "gemini_configured": bool(settings.GEMINI_API_KEY)
        }
    }

@router.get("/metrics")
async def metrics(db: Session = Depends(get_db)):
    """Metricas para observabilidade"""
    return {
        "total_notebooks": db.query(Notebook).count(),
        "total_messages": db.query(Message).count(),
        "total_cost_usd": db.query(func.sum(Message.cost_usd)).scalar() or 0
    }

# app/logging_config.py
import structlog
from app.config import get_settings

def configure_logging():
    settings = get_settings()

    structlog.configure(
        processors=[
            structlog.stdlib.filter_by_level,
            structlog.stdlib.add_logger_name,
            structlog.stdlib.add_log_level,
            structlog.processors.TimeStamper(fmt="iso"),
            structlog.processors.StackInfoRenderer(),
            structlog.processors.format_exc_info,
            structlog.processors.JSONRenderer()
            if settings.LOG_FORMAT == "json"
            else structlog.dev.ConsoleRenderer(),
        ],
        wrapper_class=structlog.stdlib.BoundLogger,
        context_class=dict,
        logger_factory=structlog.stdlib.LoggerFactory(),
        cache_logger_on_first_use=True,
    )

# Uso
log = structlog.get_logger()
log.info("request_processed", request_id="123", tokens=500, cost=0.002)

# Makefile
.PHONY: dev build deploy logs

# Desenvolvimento local
dev:
	uvicorn app.main:app --reload --port 8000

# Build da imagem
build:
	docker build -t notebooklmx:latest .

# Deploy com docker-compose
deploy:
	docker-compose up -d

# Logs em tempo real
logs:
	docker-compose logs -f app

# Backup do banco
backup:
	cp data/notebooklmx.db backups/notebooklmx_$(date +%Y%m%d).db

# Migracoes
migrate:
	alembic upgrade head

# Testes
test:
	pytest tests/ -v --cov=app

# Limpeza de artefatos antigos
cleanup:
	find artifacts/ -mtime +30 -delete