← volver

Uso avanzado de systemd‑timers y sockets para mantenimiento y autoscaling en Linux

Por · · [Admin-Sistemas] · lectura estimada: ~5 min

En entornos de producción modernos, la capacidad de ejecutar tareas de mantenimiento, recuperación y escalado de forma automática y fiable es esencial. systemd ofrece dos mecanismos potentes y poco explotados: timers y socket activation. Este artículo muestra cómo combinarlos para crear soluciones avanzadas, desde limpiezas periódicas hasta auto‑recuperación de servicios y escalado horizontal basado en carga.

1. Conceptos básicos de systemd‑timers y sockets

1.1 ¿Qué es un systemd‑timer?

Un .timer es la contraparte de un .service que define cuándo debe iniciarse. A diferencia de cron, los timers pueden depender de otros units, usar expresiones de calendario completas y beneficiarse del registro unificado de journalctl.

1.2 ¿Qué es la activación por socket?

Con socket activation, systemd escucha en un socket (TCP, UDP, Unix) y lanza el servicio asociado solo cuando llega una conexión. Esto ahorra recursos y permite arquitecturas "on‑demand".

1.3 Ventajas de combinarlos

  • Eficiencia: los servicios se crean solo cuando son necesarios.
  • Orquestación sencilla: los timers pueden disparar sockets que a su vez inicien servicios.
  • Observabilidad: todo está centralizado en systemctl y journalctl.

2. Creación de un timer para mantenimiento periódico

2.1 Definir el unit de servicio

Ejemplo: limpiar archivos temporales de /var/tmp cada día.

# /etc/systemd/system/clean-tmp.service
[Unit]
Description=Limpiar archivos temporales obsoletos
Documentation=man:tmpwatch(8)

[Service] Type=oneshot ExecStart=/usr/sbin/tmpwatch —mtime —all 7d /var/tmp

2.2 Definir el timer asociado

El timer se dispara a medianoche, con tolerancia de 5 minutos para evitar sobrecargas simultáneas.

# /etc/systemd/system/clean-tmp.timer
[Unit]
Description=Timer para clean‑tmp.service

[Timer] OnCalendar=--* 00:00:00 RandomizedDelaySec=5m Persistent=true

[Install] WantedBy=timers.target

2.3 Activar y verificar

systemctl daemon-reload
systemctl enable --now clean-tmp.timer
systemctl list-timers --all | grep clean-tmp
journalctl -u clean-tmp.service -b

3. Recuperación automática mediante socket activation

3.1 Caso práctico: servicio de backup que se inicia solo cuando llega una petición

Supongamos que un script backup.sh se ejecuta cuando un cliente remoto abre una conexión TCP al puerto 2222.

3.2 Unit de socket

# /etc/systemd/system/backup.socket
[Unit]
Description=Socket para disparar el servicio de backup

[Socket] ListenStream=0.0.0.0:2222 Accept=yes PassCredentials=yes

[Install] WantedBy=sockets.target

3.3 Unit de servicio “por conexión”

Con Accept=yes, systemd crea una instancia backup@.service por cada conexión.

# /etc/systemd/system/backup@.service
[Unit]
Description=Servicio de backup para %I
After=network.target

[Service] StandardInput=socket StandardOutput=journal ExecStart=/usr/local/bin/backup.sh %I TimeoutSec=300

3.4 Prueba de la configuración

systemctl daemon-reload
systemctl enable --now backup.socket
# Desde otro host:
nc -v server_ip 2222
# Ver logs:
journalctl -u backup@.service -f

3.5 Por qué funciona

Al recibir la primera petición, systemd crea una instancia backup@.service, pasa el descriptor del socket a backup.sh y lo ejecuta. Cuando el script termina, la unidad se destruye, sin procesos inactivos.

4. Autoscaling basado en carga usando timers + sockets

4.1 Arquitectura propuesta

Un timer ejecuta cada minuto un script que consulta métricas (CPU, cola de trabajo) y decide si debe lanzar nuevas instancias de un servicio (por ejemplo, un worker de Celery). El script se comunica con systemd mediante systemctl start o systemctl stop. Gracias a la activación por socket, los workers sólo consumen recursos cuando hay clientes conectados.

4.2 Servicio worker con socket activation

# /etc/systemd/system/worker.socket
[Unit]
Description=Socket para workers de Celery

[Socket] ListenStream=/run/worker.sock Accept=yes

[Install] WantedBy=sockets.target

# /etc/systemd/system/worker@.service
[Unit]
Description=Instancia de worker %i
After=network.target

[Service]
ExecStart=/usr/local/bin/celery -A proj worker --loglevel=info
StandardInput=socket
StandardOutput=journal

4.3 Script de escala

#!/usr/bin/env bash
# /usr/local/bin/auto-scale.sh

MAX_WORKERS=10 MIN_WORKERS=2 THRESHOLD=70 # % de CPU

cpu=$(awk ‘/cpu /{print ($2+$4)100/($2+$4+$5)}’ /proc/stat) workers=$(systemctl list-units “worker@.service” —no-legend | wc -l)

if (( $(echo “$cpu > $THRESHOLD” | bc -l) )) && (( workers < MAX_WORKERS )); then idx=$((workers+1)) systemctl start “worker@${idx}.service” elif (( $(echo “$cpu < $THRESHOLD/2” | bc -l) )) && (( workers > MIN_WORKERS )); then idx=$workers systemctl stop “worker@${idx}.service” fi

4.4 Timer que ejecuta el script

# /etc/systemd/system/auto-scale.timer
[Unit]
Description=Timer para auto‑escalar workers

[Timer] OnUnitActiveSec=1min AccuracySec=5s

[Install] WantedBy=timers.target

# /etc/systemd/system/auto-scale.service
[Unit]
Description=Ejecuta el script de auto‑escalado

[Service]
Type=oneshot
ExecStart=/usr/local/bin/auto-scale.sh

4.5 Poner en marcha

chmod +x /usr/local/bin/auto-scale.sh
systemctl daemon-reload
systemctl enable --now worker.socket
systemctl enable --now auto-scale.timer

5. Troubleshooting y errores comunes

5.1 El timer no se dispara

  • Símbolo mal escrito: verifica el nombre del archivo (.timer vs .timers).
  • Persistencia: si el servidor se reinicia, usa Persistent=true para que el timer se ejecute al volver.
  • Logs: journalctl -u nombre.timer -f muestra si el timer está activo o ha fallado al cargar.

5.2 El socket no acepta conexiones

  • Puerto en uso: usa ss -ltnp | grep 2222 para confirmar que otro proceso no lo ocupa.
  • Permisos del socket Unix: revisa ls -l /run/worker.sock y ajusta SocketUser=, SocketGroup=.
  • Firewall: asegúrate de que iptables o firewalld permite el puerto.

5.3 El script de auto‑escalado no crea nuevas unidades

  • Rutas completas: systemd necesita la ruta absoluta al binario (/usr/bin/systemctl).
  • Limitaciones de unidades: revisa systemctl status worker@*.service para detectar fallos de inicio.
  • Variables de entorno: el timer se ejecuta sin entorno interactivo; exporta PATH o usa rutas completas en el script.

5.4 Mensajes de error en journal

journalctl -u clean-tmp.service -p err --since "1 hour ago"

Filtra por nivel de prioridad (err, crit) para centrarte en lo relevante.

6. Conclusión

Combinar systemd‑timers y socket activation permite diseñar flujos de trabajo totalmente declarativos, reproducibles y auditables. Desde limpiezas rutinarias hasta sistemas de auto‑escalado basados en métricas, todo se gestiona con unidades .service, .timer y .socket que se integran con el resto del ecosistema de systemd. La clave está en:

  • Definir claramente la dependencia entre unidades.
  • Usar Persistent=true y RandomizedDelaySec para evitar picos.
  • Explotar Accept=yes para crear instancias por conexión y liberar recursos al finalizar.
  • Monitorizar con journalctl y crear scripts de diagnóstico que revisen el estado de los timers y sockets.

Adoptar este enfoque no solo reduce la carga operativa, sino que también mejora la resiliencia y la capacidad de respuesta de los servidores Linux en entornos de producción exigentes.

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal