checklist/DEPLOY_DOCKPLOY.md

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)

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)

VITE_API_URL=https://api.tudominio.com

2. Actualizar CORS en Backend

Editar backend/app/main.py:

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:

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:

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:

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:

#!/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:

docker-compose -f docker-compose.prod.yml build
docker-compose -f docker-compose.prod.yml up -d

Ver logs:

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:

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')
"