# Guía de Deployment en Dockploy

## Arquitectura de Conexión

### Desarrollo (Docker Compose Local)
```
Frontend (localhost:5173) → Backend (localhost:8000) → PostgreSQL (localhost:5432)
```

### Producción (Dockploy)
```
Frontend (tudominio.com) → Backend (api.tudominio.com) → PostgreSQL (interno)
```

---

## 📋 Pasos para Deploy en Dockploy

### 1. Preparar Variables de Entorno

**Backend (.env)**
```bash
DATABASE_URL=postgresql://user:pass@postgres:5432/checklist_db
SECRET_KEY=tu-clave-secreta-minimo-32-caracteres-super-segura
OPENAI_API_KEY=tu-api-key-de-openai
ENVIRONMENT=production
ALLOWED_ORIGINS=https://tudominio.com,https://www.tudominio.com
```

**Frontend (.env)**
```bash
VITE_API_URL=https://api.tudominio.com
```

### 2. Actualizar CORS en Backend

Editar `backend/app/main.py`:
```python
import os

# CORS
allowed_origins = os.getenv("ALLOWED_ORIGINS", "http://localhost:5173").split(",")
app.add_middleware(
    CORSMiddleware,
    allow_origins=allowed_origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
```

### 3. Crear Dockerfile de Producción para Frontend

Crear `frontend/Dockerfile.prod`:
```dockerfile
FROM node:18-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

COPY . .
ARG VITE_API_URL
ENV VITE_API_URL=$VITE_API_URL

RUN npm run build

# Servidor Nginx para servir archivos estáticos
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
```

Crear `frontend/nginx.conf`:
```nginx
server {
    listen 80;
    server_name _;
    root /usr/share/nginx/html;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }

    # Configuración de cache para assets
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }
}
```

### 4. Estructura Recomendada en Dockploy

**Opción A: Servicios Separados (Recomendado)**
- **Servicio 1**: PostgreSQL (Base de datos interna)
- **Servicio 2**: Backend API (api.tudominio.com)
- **Servicio 3**: Frontend (tudominio.com)

**Opción B: Docker Compose en Dockploy**
Usar `docker-compose.prod.yml`:
```yaml
version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app-network

  backend:
    build: ./backend
    environment:
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      SECRET_KEY: ${SECRET_KEY}
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      ENVIRONMENT: production
      ALLOWED_ORIGINS: ${ALLOWED_ORIGINS}
    ports:
      - "8000:8000"
    depends_on:
      - postgres
    networks:
      - app-network

  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile.prod
      args:
        VITE_API_URL: ${VITE_API_URL}
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network

volumes:
  postgres_data:

networks:
  app-network:
    driver: bridge
```

### 5. Configuración de Dominios en Dockploy

1. **Backend API**: 
   - Dominio: `api.tudominio.com`
   - Puerto interno: `8000`
   - Habilitar SSL/TLS

2. **Frontend**:
   - Dominio: `tudominio.com`
   - Puerto interno: `80`
   - Habilitar SSL/TLS

3. **PostgreSQL**:
   - Solo acceso interno (no exponer públicamente)

### 6. Scripts de Migración

Crear `backend/migrate.sh`:
```bash
#!/bin/bash
# Ejecutar migraciones en producción
python -c "from app.core.database import Base, engine; Base.metadata.create_all(bind=engine)"
```

### 7. Health Checks

El backend ya tiene el endpoint de health. Dockploy puede monitorearlo:
```
GET https://api.tudominio.com/docs
```

---

## 🔐 Seguridad en Producción

1. **Variables de Entorno**:
   - Usar secretos de Dockploy, NO hardcodear
   - Cambiar `SECRET_KEY` a algo seguro (min 32 caracteres)
   - No exponer `DATABASE_URL` públicamente

2. **HTTPS**:
   - Dockploy maneja SSL automáticamente con Let's Encrypt
   - Asegurar que CORS solo acepte HTTPS en producción

3. **Database**:
   - NO exponer puerto 5432 públicamente
   - Usar credenciales fuertes
   - Configurar backups automáticos

---

## 📝 Checklist Pre-Deploy

- [ ] Cambiar `SECRET_KEY` en variables de entorno
- [ ] Configurar `VITE_API_URL` con dominio de producción
- [ ] Actualizar CORS con dominios de producción
- [ ] Crear Dockerfile.prod para frontend
- [ ] Configurar nginx.conf
- [ ] Probar build local: `docker-compose -f docker-compose.prod.yml up`
- [ ] Configurar dominios en Dockploy
- [ ] Habilitar SSL/TLS en ambos servicios
- [ ] Crear usuario admin inicial en producción
- [ ] Configurar backups de PostgreSQL

---

## 🎯 Comandos Útiles

**Build local de producción:**
```bash
docker-compose -f docker-compose.prod.yml build
docker-compose -f docker-compose.prod.yml up -d
```

**Ver logs:**
```bash
docker-compose -f docker-compose.prod.yml logs -f backend
docker-compose -f docker-compose.prod.yml logs -f frontend
```

**Crear usuario admin en producción:**
```bash
docker-compose -f docker-compose.prod.yml exec backend python -c "
from app.core.database import SessionLocal
from app.core.security import get_password_hash
from app.models import User

db = SessionLocal()
admin = User(
    username='admin',
    email='admin@tudominio.com',
    full_name='Administrador',
    hashed_password=get_password_hash('tu-password-segura'),
    role='admin',
    is_active=True
)
db.add(admin)
db.commit()
print('Admin creado exitosamente')
"
```