Más de 100 comandos esenciales de Linux que DEBES conocer (guía 2026)

$ pwd
/home/username

$ 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 /var/log       # ruta absoluta
$ cd ..             # subir un nivel
$ cd ~/Documents    # ~ es tu directorio home
$ cd -              # volver al directorio anterior

$ touch newfile.txt

$ cp file1.txt file2.txt           # copiar archivo
$ cp -r dir1/ dir2/                # copiar directorio recursivamente
$ cp -iv file1.txt file2.txt       # interactivo + detallado

$ mv oldname.txt newname.txt       # renombrar
$ mv file.txt /path/to/dest/       # mover

$ rm file.txt                      # eliminar archivo
$ rm -r directory/                 # eliminar directorio recursivamente
$ rm -i *.log                      # interactivo, pregunta antes de cada borrado

$ ln -s /path/to/target link_name    # enlace simbólico (blando)
$ ln /path/to/target link_name       # enlace duro

# 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

$ gzip file.txt          # comprime file.txt → file.txt.gz (elimina el original)
$ gunzip file.txt.gz     # descomprime

$ zip -r archive.zip directory/
$ unzip archive.zip
$ unzip archive.zip -d /destination/

$ 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

$ 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

$ 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

$ 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 -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 -d':' -f1 /etc/passwd       # primer campo, delimitado por :
$ cut -c1-10 file.txt             # primeros 10 caracteres de cada línea

$ 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 '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 file1.txt file2.txt
$ diff -u file1.txt file2.txt                  # formato unificado (más fácil de leer)

$ 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)

-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 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)

$ 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

$ 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)

$ 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

$ lsblk                       # lista todos los dispositivos de bloque y puntos de montaje
$ blkid                       # muestra UUIDs (necesarios para las entradas de /etc/fstab)

$ 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

$ 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

$ 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)

$ 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

$ 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)

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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

$ ssh-keygen -t ed25519 -C "[email protected]"
$ ssh-copy-id user@remote-host                # copia la clave pública al servidor

$ 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)

$ 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

$ sudo dnf install nginx
$ sudo dnf update
$ sudo dnf remove nginx
$ sudo dnf search keyword

# 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

$ sudo fdisk /dev/sda             # particionado MBR (interactivo)
$ sudo parted /dev/sda            # particionado GPT (para discos >2 TB)

$ 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

$ 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

$ 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

#!/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"

# 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

* * * * * 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)

$ 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

$ at 2:00 PM                              # trabajo programado de una sola vez
at> /path/to/script.sh
at> <Ctrl+D>

# /etc/systemd/system/backup.timer
[Unit]
Description=Daily backup timer

[Timer]
OnCalendar=*-*-* 02:00:00
RandomizedDelaySec=900
Persistent=true

[Install]
WantedBy=timers.target

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

[Service]
Type=oneshot
ExecStart=/path/to/backup.sh

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

$ 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

$ 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

$ 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