--- title: "Más de 100 comandos esenciales de Linux que DEBES conocer (guía 2026)" description: "Domina la línea de comandos de Linux con esta chuleta de más de 100 comandos esenciales de Linux." date: 2024-07-10 categories: ["linux"] tags: ["linux-commands","bash","cheat-sheet"] --- import Button from "@components/widgets/Button.astro"; import Notice from "@components/widgets/Notice.astro"; import ListCheck from "@components/widgets/ListCheck.astro"; import Accordion from "@components/widgets/Accordion.astro"; import Tabs from "@components/widgets/Tabs.astro"; import Tab from "@components/widgets/Tab.astro"; Tanto si eres principiante como un administrador de sistemas experimentado, conocer los **comandos de Linux** adecuados puede transformar tu flujo de trabajo. Esta chuleta de comandos esenciales de Linux cubre más de 100 comandos, desde la navegación básica de archivos hasta la administración avanzada del sistema y herramientas CLI modernas. Es la guía de referencia que me habría gustado tener cuando empecé a administrar servidores Linux, y la que sigo teniendo en marcadores a día de hoy. Linux impulsa la mayoría de los servidores, supercomputadoras e infraestructura cloud del mundo. Según la Stack Overflow Developer Survey 2025, Bash/Shell es el 5.º lenguaje más popular con un 49 % de adopción. Si ejecutas un [VPS de Hetzner](https://go.bitdoze.com/hetzner), despliegas contenedores Docker o administras máquinas remotas, estos comandos son tu caja de herramientas diaria. _Los precios de los VPS subieron en todos los proveedores en 2026 — si estás reconsiderando un servidor alquilado, mira [qué cambió y cuándo gana un mini PC](/es/subidas-precios-vps/)._ Esta guía está organizada por tarea, no alfabéticamente. Cada sección explica qué hacen los comandos, cómo usarlos y qué vigilar. He incluido pasos de verificación después de las operaciones críticas y señalo los fallos más comunes, el tipo de cosas que te ahorran un incidente a las 2 de la madrugada.
Qué cubre esta guía
 --- ## Navegación básica y gestión de archivos Estos son los comandos de Linux que usarás en los primeros cinco minutos de cualquier sesión. Si eres nuevo, empieza aquí. ### Navegar por el sistema de archivos (`pwd`, `ls`, `cd`) #### `pwd` - muestra el directorio de trabajo Te dice en qué punto del sistema de archivos estás. ```bash $ pwd /home/username ``` #### `ls` - lista el contenido de directorios El comando de Linux más ejecutado (en serio, encabeza los análisis de historial de shell). Opciones clave: - `-l`: listado largo con permisos, propietario, tamaño y fecha - `-a`: incluye archivos ocultos (dotfiles) - `-h`: tamaños legibles (4.0K en lugar de 4096) - `-R`: recorre los subdirectorios recursivamente ```bash $ ls Desktop Documents Downloads Music Pictures Videos $ ls -lah total 36K drwxr-xr-x 5 username username 4.0K Jan 15 10:22 . drwxr-xr-x 3 root root 4.0K Jan 10 08:00 .. -rw------- 1 username username 128 Jan 15 10:22 .bash_history drwxr-xr-x 2 username username 4.0K Jan 10 08:01 Desktop drwxr-xr-x 2 username username 4.0K Jan 10 08:01 Documents ``` #### `cd` - cambiar de directorio ```bash $ cd /var/log # ruta absoluta $ cd .. # subir un nivel $ cd ~/Documents # ~ es tu directorio home $ cd - # volver al directorio anterior ``` ### Operaciones con archivos (`touch`, `cp`, `mv`, `rm`, `ln`) #### `touch` - crea un archivo vacío o actualiza su fecha ```bash $ touch newfile.txt ``` #### `cp` - copia archivos y directorios ```bash $ cp file1.txt file2.txt # copiar archivo $ cp -r dir1/ dir2/ # copiar directorio recursivamente $ cp -iv file1.txt file2.txt # interactivo + detallado ``` Verifica con `ls -l` en el destino. #### `mv` - mover o renombrar ```bash $ mv oldname.txt newname.txt # renombrar $ mv file.txt /path/to/dest/ # mover ``` #### `rm` - elimina archivos y directorios ```bash $ rm file.txt # eliminar archivo $ rm -r directory/ # eliminar directorio recursivamente $ rm -i *.log # interactivo, pregunta antes de cada borrado ``` No hay papelera. `rm` borra para siempre. La metedura de pata clásica es `rm -rf $VAR/` cuando la variable `$VAR` está vacía: eso se convierte en `rm -rf /`. Revisa siempre las variables dos veces. Considera `trash-cli` (`trash-put file.txt`) como alternativa más segura para uso interactivo. #### `ln` - crea enlaces Los enlaces te permiten referenciar un archivo desde otra ubicación sin copiarlo. ```bash $ ln -s /path/to/target link_name # enlace simbólico (blando) $ ln /path/to/target link_name # enlace duro ``` Los enlaces simbólicos son mucho más comunes. Se usan en todas partes en los despliegues: enlazando archivos de configuración, apuntando `/usr/local/bin` a tus binarios compilados, etc. ### Archivado y compresión (`tar`, `gzip`, `zip`) #### `tar` - la navaja suiza de los archivadores La mnemotecnia de las opciones: **c** (crear), **x** (extraer), **z** (gzip), **j** (bzip2), **f** (archivo). ```bash # Crear $ tar -czf archive.tar.gz /path/to/dir/ # comprimido con gzip (lo más común) $ tar -cjf archive.tar.bz2 /path/to/dir/ # bzip2 (más pequeño, más lento) # Extraer $ tar -xzf archive.tar.gz # extraer gzip $ tar -xf archive.tar.gz # el tar moderno detecta la compresión solo # Listar el contenido (compruébalo siempre antes de extraer) $ tar -tzf archive.tar.gz | head ``` En cualquier distro Linux reciente, `tar -xf` funciona sin `-z` ni `-j`: averigua la compresión a partir de la cabecera del archivo. Así que `tar -xf archive.tar.gz` es suficiente. #### `gzip` / `gunzip` - compresión independiente ```bash $ gzip file.txt # comprime file.txt → file.txt.gz (elimina el original) $ gunzip file.txt.gz # descomprime ``` #### `zip` / `unzip` - archivadores multiplataforma ```bash $ zip -r archive.zip directory/ $ unzip archive.zip $ unzip archive.zip -d /destination/ ``` --- ## Ver, buscar y editar archivos ### Ver el contenido de archivos (`cat`, `more`, `less`, `head`, `tail`) ```bash $ cat file.txt # vuelca el archivo entero a stdout $ less file.txt # visor paginado (flechas, /buscar, q para salir) $ head -20 file.txt # primeras 20 líneas $ tail -20 file.txt # últimas 20 líneas $ tail -f /var/log/syslog # seguimiento en vivo, esencial para vigilar logs ``` `less` es casi siempre mejor que `cat` para leer. `cat` sirve para combinar archivos o enviarlos por un pipe a otros comandos. ### Buscar texto (`grep`) Uno de los 5 comandos de Linux más usados. Si no usas `grep`, estás haciendo demasiado trabajo a mano. ```bash $ grep "error" /var/log/syslog # búsqueda básica $ grep -r "password" /etc/ # búsqueda recursiva $ grep -i "warning" file.txt # sin distinguir mayúsculas $ grep -v "DEBUG" file.txt # invierte, excluye coincidencias $ grep -n "TODO" *.py # muestra números de línea $ grep -c "error" /var/log/syslog # cuenta coincidencias $ grep -E "err|warn|crit" file.txt # regex extendida (patrón OR) $ grep -B2 -A3 "panic" logfile.txt # 2 líneas antes, 3 después $ ps aux | grep nginx # filtra la salida de un pipeline ``` Verifica con `grep -c` antes de cualquier operación destructiva basada en coincidencias. ### Encontrar archivos (`find`) ```bash $ find . -name "*.txt" # por nombre $ find . -type f -name "*.log" # solo archivos $ find . -type d -name "node_modules" # solo directorios $ find . -mtime -7 # modificados en los últimos 7 días $ find . -size +100M # archivos de más de 100 MB $ find . -name "*.log" -delete # borra coincidencias (GNU find) $ find . -name "*.txt" | xargs grep "error" # combo find + grep ``` `find . -name "*.log" -exec rm {} \;` es potente y peligroso. Prueba siempre primero con `ls`: `find . -name "*.log" -exec ls {} \;`. Además, empieza con `.` (directorio actual), no con `/`: buscar en todo el sistema de archivos es lento y ruidoso. ### Procesamiento de texto (`sort`, `uniq`, `wc`, `cut`, `awk`, `sed`, `diff`) Son herramientas de pipeline: brillan cuando se encadenan con `|`. #### `sort` y `uniq` ```bash $ sort file.txt # orden alfabético $ sort -n numbers.txt # orden numérico $ sort -r file.txt # inverso $ sort -k2 -t: data.txt # ordena por el 2.º campo, delimitado por : $ sort file.txt | uniq # elimina duplicados adyacentes (ordena siempre primero) $ sort file.txt | uniq -c # cuenta ocurrencias ``` #### `wc` - conteo de palabras ```bash $ wc -l file.txt # número de líneas $ wc -w file.txt # número de palabras $ wc -c file.txt # número de bytes ``` #### `cut` - extraer columnas ```bash $ cut -d':' -f1 /etc/passwd # primer campo, delimitado por : $ cut -c1-10 file.txt # primeros 10 caracteres de cada línea ``` #### `awk` - escaneo y procesado por patrones ```bash $ awk '{print $1}' file.txt # primera columna $ awk -F: '{print $1, $3}' /etc/passwd # campos 1 y 3, delimitados por : $ awk '$3 > 100' data.txt # líneas donde el 3.er campo > 100 ``` #### `sed` - editor de flujo ```bash $ sed 's/old/new/g' file.txt # reemplaza todas las ocurrencias $ sed -i 's/old/new/g' file.txt # edición in-place (¡cuidado!) $ sed -n '10,20p' file.txt # imprime las líneas 10-20 $ sed '/^#/d' config.txt # borra las líneas de comentario ``` #### `diff` - comparar archivos ```bash $ diff file1.txt file2.txt $ diff -u file1.txt file2.txt # formato unificado (más fácil de leer) ``` Distintas herramientas para obtener el primer campo delimitado por `:` de `/etc/passwd`: ```bash # Con cut $ cut -d':' -f1 /etc/passwd # Con awk $ awk -F: '{print $1}' /etc/passwd # Con sed $ sed 's/:.*//' /etc/passwd ``` `cut` es lo más simple para datos con delimitador fijo. `awk` es mejor cuando necesitas lógica. `sed` es excesivo aquí, pero funciona. ```bash # Con grep $ grep -c "error" logfile.txt # Con awk $ awk '/error/ {count++} END {print count}' logfile.txt # Con wc + grep $ grep "error" logfile.txt | wc -l ``` ### Editores (`nano`, `vim`) ```bash $ nano file.txt # sencillo, ideal para empezar (Ctrl+X para salir) $ vim file.txt # potente, curva de aprendizaje dura (Esc y luego :wq para guardar y salir) ``` Vale la pena aprender `vim` porque está instalado en prácticamente todos los servidores Linux. Cuando conectas por SSH a un [VPS de Hetzner](https://go.bitdoze.com/hetzner) recién creado, `vim` está ahí. `nano` puede que no. --- ## Permisos y propiedad de archivos ### Entender los permisos Cada archivo tiene un propietario, un grupo y permisos para propietario/grupo/otros. Usa `ls -l` para verlos: ``` -rwxr-xr-- 1 alice developers 4096 Jan 15 10:00 deploy.sh │└┬┘└┬┘└┬┘ │ │ │ └── otros: solo lectura (r--) │ │ └────── grupo: lectura + ejecución (r-x) │ └────────── propietario: lectura + escritura + ejecución (rwx) └──────────── archivo normal (-) ``` Notación numérica (octal): | Dígito | Permisos | Significado | |-------|------------|---------| | 7 | rwx | lectura + escritura + ejecución | | 6 | rw- | lectura + escritura | | 5 | r-x | lectura + ejecución | | 4 | r-- | solo lectura | | 0 | --- | sin permisos | Modos de permiso habituales: - `755`, propietario con todo, el resto lectura+ejecución (scripts, directorios) - `644`, propietario lectura+escritura, el resto lectura (archivos de configuración, datos) - `600`, solo propietario (claves privadas, archivos sensibles) ### Cambiar permisos (`chmod`) ```bash # Notación simbólica $ chmod u+x script.sh # añade ejecución al propietario $ chmod g-w file.txt # quita escritura al grupo $ chmod a+r file.txt # añade lectura para todos # Notación numérica (octal) $ chmod 755 script.sh # rwxr-xr-x $ chmod 644 config.txt # rw-r--r-- $ chmod 600 ~/.ssh/id_ed25519 # rw------- (clave privada) ``` Verifica después de cada cambio: `ls -l file` `chmod 777` da acceso total a todo el mundo. En claves SSH es aún peor: SSH se negará a usar una clave privada con permisos abiertos. Verás "Permissions 0664 for 'id_ed25519' are too open." Solución: `chmod 600 ~/.ssh/id_ed25519`. ### Cambiar el propietario (`chown`, `chgrp`) ```bash $ chown user:group file.txt $ chown -R www-data:www-data /var/www/ # recursivo (habitual en servidores web) $ chgrp developers project/ # cambia solo el grupo ``` --- ## Información y monitorización del sistema ### Información del sistema (`uname`, `hostname`, `uptime`, `free`, `dmesg`) ```bash $ uname -a # toda la info del sistema (kernel, arquitectura, etc.) $ uname -r # solo la versión del kernel $ hostname # nombre de host de la máquina $ uptime # tiempo encendido + medias de carga $ free -h # uso de memoria en formato legible $ dmesg | tail # buffer circular del kernel (problemas de hardware/drivers) ``` `free -h` y `df -h` son los dos primeros comandos que ejecuto cuando un VPS va lento o se comporta raro. En segundos te dicen si es un problema de memoria o de disco. ¿Quieres profundizar en la monitorización? Mira cómo [monitorizar el uso de CPU y enviar alertas por correo](/es/monitorizar-cpu-alertas-email-linux/) para alertas proactivas. ### Uso de disco (`df`, `du`) ```bash $ df -h # visión general del espacio en disco $ du -sh /var/log # tamaño total de /var/log $ du -sh /* # tamaño de cada directorio de primer nivel $ du -sh /var/* | sort -h # encuentra el directorio más grande de /var ``` Secuencia rápida de diagnóstico: 1. `df -h` — ¿qué sistema de archivos está lleno? 2. `du -sh /*` — ¿qué directorio de primer nivel es el culpable? 3. `du -sh /var/*` — sigue bajando 4. `journalctl --disk-usage` — ¿los journals de systemd comen disco? 5. `apt autoremove && apt clean` — recupera la caché de paquetes 6. `journalctl --vacuum-size=500M` — limita el tamaño del journal Para profundizar en imágenes y clonado de discos, mira la [guía del comando dd](/es/guia-comando-dd-linux/). ### Listar dispositivos de bloque (`lsblk`, `blkid`) ```bash $ lsblk # lista todos los dispositivos de bloque y puntos de montaje $ blkid # muestra UUIDs (necesarios para las entradas de /etc/fstab) ``` Son esenciales al añadir volúmenes extra a un VPS. --- ## Gestión de usuarios y grupos ### Comandos de usuarios (`whoami`, `id`, `useradd`, `usermod`, `passwd`, `userdel`) ```bash $ whoami # usuario actual $ id # UID, GID y grupos del usuario actual $ sudo useradd -m -s /bin/bash newuser # crea usuario con directorio home $ sudo usermod -aG sudo newuser # añade al grupo sudo $ sudo passwd newuser # establece la contraseña $ sudo userdel -r olduser # borra usuario + directorio home ``` Prefija cualquier comando con `sudo` para ejecutarlo como root. La mayoría de comandos de administración del sistema lo requieren. Usa `sudo -i` para una shell root completa. Usa `sudo !!` para repetir el último comando con sudo delante (útil cuando se te olvida). Fallo típico: `userdel` sin `-r` deja el directorio home atrás. Usa siempre `userdel -r` para limpiar. ### Comandos de grupos (`groupadd`, `groupdel`, `groups`, `who`) ```bash $ sudo groupadd newgroup # crea grupo $ sudo groupdel oldgroup # borra grupo $ groups # muestra los grupos del usuario actual $ who # quién tiene sesión iniciada $ w # quién está conectado y qué hace ``` --- ## Gestión de procesos ### Ver procesos (`ps`, `top`, `htop`) ```bash $ ps aux # todos los procesos, formato BSD $ ps -ef # todos los procesos, formato completo $ ps -u username # procesos de un usuario concreto $ top # visor de procesos en tiempo real (q para salir) $ htop # top interactivo y amigable (puede requerir instalación) ``` Cuando `top` o `htop` muestran memoria alta, revisa el [uso de swap](/es/uso-swap-linux/) para ver si hay procesos movidos a swap. ### Gestionar procesos (`kill`, `killall`, `pkill`, `bg`, `fg`, `nohup`, `jobs`) `kill PID` envía SIGTERM (señal 15): una petición educada de terminar. El proceso puede capturarla, limpiar archivos temporales, cerrar conexiones y apagarse con elegancia. Usa `kill -9 PID` (SIGKILL) solo como último recurso: no se puede capturar ni ignorar, y el proceso no tiene oportunidad de limpiar. ```bash $ kill PID # SIGTERM — apagado educado (señal por defecto) $ kill -9 PID # SIGKILL — matar a la fuerza, último recurso $ kill -l # lista todos los nombres de señal $ killall processname # mata todos los procesos por nombre (SIGTERM) $ pkill -f "pattern" # mata por coincidencia en la línea de comandos ``` Trabajos en segundo plano: ```bash $ long_running_command & $ jobs # lista trabajos en segundo plano $ fg %1 # trae el trabajo 1 al primer plano $ bg %1 # reanuda el trabajo 1 en segundo plano $ nohup ./server.sh & # sigue ejecutándose tras cerrar sesión (esencial en VPS) ``` Verifica después de matar: `ps aux | grep processname` — asegúrate de que ya no está. Fallos típicos: - Nunca hagas `kill -9` al PID 1 (init/systemd): kernel panic o sistema colgado. - `killall nginx` mata *todos* los procesos nginx. Sé específico. ### Prioridad de procesos (`nice`, `renice`) ```bash $ nice -n 10 ./heavy_task.sh # arranca con menor prioridad (más "nice") $ renice -n 5 -p PID # cambia la prioridad de un proceso en ejecución ``` Rango de prioridad: -20 (la más alta) a 19 (la más baja). Por defecto es 0. --- ## Gestión de servicios con systemd `systemctl` y `journalctl` son la forma de gestionar servicios en cualquier distro Linux moderna. Esta sección faltaba por completo en la versión original de esta guía, y es lo primero que necesitas cuando un servicio no arranca. ### Gestionar servicios (`systemctl`) ```bash $ systemctl status nginx # comprueba el estado del servicio $ systemctl start nginx # arranca ahora $ systemctl stop nginx # detiene ahora $ systemctl restart nginx # reinicia $ systemctl enable nginx # se inicia al arrancar $ systemctl disable nginx # no arranca al iniciar $ systemctl enable --now nginx # habilita + arranca (patrón habitual) $ systemctl disable --now nginx # deshabilita + detiene $ systemctl list-units --state=failed # ver todos los servicios fallidos $ systemctl daemon-reload # recarga los unit files tras editarlos ``` `systemctl start nginx` arranca el servicio ahora mismo. `systemctl enable nginx` hace que arranque automáticamente en el boot. Normalmente quieres ambos: `systemctl enable --now nginx`. Verifica tras cada reinicio: `systemctl status nginx` y `journalctl -u nginx --since "1 min ago"`. Fallo típico: `systemctl disable` sin `systemctl stop` deja el servicio corriendo hasta el próximo reinicio, pero no arrancará después. Confuso. Usa `disable --now`. ### Ver logs (`journalctl`) ```bash $ journalctl -u nginx # logs de nginx $ journalctl -u nginx -f # seguimiento en vivo (como tail -f) $ journalctl -u nginx --since "1 hour ago" $ journalctl -p err # solo errores de todos los servicios $ journalctl --disk-usage # ¿cuánto disco usan los journals? $ journalctl --vacuum-size=500M # limita el journal a 500 MB ``` En VPS que llevan mucho tiempo encendidos, los journals de systemd pueden crecer en silencio hasta varios gigabytes. Compruébalo con `journalctl --disk-usage`. Pon un límite en `/etc/systemd/journald.conf` con `SystemMaxUse=500M`, o usa `journalctl --vacuum-size=500M` para recortar. --- ## Redes y acceso remoto ### Conectividad y diagnóstico (`ping`, `traceroute`, `dig`, `nc`) ```bash $ ping -c 4 google.com # envía 4 paquetes $ traceroute google.com # traza la ruta de red $ dig bitdoze.com # consulta DNS (registro A) $ dig bitdoze.com MX # registros MX (correo) $ nc -zv host.example.com 22 # prueba si el puerto 22 está abierto $ nc -zv host.example.com 443 # prueba el puerto HTTPS ``` `dig` es más potente que `nslookup` y da una salida más limpia. `nc` (netcat) es imprescindible para depurar problemas de "no puedo conectar". ### Configuración de red (`ip`, `ss`) `ifconfig` y `netstat` forman parte del paquete obsoleto `net-tools`. Se eliminaron de la instalación por defecto de RHEL 9 y no están en Ubuntu 24.04 minimal. Si ejecutas `ifconfig` y ves "command not found", esa es la razón. Usa `ip` y `ss` en su lugar: son más potentes y siempre están disponibles. ```bash $ ip a # muestra todas las IP (sustituye a ifconfig) $ ip link # muestra las interfaces de red $ ip route # muestra la tabla de rutas $ ss -tuln # puertos TCP/UDP en escucha (sustituye a netstat) $ ss -tp # conexiones establecidas con nombres de proceso ``` `ss -tuln` es la forma moderna de ver qué está escuchando. Es más rápido que `netstat` y no necesita paquete aparte. ### Acceso remoto (`ssh`, `ssh-keygen`, `scp`, `sftp`, `rsync`) #### SSH básico ```bash $ ssh user@remote-host # conectar $ ssh -p 2222 user@remote-host # puerto personalizado $ ssh -i ~/.ssh/my_key user@remote-host # clave concreta $ ssh -L 8080:localhost:80 user@remote-host # reenvío de puerto local ``` #### Claves SSH ```bash $ ssh-keygen -t ed25519 -C "your_email@example.com" $ ssh-copy-id user@remote-host # copia la clave pública al servidor ``` Genera siempre claves Ed25519 (`ssh-keygen -t ed25519`). Son más cortas, más rápidas y más seguras que RSA. Las claves RSA de 2048 bits se consideran débiles para los estándares actuales. Ed25519 es el valor por defecto en todas las versiones modernas de OpenSSH. Verifica: `ls -la ~/.ssh/` después del keygen. Prueba el acceso sin contraseña con `ssh user@remote-host`. Fallo típico: `chmod 777` sobre la clave privada SSH → SSH la rechaza. Usa siempre `chmod 600 ~/.ssh/id_*`. Para más sobre endurecer SSH, mira [cómo securizar tu servidor SSH](/es/securizar-servidor-ssh-linux/). #### Transferencia de archivos (`scp`, `sftp`, `rsync`) ```bash $ scp file.txt user@remote:/path/ # copiar al remoto $ scp user@remote:/path/file.txt ./ # copiar desde el remoto $ sftp user@remote # transferencia interactiva $ rsync -avz /local/dir/ user@remote:/path/ # sincroniza directorios $ rsync -avz --delete /src/ /dest/ # espejo (borra los sobrantes) ``` `rsync -avz` es mi opción por defecto para cualquier sincronización. Solo transfiere archivos modificados, comprime en tránsito y preserva permisos. ### Firewalls (`ufw`, `firewall-cmd`, `iptables`/`nftables`) ```bash $ sudo ufw allow 22/tcp # permite SSH $ sudo ufw allow 443/tcp # permite HTTPS $ sudo ufw enable # activa el firewall $ sudo ufw status verbose # muestra las reglas ``` ```bash $ sudo firewall-cmd --permanent --add-service=ssh $ sudo firewall-cmd --permanent --add-service=https $ sudo firewall-cmd --reload $ sudo firewall-cmd --list-all ``` ```bash $ sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT $ sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT $ sudo iptables -L -n -v ``` Nota: las reglas de `iptables` se pierden al reiniciar salvo que las guardes con `iptables-save`. En las distros modernas, `nftables` es el backend del kernel: los comandos `iptables` funcionan a través de una capa de compatibilidad. `iptables -F` borra todas las reglas, incluida la que permite tu conexión SSH. Te quedarás fuera. Asegúrate siempre de que SSH (puerto 22) esté permitido antes de aplicar reglas nuevas. --- ## Gestión de paquetes ### Debian/Ubuntu (`apt`) ```bash $ sudo apt update # actualiza el índice de paquetes $ sudo apt upgrade # actualiza los paquetes instalados $ sudo apt install nginx # instala un paquete $ sudo apt remove nginx # desinstala (conserva la config) $ sudo apt purge nginx # elimina paquete Y configuración $ sudo apt autoremove # elimina dependencias sin uso $ sudo apt search keyword # busca paquetes $ sudo apt show nginx # detalles del paquete ``` `apt` es para uso interactivo en el terminal: tiene barras de progreso y salida en color. `apt-get` es para scripts y Dockerfiles donde quieres una salida estable y parseable entre versiones. Usa `apt` en el terminal, `apt-get` en tus pipelines de CI. ### RHEL/Fedora (`dnf` / `dnf5`) Fedora 41 (octubre de 2024) convirtió a DNF5 en el gestor de paquetes por defecto. RHEL 9 y CentOS Stream 9 siguen usando `dnf` (v4). Los comandos son los mismos: ```bash $ sudo dnf install nginx $ sudo dnf update $ sudo dnf remove nginx $ sudo dnf search keyword ``` `yum` está prácticamente muerto en sistemas modernos. Si aún lo usas, cambia a `dnf`. ### Otros gestores de paquetes ```bash # Arch Linux $ sudo pacman -S package_name # instalar $ sudo pacman -Syu # actualizar todo $ sudo pacman -R package_name # desinstalar # openSUSE $ sudo zypper install package_name $ sudo zypper update # Flatpak (multi-distro) $ flatpak install flathub org.app.Name $ flatpak update # Snap (Ubuntu/Canonical) $ sudo snap install package_name $ snap list ``` ```bash # Debian/Ubuntu sudo apt install nginx # RHEL/Fedora sudo dnf install nginx # Arch sudo pacman -S nginx # openSUSE sudo zypper install nginx ``` ```bash # Debian/Ubuntu sudo apt update && sudo apt upgrade # RHEL/Fedora sudo dnf upgrade # Arch sudo pacman -Syu # openSUSE sudo zypper update ``` --- ## Gestión de discos y almacenamiento ### Particionado (`fdisk`, `parted`) ```bash $ sudo fdisk /dev/sda # particionado MBR (interactivo) $ sudo parted /dev/sda # particionado GPT (para discos >2 TB) ``` `fdisk` sobre el disco equivocado = pérdida de datos irreversible. Ejecuta siempre `lsblk` primero para confirmar qué disco es cuál. Cuando pulsas `w` (write) en fdisk no hay vuelta atrás. ### Sistemas de archivos (`mkfs`, `mount`, `umount`, `fsck`) ```bash $ sudo mkfs.ext4 /dev/sda1 # crea un sistema de archivos ext4 $ sudo mount /dev/sda1 /mnt # montar $ sudo umount /mnt # desmontar $ sudo fsck /dev/sda1 # comprueba errores del sistema de archivos ``` Para montar [recursos NFS](/es/configurar-nfs-linux/) en red, usa `mount -t nfs server:/share /mnt/nfs`. Para que los montajes sobrevivan a los reinicios, añade entradas en `/etc/fstab` (usa `blkid` para obtener los UUIDs). --- ## Productividad e historial del shell ### Atajos de comandos (`alias`, `history`, `!!`, `!$`) ```bash $ alias ll='ls -la' # crea un atajo $ alias # lista todos los alias $ history # muestra el historial de comandos $ history | grep docker # busca en el historial $ !! # repite el último comando (útil con sudo: sudo !!) $ !$ # último argumento del comando anterior ``` Pulsa `Ctrl+R` para una búsqueda incremental inversa en el historial. Empieza a escribir y encontrará comandos coincidentes. Para una experiencia mejor, configura el [autocompletado de comandos en Zsh](/es/activar-autocompletado-comandos-zsh/) y el [resaltado de sintaxis en Zsh](/es/activar-resaltado-sintaxis-zsh/). ### Pipes, redirecciones y utilidades (`tee`, `xargs`, `watch`, `export`, `env`, `source`) ```bash $ command | tee output.log # escribe a archivo Y a stdout $ find . -name "*.tmp" | xargs rm # construye el comando rm desde stdin $ watch -n 2 docker ps # repite cada 2 segundos (genial para monitorizar) $ export VAR=value # define una variable de entorno $ env # lista todas las variables de entorno $ source ~/.bashrc # recarga la config del shell sin reiniciar el terminal ``` El verdadero poder de los comandos de Linux está en combinarlos con pipes (`|`). Cada comando hace una cosa bien — encadénalos: ```bash $ ps aux | grep nginx | awk '{print $2}' | xargs kill ``` Esto encuentra todos los procesos nginx, extrae sus PID y los mata. Una línea. --- ## Scripting y automatización ### Fundamentos de shell scripting ```bash #!/bin/bash echo "Starting backup..." DATE=$(date +%Y%m%d) tar -czf /backups/backup_$DATE.tar.gz /data/ echo "Backup complete: backup_$DATE.tar.gz" ``` Construcciones clave: ```bash # Variables name="World" echo "Hello, $name!" # Condicionales if [ -f /tmp/lockfile ]; then echo "Lock file exists" elif [ -d /tmp/workdir ]; then echo "Working directory found" else echo "Clean state" fi # Bucle for for file in *.log; do echo "Processing $file" done # Bucle while count=1 while [ $count -le 5 ]; do echo "Count: $count" count=$((count + 1)) done ``` ### Programación de tareas (`cron`, `at`) El diagrama de sintaxis de crontab: ``` * * * * * command_to_execute - - - - - | | | | | | | | | +----- Día de la semana (0-7, domingo = 0 o 7) | | | +------- Mes (1-12) | | +--------- Día del mes (1-31) | +----------- Hora (0-23) +------------- Minuto (0-59) ``` ```bash $ crontab -e # edita tu crontab $ crontab -l # lista los cron jobs actuales # Ejemplos: 0 2 * * * /path/to/backup.sh # cada día a las 2 AM */5 * * * * /path/to/healthcheck.sh # cada 5 minutos 0 0 * * 0 /path/to/weekly_cleanup.sh # cada domingo a medianoche ``` ```bash $ at 2:00 PM # trabajo programado de una sola vez at> /path/to/script.sh at> ``` ### Timers de systemd (la alternativa moderna a cron) Los timers de systemd ofrecen mejor logging, gestión de dependencias y soporte de retardo aleatorio. Son el enfoque moderno en todas las distros basadas en systemd. ```ini # /etc/systemd/system/backup.timer [Unit] Description=Daily backup timer [Timer] OnCalendar=*-*-* 02:00:00 RandomizedDelaySec=900 Persistent=true [Install] WantedBy=timers.target ``` ```ini # /etc/systemd/system/backup.service [Unit] Description=Run backup [Service] Type=oneshot ExecStart=/path/to/backup.sh ``` ```bash $ sudo systemctl enable --now backup.timer $ systemctl list-timers # ver todos los timers activos ``` cron es más simple y universalmente entendido. Los timers de systemd ofrecen mejor logging (`journalctl -u backup`), gestión de dependencias y `RandomizedDelaySec` para evitar problemas de thundering herd. Para tareas simples, cron basta. Para cualquier cosa que dependa de otros servicios, considera los timers de systemd. --- ## Herramientas de desarrollo y DevOps ### Control de versiones (`git`) Git lo usa el 93,87 % de los desarrolladores (Stack Overflow 2025). Estos son los comandos que usarás a diario: ```bash $ git init # inicializa un repo nuevo $ git clone https://github.com/... # clona un repo remoto $ git status # ¿qué ha cambiado? $ git add . # prepara todos los cambios $ git commit -m "message" # commit de los cambios preparados $ git push # sube al remoto $ git pull # trae del remoto $ git log --oneline # historial compacto $ git diff # ver cambios sin preparar ``` Para una guía completa, mira [comandos de Git](/es/comandos-git/). ### Contenedores (`docker`) Docker tiene un 71,1 % de adopción entre desarrolladores (Stack Overflow 2025). Estos son los comandos más usados: ```bash $ docker run -d -p 80:80 nginx # ejecuta un contenedor en segundo plano $ docker ps # lista contenedores en ejecución $ docker ps -a # lista todos los contenedores (incluidos los parados) $ docker logs container_name # ver logs $ docker exec -it container_name bash # abre una shell en el contenedor $ docker stop container_name # detener $ docker rm container_name # elimina un contenedor parado $ docker images # lista imágenes $ docker compose up -d # arranca el stack de compose $ docker compose down # para y elimina el stack de compose ``` Para la referencia completa, mira [comandos de Docker](/es/comandos-docker/). ### Orquestación de contenedores (`kubectl`) Si usas Kubernetes: ```bash $ kubectl get pods # lista pods $ kubectl logs pod_name # ver logs del pod $ kubectl exec -it pod_name -- bash # abre una shell en el pod $ kubectl apply -f manifest.yaml # aplica la configuración $ kubectl get services # lista servicios ``` Esto solo es relevante si usas K8s: sáltalo si trabajas con Docker Compose o un PaaS. --- ## Alternativas CLI modernas ### ¿Por qué usar herramientas modernas? En los últimos años, los desarrolladores han reescrito muchas herramientas Unix clásicas en Rust y Go. El resultado: son más rápidas, más bonitas y a menudo más ergonómicas. La contrapartida: hay que instalarlas, mientras que las herramientas clásicas siempre están disponibles en un VPS mínimo. Si administras servidores para ganarte la vida, estas herramientas merecen el tiempo de instalación. Si escribes un Dockerfile que debe funcionar en todas partes, quédate con las clásicas. ### El toolkit moderno | Herramienta clásica | Alternativa moderna | Ventaja clave | |------------|-------------------|-------------| | `cat` | [bat](https://github.com/sharkdp/bat) | Resaltado de sintaxis, números de línea, integración con git | | `ls` | [eza](https://github.com/eza-community/eza) | Colores, iconos, vista de árbol, detección de git | | `cd` | [zoxide](https://github.com/ajeetdsouza/zoxide) | Recuerda directorios frecuentes, salta con nombres parciales | | `grep` | [ripgrep (rg)](https://github.com/BurntSushi/ripgrep) | Más rápido, respeta .gitignore, salida limpia | | `find` | [fd](https://github.com/sharkdp/fd) | Sintaxis intuitiva, más rápido, con colores | | `top`/`htop` | [btop](https://github.com/aristocratos/btop) | TUI completa, gráficas de GPU/red/disco | | `du` | [ncdu](https://dev.yorhel.nl/ncdu) / [dust](https://github.com/bootandy/dust) | Navegación interactiva del uso de disco | | `df` | [duf](https://github.com/muesli/duf) | Visión de disco colorida y filtrable | | `man` | [tldr](https://github.com/tldr-pages/tldr) | Ejemplos prácticos, mantenido por la comunidad | | `sed` | [sd](https://github.com/chmln/sd) | Sintaxis de buscar-y-reemplazar más simple | | `curl` (APIs) | [httpie](https://github.com/httpie/cli) | Consciente de JSON, con resaltado de sintaxis | | `diff` | [delta](https://github.com/dandavison/delta) | Con resaltado de sintaxis, lado a lado | | Ctrl+R | [fzf](https://github.com/junegunn/fzf) | Buscador difuso para archivos, historial, todo | | Historial | [atuin](https://github.com/atuinsh/atuin) | Historial de shell sincronizado y buscable entre máquinas | Nota: `exa` (el reemplazo original de `ls`) está sin mantenimiento desde 2023. Usa `eza`: es el fork activo de la comunidad. Para una guía completa de `zoxide`, mira [Zoxide: la forma inteligente de navegar por tu terminal](/es/zoxide-tutorial/). ### Instalar un pack inicial ```bash $ sudo apt install bat ripgrep fd-find eza btop ncdu fzf zoxide # Arregla los conflictos de nombre en Ubuntu: $ sudo ln -s /usr/bin/batcat /usr/local/bin/bat $ sudo ln -s /usr/bin/fdfind /usr/local/bin/fd ``` ```bash $ sudo dnf install bat ripgrep fd-find eza btop ncdu duf fzf zoxide ``` ```bash $ sudo pacman -S bat ripgrep fd eza btop ncdu duf fzf zoxide ``` Instala lo esencial con un comando: ```bash sudo apt install bat ripgrep fd-find eza btop ncdu fzf zoxide ``` Luego añade a `~/.bashrc` para la integración con el shell: ```bash eval "$(zoxide init bash)" eval "$(fzf --bash)" alias ls='eza --icons' alias cat='bat --paging=never' ``` Fallo típico: en Ubuntu, `fd` se instala como `fdfind` y `bat` como `batcat` por conflictos de nombres de paquete. Crea los symlinks como se muestra arriba. --- ## Chuleta de referencia rápida Esta tabla condensada cubre todos los comandos de la guía. Guárdala en marcadores. | Categoría | Comando | Descripción | Ejemplo | |----------|---------|-------------|---------| | Navegación | `pwd` | Directorio actual | `pwd` | | Navegación | `ls` | Lista el contenido | `ls -lah` | | Navegación | `cd` | Cambia de directorio | `cd /var/log` | | Archivos | `touch` | Crea archivo vacío | `touch new.txt` | | Archivos | `cp` | Copiar | `cp -r dir1/ dir2/` | | Archivos | `mv` | Mover/renombrar | `mv old new` | | Archivos | `rm` | Eliminar | `rm -i file.txt` | | Archivos | `ln` | Crea un enlace | `ln -s target link` | | Compresión | `tar` | Empaqueta | `tar -czf a.tar.gz dir/` | | Compresión | `gzip` | Comprimir | `gzip file.txt` | | Compresión | `zip`/`unzip` | Archivos zip | `zip -r a.zip dir/` | | Ver | `cat` | Imprime un archivo | `cat file.txt` | | Ver | `less` | Visor paginado | `less file.txt` | | Ver | `head`/`tail` | Primeras/últimas líneas | `tail -f logfile` | | Buscar | `grep` | Búsqueda de texto | `grep -rn "err" .` | | Buscar | `find` | Búsqueda de archivos | `find . -name "*.log"` | | Texto | `sort` | Ordena líneas | `sort -n nums.txt` | | Texto | `uniq` | Elimina duplicados | `sort f \| uniq -c` | | Texto | `wc` | Contar | `wc -l file.txt` | | Texto | `cut` | Extrae columnas | `cut -d: -f1 /etc/passwd` | | Texto | `awk` | Procesado por patrones | `awk '{print $1}' f` | | Texto | `sed` | Edición en stream | `sed 's/old/new/g' f` | | Texto | `diff` | Compara archivos | `diff -u f1 f2` | | Permisos | `chmod` | Cambia permisos | `chmod 755 script.sh` | | Permisos | `chown` | Cambia propietario | `chown user:group f` | | Sistema | `uname` | Info del sistema | `uname -a` | | Sistema | `uptime` | Medias de carga | `uptime` | | Sistema | `free` | Uso de memoria | `free -h` | | Sistema | `df` | Espacio en disco | `df -h` | | Sistema | `du` | Tamaño de directorio | `du -sh /var/*` | | Sistema | `lsblk` | Dispositivos de bloque | `lsblk` | | Sistema | `dmesg` | Mensajes del kernel | `dmesg \| tail` | | Usuarios | `whoami` | Usuario actual | `whoami` | | Usuarios | `id` | Info de usuario/grupo | `id` | | Usuarios | `useradd` | Añade usuario | `useradd -m newuser` | | Usuarios | `passwd` | Establece contraseña | `passwd newuser` | | Usuarios | `groups` | Grupos del usuario | `groups` | | Usuarios | `sudo` | Ejecuta como root | `sudo command` | | Procesos | `ps` | Instantánea de procesos | `ps aux` | | Procesos | `top`/`htop` | Visor en tiempo real | `htop` | | Procesos | `kill` | Termina (SIGTERM) | `kill PID` | | Procesos | `kill -9` | Mata a la fuerza (SIGKILL) | `kill -9 PID` | | Procesos | `pkill` | Mata por nombre | `pkill nginx` | | Procesos | `nohup` | Sobrevive al logout | `nohup ./app &` | | Procesos | `nice`/`renice` | Prioridad de proceso | `nice -n 10 cmd` | | Servicios | `systemctl` | Gestiona servicios | `systemctl status nginx` | | Servicios | `journalctl` | Ver logs | `journalctl -u nginx -f` | | Red | `ping` | Prueba conectividad | `ping -c4 host` | | Red | `traceroute` | Traza la ruta | `traceroute host` | | Red | `dig` | Consulta DNS | `dig domain.com` | | Red | `nc` | Prueba de puerto | `nc -zv host 22` | | Red | `ip` | Config de red | `ip a` | | Red | `ss` | Estadísticas de sockets | `ss -tuln` | | Remoto | `ssh` | Shell remota | `ssh user@host` | | Remoto | `ssh-keygen` | Genera clave | `ssh-keygen -t ed25519` | | Remoto | `scp` | Copia segura | `scp f user@h:/path/` | | Remoto | `rsync` | Sincroniza archivos | `rsync -avz src/ dest/` | | Firewall | `ufw` | Firewall de Ubuntu | `ufw allow 443/tcp` | | Firewall | `firewall-cmd` | Firewall de RHEL | `firewall-cmd --add-service=https` | | Paquetes | `apt` | Debian/Ubuntu | `apt install pkg` | | Paquetes | `dnf` | RHEL/Fedora | `dnf install pkg` | | Paquetes | `pacman` | Arch | `pacman -S pkg` | | Disco | `fdisk` | Particiona | `fdisk /dev/sda` | | Disco | `mkfs` | Crea sistema de archivos | `mkfs.ext4 /dev/sda1` | | Disco | `mount`/`umount` | Montar/desmontar | `mount /dev/sda1 /mnt` | | Shell | `alias` | Atajo de comando | `alias ll='ls -la'` | | Shell | `history` | Historial de comandos | `history \| grep docker` | | Shell | `tee` | Pipe + archivo | `cmd \| tee log.txt` | | Shell | `xargs` | Construye desde stdin | `find . -name "*.tmp" \| xargs rm` | | Shell | `watch` | Repite comando | `watch -n2 docker ps` | | Shell | `export` | Define variable de entorno | `export KEY=value` | | Shell | `source` | Recarga la config | `source ~/.bashrc` | | Script | `echo` | Imprime texto | `echo "hello"` | | Script | `read` | Lee entrada | `read -p "? " var` | | Script | `cron` | Programa tareas | `crontab -e` | | Script | `at` | Programación única | `at 2:00 PM` | | Dev | `git` | Control de versiones | `git commit -m "msg"` | | Dev | `docker` | Contenedores | `docker compose up -d` | | Dev | `kubectl` | Kubernetes | `kubectl get pods` | | Monitorización | `vmstat` | Memoria virtual | `vmstat 1 5` | | Monitorización | `iostat` | Estadísticas de E/S | `iostat -x 1 3` | | Monitorización | `sar` | Actividad del sistema | `sar -u 1 3` | | Varios | `wget` | Descarga archivo | `wget url` | | Varios | `curl` | Transfiere datos | `curl -I url` | | Varios | `file` | Tipo de archivo | `file mystery_file` | | Varios | `stat` | Detalles del archivo | `stat file.txt` | | Varios | `which` | Localiza un comando | `which python3` | | Varios | `lsof` | Archivos abiertos | `lsof -i :80` | | Varios | `env` | Variables de entorno | `env` | --- ## Preguntas frecuentes Empieza con estos 12 comandos — cubren el 80 % del trabajo diario en el terminal: `ls`, `cd`, `cp`, `mv`, `rm`, `cat`, `grep`, `find`, `chmod`, `sudo`, `ssh`, `tar` Cuando te sientas cómodo, añade `awk`, `sed`, `systemctl` y `docker`. Después, el resto llega de forma natural según lo necesites. `apt` es el comando moderno y amigable para uso interactivo en el terminal — tiene barras de progreso, salida en color y una interfaz más limpia. `apt-get` es el comando más antiguo, pensado para scripts y automatización donde importa la estabilidad de la salida entre versiones. Usa `apt` en el terminal, `apt-get` en Dockerfiles y scripts de CI. Usa `find`: `find / -name "filename.txt" 2>/dev/null` Para una búsqueda por nombre más rápida: `find . -name "*.conf"` Si tienes `locate` instalado: `locate filename.txt` (usa una base de datos preconstruida, mucho más rápido pero necesita `updatedb` para refrescarse). ```bash df -h # visión general por sistema de archivos du -sh /path # tamaño del directorio du -sh /* | sort -h # encuentra los directorios más grandes ``` Cuando el disco de tu VPS se llena, empieza con `df -h` para ver qué sistema de archivos está lleno y luego baja con `du -sh`. `kill PID` envía SIGTERM (señal 15): una petición educada de apagarse. El proceso puede capturarla, limpiar y salir con elegancia. `kill -9 PID` envía SIGKILL (señal 9): una terminación inmediata que no se puede capturar. El proceso no tiene oportunidad de limpiar archivos temporales, cerrar conexiones de base de datos ni liberar bloqueos. Prueba siempre primero con `kill`. Usa `kill -9` solo cuando el proceso ignora SIGTERM. ```bash ss -tuln # puertos TCP y UDP en escucha (moderno, siempre disponible) ss -tp # conexiones establecidas con nombres de proceso ``` Para probar si un puerto concreto está abierto en un host remoto: `nc -zv host 443` Para un escaneo de puertos completo (úsalo con responsabilidad): `nmap host` Los cambios con más impacto: - `cat` → `bat` (resaltado de sintaxis) - `ls` → `eza` (colores, iconos, árbol) - `grep` → `ripgrep` (más rápido, más listo) - `find` → `fd` (sintaxis más simple) - `top` → `btop` (TUI completa) - `cd` → `zoxide` (recuerda tus directorios) - `Ctrl+R` → `fzf` (búsqueda difusa de todo) Mira la sección de [alternativas CLI modernas](#alternativas-cli-modernas) para los comandos de instalación. --- ## Conclusión Dominar los comandos de Linux es la habilidad más valiosa para cualquiera que administre servidores, autoaloje aplicaciones o desarrolle en Linux. Esta chuleta cubre más de 100 comandos organizados por tarea: desde la navegación básica hasta las herramientas CLI modernas.
Puntos clave
 La mejor forma de aprender es usar estos comandos en un servidor real. Si necesitas uno, [Hetzner](https://go.bitdoze.com/hetzner) tiene VPS Linux asequibles desde unos pocos euros al mes — perfectos para practicar. Guarda esta chuleta en marcadores y vuelve a ella mientras construyes tus habilidades en Linux. Para guías relacionadas en profundidad, mira [comandos de Docker](/es/comandos-docker/) y [comandos de Git](/es/comandos-git/). Para referencias rápidas sin leer páginas man enteras, instala `tldr`: te da ejemplos prácticos en lugar de documentación exhaustiva. `tldr tar` te dice las 5 cosas que realmente necesitas saber.