Monitorear Uso de Disco
Alerta cuando el espacio en disco cruza umbrales usando un script de Bash que verifica mount points y notifica operadores.
Visión General
El espacio en disco es un asesino silencioso de servicios productivos. Cuando un log, caché o base de datos llena el disco, las aplicaciones se caen, las escrituras fallan y la recuperación se vuelve urgente. Un simple script de Bash que verifica mount points y alerta al cruzar umbrales te compra las horas que necesitas para reaccionar — y conectado a un job de limpieza, libera espacio antes de la caída.
Cuándo Usar
Usa este recurso cuando:
- Quieras alertas de disco sin desplegar un agente de monitoreo completo en el servidor.
- Las alertas tengan que llegar a email, Slack o un archivo de log cuando el uso suba.
- Tu flota sean contenedores, VMs o servidores bare-metal con disco justo.
- Quieras que el script libere espacio por sí solo una vez que el uso cruza un umbral.
Sáltalo si ya tienes un agente de monitoreo desplegado — Prometheus node_exporter, Datadog o el agente del proveedor cloud ya incluyen alertas de disco, y un segundo script en cron solo añade ruido.
Solución
Script de monitoreo de uso de disco
#!/usr/bin/env bash
set -euo pipefail
THRESHOLD="${1:-80}"
EMAIL="${2:-admin@example.com}"
# Verificar todos los mount points locales
df -Hl | awk 'NR>1 && /^\/dev/{print $1, $5, $6}' | while read -r fs usage mount; do
usage_val="${usage%\%}"
if (( usage_val >= THRESHOLD )); then
echo "WARNING: $mount ($fs) is at $usage"
# Enviar alerta (ejemplo con mail)
echo "Disk usage on $mount is $usage" | mail -s "Disk alert: $mount" "$EMAIL"
else
echo "OK: $mount is at $usage"
fi
done
# Opcional: disparar limpieza para mounts específicos
# if (( usage_val >= 90 )); then
# /usr/local/bin/cleanup-logs.sh
# fi
Archivos ejecutables: todos los scripts de esta página están en el repo companion de bash-monitoring-disk-usage, incluidas las unidades systemd y las reglas de alertas de Prometheus.
Explicación
El script ejecuta df -Hl para obtener cada filesystem local con su porcentaje de uso. awk filtra el encabezado y las entradas que no son dispositivos. Para cada mount point, elimina el signo de porcentaje, compara el valor numérico con el umbral e imprime una advertencia o mensaje OK. Al cruzar el umbral, el script envía la alerta por email. El bloque de limpieza queda comentado — audita qué borra antes de activarlo.
Variantes
| Canal de alerta | Herramienta | Mejor para |
|---|---|---|
mail | Servidores simples con MTA local | |
| Slack | webhook curl | Equipos que ya usan Slack |
| PagerDuty | event API | Escalación on-call en producción |
| Log de archivo | redirect a syslog | Agregación centralizada de logs |
Integración de alertas por Slack
#!/usr/bin/env bash
set -euo pipefail
SLACK_WEBHOOK="${SLACK_WEBHOOK:-https://hooks.slack.com/services/XXX}"
THRESHOLD="${1:-80}"
HOSTNAME=$(hostname)
send_slack_alert() {
local mount="$1" usage="$2" fs="$3"
local payload
payload=$(cat <<EOF
{
"text": "Alerta de disco en ${HOSTNAME}",
"attachments": [{
"color": "danger",
"fields": [
{"title": "Mount", "value": "${mount}", "short": true},
{"title": "Uso", "value": "${usage}", "short": true},
{"title": "Filesystem", "value": "${fs}", "short": true},
{"title": "Host", "value": "${HOSTNAME}", "short": true}
]
}]
}
EOF
)
curl -s -X POST -H 'Content-Type: application/json' -d "$payload" "$SLACK_WEBHOOK"
}
df -Hl | awk 'NR>1 && /^\/dev/{print $1, $5, $6}' | while read -r fs usage mount; do
usage_val="${usage%\%}"
if (( usage_val >= THRESHOLD )); then
send_slack_alert "$mount" "$usage" "$fs"
echo "[$(date -Iseconds)] WARNING: $mount ($fs) at $usage — alerta Slack enviada"
fi
done
Umbrales por partición
Un solo umbral rara vez encaja en todos los mounts — /var tolera crecimiento mejor que /. Define un umbral por partición:
#!/usr/bin/env bash
set -euo pipefail
ALERT_EMAIL="admin@example.com"
# Formato: "mountpoint:umbral"
PARTITIONS=(
"/:80"
"/var:90"
"/home:75"
"/tmp:85"
)
for entry in "${PARTITIONS[@]}"; do
mount="${entry%%:*}"
threshold="${entry##*:}"
usage_val=$(df -H "$mount" | awk 'NR>1 {print $5}' | tr -d '%')
if (( usage_val >= threshold )); then
echo "ALERT: $mount at ${usage_val}% (umbral: ${threshold}%)"
echo "Partition $mount at ${usage_val}%" | mail -s "Disk alert: $mount" "$ALERT_EMAIL"
fi
done
Alertar solo cuando cambia el estado
Si el script corre cada 5 minutos y un mount se queda en 92%, recibes una alerta cada 5 minutos. Mantén un archivo de estado para que cada mount alerte una sola vez al cruzar el umbral y se limpie al recuperarse:
#!/usr/bin/env bash
set -euo pipefail
THRESHOLD=80
STATE_FILE="${STATE_FILE:-/var/run/disk-alert-state}"
touch "$STATE_FILE"
df -Hl | awk 'NR>1 && /^\/dev/{print $1, $5, $6}' | while read -r fs usage mount; do
usage_val="${usage%\%}"
if (( usage_val >= THRESHOLD )) && ! grep -qx "$mount" "$STATE_FILE"; then
echo "$mount" >> "$STATE_FILE"
echo "Disk alert on $(hostname): $mount at $usage" | mail -s "Disk alert: $mount" admin@example.com
elif (( usage_val < THRESHOLD )) && grep -qx "$mount" "$STATE_FILE"; then
sed -i "\|^${mount}$|d" "$STATE_FILE"
echo "RECOVERED: $mount back to $usage"
fi
done
Monitoreo de inodos (el disco puede tener espacio pero no inodos)
#!/usr/bin/env bash
set -euo pipefail
INODE_THRESHOLD="${1:-80}"
df -i | awk 'NR>1 && /^\/dev/{print $1, $5, $6}' | while read -r fs iusage mount; do
iusage_val="${iusage%\%}"
if (( iusage_val >= INODE_THRESHOLD )); then
echo "WARNING: $mount ($fs) uso de inodos en $iusage"
# Encontrar directorios con más archivos
top_dirs=$(find "$mount" -xdev -type d -exec sh -c 'echo $(find "$0" -maxdepth 1 -type f | wc -l) "$0"' {} \; 2>/dev/null | sort -rn | head -5)
echo "Directorios con más archivos:"
echo "$top_dirs"
fi
done
Encontrar qué está consumiendo espacio
Cuando salta una alerta, la siguiente pregunta es qué directorios crecieron. Este snippet complementario lista los directorios y archivos más grandes:
#!/usr/bin/env bash
echo "=== Top 10 directorios más grandes ==="
du -sh /* 2>/dev/null | sort -rh | head -10
echo "=== Top 10 archivos más grandes ==="
find / -type f -size +100M -exec du -h {} + 2>/dev/null | sort -rh | head -10
Timer de systemd para monitoreo de disco (reemplaza cron)
# /etc/systemd/system/disk-monitor.service
[Unit]
Description=Monitoreo de uso de disco
After=network.target
[Service]
Type=oneshot
ExecStart=/usr/local/bin/disk-monitor.sh 80 admin@example.com
StandardOutput=journal
StandardError=journal
# /etc/systemd/system/disk-monitor.timer
[Unit]
Description=Ejecutar monitor de disco cada 5 minutos
[Timer]
OnBootSec=1min
OnUnitActiveSec=5min
AccuracySec=30s
[Install]
WantedBy=timers.target
# Habilitar e iniciar el timer
sudo systemctl daemon-reload
sudo systemctl enable --now disk-monitor.timer
systemctl list-timers disk-monitor.timer
Consulta la referencia de systemd.timer para la sintaxis completa de calendario. En hosts sin systemd, una entrada de cron hace el mismo trabajo: */5 * * * * /usr/local/bin/disk-monitor.sh 80 admin@example.com.
Alertas de disco con Prometheus node_exporter
Si ya ejecutas Prometheus, omite el script de cron y alerta sobre las métricas node_filesystem_* — incluido predict_linear, que dispara antes de que el disco se llene. Para la instalación completa del servidor, consulta la guía de Prometheus y Grafana.
# prometheus-alerts.yml
groups:
- name: disk_usage
rules:
- alert: HighDiskUsage
expr: |
(1 - node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 > 80
for: 5m
labels:
severity: warning
annotations:
summary: "Uso de disco alto en {{ $labels.instance }}"
description: "{{ $labels.mountpoint }} está al {{ printf \"%.1f\" $value }}% de uso"
- alert: CriticalDiskUsage
expr: |
(1 - node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 > 90
for: 2m
labels:
severity: critical
annotations:
summary: "Uso de disco crítico en {{ $labels.instance }}"
description: "{{ $labels.mountpoint }} está al {{ printf \"%.1f\" $value }}% de uso"
- alert: HighInodeUsage
expr: |
(1 - node_filesystem_files_free / node_filesystem_files) * 100 > 80
for: 5m
labels:
severity: warning
annotations:
summary: "Uso de inodos alto en {{ $labels.instance }}"
description: "{{ $labels.mountpoint }} tiene {{ printf \"%.1f\" $value }}% de uso de inodos"
- alert: DiskWillFillIn24h
expr: |
predict_linear(node_filesystem_avail_bytes[1h], 24 * 3600) < 0
for: 10m
labels:
severity: critical
annotations:
summary: "El disco se llenará en 24h en {{ $labels.instance }}"
description: "{{ $labels.mountpoint }} predicho a llenarse según la tasa actual"
Limpieza automática con trigger de rotación de logs
Combínala con una política de rotación — la receta Script de rotación de backups cubre patrones de retención que conectan con la limpieza de abajo.
#!/usr/bin/env bash
set -euo pipefail
CLEANUP_THRESHOLD="${1:-90}"
LOG_DIR="${2:-/var/log/app}"
ARCHIVE_DIR="${3:-/var/log/archive}"
df -Hl | awk 'NR>1 && /^\/dev/{print $1, $5, $6}' | while read -r fs usage mount; do
usage_val="${usage%\%}"
if (( usage_val >= CLEANUP_THRESHOLD )); then
echo "[$(date -Iseconds)] CRITICAL: $mount at $usage — disparando limpieza"
# Comprimir logs con más de 7 días
find "$LOG_DIR" -name "*.log" -mtime +7 -exec gzip -9 {} \;
# Mover logs comprimidos a archivo
find "$LOG_DIR" -name "*.gz" -mtime +1 -exec mv {} "$ARCHIVE_DIR/" \;
# Eliminar archivos con más de 90 días
find "$ARCHIVE_DIR" -name "*.gz" -mtime +90 -delete
# Limpiar caché del gestor de paquetes
if command -v apt-get &>/dev/null; then
apt-get clean
elif command -v yum &>/dev/null; then
yum clean all
fi
# Limpiar Docker si está presente
if command -v docker &>/dev/null; then
docker system prune -f --volumes
fi
# Reportar espacio liberado
new_usage=$(df -Hl "$mount" | awk 'NR>1 {print $5}')
echo "[$(date -Iseconds)] Limpieza completa. $mount ahora en $new_usage"
fi
done
Lo que Funciona
- Configura umbrales por debajo del 100%. Alerta al 80% y actúa al 90% para tener tiempo de responder.
- Monitorea mount points, no solo el disco total. Un
/tmpo/var/logpequeño puede llenarse independientemente del disco raíz. - Incluye el filesystem en la alerta. Saber qué partición está llena acelera la respuesta.
- Ejecuta desde cron cada pocos minutos. Un log desbocado puede llenar una partición entre chequeos por hora.
- Empareja monitoreo con limpieza. Una alerta de uso alto sin plan de limpieza es solo media solución — la receta de rotación de logs es el complemento habitual.
- Monitorea el uso de inodos por separado. Un disco puede tener espacio libre pero quedarse sin inodos (slots de archivos). Esto pasa con workloads que crean millones de archivos pequeños — servidores de mail, directorios de caché, almacenamiento de sesiones. Verifica los inodos con
df -iy alerta con los mismos umbrales. - Usa alertas predictivas. En lugar de alertar sobre el uso actual, alerta sobre el uso predicho. Prometheus
predict_linear()puede pronosticar cuándo se llenará un disco basándose en la tasa de cambio. Eso convierte una emergencia a las 2 AM en un ticket que manejas en horario laboral. - Excluye mounts de solo lectura y tmpfs. Filtra
tmpfs,devtmpfs,overlayy filesystems de solo lectura del monitoreo. O no se pueden limpiar o los gestiona el kernel:
# Monitorear solo dispositivos de bloque reales, excluyendo tmpfs y overlays
df -Hl -x tmpfs -x devtmpfs -x overlay -x squashfs | awk 'NR>1 && /^\/dev/{print $1, $5, $6}'
- Registra tendencias de uso de disco. Loguea el uso diario a un archivo o base de datos. Las tendencias revelan qué mounts crecen más rápido y ayudan a planificar upgrades de capacidad antes de que las alertas se disparen:
# Agregar uso diario a un CSV para análisis de tendencias
echo "$(date -Iseconds),$(hostname),$mount,$usage" >> /var/log/disk-usage-trends.csv
Errores Comunes
- Usar
df -hsin cuidado en el parsing. La columna de porcentaje puede estar vacía para filesystems especiales; filtra entradas/dev/. - Alertar demasiado tarde. Esperar al 95% deja casi ningún tiempo para reaccionar.
- Ignorar mounts efímeros.
/tmpy volúmenes de docker pueden llenarse rápido y colapsar servicios. - Enviar alertas a individuos. Usa un alias de equipo o rotación on-call para que las vacaciones no rompan el alerting.
- No manejar fallos de correo. Si el MTA está caído, la alerta nunca llega; registra en un segundo canal.
- No monitorear el almacenamiento de Docker. Docker usa
/var/lib/dockerque puede crecer rápidamente con imágenes, contenedores y volúmenes. Monitorea esta ruta por separado y programa jobs regulares dedocker system prune. Cuando esa partición se llena, los contenedores nuevos simplemente no arrancan. - Olvidar mounts de red montados. NFS y SMB mounts pueden llenarse en el servidor remoto, causando que las escrituras locales se cuelguen. Monitorea mounts de red con timeouts más cortos y alerta sobre latencia además de uso. Usa
timeoutcondfpara evitar colgarse en servidores NFS no responsivos:
timeout 10 df -Hl "$NFS_MOUNT" || echo "NFS mount $NFS_MOUNT no responde"
- Usar umbrales de porcentaje en discos muy grandes o muy pequeños. En un disco de 100TB, 80% significa 20TB libres — mucho espacio. En un disco de 10GB, 80% significa 2GB libres — crítico. Usa umbrales absolutos en bytes para discos pequeños y umbrales de porcentaje para grandes:
# Alertar si el espacio libre es menor a 5GB O el uso es mayor a 90%
avail_bytes=$(df -B1 "$mount" | awk 'NR>1 {print $4}')
if (( avail_bytes < 5368709120 )) || (( usage_val >= 90 )); then
echo "WARNING: $mount tiene solo $((avail_bytes / 1073741824))GB libres"
fi Preguntas frecuentes
¿Cómo monitoreo toda una flota de servidores?
Ejecuta el script en cada servidor vía cron y envía alertas a un sistema de logging o alerting centralizado. Mejor aún, deja que Ansible o tu gestor de configuración lo despliegue en todas partes. En flotas de AWS, la receta de scripts de Bash para AWS CLI cubre el mismo patrón de automatización entre instancias.
¿Puedo verificar el uso de disco de un directorio específico?
Sí. Usa du -sh /path para verificar un solo directorio, pero para alertas a nivel de partición usa df porque du no detecta límites de mount point.
¿Cómo evito la fatiga de alertas cuando un disco sigue lleno?
Alerta solo cuando cambia el estado. Mantén un archivo de estado con los mounts ya alertados (mira la variante de cambio de estado arriba) y notifica de nuevo cuando el mount se recupere.
¿Debería usar umbrales de porcentaje o absolutos?
El porcentaje funciona para la mayoría de discos, pero en volúmenes muy pequeños alerta también por espacio libre absoluto — el 10% de un disco de 10GB es 1GB, que puede desaparecer en minutos.
¿Debería borrar archivos automáticamente cuando el disco esté lleno?
Solo si auditaste qué se borra. El borrado automático puede eliminar evidencia que necesitas para debugging — archivar logs o avisar a un operador es más seguro.
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
RecipeRotació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.
RecipeCómo Iterar sobre Archivos en Bash
Cómo iterar de forma segura sobre archivos y directorios en Bash, manejando espacios, globs y listas grandes de archivos con patrones correctos.
GuidePrometheus y Grafana: métricas, dashboards y alertas
Instrumenta servicios con métricas de Prometheus, consúltalas en PromQL, construye dashboards en Grafana y publica reglas de alerta que no oscilan.
DocPlantilla de Runbook de Alertas: de la Página al Postmortem
Runbook estandarizado para responder a alertas: triage, diagnóstico, mitigación, resolución y pasos post-incidente con rutas de escalamiento.