Rotación y Compresión de Logs en Bash
Rota, comprime y purga logs de aplicaciones con configuraciones de logrotate y scripts bash personalizados —incluyendo zstd, copytruncate, chequeo de disco y envío a S3.
Visión General
logrotate es la utilidad estándar de Linux que rota, comprime y purga archivos de log —y existe porque un solo log descontrolado puede llenar el disco y tirar la aplicación con él. Esta receta cubre dos enfoques: configuraciones de logrotate donde esté instalado, y scripts bash personalizados para contenedores o sistemas mínimos donde no lo está. Los scripts de abajo están parametrizados, manejan la trampa del descriptor de archivo que pierde líneas de log silenciosamente, e incluyen las variantes que la mayoría de tutoriales omite: zstd, envío a S3 y rotación desde la propia aplicación.
Archivos complementarios: todos los scripts y configuraciones de esta página están en el repositorio complementario de bash-log-rotation, un archivo ejecutable por caso de uso.
Cuándo Usar
- Tienes un servidor web o una aplicación que escribe logs continuamente.
- Necesitas logs comprimidos y purgados para mantener el uso de disco acotado.
- Envías logs comprimidos a almacenamiento frío o necesitas retención por compliance.
- Tu entorno no puede ejecutar logrotate (contenedor, embebido, imagen mínima).
Sáltalo si tu app ya registra a journald o al driver json-file de Docker con max-size/max-file configurados —la plataforma ya rota por ti y apilar scripts encima solo agrega puntos de fallo.
Solución
Usando logrotate
# /etc/logrotate.d/myapp
/var/log/myapp/*.log {
daily
rotate 14
compress
delaycompress
missingok
notifempty
dateext
dateformat -%Y%m%d-%H%M%S
sharedscripts
create 0644 myapp myapp
postrotate
# Se ejecuta UNA vez para todo el bloque gracias a sharedscripts
if [ -f /var/run/myapp.pid ]; then
kill -HUP "$(cat /var/run/myapp.pid)"
else
systemctl reload myapp
fi
endscript
}
Prueba la configuración:
# Dry run — muestra qué pasaría sin cambiar nada
logrotate -d /etc/logrotate.d/myapp
# Forzar la rotación ahora
logrotate -f /etc/logrotate.d/myapp
Rotación por tamaño con logrotate
# /etc/logrotate.d/myapp-size
/var/log/myapp/*.log {
size 50M
rotate 10
compress
delaycompress
missingok
notifempty
sharedscripts
create 0644 myapp myapp
postrotate
systemctl reload myapp
endscript
}
Compresión con zstd en lugar de gzip
# /etc/logrotate.d/myapp-zstd
/var/log/myapp/*.log {
daily
rotate 30
compress
compresscmd /usr/bin/zstd
compressext .zst
delaycompress
missingok
notifempty
create 640 myapp myapp
sharedscripts
postrotate
systemctl reload myapp
endscript
}
zstd comprime a 50-80MB/s por núcleo frente a los 10-15MB/s de gzip con un ratio similar —vale la pena para volúmenes grandes. En un log de 500MB: gzip -6 tarda ~12s, zstd -3 ~2s.
copytruncate para procesos sin soporte de señales
# /etc/logrotate.d/myapp-truncate
/var/log/myapp/*.log {
daily
rotate 14
compress
copytruncate
missingok
notifempty
}
copytruncate copia el log y luego lo trunca en su sitio —la app sigue escribiendo al mismo descriptor. Contrapartida: una breve ventana durante la copia donde se pueden perder líneas.
Script de rotación propio (sin logrotate)
#!/bin/bash
set -euo pipefail
LOG_DIR="${1:-/var/log/myapp}"
RETENTION_DAYS="${2:-14}"
MAX_SIZE_MB="${3:-10}"
mkdir -p "$LOG_DIR/archive"
for log in "$LOG_DIR"/*.log; do
[ -f "$log" ] || continue
size_mb=$(du -m "$log" | cut -f1)
if [ "$size_mb" -gt "$MAX_SIZE_MB" ]; then
base=$(basename "$log" .log)
timestamp=$(date +%Y%m%d-%H%M%S)
rotated="$LOG_DIR/archive/${base}-${timestamp}.log"
mv "$log" "$rotated"
gzip "$rotated"
# Recrear el log para que la app siga escribiendo — y si lo soporta,
# señalizarla para reabrir el descriptor (nginx, la mayoría de daemons)
touch "$log"
# kill -HUP "$(cat /var/run/myapp.pid)" 2>/dev/null || true
fi
done
find "$LOG_DIR/archive" -name '*.gz' -type f -mtime "+$RETENTION_DAYS" -delete
echo "[$(date -Iseconds)] Rotación completada en $LOG_DIR"
Si la app no puede reabrir su log (sin soporte de señales), prefiere el patrón copytruncate: cp "$log" "$rotated"; : > "$log"; gzip "$rotated".
Rotación por señal (proceso en ejecución)
#!/bin/bash
set -euo pipefail
LOG_DIR="/var/log/myapp"
LOG_FILE="${LOG_DIR}/app.log"
PID_FILE="/var/run/myapp.pid"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
mv "$LOG_FILE" "${LOG_DIR}/app_${TIMESTAMP}.log"
touch "$LOG_FILE"
if [ -f "$PID_FILE" ]; then
kill -HUP "$(cat "$PID_FILE")"
fi
# Dale a la app un momento para empezar a escribir en el nuevo archivo
sleep 5
gzip "${LOG_DIR}/app_${TIMESTAMP}.log"
find "$LOG_DIR" -name "app_*.log.gz" -type f -mtime +14 -delete
Compresión paralela con pigz
#!/bin/bash
set -euo pipefail
LOG_DIR="/var/log/myapp"
LOG_FILE="${LOG_DIR}/app.log"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
[ -f "$LOG_FILE" ] || exit 0
ROTATED="${LOG_DIR}/app_${TIMESTAMP}.log"
mv "$LOG_FILE" "$ROTATED"
touch "$LOG_FILE"
# pigz usa todos los núcleos — ~2x más rápido que gzip en multinúcleo
if command -v pigz >/dev/null; then
pigz "$ROTATED"
else
gzip "$ROTATED"
fi
find "$LOG_DIR" -name "app_*.log.gz" -type f -mtime +14 -delete
Rotación con chequeo de espacio en disco
#!/bin/bash
set -euo pipefail
LOG_DIR="/var/log/myapp"
LOG_FILE="${LOG_DIR}/app.log"
RETENTION=14
# La columna 5 de df es Use% (qué tan LLENO está el disco). -P lo mantiene en una línea
USED_PERCENT=$(df -P "$LOG_DIR" | awk 'NR==2 {gsub(/%/,"",$5); print $5}')
if [ "$USED_PERCENT" -gt 90 ]; then
echo "CRÍTICO: disco al ${USED_PERCENT}% — purga agresiva"
RETENTION=3
fi
[ -f "$LOG_FILE" ] || exit 0
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
ROTATED="${LOG_DIR}/app_${TIMESTAMP}.log"
mv "$LOG_FILE" "$ROTATED"
touch "$LOG_FILE"
gzip "$ROTATED"
find "$LOG_DIR" -name "app_*.log.gz" -type f -mtime +$RETENTION -delete
# Alerta si el disco sigue casi lleno tras la rotación
USED_PERCENT=$(df -P "$LOG_DIR" | awk 'NR==2 {gsub(/%/,"",$5); print $5}')
if [ "$USED_PERCENT" -gt 90 ]; then
echo "AVISO: disco sigue al ${USED_PERCENT}% tras la rotación"
fi
Notificación por email al rotar
# /etc/logrotate.d/myapp-notify
# Requiere mailutils (Debian) o mailx (RHEL) — postrotate se ejecuta una vez
# gracias a sharedscripts, así recibes un email, no uno por cada log
/var/log/myapp/*.log {
daily
rotate 14
compress
delaycompress
missingok
notifempty
sharedscripts
create 0644 myapp myapp
postrotate
systemctl reload myapp
echo "Log rotado en $(hostname) a las $(date)" | \
mail -s "Rotación de log: myapp" ops@example.com
endscript
}
Entrada cron para el script personalizado:
# Rotar a diario a las 4 AM, registrar la salida
0 4 * * * /opt/scripts/log-rotate.sh >> /var/log/rotate.log 2>&1
Envío de logs rotados a S3
#!/bin/bash
set -euo pipefail
LOG_DIR="${1:-/var/log/myapp}"
S3_BUCKET="${2:-my-app-logs}"
S3_PREFIX="logs/$(hostname)"
RETENTION_DAYS="${4:-90}"
# Subir archivos de más de un día (ya rotados y comprimidos)
find "$LOG_DIR/archive" -name '*.gz' -type f -mtime +1 | while read -r archive; do
rel_path="${archive#$LOG_DIR/archive/}"
if aws s3 cp "$archive" "s3://$S3_BUCKET/$S3_PREFIX/$rel_path" \
--storage-class STANDARD_IA --no-progress; then
echo "[$(date -Iseconds)] Subido $rel_path"
rm "$archive"
else
echo "[$(date -Iseconds)] FALLÓ $rel_path"
fi
done
# Las copias locales fuera de retención se borran; una regla de lifecycle
# del bucket las mueve a almacenamiento más barato en S3
find "$LOG_DIR/archive" -name '*.gz' -type f -mtime "+$RETENTION_DAYS" -delete
Rotación desde la app en Python
Para apps en Python, RotatingFileHandler rota en proceso —sin herramientas externas. Esta subclase añade compresión gzip:
import logging, gzip, os
from logging.handlers import RotatingFileHandler
class CompressedRotatingFileHandler(RotatingFileHandler):
def rotate(self, source, dest):
super().rotate(source, dest)
if os.path.exists(dest):
with open(dest, 'rb') as f_in:
with gzip.open(f'{dest}.gz', 'wb') as f_out:
f_out.writelines(f_in)
os.remove(dest)
handler = CompressedRotatingFileHandler(
'/var/log/app/application.log',
maxBytes=100*1024*1024, # 100MB
backupCount=30,
)
logger = logging.getLogger('app')
handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s'))
logger.addHandler(handler)
logger.setLevel(logging.INFO)
Explicación
logrotate se ejecuta a diario —vía logrotate.timer en distros systemd, /etc/cron.daily/logrotate en las antiguas— y procesa cada config de /etc/logrotate.d/. Directivas clave:
daily/weekly/monthly/size N: cuándo rotar.sizegana si se alcanza antes;minsize/maxsizeañaden límites.rotate N: conservar N archivos antes de borrar.compress/delaycompress: comprimir archivos con gzip;delaycompresssalta la compresión un ciclo para que el proceso que sigue escribiendo al descriptor viejo termine.sharedscripts: ejecutapostrotateuna vez por bloque en lugar de una por archivo —sin esto, un wildcard*.logreenvía el HUP (o el email) por cada archivo.dateext/dateformat: nombres de archivo con fecha en vez de.1,.2—evita que una segunda rotación el mismo día sobrescriba la primera.su/create: obligatorio al rotar logs de otro usuario (el clásico error “parent directory has insecure permissions”).
El enfoque de script propio comprueba el tamaño, mueve el log con mv, lo recrea con touch y comprime —el orden importa: recrear (o señalizar) es lo que evita que la app siga escribiendo al inode renombrado y pierda líneas. Los scripts usan flags de GNU coreutils (du -m, stat -c%s); en BSD/macOS cambia stat -c%s por stat -f%z.
Variantes
| Enfoque | Herramienta | Compresión | Usar cuando |
|---|---|---|---|
| logrotate | logrotate | gzip / zstd | Servidores Linux estándar |
| copytruncate | logrotate | gzip | Apps que no pueden reabrir el descriptor |
| Por tamaño, propio | bash + stat | gzip / pigz | Contenedores, sistemas mínimos |
| Por señal | bash + kill | gzip | Daemons con soporte de HUP |
| Envío a S3 | bash + aws cli | gzip | Retención por compliance, almacenamiento frío |
| Handler en la app | Python logging | gzip | Apps que deben rotarse a sí mismas |
Mejores Prácticas
- Prefiere
logrotatecuando esté disponible —gestiona permisos,suy señales por ti. - Acostúmbrate al dry-run:
logrotate -dantes de cualquier cambio de config, y prueba los scripts propios contra una copia de los logs —unfind -deletemal puesto se come datos en vivo. - Rota al 70-80% de uso de disco, no al 99% —monitóralo (ver Monitoreo de uso de disco con Bash).
- Restringe los permisos de los archivos (
chmod 640) —los logs pueden contener datos sensibles. - Envía los archivos a almacenamiento frío para cualquier retención de compliance; combínalo con el script de rotación de backups para el ciclo completo.
Errores Comunes
mv+gzipsin recrear el log ni señalizar la app —el proceso sigue escribiendo al inode movido y las líneas se pierden. Es el bug más común de pérdida de logs.- Configs wildcard sin
sharedscripts—postrotatese dispara una vez por archivo, así que la app se recarga (o se manda un email) por cada log. copytruncateen logs enormes —copia todo el archivo primero y duplica el uso de disco momentáneamente; un pico de escrituras durante la copia se pierde.- Nombres con
date +%Y%m%dsin componente de hora —una segunda rotación el mismo día sobrescribe la primera silenciosamente. dfsin-P—los nombres de dispositivo largos rompen la línea yawklee la columna equivocada.
Tips de Rendimiento
zstdsobregzippara volúmenes grandes:zstd -3~50-80MB/s por núcleo vsgzip -6~10-15MB/s, ratio similar —es lo que usan Facebook, Amazon y Cloudflare.pigzcuando gzip es obligatorio: mismo formato, todos los núcleos —~2x más rápido en un equipo típico de 4 núcleos.- Baja el nivel antes de cambiar de herramienta:
gzip -1es ~5x más rápido que-9a costa de un ratio modesto; con logrotate usacompressoptions -1. - Rota fuera de hora pico: cron a las 4 AM, no a medianoche —todo el mundo programa medianoche.
Ver También
- Reglas avanzadas de iptables — para los servidores que estás endureciendo junto al logging
- Monitoreo de uso de disco con Bash — alerta antes de que se llene el disco que guarda tus logs
- Página man de logrotate(8) — cada directiva, documentada upstream
- Wiki de Debian: logrotate — notas y ejemplos por distro
Preguntas frecuentes
¿Cuál es la diferencia entre postrotate y prerotate?
prerotate se ejecuta antes de rotar el log; postrotate después. Usa prerotate para detener un servicio limpiamente y postrotate para recargarlo y que reabra el nuevo archivo. Ambos cierran con endscript, y bajo un patrón wildcard conviene sharedscripts para que el bloque corra una vez, no por archivo.
¿Cómo roto logs en un contenedor Docker?
El stdout/stderr del contenedor va al driver json-file de Docker —configura la rotación en /etc/docker/daemon.json:
{
"log-driver": "json-file",
"log-opts": {
"max-size": "100m",
"max-file": "5"
}
}
Para apps que escriben archivos de log dentro del contenedor, monta el directorio como volumen y ejecuta logrotate en el host:
docker run -v /var/log/myapp:/var/log/myapp myapp
¿Cómo manejo varios logs con políticas diferentes?
Crea una config por archivo (o patrón) en /etc/logrotate.d/ —cada bloque tiene su frecuencia, retención y postrotate. No los juntes en un solo bloque wildcard salvo que todos compartan la misma política.
# /etc/logrotate.d/myapp-access
/var/log/myapp/access.log { daily rotate 7 compress }
# /etc/logrotate.d/myapp-error
/var/log/myapp/error.log { weekly rotate 52 compress }
¿Es esta solución lista para producción?
Sí —logrotate viene con Ubuntu, Debian, RHEL, CentOS y Amazon Linux. Los scripts propios solo usan coreutils (mv, gzip, find, touch). zstd corre en Facebook, Amazon y Cloudflare, y el patrón de envío a S3 es el que usan los equipos con retención de 1-7 años por compliance.
¿Cómo depuro una rotación que no funciona?
Ejecuta logrotate -d para un dry run y logrotate -v para verla en vivo —el fallo clásico es "parent directory has insecure permissions" (se arregla con su). En scripts propios añade set -x; verifica los archivos con gzip -t/zstd -t; comprueba que la app reabrió el descriptor con ls -l /proc/<pid>/fd. Si nada rotó, mira el archivo de estado /var/lib/logrotate/status.
¿Qué hace copytruncate?
copytruncate copia el log actual a un nombre rotado y luego trunca el original en su sitio —la app sigue escribiendo al mismo descriptor, así que no hace falta señal. Contrapartida: una breve ventana durante la copia donde se pueden perder líneas, y uso de disco duplicado mientras copia.
Recursos Relacionados
Rotación de copias en Bash: retención e integridad
Automatiza la rotación de copias en Bash con archivos diarios, semanales y mensuales, retención, cifrado y verificación de integridad.
RecipeScripting en Bash para Automatización DevOps y Tareas de
Como escribir scripts Bash robustos para automatizar despliegues, monitoreo de sistemas, rotacion de logs y tareas de mantenimiento rutinarias
RecipeComprimir y Descomprimir Archivos con ZIP, GZIP y TAR
Crea y extrae archivos ZIP, GZIP y TAR en Python, Node.js, Java y Bash con lectura en streaming y patrones de extracción segura.
RecipePlaybook de Ansible para Configuración de Servidores
Cómo escribir y ejecutar playbooks de Ansible para aprovisionar, configurar y administrar servidores con tareas idempotentes, roles e inventarios.
RecipeScripts de Bash para AWS CLI
Un conjunto de scripts de Bash que envuelven AWS CLI para aprovisionar, etiquetar, auditar y limpiar recursos de AWS, incluidos despliegues multi-cuenta.
RecipeMonitorear Uso de Disco
Alerta cuando el espacio en disco cruza umbrales usando un script de Bash que verifica mount points y notifica operadores.