StackPractices
intermediate Por Mathias Paulenko

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.

Temas: devops

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. size gana si se alcanza antes; minsize/maxsize añaden límites.
  • rotate N: conservar N archivos antes de borrar.
  • compress/delaycompress: comprimir archivos con gzip; delaycompress salta la compresión un ciclo para que el proceso que sigue escribiendo al descriptor viejo termine.
  • sharedscripts: ejecuta postrotate una vez por bloque en lugar de una por archivo —sin esto, un wildcard *.log reenví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”).
Flujo de decisión para rotación de logs: si el host tiene logrotate úsalo — sharedscripts + postrotate HUP cuando la app soporta señales, copytruncate cuando no; si no lo tiene, usa un script bash propio o rota desde la app con RotatingFileHandler

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

EnfoqueHerramientaCompresiónUsar cuando
logrotatelogrotategzip / zstdServidores Linux estándar
copytruncatelogrotategzipApps que no pueden reabrir el descriptor
Por tamaño, propiobash + statgzip / pigzContenedores, sistemas mínimos
Por señalbash + killgzipDaemons con soporte de HUP
Envío a S3bash + aws cligzipRetención por compliance, almacenamiento frío
Handler en la appPython logginggzipApps que deben rotarse a sí mismas

Mejores Prácticas

  • Prefiere logrotate cuando esté disponible —gestiona permisos, su y señales por ti.
  • Acostúmbrate al dry-run: logrotate -d antes de cualquier cambio de config, y prueba los scripts propios contra una copia de los logs —un find -delete mal 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 + gzip sin 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 —postrotate se dispara una vez por archivo, así que la app se recarga (o se manda un email) por cada log.
  • copytruncate en 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%d sin componente de hora —una segunda rotación el mismo día sobrescribe la primera silenciosamente.
  • df sin -P —los nombres de dispositivo largos rompen la línea y awk lee la columna equivocada.

Tips de Rendimiento

  • zstd sobre gzip para volúmenes grandes: zstd -3 ~50-80MB/s por núcleo vs gzip -6 ~10-15MB/s, ratio similar —es lo que usan Facebook, Amazon y Cloudflare.
  • pigz cuando 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 -1 es ~5x más rápido que -9 a costa de un ratio modesto; con logrotate usa compressoptions -1.
  • Rota fuera de hora pico: cron a las 4 AM, no a medianoche —todo el mundo programa medianoche.

Ver También

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.