Skip to content

Configuración de Producción

Despliega Potato en producción con múltiples usuarios.

Configuración de Producción

Despliega Potato para tareas de anotación del mundo real con múltiples usuarios, persistencia de datos y seguridad adecuada.

Configuración del Servidor

Configuración Básica de Producción

yaml
server:
  host: 0.0.0.0
  port: 8000
  workers: 4
  timeout: 120

Usando HTTPS

Para conexiones seguras (recomendado para producción):

yaml
server:
  host: 0.0.0.0
  port: 443
  ssl:
    cert: /path/to/cert.pem
    key: /path/to/key.pem

Ejecución con Gunicorn

Para mejor rendimiento y confiabilidad:

bash
gunicorn "potato.server:create_app('config.yaml')" \
  --workers 4 \
  --bind 0.0.0.0:8000 \
  --timeout 120

Con SSL

bash
gunicorn "potato.server:create_app('config.yaml')" \
  --workers 4 \
  --bind 0.0.0.0:443 \
  --certfile /path/to/cert.pem \
  --keyfile /path/to/key.pem

Configuración de Proxy Inverso

Configuración de Nginx

nginx
upstream potato {
    server 127.0.0.1:8000;
}
 
server {
    listen 80;
    server_name annotation.example.com;
    return 301 https://$server_name$request_uri;
}
 
server {
    listen 443 ssl;
    server_name annotation.example.com;
 
    ssl_certificate /etc/letsencrypt/live/annotation.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/annotation.example.com/privkey.pem;
 
    location / {
        proxy_pass http://potato;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
 
    # Increase timeouts for long annotation sessions
    proxy_read_timeout 300;
    proxy_connect_timeout 300;
    proxy_send_timeout 300;
}

Configuración de Apache

apache
<VirtualHost *:443>
    ServerName annotation.example.com
 
    SSLEngine on
    SSLCertificateFile /path/to/cert.pem
    SSLCertificateKeyFile /path/to/key.pem
 
    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:8000/
    ProxyPassReverse / http://127.0.0.1:8000/
 
    <Proxy *>
        Order allow,deny
        Allow from all
    </Proxy>
</VirtualHost>

Despliegue con Docker

Dockerfile

dockerfile
FROM python:3.10-slim
 
WORKDIR /app
 
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY . .
 
EXPOSE 8000
 
CMD ["gunicorn", "potato.server:create_app('config.yaml')", \
     "--workers", "4", "--bind", "0.0.0.0:8000"]

Docker Compose

yaml
version: '3.8'
 
services:
  potato:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - ./data:/app/data
      - ./annotations:/app/annotations
    environment:
      - POTATO_DEBUG=false
    restart: unless-stopped
 
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./certs:/etc/ssl/certs
    depends_on:
      - potato
    restart: unless-stopped

Autenticación de Usuarios

Acceso Restringido

yaml
allow_all_users: false
authorized_users:
  - user1@example.com
  - user2@example.com
  - user3@example.com

Acceso de Administrador

yaml
admin_users:
  - admin@example.com
 
admin_dashboard:
  enabled: true
  path: /admin

Gestión de Sesiones

yaml
session:
  secret_key: "your-secure-secret-key-here"
  timeout: 3600  # 1 hour
  secure_cookie: true  # Requires HTTPS

Persistencia de Datos

Almacenamiento Basado en Archivos

yaml
output:
  path: /var/potato/annotations/
  format: json
  backup_interval: 3600  # Hourly backups

Backend de Base de Datos

Para despliegues más grandes, usa MySQL:

yaml
database:
  type: mysql
  host: localhost
  port: 3306
  name: potato_db
  user: potato
  password: ${DB_PASSWORD}  # Use environment variable

Consulta MySQL Backend para más detalles.

Monitoreo

Endpoint de Verificación de Salud

yaml
monitoring:
  health_check: /health
  metrics: /metrics

Configuración de Registro

yaml
logging:
  level: INFO
  file: /var/log/potato/app.log
  max_size: 100MB
  backup_count: 5
  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

Métricas de Prometheus

yaml
monitoring:
  prometheus:
    enabled: true
    port: 9090

Escalabilidad

Escalado Horizontal

Para despliegues con alto tráfico:

yaml
# docker-compose.yml
services:
  potato:
    deploy:
      replicas: 3
    # ... rest of config
 
  nginx:
    # Load balancer
    volumes:
      - ./nginx-lb.conf:/etc/nginx/nginx.conf

Configuración del Balanceador de Carga

nginx
upstream potato_cluster {
    least_conn;
    server potato_1:8000;
    server potato_2:8000;
    server potato_3:8000;
}

Estrategia de Respaldo

Respaldos Automatizados

bash
#!/bin/bash
# backup.sh
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR=/var/backups/potato
 
# Backup annotations
tar -czf $BACKUP_DIR/annotations_$DATE.tar.gz /var/potato/annotations/
 
# Backup config
cp /var/potato/config.yaml $BACKUP_DIR/config_$DATE.yaml
 
# Keep only last 7 days
find $BACKUP_DIR -mtime +7 -delete

Agrega al crontab:

bash
0 2 * * * /var/potato/backup.sh

Lista de Verificación de Seguridad

  • Usar HTTPS con certificado SSL válido
  • Establecer una clave secreta de sesión segura
  • Restringir el acceso de usuarios con authorized_users
  • Mantener Potato y sus dependencias actualizados
  • Usar variables de entorno para datos sensibles
  • Configurar reglas de firewall
  • Habilitar registro y monitoreo
  • Configurar respaldos regulares
  • Usar backend de base de datos para producción
  • Revisar el acceso de administrador regularmente

Variables de Entorno

bash
# .env file
POTATO_SECRET_KEY=your-super-secret-key
POTATO_DB_PASSWORD=database-password
POTATO_ADMIN_EMAIL=admin@example.com

Carga en Docker Compose:

yaml
services:
  potato:
    env_file:
      - .env

Solución de Problemas

Revisar Logs

bash
# Gunicorn logs
journalctl -u potato -f
 
# Docker logs
docker-compose logs -f potato

Problemas Comunes

502 Bad Gateway: Verifica que Potato esté ejecutándose y vinculado al puerto correcto

Problemas de sesión: Asegúrate de que la clave secreta sea consistente entre reinicios

Rendimiento lento: Aumenta el número de workers o agrega un backend de base de datos

Próximos Pasos