Configuración de Supervisor para Gestión de Procesos: Guía Completa de Monitoreo de Aplicaciones

Supervisor es un sistema cliente/servidor que permite a los usuarios monitorear y controlar procesos en sistemas operativos tipo UNIX. A diferencia de los sistemas init tradicionales, Supervisor está diseñado específicamente para la gestión de procesos, ofreciendo reinicios automáticos, registro centralizado y un formato de configuración simple. Esta guía completa cubre la instalación, configuración y mejores prácticas de Supervisor para gestionar aplicaciones de producción de manera confiable.

Introducción

Las aplicaciones modernas a menudo consisten en múltiples procesos que deben ejecutarse continuamente: servidores web, colas de trabajadores, tareas programadas, agentes de monitoreo y demonios personalizados. Gestionar estos procesos manualmente se vuelve propenso a errores y consume tiempo. Supervisor resuelve este problema proporcionando una gestión robusta de procesos con mínima complejidad.

¿Por Qué Usar Supervisor?

Reinicio Automático: Los procesos que fallan se reinician automáticamente, asegurando alta disponibilidad sin intervención manual.

Gestión Centralizada: Controla múltiples procesos desde un único archivo de configuración e interfaz de línea de comandos, simplificando las operaciones.

Monitoreo de Procesos: Rastrea el estado, uso de recursos y tiempo de actividad de los procesos a través de una interfaz web simple o herramientas de línea de comandos.

Registro Consistente: Captura stdout y stderr de todos los procesos gestionados en una ubicación estandarizada, facilitando la depuración.

Privilegios de Usuario: Ejecuta procesos como usuarios específicos con permisos controlados, mejorando la seguridad.

Configuración Simple: Los archivos de configuración estilo INI son fáciles de leer, escribir y mantener en comparación con scripts init complejos.

Grupos de Procesos: Organiza procesos relacionados en grupos para operaciones masivas (iniciar todos los workers, reiniciar todos los servidores web, etc.).

Supervisor vs. Systemd

Aunque las distribuciones Linux modernas incluyen systemd para la gestión de servicios, Supervisor ofrece ventajas distintivas:

• Enfocado en aplicaciones: Diseñado específicamente para procesos de aplicación, no servicios del sistema
• Multiplataforma: Funciona consistentemente en diferentes distribuciones Linux
• Configuración más simple: El formato INI es más intuitivo que los archivos de unidad systemd
• Mejor adaptado para aplicaciones no-root: Más fácil de gestionar aplicaciones como usuarios regulares
• Interfaz web: Panel web integrado para monitoreo
• Amigable para desarrollo: Fácil de usar en entornos de desarrollo

Supervisor sobresale en la gestión de procesos a nivel de aplicación, mientras que systemd es mejor para servicios a nivel de sistema. Muchas implementaciones usan ambos: systemd gestiona Supervisor, mientras que Supervisor gestiona los procesos de aplicación.

Casos de Uso Comunes

• Workers de Aplicaciones Web: Gestionar procesos Celery, RQ o workers personalizados
• Servidores de Aplicaciones: Ejecutar aplicaciones Gunicorn, uWSGI o Node.js
• Procesadores de Colas: Monitorear y reiniciar consumidores de colas de mensajes
• Tareas Programadas: Gestionar procesos de larga duración tipo cron
• Microservicios: Coordinar múltiples procesos de servicio
• Entornos de Desarrollo: Gestionar procesos de desarrollo local
• Aplicaciones Legacy: Envolver aplicaciones sin soporte nativo de servicios

Prerequisitos

Antes de instalar Supervisor, asegúrate de que tu sistema cumple con los requisitos.

Requisitos del Sistema

Requisitos Mínimos:

• Servidor Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+, Rocky Linux 8+)
• Python 2.7 o Python 3.4+ (usualmente preinstalado)
• 256MB RAM
• 100MB espacio en disco
• Acceso root o sudo (para instalación a nivel de sistema)

Recomendado para Producción:

• 512MB+ RAM
• 1GB+ espacio en disco (para logs)
• Monitoreo y alertas dedicados
• Estrategia de respaldo para archivos de configuración

Prerequisitos de Software

• Python (2.7 o 3.4+)
• pip (gestor de paquetes Python)
• Editor de texto (vim, nano, etc.)
• Comprensión básica de gestión de procesos

Requisitos de la Aplicación

Antes de usar Supervisor para gestionar tu aplicación:

• La aplicación debe ejecutarse en primer plano (no convertirse en demonio)
• Comprensión clara de los argumentos de línea de comandos
• Usuario/grupo conocido para ejecución del proceso
• Directorio de trabajo identificado
• Variables de entorno documentadas

Instalación

Supervisor puede instalarse a través de gestores de paquetes o pip de Python.

Método 1: Instalación por Gestor de Paquetes (Recomendado)

Instalación en Ubuntu/Debian

# Actualizar índice de paquetes
sudo apt update

# Instalar Supervisor
sudo apt install -y supervisor

# Verificar instalación
supervisord --version

Instalación en CentOS/Rocky Linux

# Habilitar repositorio EPEL
sudo dnf install -y epel-release

# Instalar Supervisor
sudo dnf install -y supervisor

# Verificar instalación
supervisord --version

Habilitar e Iniciar Servicio

# Habilitar Supervisor para iniciar al arrancar
sudo systemctl enable supervisord

# Iniciar Supervisor
sudo systemctl start supervisord

# Verificar estado
sudo systemctl status supervisord

Método 2: Instalación por Python pip

Para la última versión o instalaciones personalizadas:

# Instalar vía pip (a nivel de sistema)
sudo pip3 install supervisor

# O instalar en entorno virtual
python3 -m venv /opt/supervisor-env
source /opt/supervisor-env/bin/activate
pip install supervisor

# Verificar instalación
supervisord --version

Crear Directorio de Configuración

# Crear directorios
sudo mkdir -p /etc/supervisor/conf.d
sudo mkdir -p /var/log/supervisor

# Generar configuración por defecto
echo_supervisord_conf | sudo tee /etc/supervisor/supervisord.conf

# Configurar para incluir configuraciones adicionales
sudo tee -a /etc/supervisor/supervisord.conf << 'EOF'

[include]
files = /etc/supervisor/conf.d/*.conf
EOF

Crear Servicio Systemd (para instalación pip)

Crear /etc/systemd/system/supervisord.service:

[Unit]
Description=Supervisor process control system
Documentation=http://supervisord.org
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/bin/supervisord -c /etc/supervisor/supervisord.conf
ExecReload=/usr/local/bin/supervisorctl reload
ExecStop=/usr/local/bin/supervisorctl shutdown
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Habilitar e iniciar:

sudo systemctl daemon-reload
sudo systemctl enable supervisord
sudo systemctl start supervisord

Método 3: Gestión de Contenedores Docker

Usar Supervisor dentro de contenedores Docker:

Ejemplo de Dockerfile:

FROM ubuntu:22.04

RUN apt-get update && apt-get install -y \
    supervisor \
    python3 \
    python3-pip \
    && rm -rf /var/lib/apt/lists/*

COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
COPY app.py /app/app.py

WORKDIR /app

CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/supervisord.conf"]

Verificación Post-Instalación

# Verificar estado de Supervisor
sudo supervisorctl status

# Verificar versión
supervisord --version

# Verificar configuración
sudo supervisord -c /etc/supervisor/supervisord.conf -t

# Verificar procesos en ejecución
ps aux | grep supervisord

Configuración

Supervisor usa archivos de configuración estilo INI. Comprender la estructura de configuración es esencial para una gestión efectiva de procesos.

Archivo de Configuración Principal

Ubicación: /etc/supervisor/supervisord.conf (instalación por paquete) o ubicación personalizada

Secciones Clave:

[unix_http_server] - Interfaz de Socket UNIX

[unix_http_server]
file=/var/run/supervisor.sock   ; Ruta del archivo de socket UNIX
chmod=0700                       ; Permisos del archivo de socket
chown=nobody:nogroup            ; Propietario del archivo de socket

[inet_http_server] - Interfaz Web

[inet_http_server]
port=127.0.0.1:9001             ; IP y puerto para interfaz web
username=admin                   ; Nombre de usuario para autenticación
password=secure_password_here   ; Contraseña para autenticación

Nota de Seguridad: Solo enlazar a localhost (127.0.0.1) a menos que uses reglas de firewall. Nunca exponer sin autenticación.

[supervisord] - Configuración del Proceso Principal

[supervisord]
logfile=/var/log/supervisor/supervisord.log  ; Archivo de log principal
logfile_maxbytes=50MB                        ; Tamaño máximo de archivo de log
logfile_backups=10                           ; Número de respaldos de log
loglevel=info                                ; Nivel de log (critical, error, warn, info, debug, trace)
pidfile=/var/run/supervisord.pid             ; Ubicación del archivo PID
nodaemon=false                               ; Ejecutar en primer plano (false para modo demonio)
minfds=1024                                  ; Descriptores de archivo mínimos
minprocs=200                                 ; Descriptores de proceso mínimos
user=root                                    ; Usuario para ejecutar supervisord

[supervisorctl] - Configuración de Interfaz de Control

[supervisorctl]
serverurl=unix:///var/run/supervisor.sock    ; Usar socket UNIX
; serverurl=http://127.0.0.1:9001           ; O usar socket TCP
username=admin                                ; Nombre de usuario para auth
password=secure_password_here                ; Contraseña para auth

[include] - Incluir Archivos de Configuración Adicionales

[include]
files = /etc/supervisor/conf.d/*.conf

Configuración de Programas

Crear archivos de configuración individuales para cada aplicación en /etc/supervisor/conf.d/.

Configuración Básica de Programa

Crear /etc/supervisor/conf.d/myapp.conf:

[program:myapp]
command=/usr/bin/python3 /opt/myapp/app.py           ; Comando a ejecutar
directory=/opt/myapp                                  ; Directorio de trabajo
user=myappuser                                        ; Ejecutar como este usuario
autostart=true                                        ; Iniciar al arranque de supervisor
autorestart=true                                      ; Reiniciar si el proceso termina
startretries=3                                        ; Número de intentos de reinicio
redirect_stderr=true                                  ; Redirigir stderr a stdout
stdout_logfile=/var/log/supervisor/myapp.log         ; Ubicación del archivo de log
stdout_logfile_maxbytes=10MB                         ; Tamaño máximo de archivo de log
stdout_logfile_backups=5                             ; Número de respaldos de log
environment=PATH="/usr/local/bin",PYTHONPATH="/opt/myapp"  ; Variables de entorno

Configuración Avanzada de Programa

[program:worker]
command=/opt/venv/bin/celery -A myproject worker --loglevel=info
directory=/opt/myproject
user=worker
numprocs=4                                            ; Ejecutar 4 instancias
process_name=%(program_name)s_%(process_num)02d     ; Nombres únicos para cada instancia
autostart=true
autorestart=true
startsecs=10                                          ; El proceso debe permanecer ejecutándose 10s
startretries=3
stopwaitsecs=600                                      ; Esperar 600s para apagado gracioso
stopasgroup=true                                      ; Detener grupo de procesos
killasgroup=true                                      ; Matar grupo completo de procesos
priority=999                                          ; Prioridad de inicio (menor inicia primero)
redirect_stderr=true
stdout_logfile=/var/log/supervisor/worker-%(process_num)02d.log
stdout_logfile_maxbytes=10MB
stdout_logfile_backups=5
stderr_logfile=/var/log/supervisor/worker-%(process_num)02d-error.log
environment=
    DJANGO_SETTINGS_MODULE="myproject.settings",
    DATABASE_URL="postgresql://user:pass@localhost/db",
    REDIS_URL="redis://localhost:6379/0"

Configuración de Grupos

Organizar procesos relacionados en grupos:

[group:webservers]
programs=gunicorn1,gunicorn2,nginx_frontend
priority=999

[program:gunicorn1]
command=/opt/venv/bin/gunicorn myapp.wsgi:application -b 127.0.0.1:8001
directory=/opt/myapp
user=www-data
autostart=true
autorestart=true
redirect_stderr=true
stdout_logfile=/var/log/supervisor/gunicorn1.log

[program:gunicorn2]
command=/opt/venv/bin/gunicorn myapp.wsgi:application -b 127.0.0.1:8002
directory=/opt/myapp
user=www-data
autostart=true
autorestart=true
redirect_stderr=true
stdout_logfile=/var/log/supervisor/gunicorn2.log

Configuración de Listeners de Eventos

Monitorear eventos de procesos y activar acciones:

[eventlistener:memmon]
command=/opt/venv/bin/memmon -a 200MB -m [email protected]
events=TICK_60

Aplicar Cambios de Configuración

Después de crear o modificar configuraciones:

# Recargar configuración
sudo supervisorctl reread

# Actualizar con nueva configuración
sudo supervisorctl update

# O reiniciar supervisord completamente
sudo systemctl restart supervisord

# Verificar que los programas están cargados
sudo supervisorctl status

Ejemplos Prácticos

Ejemplo 1: Gestionar Aplicación Django con Gunicorn

Estructura de la Aplicación:

/opt/mydjango/
├── manage.py
├── mydjango/
│   ├── __init__.py
│   ├── settings.py
│   └── wsgi.py
└── venv/

Configuración de Supervisor (/etc/supervisor/conf.d/django.conf):

[program:django_gunicorn]
command=/opt/mydjango/venv/bin/gunicorn \
    --workers 4 \
    --bind 127.0.0.1:8000 \
    --timeout 60 \
    --access-logfile /var/log/django/access.log \
    --error-logfile /var/log/django/error.log \
    mydjango.wsgi:application

directory=/opt/mydjango
user=www-data
group=www-data
autostart=true
autorestart=true
startsecs=10
stopwaitsecs=30
stopasgroup=true
killasgroup=true
redirect_stderr=true
stdout_logfile=/var/log/supervisor/django_gunicorn.log
stdout_logfile_maxbytes=10MB
stdout_logfile_backups=5

environment=
    DJANGO_SETTINGS_MODULE="mydjango.settings",
    SECRET_KEY="your-secret-key",
    DATABASE_URL="postgresql://user:pass@localhost/mydb"

Aplicar Configuración:

# Crear directorio de logs
sudo mkdir -p /var/log/django
sudo chown www-data:www-data /var/log/django

# Actualizar Supervisor
sudo supervisorctl reread
sudo supervisorctl update

# Iniciar aplicación
sudo supervisorctl start django_gunicorn

# Verificar estado
sudo supervisorctl status django_gunicorn

Ejemplo 2: Gestionar Workers Celery

Configuración (/etc/supervisor/conf.d/celery.conf):

; Celery Worker
[program:celery_worker]
command=/opt/myapp/venv/bin/celery -A myapp worker --loglevel=info --concurrency=4
directory=/opt/myapp
user=celery
numprocs=1
autostart=true
autorestart=true
startsecs=10
stopwaitsecs=600
stopasgroup=true
killasgroup=true
priority=998
redirect_stderr=true
stdout_logfile=/var/log/supervisor/celery_worker.log
stdout_logfile_maxbytes=50MB
stdout_logfile_backups=10
environment=DJANGO_SETTINGS_MODULE="myapp.settings"

; Celery Beat (Programador)
[program:celery_beat]
command=/opt/myapp/venv/bin/celery -A myapp beat --loglevel=info
directory=/opt/myapp
user=celery
numprocs=1
autostart=true
autorestart=true
startsecs=10
stopwaitsecs=60
priority=999
redirect_stderr=true
stdout_logfile=/var/log/supervisor/celery_beat.log
stdout_logfile_maxbytes=10MB
stdout_logfile_backups=5
environment=DJANGO_SETTINGS_MODULE="myapp.settings"

; Grupo para gestión fácil
[group:celery]
programs=celery_worker,celery_beat
priority=999

Comandos de Gestión:

# Iniciar todos los procesos Celery
sudo supervisorctl start celery:*

# Detener todos los procesos Celery
sudo supervisorctl stop celery:*

# Reiniciar todos los procesos Celery
sudo supervisorctl restart celery:*

# Verificar estado
sudo supervisorctl status celery:*

Ejemplo 3: Gestionar Aplicación Node.js

Configuración (/etc/supervisor/conf.d/nodejs.conf):

[program:nodejs_app]
command=/usr/bin/node /opt/nodeapp/server.js
directory=/opt/nodeapp
user=nodejs
autostart=true
autorestart=true
startsecs=5
startretries=3
stopwaitsecs=10
redirect_stderr=true
stdout_logfile=/var/log/supervisor/nodejs_app.log
stdout_logfile_maxbytes=10MB
stdout_logfile_backups=5
environment=
    NODE_ENV="production",
    PORT="3000",
    DATABASE_URL="mongodb://localhost:27017/mydb"

Ejemplo 4: Gestionar Múltiples Instancias

Configuración (/etc/supervisor/conf.d/api_servers.conf):

[program:api_server]
command=/opt/api/venv/bin/gunicorn api.wsgi:application --bind 127.0.0.1:%(process_num)s
directory=/opt/api
user=api
numprocs=4
process_name=%(program_name)s_%(process_num)s
autostart=true
autorestart=true
startsecs=10
stopwaitsecs=30
redirect_stderr=true
stdout_logfile=/var/log/supervisor/api_server_%(process_num)s.log
environment=PORT="800%(process_num)s"

Esto crea 4 instancias:

• api_server_8000 (escuchando en puerto 8000)
• api_server_8001 (escuchando en puerto 8001)
• api_server_8002 (escuchando en puerto 8002)
• api_server_8003 (escuchando en puerto 8003)

Ejemplo 5: Script de Aplicación Personalizada

Script de Aplicación (/opt/scripts/data_processor.py):

#!/usr/bin/env python3
import time
import sys
import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    stream=sys.stdout
)

logger = logging.getLogger(__name__)

def main():
    logger.info("Data processor started")

    while True:
        try:
            # Simular procesamiento de datos
            logger.info("Processing data batch...")
            time.sleep(10)

        except KeyboardInterrupt:
            logger.info("Received shutdown signal")
            break
        except Exception as e:
            logger.error(f"Error processing data: {e}")
            time.sleep(5)

    logger.info("Data processor stopped")

if __name__ == "__main__":
    main()

Configuración de Supervisor:

[program:data_processor]
command=/usr/bin/python3 /opt/scripts/data_processor.py
directory=/opt/scripts
user=processor
autostart=true
autorestart=true
startsecs=5
redirect_stderr=true
stdout_logfile=/var/log/supervisor/data_processor.log
stdout_logfile_maxbytes=10MB
stdout_logfile_backups=5

Verificación

Verificar Estado del Proceso

# Ver estado de todos los procesos
sudo supervisorctl status

# Ver estado de programa específico
sudo supervisorctl status myapp

# Ver estado de grupo
sudo supervisorctl status mygroup:*

# Ver información detallada del proceso
sudo supervisorctl pid myapp
sudo supervisorctl tail myapp

Monitorear Logs

# Seguir logs en tiempo real
sudo supervisorctl tail -f myapp

# Seguir stderr
sudo supervisorctl tail -f myapp stderr

# Ver últimos 1000 bytes
sudo supervisorctl tail myapp

# Limpiar log
sudo supervisorctl clear myapp

Control de Procesos

# Iniciar proceso
sudo supervisorctl start myapp

# Detener proceso
sudo supervisorctl stop myapp

# Reiniciar proceso
sudo supervisorctl restart myapp

# Iniciar todos los procesos
sudo supervisorctl start all

# Detener todos los procesos
sudo supervisorctl stop all

# Reiniciar todos los procesos
sudo supervisorctl restart all

Validación de Configuración

# Probar sintaxis de configuración
sudo supervisord -c /etc/supervisor/supervisord.conf -t

# Recargar configuración
sudo supervisorctl reread

# Actualizar procesos con nueva configuración
sudo supervisorctl update

# Mostrar información del proceso
sudo supervisorctl avail

Acceso a Interfaz Web

Si la interfaz web está habilitada:

# Acceder vía navegador
http://localhost:9001

# O vía túnel SSH
ssh -L 9001:localhost:9001 user@server
# Luego acceder a http://localhost:9001 en máquina local

Monitoreo de Rendimiento

# Verificar uso de recursos del proceso supervisor
ps aux | grep supervisord

# Monitorear procesos gestionados
watch -n 1 'sudo supervisorctl status'

# Verificar uso de memoria de procesos gestionados
for pid in $(sudo supervisorctl pid all); do
    ps -p $pid -o pid,vsz,rss,cmd
done

Solución de Problemas

Problema 1: El Proceso No Inicia

Síntoma: El proceso permanece en estado STARTING o pasa inmediatamente a FATAL

Solución:

# Verificar logs del proceso
sudo supervisorctl tail myapp stderr

# Verificar log principal de supervisord
sudo tail -f /var/log/supervisor/supervisord.log

# Problemas comunes:

# 1. Comando no encontrado o ruta incorrecta
# Verificar que el comando existe
which python3
# Usar ruta completa en configuración

# 2. Problemas de permisos
# Verificar propiedad del archivo
ls -la /opt/myapp/
# Corregir permisos
sudo chown -R myappuser:myappuser /opt/myapp/

# 3. Directorio de trabajo no existe
# Crear directorio
sudo mkdir -p /opt/myapp
sudo chown myappuser:myappuser /opt/myapp

# 4. Usuario no existe
# Crear usuario
sudo useradd -r -s /bin/false myappuser

# 5. Problemas de entorno
# Probar comando manualmente como usuario especificado
sudo -u myappuser /usr/bin/python3 /opt/myapp/app.py

# 6. startsecs muy corto
# Aumentar startsecs en configuración
# startsecs=10

Problema 2: El Proceso Sigue Reiniciándose

Síntoma: El proceso falla y se reinicia continuamente

Solución:

# Verificar logs de aplicación
sudo supervisorctl tail myapp stderr

# Verificar problemas comunes:

# 1. La aplicación termina inmediatamente
# Asegurar que la aplicación se ejecuta en primer plano (no se convierte en demonio)

# 2. Puerto ya en uso
sudo ss -tlnp | grep :8000

# 3. Dependencias faltantes
# Verificar si todos los paquetes requeridos están instalados

# 4. Errores de configuración en aplicación
# Probar aplicación independientemente

# 5. Agotamiento de recursos
# Verificar memoria/espacio en disco
free -h
df -h

# Deshabilitar temporalmente autorestart para investigar
# Editar config: autorestart=false
sudo supervisorctl update
sudo supervisorctl start myapp
# Investigar por qué termina

Problema 3: No Se Puede Conectar a Supervisor

Síntoma: unix:///var/run/supervisor.sock no such file o conexión rechazada

Solución:

# Verificar si supervisord está ejecutándose
sudo systemctl status supervisord

# Si no está ejecutándose, iniciarlo
sudo systemctl start supervisord

# Verificar que existe archivo de socket
ls -la /var/run/supervisor.sock

# Verificar permisos
# El socket debe ser legible/escribible por usuario supervisor

# Si se usa interfaz TCP, verificar puerto
sudo ss -tlnp | grep 9001

# Verificar configuración
sudo supervisord -c /etc/supervisor/supervisord.conf -t

# Reiniciar supervisord
sudo systemctl restart supervisord

Problema 4: El Proceso No Se Detiene

Síntoma: El proceso permanece en estado STOPPING

Solución:

# Verificar estado del proceso
sudo supervisorctl status myapp

# Verificar si el proceso está colgado
sudo supervisorctl pid myapp
ps aux | grep <pid>

# Aumentar stopwaitsecs
# Editar config: stopwaitsecs=60
sudo supervisorctl update

# Forzar eliminación si es necesario
sudo supervisorctl stop myapp
# Si aún está ejecutándose:
sudo kill -9 <pid>

# Asegurar que killasgroup está configurado
# stopasgroup=true
# killasgroup=true

Problema 5: Los Logs No Aparecen

Síntoma: Sin salida en logs de Supervisor

Solución:

# Verificar ubicación del archivo de log
sudo supervisorctl tail myapp

# Verificar que la aplicación escribe a stdout/stderr
# No a archivos directamente

# Verificar configuración redirect_stderr
# redirect_stderr=true

# Verificar que el directorio de log existe y es escribible
ls -la /var/log/supervisor/
sudo chown supervisor:supervisor /var/log/supervisor/

# Verificar si la aplicación está almacenando salida en búfer
# Para Python, usar salida sin búfer:
# command=/usr/bin/python3 -u /opt/myapp/app.py

# Limpiar log y reiniciar
sudo supervisorctl clear myapp
sudo supervisorctl restart myapp

Problema 6: Los Cambios de Configuración No Se Aplican

Síntoma: La configuración modificada no surte efecto

Solución:

# Después de modificar configuración:

# 1. Releer configuración
sudo supervisorctl reread

# 2. Actualizar procesos
sudo supervisorctl update

# 3. Si el proceso aún usa configuración antigua, reiniciarlo
sudo supervisorctl restart myapp

# O reiniciar supervisord completamente
sudo systemctl restart supervisord

# Verificar sintaxis de configuración
sudo supervisord -c /etc/supervisor/supervisord.conf -t

# Verificar qué archivo de configuración se está usando
ps aux | grep supervisord

Mejores Prácticas

Mejores Prácticas de Configuración

1. Un Programa Por Archivo:

# En lugar de un archivo grande, usar archivos separados
/etc/supervisor/conf.d/app1.conf
/etc/supervisor/conf.d/app2.conf
/etc/supervisor/conf.d/workers.conf

2. Usar Variables de Entorno:

environment=
    DATABASE_URL="%(ENV_DATABASE_URL)s",
    SECRET_KEY="%(ENV_SECRET_KEY)s"

3. Configuración Apropiada de Auto-reinicio:

; Para aplicaciones estables
autorestart=true

; Para aplicaciones que deben permanecer detenidas si fallan
autorestart=false

; Para aplicaciones que fallan durante el inicio
autorestart=unexpected

4. Establecer Tiempos de Espera Razonables:

startsecs=10          ; La aplicación necesita 10s para iniciarse completamente
stopwaitsecs=30       ; Permitir 30s para apagado gracioso

5. Usar Prioridad para Orden de Inicio:

[program:database]
priority=100          ; Iniciar primero

[program:webapp]
priority=200          ; Iniciar después de la base de datos

[program:worker]
priority=300          ; Iniciar al final

Mejores Prácticas de Seguridad

1. Ejecutar Procesos como Usuarios No-Root:

[program:myapp]
user=myappuser
group=myappuser

2. Asegurar Interfaz Web:

[inet_http_server]
port=127.0.0.1:9001   ; Enlazar solo a localhost
username=admin
password=strong_random_password

3. Proteger Archivos de Configuración:

sudo chmod 600 /etc/supervisor/conf.d/*.conf
sudo chown root:root /etc/supervisor/conf.d/*.conf

4. Usar Túneles SSH para Acceso Remoto:

# En lugar de exponer interfaz web, usar túnel SSH
ssh -L 9001:localhost:9001 user@server

5. Restringir Acceso a supervisorctl:

# Limitar quién puede ejecutar supervisorctl
sudo chown root:supervisor /usr/bin/supervisorctl
sudo chmod 750 /usr/bin/supervisorctl

Mejores Prácticas de Registro

1. Configurar Rotación de Logs:

stdout_logfile=/var/log/supervisor/myapp.log
stdout_logfile_maxbytes=50MB
stdout_logfile_backups=10

2. Separar stdout y stderr:

redirect_stderr=false
stdout_logfile=/var/log/supervisor/myapp-stdout.log
stderr_logfile=/var/log/supervisor/myapp-stderr.log

3. Rotación de Logs a Nivel de Sistema:

Crear /etc/logrotate.d/supervisor:

/var/log/supervisor/*.log {
    daily
    rotate 14
    compress
    delaycompress
    notifempty
    missingok
    postrotate
        /usr/bin/supervisorctl reload > /dev/null 2>&1 || true
    endscript
}

4. Registro Centralizado:

Enviar logs a servidor de registro central:

# Usar syslog para reenvío
tail -f /var/log/supervisor/myapp.log | logger -t myapp

Mejores Prácticas de Monitoreo

1. Verificaciones Regulares de Salud:

#!/bin/bash
# healthcheck.sh

FAILED=$(sudo supervisorctl status | grep -v RUNNING | grep -v STOPPED)

if [ -n "$FAILED" ]; then
    echo "Failed processes detected:"
    echo "$FAILED"
    # Enviar alerta
    echo "$FAILED" | mail -s "Supervisor Alert" [email protected]
fi

2. Script de Monitoreo Automatizado:

#!/bin/bash
# monitor.sh

while true; do
    STATUS=$(sudo supervisorctl status all)

    # Verificar procesos FATAL
    FATAL=$(echo "$STATUS" | grep FATAL)
    if [ -n "$FATAL" ]; then
        echo "$(date): FATAL processes detected"
        echo "$FATAL"
        # Intentar reinicio
        sudo supervisorctl restart all
    fi

    sleep 60
done

3. Integración con Herramientas de Monitoreo:

Usar API XML-RPC de Supervisor:

import xmlrpc.client

server = xmlrpc.client.ServerProxy('http://localhost:9001/RPC2')

# Obtener información de todos los procesos
all_procs = server.supervisor.getAllProcessInfo()

for proc in all_procs:
    if proc['state'] != 20:  # 20 = RUNNING
        print(f"Process {proc['name']} is not running: {proc['statename']}")

Mejores Prácticas de Despliegue

1. Control de Versiones de Configuración:

# Mantener configuraciones en control de versiones
git init /etc/supervisor
cd /etc/supervisor
git add conf.d/*.conf supervisord.conf
git commit -m "Initial supervisor configuration"

2. Despliegue Automatizado:

#!/bin/bash
# deploy.sh

# Obtener código más reciente
git pull origin main

# Actualizar dependencias
pip install -r requirements.txt

# Recargar configuración de supervisor
sudo supervisorctl reread
sudo supervisorctl update

# Reiniciar aplicación
sudo supervisorctl restart myapp

# Verificar
sudo supervisorctl status myapp

3. Actualizaciones Sin Tiempo de Inactividad:

# Iniciar nueva versión en puerto diferente
sudo supervisorctl start myapp_v2

# Verificar que la nueva versión es saludable
# ... verificaciones de salud ...

# Actualizar balanceador de carga a nueva versión
# ... actualizar nginx/haproxy ...

# Detener versión antigua
sudo supervisorctl stop myapp_v1

# Renombrar para próximo despliegue
sudo supervisorctl restart myapp_v2:myapp_v1

Mejores Prácticas de Rendimiento

1. Optimizar Cantidad de Workers:

; Para tareas limitadas por CPU
numprocs=4  ; Coincidir con cantidad de núcleos CPU

; Para tareas limitadas por I/O
numprocs=16  ; Puede exceder cantidad de núcleos

2. Límites de Recursos:

# Establecer límites en configuración de supervisor
[program:myapp]
umask=022
priority=999

3. Monitorear Uso de Recursos:

# Verificar uso de memoria
for pid in $(sudo supervisorctl pid all); do
    ps -p $pid -o pid,vsz,rss,%mem,%cpu,cmd
done

Conclusión

Supervisor es una herramienta invaluable para gestionar procesos de aplicación de manera confiable y eficiente. Al proporcionar reinicios automáticos, configuración centralizada, registro completo e interfaces de gestión simples, Supervisor simplifica dramáticamente la gestión de procesos en entornos de producción.

Conclusiones Clave:

Confiabilidad: El monitoreo automático de procesos y los reinicios aseguran que tus aplicaciones permanezcan disponibles incluso después de fallos o reinicios del servidor.

Simplicidad: Los archivos de configuración estilo INI y las herramientas de línea de comandos directas hacen que Supervisor sea accesible tanto para desarrolladores como para operadores.

Flexibilidad: El soporte para grupos de procesos, múltiples instancias, variables de entorno y privilegios de usuario acomoda diversas arquitecturas de aplicación.

Visibilidad: El registro centralizado y el monitoreo de estado proporcionan una visión clara de la salud y comportamiento de la aplicación.

Listo para Producción: Cuando se configura según las mejores prácticas, Supervisor proporciona gestión de procesos de nivel empresarial adecuada para cargas de trabajo de producción críticas.

Ya sea que estés gestionando una única aplicación web Python u orquestando docenas de microservicios, Supervisor proporciona las herramientas necesarias para una gestión confiable de procesos. Los ejemplos y mejores prácticas en esta guía establecen una base sólida para implementar Supervisor en tu infraestructura.

A medida que tu ecosistema de aplicaciones crece, Supervisor escala contigo a través de grupos de procesos, múltiples instancias e integración con herramientas de monitoreo. Combinado con registro, monitoreo y prácticas de despliegue adecuadas, Supervisor se convierte en una piedra angular de operaciones de aplicación confiables.

Recuerda que la gestión de procesos es solo un componente de una infraestructura robusta. Combina Supervisor con monitoreo, alertas, agregación de logs y automatización de despliegue adecuados para construir sistemas verdaderamente resilientes.

Tus aplicaciones ahora están bajo la vigilancia atenta de Supervisor, listas para recuperarse automáticamente de fallos y proporcionar la confiabilidad que tus usuarios esperan. Monitorea tus procesos, itera en tu configuración y aprovecha las características de Supervisor para construir infraestructura de aplicación a prueba de balas.