Instalação com Docker

# Verificar Docker
docker --version
# Docker version 24.0.7, build afdd53b

# Verificar Docker Compose
docker compose version
# Docker Compose version v2.23.0

# Verificar recursos
docker system info | grep -E 'CPUs|Total Memory'

# Clone o repositório
git clone https://github.com/sinapse/core-api.git
cd core-api

# Ou com SSH (recomendado)
git clone [email protected]:sinapse/core-api.git
cd core-api

# Copiar arquivo de exemplo
cp .env.example .env

# Gerar secret key
python -c "import secrets; print(secrets.token_urlsafe(32))"
# Copie a saída e use como SECRET_KEY no .env

# Editar configurações
nano .env  # ou use seu editor preferido

# Aplicação
APP_NAME=Sinapse
APP_VERSION=1.0.0
DEBUG=true
ENVIRONMENT=development

# Segurança
SECRET_KEY=sua_secret_key_gerada_acima
JWT_SECRET_KEY=outra_secret_key_diferente
JWT_ALGORITHM=HS256
JWT_EXPIRATION_MINUTES=60

# Banco de Dados
DATABASE_URL=postgresql+asyncpg://sinapse:sinapse123@postgres:5432/sinapse_db
POSTGRES_USER=sinapse
POSTGRES_PASSWORD=sinapse123
POSTGRES_DB=sinapse_db

# Redis
REDIS_URL=redis://redis:6379/0

# Inicialização
INIT_ADMIN_EMAIL=[email protected]
INIT_ADMIN_PASSWORD=Admin123!
INIT_ADMIN_NAME=Administrador

# CORS (desenvolvimento)
CORS_ORIGINS=["http://localhost:3000","http://localhost:8000"]

# Build das imagens
docker compose build

# Iniciar serviços
docker compose up -d

# Verificar logs
docker compose logs -f

# Aguardar PostgreSQL estar pronto
docker compose exec postgres pg_isready
# /var/run/postgresql:5432 - accepting connections

# Executar migrações
docker compose exec api alembic upgrade head

# Criar dados iniciais (admin, grupos, permissões)
docker compose exec api python scripts/create_initial_data.py

# Verificar saúde da API
curl http://localhost:8000/api/v1/health

version: '3.9'

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: sinapse_api
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql+asyncpg://sinapse:sinapse123@postgres:5432/sinapse_db
      - REDIS_URL=redis://redis:6379/0
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    volumes:
      - ./logs:/app/logs
      - ./uploads:/app/uploads
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  postgres:
    image: postgres:15-alpine
    container_name: sinapse_postgres
    environment:
      POSTGRES_USER: sinapse
      POSTGRES_PASSWORD: sinapse123
      POSTGRES_DB: sinapse_db
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./scripts/init-db.sql:/docker-entrypoint-initdb.d/init.sql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U sinapse"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    container_name: sinapse_redis
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  pgadmin:
    image: dpage/pgadmin4:latest
    container_name: sinapse_pgadmin
    environment:
      PGADMIN_DEFAULT_EMAIL: [email protected]
      PGADMIN_DEFAULT_PASSWORD: admin123
    ports:
      - "5050:80"
    depends_on:
      - postgres
    profiles:
      - debug

volumes:
  postgres_data:
  redis_data:

FROM python:3.11-slim

# Instalar dependências do sistema
RUN apt-get update && apt-get install -y \
    gcc \
    libpq-dev \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Definir diretório de trabalho
WORKDIR /app

# Copiar arquivos de requirements
COPY requirements.txt .
COPY requirements-dev.txt .

# Instalar dependências Python
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código da aplicação
COPY . .

# Criar diretórios necessários
RUN mkdir -p /app/logs /app/uploads

# Expor porta
EXPOSE 8000

# Healthcheck
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
  CMD curl -f http://localhost:8000/api/v1/health || exit 1

# Comando de inicialização
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

# Verificar status
docker compose ps

# Parar serviços
docker compose stop

# Reiniciar serviços
docker compose restart

# Remover tudo (CUIDADO!)
docker compose down -v

# Logs em tempo real
docker compose logs -f api

# Logs de um serviço específico
docker compose logs postgres --tail=100

# Shell no container da API
docker compose exec api bash

# Console Python interativo
docker compose exec api python
>>> from modules.usuarios.models import UsuarioModel
>>> # Explorar modelos

# PostgreSQL CLI
docker compose exec postgres psql -U sinapse -d sinapse_db

# Redis CLI
docker compose exec redis redis-cli

# Backup do banco
docker compose exec postgres pg_dump -U sinapse sinapse_db > backup_$(date +%Y%m%d_%H%M%S).sql

# Restaurar backup
docker compose exec -T postgres psql -U sinapse sinapse_db < backup_20250729_120000.sql

# Criar nova migração
docker compose exec api alembic revision --autogenerate -m "descrição da mudança"

# Aplicar migrações
docker compose exec api alembic upgrade head

# Reverter última migração
docker compose exec api alembic downgrade -1

# Edite qualquer arquivo Python
# O servidor recarregará automaticamente

# Ver logs do reload
docker compose logs -f api | grep -i reload

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Python: Remote Attach",
      "type": "python",
      "request": "attach",
      "connect": {
        "host": "localhost",
        "port": 5678
      },
      "pathMappings": [
        {
          "localRoot": "${workspaceFolder}",
          "remoteRoot": "/app"
        }
      ]
    }
  ]
}

# Em main.py ou config.py
import debugpy

if settings.DEBUG:
    debugpy.listen(("0.0.0.0", 5678))
    print("Waiting for debugger...")
    # debugpy.wait_for_client()  # Descomentar para pausar

# Executar todos os testes
docker compose exec api pytest

# Testes com cobertura
docker compose exec api pytest --cov=modules --cov-report=html

# Teste específico
docker compose exec api pytest tests/test_auth.py -v

# Testes com output
docker compose exec api pytest -s

# Login com admin criado
curl -X POST http://localhost:8000/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "[email protected]",
    "senha": "Admin123!"
  }'

# Verificar logs detalhados
docker compose logs api --tail=50

# Verificar variáveis de ambiente
docker compose exec api env | grep -E 'DATABASE|REDIS'

# Testar conexão com postgres
docker compose exec api python -c "
from sqlalchemy import create_engine
engine = create_engine('postgresql://sinapse:sinapse123@postgres:5432/sinapse_db')
conn = engine.connect()
print('Conexão OK')
"

# Ver status das migrações
docker compose exec api alembic current

# Ver histórico
docker compose exec api alembic history

# Recriar banco (DESENVOLVIMENTO APENAS!)
docker compose down -v
docker compose up -d postgres
docker compose exec api alembic upgrade head

# Verificar recursos
docker stats

# Limpar cache/volumes não usados
docker system prune -a --volumes

# Aumentar recursos no Docker Desktop
# Settings > Resources > Advanced
# - CPUs: 4+
# - Memory: 8GB+

# Verificar rede Docker
docker network ls
docker network inspect core-api_default

# Testar conectividade entre containers
docker compose exec api ping postgres
docker compose exec api nc -zv redis 6379

# docker-compose.override.yml
services:
  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    profiles:
      - monitoring

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    profiles:
      - monitoring

docker compose --profile monitoring up -d