🐧 Linux Server Hacks: Más Allá del Curso

Tutorial práctico para administradores que ya conocen los fundamentos y quieren ir al siguiente nivel.

Índice

1. Terminal Productivity — trabaja el doble de rápido
2. SSH como un pro
3. Gestión de procesos avanzada
4. Systemd: más que solo start/stop
5. Networking desde las trincheras
6. Seguridad ofensiva/defensiva básica
7. Performance Tuning del Kernel
8. Logs inteligentes con journald y awk
9. Automatización con Bash avanzado
10. Contenedores sin Docker (namespaces y cgroups a mano)
11. Backups que realmente funcionan
12. One-liners de emergencia

1. Terminal Productivity

Multiplexor de terminal: tmux

El curso te enseña a usar la terminal. Esto es usarla como un cirujano.

# Instalar tmux
sudo apt install tmux  # Debian/Ubuntu
sudo dnf install tmux  # RHEL/Fedora

# Iniciar sesión con nombre (crítico para servidores)
tmux new -s produccion

# Desconectarte SIN matar la sesión
Ctrl+b  d

# Reconectarte después de SSH
tmux attach -t produccion

# Dividir pantalla verticalmente
Ctrl+b  %

# Dividir horizontalmente
Ctrl+b  "

# Moverse entre paneles
Ctrl+b  ← → ↑ ↓

¿Por qué importa? Si tu conexión SSH cae a mitad de un proceso crítico, tmux lo sigue ejecutando. Nunca más perderás un apt upgrade a mitad.

Alias que salvan vidas

Agrega esto a tu ~/.bashrc o ~/.zshrc:

# Navegación rápida
alias ..='cd ..'
alias ...='cd ../..'
alias ll='ls -lahF --color=auto'
alias llt='ls -lahFt --color=auto'  # ordenado por fecha

# Seguridad
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'

# Servidores
alias ports='ss -tulnp'
alias myip='curl -s ifconfig.me'
alias meminfo='free -h && echo "---" && cat /proc/meminfo | grep -E "MemTotal|MemFree|Cached"'
alias cpuinfo='lscpu | grep -E "Model|CPU\(s\)|MHz"'
alias diskio='iostat -xz 1 3'

# Git shortcuts
alias gs='git status'
alias glog='git log --oneline --graph --decorate --all'

# Recarga config sin cerrar sesión
alias reload='source ~/.bashrc'

History avanzado

# En ~/.bashrc:
export HISTSIZE=50000
export HISTFILESIZE=100000
export HISTTIMEFORMAT="%Y-%m-%d %T "    # timestamps en historial
export HISTCONTROL=ignoredups:erasedups # sin duplicados
shopt -s histappend                      # múltiples sesiones no se pisan

# Buscar en el historial de forma interactiva
# Instala fzf para superpoderes:
sudo apt install fzf
# Luego: Ctrl+R te da búsqueda fuzzy interactiva

2. SSH como un Pro

Configuración del cliente (~/.ssh/config)

Esto elimina el 80% del tipeo en SSH:

# ~/.ssh/config
Host prod
    HostName 192.168.1.100
    User deploy
    Port 2222
    IdentityFile ~/.ssh/id_ed25519_prod
    ServerAliveInterval 60
    ServerAliveCountMax 3

Host staging
    HostName 10.0.0.50
    User ubuntu
    ProxyJump bastion          # salta a través de otro servidor!

Host bastion
    HostName bastion.miempresa.com
    User ec2-user
    IdentityFile ~/.ssh/bastion_key

Ahora solo escribes ssh prod en lugar del comando completo.

SSH Tunnels (el hack más poderoso)

# Tunnel LOCAL: accede a un servicio remoto como si fuera local
# Ejemplo: base de datos en servidor remoto, accesible en localhost:5432
ssh -L 5432:localhost:5432 prod

# Tunnel REMOTO: expone tu máquina local al servidor remoto
# Ejemplo: mostrar tu dev local en el puerto 8080 del servidor
ssh -R 8080:localhost:3000 prod

# SOCKS proxy: todo tu tráfico pasa por el servidor
ssh -D 9050 prod
# Luego configura tu browser para usar SOCKS5 en localhost:9050

# Mantener tunnels vivos con autossh
sudo apt install autossh
autossh -M 0 -f -N -L 5432:localhost:5432 prod

Hardening SSH (lo que el curso no dice explícitamente)

# /etc/ssh/sshd_config - cambios críticos de seguridad
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
Port 2222                        # oscuridad básica, no seguridad real
MaxAuthTries 3
LoginGraceTime 20
AllowUsers deploy ubuntu         # whitelist explícita de usuarios
ClientAliveInterval 300
ClientAliveCountMax 2

# Autenticación de 2 factores con Google Authenticator
sudo apt install libpam-google-authenticator
google-authenticator
# Agrega a /etc/pam.d/sshd:
# auth required pam_google_authenticator.so
# Y en sshd_config:
# ChallengeResponseAuthentication yes
# AuthenticationMethods publickey,keyboard-interactive

Copiar claves y comandos remotos

# Copiar tu clave pública al servidor de forma segura
ssh-copy-id -i ~/.ssh/id_ed25519.pub usuario@servidor

# Ejecutar comando remoto sin entrar a la sesión
ssh prod 'df -h && uptime'

# Copiar archivos con progreso
rsync -avz --progress ./carpeta/ prod:/destino/

# Sincronización continua (útil en deploy)
rsync -avz --delete ./dist/ prod:/var/www/app/

3. Gestión de Procesos Avanzada

htop vs alternativas modernas

# htop clásico
sudo apt install htop

# btop — mucho más visual e informativo
sudo apt install btop

# glances — monitoreo todo-en-uno con web UI
pip3 install glances
glances -w  # inicia servidor web en puerto 61208

Prioridades y afinidad de CPU

# Lanzar proceso con baja prioridad (nice va de -20 a 19)
nice -n 10 ./mi_script_pesado.sh

# Cambiar prioridad de proceso existente
renice -n 15 -p 12345

# Fijar proceso a núcleos de CPU específicos (evita context switching)
taskset -c 0,1 ./mi_aplicacion

# Ver afinidad actual
taskset -p 12345

# Con cgroups: limitar CPU de un proceso a 50%
sudo systemd-run --scope -p CPUQuota=50% ./mi_app

Señales que todo admin debe conocer

# kill -l  lista todas las señales
# Las más útiles:
kill -1  PID   # SIGHUP  — recarga configuración (sin matar)
kill -2  PID   # SIGINT  — equivale a Ctrl+C
kill -9  PID   # SIGKILL — muerte instantánea, sin cleanup
kill -15 PID   # SIGTERM — solicitud educada de terminar (DEFAULT)
kill -19 PID   # SIGSTOP — pausa el proceso
kill -18 PID   # SIGCONT — reanuda proceso pausado

# Mandar señal a todos los procesos de un programa
pkill -HUP nginx

# Matar proceso que usa un puerto específico
fuser -k 8080/tcp

4. Systemd: Más que solo start/stop

Crear tu propio servicio

# /etc/systemd/system/miapp.service
[Unit]
Description=Mi Aplicación Node.js
After=network.target postgresql.service
Requires=postgresql.service

[Service]
Type=simple
User=deploy
WorkingDirectory=/opt/miapp
ExecStart=/usr/bin/node /opt/miapp/index.js
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal
SyslogIdentifier=miapp

# Hardening del servicio
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ReadWritePaths=/opt/miapp/data

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now miapp
sudo systemctl status miapp

Timers de Systemd (mejor que cron)

# /etc/systemd/system/backup.timer
[Unit]
Description=Backup diario a las 2am

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true   # si el servidor estaba apagado, corre al iniciar

[Install]
WantedBy=timers.target

# /etc/systemd/system/backup.service
[Unit]
Description=Script de backup

[Service]
Type=oneshot
User=root
ExecStart=/usr/local/bin/backup.sh

sudo systemctl enable --now backup.timer
systemctl list-timers --all   # ver todos los timers

Debugging de servicios

# Ver logs de un servicio en tiempo real
journalctl -u nginx -f

# Logs de las últimas 2 horas
journalctl -u nginx --since "2 hours ago"

# Ver por qué falló un servicio
systemctl status miapp
journalctl -u miapp -n 50 --no-pager

# Analizar tiempo de arranque
systemd-analyze blame
systemd-analyze critical-chain

5. Networking desde las Trincheras

ss reemplaza a netstat

# Ver todas las conexiones con proceso y usuario
ss -tulnp

# Conexiones establecidas
ss -tnp state established

# Ver sockets Unix
ss -xl

# Estadísticas de red
ss -s

ip reemplaza a ifconfig

# Ver interfaces
ip addr show
ip -c addr   # con colores

# Agregar IP secundaria (sin reiniciar)
sudo ip addr add 192.168.1.200/24 dev eth0

# Ver tabla de rutas
ip route show

# Agregar ruta estática
sudo ip route add 10.0.0.0/8 via 192.168.1.1

# Ver vecinos ARP
ip neigh show

Diagnóstico de red avanzado

# Trazar ruta con tiempos detallados
mtr google.com   # mejor que traceroute

# Capturar tráfico (guardar para Wireshark)
sudo tcpdump -i eth0 -w /tmp/captura.pcap

# Captura filtrada: solo HTTP en un puerto
sudo tcpdump -i eth0 'tcp port 80' -A

# Ver tráfico en tiempo real por proceso
sudo nethogs eth0

# Ancho de banda por conexión
sudo iftop -i eth0

# Test de velocidad desde terminal
curl -s https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py | python3 -

Firewall con nftables (el sucesor de iptables)

# Ver reglas actuales
sudo nft list ruleset

# Script básico de firewall:
sudo nft -f - << 'EOF'
flush ruleset

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        # Loopback siempre permitido
        iifname "lo" accept

        # Conexiones establecidas
        ct state {established, related} accept

        # ICMP limitado
        icmp type echo-request limit rate 10/second accept

        # SSH
        tcp dport 22 ct state new limit rate 3/minute accept

        # HTTP/HTTPS
        tcp dport {80, 443} accept
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }

    chain forward {
        type filter hook forward priority 0; policy drop;
    }
}
EOF

6. Seguridad Ofensiva/Defensiva Básica

Auditoría de usuarios y permisos

# Usuarios con shell válida (posibles logins)
grep -v '/nologin\|/false' /etc/passwd

# Usuarios con UID 0 (root equivalentes — debería ser solo root)
awk -F: '($3 == 0) {print}' /etc/passwd

# Archivos SUID peligrosos
find / -perm -4000 -type f 2>/dev/null

# Archivos modificados en las últimas 24h
find / -mtime -1 -type f 2>/dev/null | grep -v '/proc\|/sys'

# Ver quién está conectado y qué hace
w
who
last | head -20
lastfail | head -20   # intentos fallidos

fail2ban configuración avanzada

# /etc/fail2ban/jail.local
[DEFAULT]
bantime  = 3600    # 1 hora baneado
findtime  = 600    # ventana de 10 min
maxretry = 3
ignoreip = 127.0.0.1/8 192.168.1.0/24  # whitelist local

[sshd]
enabled = true
port    = 2222
filter  = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 86400   # 24 horas para SSH

[nginx-http-auth]
enabled = true
filter = nginx-http-auth
logpath = /var/log/nginx/error.log

# Comandos útiles de fail2ban
sudo fail2ban-client status
sudo fail2ban-client status sshd
sudo fail2ban-client set sshd unbanip 1.2.3.4

Auditoría con auditd

sudo apt install auditd

# Monitorear accesos a archivo sensible
sudo auditctl -w /etc/passwd -p rwa -k passwd_changes
sudo auditctl -w /etc/sudoers -p rwa -k sudoers_changes

# Ver eventos
sudo ausearch -k passwd_changes
sudo aureport --auth  # reporte de autenticaciones

Escaneo rápido de vulnerabilidades

# Lynis: auditoría de seguridad del sistema
sudo apt install lynis
sudo lynis audit system

# Ver qué servicios son visibles desde fuera
nmap -sV localhost

# Chequear CVEs en paquetes instalados (Debian/Ubuntu)
sudo apt install debsecan
debsecan --suite $(lsb_release -cs) --format detail

7. Performance Tuning del Kernel

sysctl — parámetros críticos

# Ver todos los parámetros
sysctl -a

# /etc/sysctl.d/99-performance.conf

# Red: aumentar buffers para alto tráfico
net.core.rmem_max = 134217728
net.core.wmem_max = 134217728
net.ipv4.tcp_rmem = 4096 87380 134217728
net.ipv4.tcp_wmem = 4096 65536 134217728

# Habilitar BBR (mejor control de congestión TCP)
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr

# Protección contra SYN floods
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 4096

# Memoria: reducir uso de swap (0-100, 10 es bueno para servidores)
vm.swappiness = 10

# Archivos abiertos (para bases de datos y servidores de alta carga)
fs.file-max = 2097152

# Aplicar sin reiniciar
sudo sysctl -p /etc/sysctl.d/99-performance.conf

# Verificar BBR activo
sysctl net.ipv4.tcp_congestion_control

Límites del sistema (ulimit)

# Ver límites actuales
ulimit -a

# /etc/security/limits.conf — para producción
# usuario     tipo    recurso     valor
deploy        soft    nofile      65536
deploy        hard    nofile      65536
deploy        soft    nproc       32768
*             soft    core        unlimited   # core dumps para debug

# Verificar límites de un proceso en ejecución
cat /proc/$(pgrep nginx | head -1)/limits

8. Logs Inteligentes

journalctl power user

# Logs de hoy con prioridad error o mayor
journalctl --since today -p err

# Logs en formato JSON (para parsear o enviar a ELK)
journalctl -u nginx -o json | jq '.MESSAGE'

# Seguir logs de múltiples servicios a la vez
journalctl -f -u nginx -u php-fpm -u mysql

# Tamaño actual del journal
journalctl --disk-usage

# Limpiar logs antiguos
sudo journalctl --vacuum-time=30d   # conservar solo 30 días
sudo journalctl --vacuum-size=500M  # máximo 500MB

awk para análisis de logs

# Top 10 IPs en access.log de nginx
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -10

# Contar respuestas 5xx (errores de servidor)
awk '$9 ~ /^5/' /var/log/nginx/access.log | wc -l

# Tiempo de respuesta promedio (si tienes $request_time configurado)
awk '{sum+=$NF; count++} END {print sum/count "s promedio"}' /var/log/nginx/access.log

# Peticiones por hora
awk '{print $4}' /var/log/nginx/access.log | cut -d: -f2 | sort | uniq -c

# Detectar posibles ataques: misma IP, muchas peticiones en poco tiempo
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | awk '$1 > 1000'

Centralizar logs con rsyslog

# /etc/rsyslog.d/50-remote.conf en el servidor RECEPTOR
module(load="imudp")
input(type="imudp" port="514")
module(load="imtcp")
input(type="imtcp" port="514")

# Guardar logs remotos ordenados por host
$template RemoteLogs,"/var/log/remote/%HOSTNAME%/%PROGRAMNAME%.log"
*.* ?RemoteLogs

# En los servidores EMISORES:
# /etc/rsyslog.d/99-remote.conf
*.* @@logserver.empresa.com:514  # @@ = TCP, @ = UDP

9. Automatización con Bash Avanzado

Funciones y patrones útiles

#!/bin/bash
# Template de script robusto

set -euo pipefail  # e=exit on error, u=undefined vars, o=pipe failures
IFS=$'\n\t'        # separador seguro

# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

log()  { echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] $*${NC}"; }
warn() { echo -e "${YELLOW}[WARN] $*${NC}" >&2; }
err()  { echo -e "${RED}[ERROR] $*${NC}" >&2; exit 1; }

# Cleanup automático al salir (incluso por error)
trap 'err "Script interrupted at line $LINENO"' ERR
trap 'log "Cleanup..."; rm -f /tmp/miapp_lock' EXIT

# Lock file — evita ejecuciones paralelas
LOCK=/tmp/miapp_lock
[ -f "$LOCK" ] && err "Ya hay una instancia corriendo (PID: $(cat $LOCK))"
echo $$ > "$LOCK"

# Función reutilizable: retry con backoff
retry() {
    local retries=$1; shift
    local delay=$1;   shift
    local count=0
    until "$@"; do
        count=$((count + 1))
        [ $count -ge $retries ] && return 1
        warn "Intento $count/$retries falló. Reintentando en ${delay}s..."
        sleep "$delay"
        delay=$((delay * 2))  # backoff exponencial
    done
}

# Uso: retry 3 5 curl -f https://api.ejemplo.com/health

Automatización de deploys

#!/bin/bash
# deploy.sh — deploy zero-downtime básico

APP_DIR=/opt/miapp
RELEASES_DIR=$APP_DIR/releases
SHARED_DIR=$APP_DIR/shared
CURRENT=$APP_DIR/current

deploy() {
    local timestamp=$(date +%Y%m%d%H%M%S)
    local release_dir="$RELEASES_DIR/$timestamp"

    log "Desplegando release $timestamp"

    # Clonar/copiar nueva versión
    git clone --depth 1 git@github.com:miorg/miapp.git "$release_dir"

    # Enlazar directorios compartidos (uploads, configs, etc.)
    ln -s "$SHARED_DIR/config/.env" "$release_dir/.env"
    ln -s "$SHARED_DIR/uploads"     "$release_dir/public/uploads"

    # Instalar dependencias
    cd "$release_dir"
    npm ci --production

    # Cambiar symlink atómicamente (el truco del zero-downtime)
    ln -sfn "$release_dir" "$CURRENT"

    # Recargar app sin downtime
    systemctl reload miapp

    log "Deploy completado. Release activo: $timestamp"

    # Conservar solo los últimos 5 releases
    ls -dt "$RELEASES_DIR"/*/ | tail -n +6 | xargs rm -rf
}

rollback() {
    local previous=$(ls -dt "$RELEASES_DIR"/*/ | sed -n '2p')
    [ -z "$previous" ] && err "No hay release anterior"
    ln -sfn "$previous" "$CURRENT"
    systemctl reload miapp
    log "Rollback a: $previous"
}

case "${1:-deploy}" in
    deploy)   deploy   ;;
    rollback) rollback ;;
    *) err "Uso: $0 [deploy|rollback]" ;;
esac

10. Contenedores sin Docker

Entender los namespaces a mano

# Crear un namespace de red aislado
sudo ip netns add sandbox

# Ejecutar comando dentro del namespace
sudo ip netns exec sandbox ip addr  # solo ve loopback

# Conectar namespaces con veth pair
sudo ip link add veth0 type veth peer name veth1
sudo ip link set veth1 netns sandbox
sudo ip addr add 192.168.100.1/24 dev veth0
sudo ip netns exec sandbox ip addr add 192.168.100.2/24 dev veth1
sudo ip link set veth0 up
sudo ip netns exec sandbox ip link set veth1 up

# Ahora puedes hacer ping entre host y "contenedor"
ping 192.168.100.2

cgroups v2: limitar recursos

# Ver jerarquía de cgroups
ls /sys/fs/cgroup/

# Crear un grupo y limitar memoria
sudo mkdir /sys/fs/cgroup/miapp
echo "512M" | sudo tee /sys/fs/cgroup/miapp/memory.max
echo "256M" | sudo tee /sys/fs/cgroup/miapp/memory.swap.max

# Asignar proceso al cgroup
echo $PID | sudo tee /sys/fs/cgroup/miapp/cgroup.procs

# Con systemd es más fácil
sudo systemd-run --scope \
    -p MemoryMax=512M \
    -p CPUQuota=50% \
    -p IOWeight=50 \
    ./mi_aplicacion

11. Backups que Realmente Funcionan

rsync + rotación inteligente

#!/bin/bash
# backup.sh — backups incrementales con hardlinks (como Time Machine)

SRC=/var/www
DEST=/mnt/backups
DATE=$(date +%Y-%m-%d)
LATEST=$DEST/latest

# Backup incremental: solo copia lo que cambió,
# pero usa hardlinks para que parezca completo
rsync -avz --delete \
    --link-dest="$LATEST" \
    "$SRC/" \
    "$DEST/$DATE/"

# Actualizar symlink al último backup
ln -sfn "$DEST/$DATE" "$LATEST"

# Conservar: todos los últimos 7 días, 4 semanas, 12 meses
find "$DEST" -maxdepth 1 -type d -name "????-??-??" | \
    sort -r | tail -n +8 | xargs rm -rf

echo "Backup completado: $DEST/$DATE"
echo "Uso de disco: $(du -sh $DEST)"

Verificación de backups (el paso que todos olvidan)

# Nunca confíes en un backup que no has probado restaurar
# Script de verificación:

verify_backup() {
    local backup_dir=$1
    local test_dir=$(mktemp -d)

    # Restaurar en directorio temporal
    rsync -avz "$backup_dir/" "$test_dir/"

    # Verificar integridad básica
    if [ -f "$backup_dir/checksums.sha256" ]; then
        cd "$test_dir"
        sha256sum -c "$backup_dir/checksums.sha256" && \
            echo "✓ Backup íntegro" || \
            echo "✗ BACKUP CORRUPTO — ALERTA"
    fi

    rm -rf "$test_dir"
}

# Generar checksums al hacer backup
find "$DEST/$DATE" -type f -exec sha256sum {} \; > "$DEST/$DATE/checksums.sha256"

borgbackup — la solución profesional

sudo apt install borgbackup

# Inicializar repositorio encriptado
borg init --encryption=repokey-blake2 /mnt/backups/borg

# Crear backup con deduplicación y compresión
borg create --stats --progress \
    /mnt/backups/borg::{hostname}-{now:%Y-%m-%d} \
    /home /etc /var/www \
    --exclude /home/*/.cache \
    --compression lz4

# Listar backups
borg list /mnt/backups/borg

# Restaurar archivo específico
borg extract /mnt/backups/borg::mi-servidor-2025-01-15 home/user/importante.txt

# Limpieza automática
borg prune --list /mnt/backups/borg \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=12

12. One-liners de Emergencia

Guarda estos. Los necesitarás en el peor momento.

# ============ DISCO ============
# ¿Qué está llenando el disco?
du -h --max-depth=2 / 2>/dev/null | sort -hr | head -20

# Archivos más grandes en el sistema
find / -xdev -type f -size +100M 2>/dev/null | sort -k5 -rn

# Archivos abiertos que ya fueron borrados (espacio no liberado)
lsof | grep deleted | awk '{print $7, $9}' | sort -rn

# ============ MEMORIA ============
# Procesos ordenados por uso de memoria
ps aux --sort=-%mem | head -10

# Limpiar cache de páginas (CUIDADO en producción)
echo 1 > /proc/sys/vm/drop_caches

# ============ CPU ============
# Proceso más CPU-intensivo en tiempo real
while true; do ps -eo pid,ppid,cmd,%cpu --sort=-%cpu | head -5; sleep 2; clear; done

# ============ RED ============
# Bloquear IP inmediatamente
sudo iptables -I INPUT -s 1.2.3.4 -j DROP

# Ver conexiones por estado
ss -tan | awk '{print $1}' | sort | uniq -c | sort -rn

# ¿Quién hace más conexiones?
ss -tn state established | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn

# ============ PROCESOS ============
# Proceso zombie y su padre
ps aux | awk '$8=="Z" {print $0}'

# Árbol de procesos completo
pstree -p

# Archivos abiertos por proceso
lsof -p $(pgrep nginx | head -1)

# ============ SISTEMA ============
# Historia de reboots
last reboot | head -10

# Comandos recientes de todos los usuarios
find /home /root -name ".bash_history" -exec echo "=== {} ===" \; -exec cat {} \;

# Revisar crontabs de todos los usuarios
for u in $(cut -f1 -d: /etc/passwd); do crontab -u $u -l 2>/dev/null && echo "--- $u"; done

# ============ RECUPERACIÓN ============
# Disco lleno y necesitas espacio YA
# 1. Ver logs grandes y truncarlos (no borrarlos, los servicios tienen el FD abierto)
truncate -s 0 /var/log/nginx/access.log

# 2. Limpiar apt
sudo apt autoremove -y && sudo apt clean

# 3. Limpiar journals viejos
sudo journalctl --vacuum-time=3d

# 4. Limpiar imágenes Docker
docker system prune -af 2>/dev/null || true

📚 Recursos para Seguir

Regla de oro: Nunca ejecutes un comando que no entiendes en producción. Prueba siempre en staging. Y ten un plan de rollback antes de empezar.