Guía rápida de comandos de Linux: más de 200 comandos por tarea

-P

muestra la ruta física, con los enlaces simbólicos resueltos

-L

muestra la ruta lógica, conservando los enlaces simbólicos (predeterminado)

pwd

pwd -P

-l

formato largo: permisos, propietario, tamaño, fecha

-a

incluye los archivos ocultos (que empiezan por punto)

-h

tamaños legibles (con -l): 4.0K, 12M

-t

ordena por fecha de modificación, los más recientes primero

-r

invierte el orden

-S

ordena por tamaño, los más grandes primero

-d

lista el directorio en sí, no su contenido

-1

un nombre por línea

-R

entra recursivamente en los subdirectorios

ls -lah

ls -ltr

ls -lS | head

ls -ld */

macOS/BSD: Las opciones de arriba funcionan en macOS. Allí el color es -G (las versiones recientes de macOS también aceptan --color).

-L N

baja como máximo N niveles

-a

incluye los archivos ocultos

-d

solo directorios

-I pattern

omite los nombres que coinciden con el patrón

tree -L 2 -I 'node_modules|.git'

No viene instalado por defecto en la mayoría de las distribuciones: apt install tree / dnf install tree.

-p

crea los directorios padre que hagan falta; sin error si ya existe

-m mode

establece los permisos, p. ej. -m 700

-v

muestra cada directorio creado

mkdir -p project/src/components

mkdir -p app/{src,tests,docs}

-p

borra también los directorios padre vacíos

rmdir old-folder

-c

no crea el archivo si no existe

-t stamp

establece una fecha y hora concretas

-r ref

copia las fechas de otro archivo

touch notes.txt

touch -t 202601011200 file

macOS/BSD: touch -d de GNU acepta texto libre como -d '2 days ago'; en macOS, -d solo admite YYYY-MM-DDThh:mm:SS.

-r, -R

copia directorios de forma recursiva

-a

archivo: recursivo, conserva permisos, fechas y enlaces simbólicos

-i

pregunta antes de sobrescribir

-n

nunca sobrescribe un archivo existente

-u

copia solo si el origen es más reciente (GNU)

-v

muestra cada archivo copiado

cp report.pdf ~/backup/

cp -a site/ /srv/site-backup

cp -i *.conf /etc/myapp/

macOS/BSD: cp de macOS tiene -a, -R, -i y -n, pero no -u. En cp de BSD, una barra final en el origen (cp -R src/ dst) copia el contenido de src, no src en sí.

-i

pregunta antes de sobrescribir

-n

nunca sobrescribe

-v

muestra cada movimiento

-t dir

mueve a dir (GNU; útil con xargs)

mv draft.txt final.txt

mv *.jpg photos/

mv -n new.conf /etc/app/app.conf

mv reemplaza sin avisar un archivo de destino existente, salvo que uses -i o -n.

-i

pregunta antes de cada borrado

-I

pregunta una vez antes de borrar más de tres archivos o de forma recursiva (GNU)

-r

borra directorios y su contenido

-f

ignora los archivos que no existen, nunca pregunta

-v

muestra cada archivo borrado

rm old.log

rm -i *.bak

rm -- -weird-name.txt

En la línea de comandos no hay papelera ni deshacer. Lo borrado, borrado está.

rm -rf build/

rm -rf -- "${BUILD_DIR:?}/"

Peligro: Sin confirmación y sin deshacer. Un espacio de más (rm -rf / tmp) o una variable vacía (rm -rf "$DIR/"*) borran mucho más de lo previsto. rm de GNU se niega a borrar / (--preserve-root es el comportamiento predeterminado), pero nada protege /home ni /etc. Ejecuta antes ls sobre la ruta exacta.

-s

enlace simbólico (sin esta opción obtienes un enlace duro)

-f

reemplaza un enlace existente

-n

trata un enlace existente a un directorio como un archivo normal (úsalo con -f)

ln -s /opt/app/bin/app /usr/local/bin/app

ln -sfn releases/v2 current

El orden es primero el destino y luego el nombre del nuevo enlace, igual que en cp.

realpath ../config.yml

readlink -f /usr/bin/python3

macOS/BSD: Las versiones actuales de macOS tienen tanto realpath como readlink -f; las muy antiguas no tenían ninguno.

-i

muestra el tipo MIME (Linux)

-b

breve: omite el nombre del archivo

file download.bin

file -i notes.txt

macOS/BSD: En macOS la opción de MIME es -I (mayúscula); allí -i en minúscula significa otra cosa.

-c FORMAT

salida personalizada de GNU: %s tamaño, %y mtime, %U propietario, %a permisos en octal, %n nombre

stat file.txt

stat -c '%a %U %s %n' *

macOS/BSD: macOS usa -f, no -c, con otras letras: stat -f '%Lp %Su %z %N' file.

-d

crea un directorio en lugar de un archivo

tmp=$(mktemp -d) && trap 'rm -rf "$tmp"' EXIT

-n

numera todas las líneas

-A

muestra los tabuladores como ^I y los finales de línea como $ (GNU); deja ver los finales de línea CRLF

cat /etc/os-release

cat part1.txt part2.txt > whole.txt

cat -A script.sh | head

macOS/BSD: cat de macOS no tiene -A; usa cat -vet para obtener lo mismo.

tac access.log | head

macOS/BSD: No existe en macOS; usa tail -r file.

Space / b

página abajo / arriba

/text

busca hacia delante; n siguiente, N anterior

g / G

salta al principio / al final

F

sigue el archivo como tail -f; Ctrl+C para parar

q

salir

-N

muestra los números de línea

-S

no ajusta las líneas largas (desplazamiento horizontal)

less /var/log/syslog

journalctl -u nginx | less -S

-n N

las primeras N líneas (10 por defecto)

-c N

los primeros N bytes

-n -N

todo excepto las últimas N líneas (GNU)

head -n 20 data.csv

head -c 512 file.bin | xxd

macOS/BSD: head de macOS no acepta cantidades negativas.

-n N

las últimas N líneas (10 por defecto)

-n +N

empieza en la línea N

-f

sigue mostrando líneas a medida que crece el archivo

-F

sigue por nombre; sobrevive a la rotación de logs

tail -n 50 app.log

tail -F /var/log/nginx/access.log

tail -n +2 data.csv

Ctrl+O

guardar

Ctrl+X

salir

Ctrl+W

buscar

Ctrl+K / Ctrl+U

cortar línea / pegar

Alt+U

deshacer

sudo nano /etc/hosts

La barra de atajos de la parte inferior de la pantalla muestra las teclas; ^ significa Ctrl y M- significa Alt.

i

modo inserción (escribir texto)

Esc

vuelve al modo normal

:w / :q / :wq

guardar / salir / guardar y salir

:q!

salir sin guardar

/text

buscar; n para el siguiente

dd / yy / p

borrar línea / copiar línea / pegar

u / Ctrl+R

deshacer / rehacer

vim +42 app.py

-u

formato unificado (el que usan patch y git)

-r

compara directorios de forma recursiva

-q

solo indica si los archivos son distintos

-w

ignora todos los espacios en blanco

-y

lado a lado

diff -u old.conf new.conf

diff -rq dir1/ dir2/

diff <(sort a.txt) <(sort b.txt)

Compara textos lado a lado en el navegador →

-a

añade al final en lugar de sobrescribir

make 2>&1 | tee build.log

echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf

printf '%s\n' "$var"

printf '%-12s %6.2f\n' disk 93.5

echo -e y echo -n se comportan distinto según el shell; printf se comporta igual en todas partes.

xxd image.png | head

hexdump -C file.bin | head

xxd forma parte de los paquetes de vim; hexdump está en util-linux (bsdextrautils en Debian/Ubuntu recientes).

-n N

solo cadenas de al menos N caracteres (4 por defecto)

strings -n 8 firmware.bin | less

Forma parte de binutils en Linux.

ls -l deploy.sh

El primer carácter es el tipo (- archivo, d directorio, l enlace simbólico). Después vienen tres tríos: propietario, grupo y el resto. r=4, w=2, x=1, así que rwxr-x--- es 750.

Convierte rwx a octal con la calculadora de chmod →

-R

se aplica a un directorio y a todo su contenido

-v

informa de cada cambio

chmod 644 index.html

chmod 755 deploy.sh

chmod 600 ~/.ssh/id_ed25519

Calcula el modo octal con la calculadora de chmod →

chmod +x script.sh

chmod go-w file

chmod -R u=rwX,go=rX site/

Construye modos simbólicos y octales con la calculadora de chmod →

find site/ -type d -exec chmod 755 {} +

find site/ -type f -exec chmod 644 {} +

Peligro: Da permiso de escritura sobre todo el árbol a cualquier usuario y a cualquier servicio comprometido de la máquina, marca todos los archivos como ejecutables y hace que OpenSSH rechace las claves si ~/.ssh tiene 777. Aplicado a /etc o /usr puede romper sudo y el sistema. Corrige el propietario con chown, o usa los dos comandos find.

Elige el modo menos permisivo que funcione →

-R

recursivo

user:

con dos puntos al final y sin grupo, también asigna como grupo el grupo de inicio de sesión del usuario

sudo chown -R www-data:www-data /var/www/site

sudo chown "$USER": file.txt

Peligro: sudo chown -R sobre /, /usr o /etc elimina los bits setuid y los propietarios de los que dependen sudo, passwd y los servicios; recuperarse suele implicar reinstalar. Revisa bien la ruta.

umask

umask 077

La máscara quita bits: los archivos parten de 666 y los directorios de 777, así que 022 da 644 y 755.

-i

shell de inicio de sesión de root

-u user

ejecuta como ese usuario en lugar de root

-l

lista lo que tienes permitido ejecutar

-k

olvida las credenciales en caché

sudo systemctl restart nginx

sudo !!

sudo -u postgres psql

-m

modifica (añade) una entrada

-x

elimina una entrada

-b

elimina todas las entradas de la ACL

-R

recursivo

-d

define la ACL predeterminada que heredan los archivos nuevos

setfacl -m u:alice:rw report.xlsx

getfacl report.xlsx

setfacl -R -m g:devs:rwX /srv/app

Un + al final de la cadena de permisos de ls -l indica que el archivo tiene una ACL.

sudo chattr +i /etc/resolv.conf

lsattr /etc/resolv.conf

Compatible con ext4, XFS y Btrfs. Si aparece "Operation not permitted" incluso como root, revisa lsattr.

aux

todos los procesos con CPU, memoria y usuario (estilo BSD)

-ef

todos los procesos con el PID del padre (estilo System V)

-o

elige las columnas

--sort=-%mem

ordena por memoria, de mayor a menor (procps)

ps aux | grep [n]ginx

ps aux --sort=-%mem | head

ps -o pid,ppid,etime,cmd -p 1234

macOS/BSD: ps de macOS no tiene --sort; usa ps aux -m (por memoria) o ps aux -r (por CPU).

P / M

ordena por CPU / memoria (top de Linux)

1

muestra cada núcleo de CPU

k

mata un proceso por su PID

q

salir

-b -n 1

una sola captura en modo batch, para scripts

top -b -n 1 | head -20

macOS/BSD: top de macOS es un programa distinto: ordena con top -o cpu o top -o mem.

F3 or /

buscar

F4

filtrar

F6

elegir la columna de orden

F9

enviar una señal (kill)

t

vista de árbol

htop -u www-data

Instálalo con apt install htop / dnf install htop.

-a

muestra la línea de comandos completa (procps de Linux)

-f

busca en la línea de comandos completa, no solo en el nombre

-u user

solo los procesos de ese usuario

-x

coincidencia exacta del nombre

pgrep -a nginx

pgrep -f 'python manage.py runserver'

macOS/BSD: En macOS, -a significa "incluir los ancestros"; usa pgrep -lf para ver los nombres y los argumentos.

pkill -f "node server.js"

pkill -HUP nginx

pgrep -af node

Los patrones son expresiones regulares que coinciden en cualquier parte del nombre; pkill node también afecta a nodejs-helper. Compruébalo antes con pgrep.

(none) / -15 / -TERM

pide al proceso que termine limpiamente (predeterminado)

-9 / -KILL

fuerza la terminación; no se puede capturar, no hay limpieza

-1 / -HUP

muchos demonios recargan su configuración

-l

lista los nombres de las señales

kill 1234

kill -9 1234

kill %1

Prueba primero con kill a secas y espera unos segundos: -9 se salta la limpieza, así que pueden quedar archivos temporales, bloqueos y datos a medio escribir.

killall firefox

En Linux está en el paquete psmisc.

jobs

bg %1

fg %1

Ctrl+Z suspende el programa en primer plano (se detiene hasta que uses bg o fg).

nohup ./server > server.log 2>&1 &

Para cualquier cosa de larga duración, un servicio de systemd (consulta Servicios y logs) o tmux es más robusto.

Ctrl+B d

desconectarse (la sesión sigue en ejecución)

Ctrl+B c

nueva ventana

Ctrl+B % / Ctrl+B "

dividir en izquierda/derecha / arriba/abajo

tmux ls

listar las sesiones

tmux new -s deploy

tmux attach -t deploy

Instálalo con tu gestor de paquetes. GNU screen es la alternativa más antigua (Ctrl+A d para desconectarte, screen -r para volver a conectarte).

nice -n 19 tar -czf backup.tgz /data

sudo renice -n -5 -p 1234

El valor nice va de -20 (máxima prioridad) a 19 (mínima). Solo root puede bajar de 0.

timeout 30s curl -s https://example.com/health

timeout -s KILL 5m ./job.sh

Sale con el código 124 cuando se alcanza el límite de tiempo.

sudo fuser -vm /mnt/usb

sudo fuser -v 8080/tcp

Peligro: fuser -k mata sin preguntar todos los procesos que usan el destino; en un punto de montaje, eso puede incluir tu propio shell.

-a

todo

-r

versión del kernel

-m

arquitectura de la máquina: x86_64, aarch64

uname -r

uname -m

cat /etc/os-release

lsb_release -a

macOS/BSD: macOS: sw_vers.

uptime

La carga es el número de procesos en ejecución o en espera. Compárala con el número de CPU (nproc): una carga de 4 en 4 núcleos significa que están totalmente ocupados.

free -h

macOS/BSD: macOS: vm_stat, o top -l 1 | grep PhysMem.

Linux usa la RAM sobrante como caché de disco, así que "free" parece bajo en una máquina sana. "available" es lo que los programas aún pueden obtener.

lscpu

make -j"$(nproc)"

macOS/BSD: macOS: sysctl -n hw.ncpu y sysctl -n machdep.cpu.brand_string.

-T

marcas de tiempo legibles

-w

sigue los mensajes nuevos

--level=err,warn

solo los problemas

sudo dmesg -T | tail -30

sudo dmesg -T | grep -i 'out of memory'

vmstat 1 5

iostat -xz 1

iostat viene en el paquete sysstat.

+%F

YYYY-MM-DD

+%s

marca de tiempo Unix (segundos)

-d 'text'

interpreta una fecha: tomorrow, 2 days ago, @1700000000 (GNU)

-u

UTC

date '+%Y-%m-%d %H:%M:%S'

date +%s

date -d @1700000000

date -d '2 days ago' +%F

macOS/BSD: date de macOS no tiene -d. Usa date -r 1700000000 para una marca de tiempo, date -v-2d para "hace 2 días" y date -j -f '%Y-%m-%d' 2026-10-18 +%s para interpretar una fecha.

Convierte marcas de tiempo con el conversor de timestamps Unix →

-h

tamaños legibles

-T

muestra el tipo de sistema de archivos (GNU)

-i

uso de inodos en lugar de bytes

df -h

df -h .

df -i

macOS/BSD: En macOS, -T filtra por tipo en vez de mostrarlo.

-s

un total por argumento

-h

tamaños legibles

-d N

límite de profundidad (forma larga de GNU: --max-depth=N)

-x

no sale del sistema de archivos

du -sh /var/log

du -h -d 1 | sort -h

sudo du -xh -d 1 / | sort -h | tail

macOS/BSD: du de macOS tiene -d pero no --max-depth.

sudo ncdu -x /

Instálalo con apt install ncdu / dnf install ncdu.

-f

tipo de sistema de archivos, etiqueta, UUID y punto de montaje

lsblk

lsblk -f

macOS/BSD: macOS: diskutil list.

sudo umount /mnt/usb

sudo umount -l /mnt/nas

"target is busy" significa que un proceso lo está usando (a menudo tu propio shell, situado en ese directorio): encuéntralo con fuser -vm o lsof.

UUID=3f6c...  /data  ext4  defaults,nofail  0  2

sudo mount -a

Una errata en fstab puede hacer que el siguiente arranque entre en modo de emergencia. Ejecuta siempre sudo mount -a (o findmnt --verify) después de editarlo.

sudo fdisk -l

sudo parted /dev/sdb print

Peligro: Escribir una tabla de particiones (w en fdisk, mklabel en parted) deja inaccesibles los datos que hubiera en ese disco. Confirma antes el nombre del dispositivo con lsblk; /dev/sda y /dev/sdb se intercambian con facilidad.

sudo mkfs.ext4 -L data /dev/sdb1

sudo mkfs.vfat -F 32 /dev/sdc1

Peligro: Borra al instante el sistema de archivos del destino, sin confirmación si el dispositivo no está montado. Comprueba el dispositivo con lsblk -f; formatear /dev/sda en lugar de /dev/sda1, o el disco equivocado, lo destruye.

sudo fsck -f /dev/sdb1

Peligro: Nunca ejecutes fsck en un sistema de archivos montado en lectura/escritura: puede corromperlo. Desmóntalo antes o, si es el sistema de archivos raíz, arranca desde un medio de rescate.

if= / of=

archivo o dispositivo de entrada / salida

bs=4M

tamaño de bloque; cuanto mayor, más rápido

status=progress

muestra los bytes copiados (GNU)

conv=fsync

vuelca los datos al dispositivo antes de salir

sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress conv=fsync

dd if=/dev/zero of=test.img bs=1M count=100

Peligro: dd sobrescribe el destino of= sin preguntar. Intercambiar if= y of=, o elegir el /dev/sdX equivocado, borra ese disco. Compruébalo con lsblk justo antes de ejecutarlo.

macOS/BSD: macOS: usa como destino /dev/rdiskN (de diskutil list) tras diskutil unmountDisk, usa bs=4m y pulsa Ctrl+T para ver el progreso.

swapon --show

sudo fallocate -l 2G /swapfile && sudo chmod 600 /swapfile && sudo mkswap /swapfile && sudo swapon /swapfile

En Btrfs, un archivo de swap necesita pasos adicionales (btrfs filesystem mkswapfile en versiones recientes de btrfs-progs).

shred -u -n 3 secrets.txt

Peligro: Irreversible. Además, no es fiable en SSD, en sistemas de archivos con journaling o copy-on-write (Btrfs, ZFS) ni en nada con snapshots; para una protección real, usa cifrado de disco completo.

ip -br a

ip a show eth0

hostname -I

macOS/BSD: macOS: ifconfig, o ipconfig getifaddr en0.

ip sustituye al antiguo ifconfig (net-tools), que muchas distribuciones ya no instalan.

Calcula el rango de red con la calculadora de subredes →

ip r

ip route get 1.1.1.1

sudo ip route add 10.20.0.0/16 via 192.168.1.1

Comprueba rangos CIDR con la calculadora de subredes →

ip link

sudo ip link set eth0 down && sudo ip link set eth0 up

Peligro: Si desactivas la interfaz por la que estás conectado por SSH, se corta tu sesión.

-t / -u

TCP / UDP

-l

solo sockets en escucha

-p

muestra el proceso (con sudo para ver los de otros usuarios)

-n

puertos numéricos, sin DNS

-s

recuento resumido

sudo ss -tulpn

ss -tn state established '( dport = :443 )'

ss -s

macOS/BSD: macOS: lsof -iTCP -sTCP:LISTEN -n -P, o netstat -an.

ss sustituye a netstat; netstat -tulpn sigue funcionando donde está instalado net-tools.

-I

solo las cabeceras (petición HEAD)

-L

sigue las redirecciones

-o file / -O

guarda en un archivo / guarda con el nombre remoto

-s / -S

silencioso / pero muestra los errores

-f

falla (código 22) ante HTTP 4xx/5xx en lugar de mostrar la página de error

-v

detallado: cabeceras de petición y respuesta, TLS

curl -I https://example.com

curl -LO https://example.com/file.tar.gz

curl -s -o /dev/null -w '%{http_code}\n' https://example.com

curl -fsSL https://example.com/install.sh -o install.sh

Convierte un comando curl a Python, JavaScript o Go →

-d data

cuerpo de la petición; implica POST

--data-binary @file

envía un archivo tal cual

-H header

añade una cabecera

-X METHOD

PUT, PATCH, DELETE…

-u user:pass

autenticación básica

curl -H 'Content-Type: application/json' -d '{"name":"Ada"}' https://api.example.com/users

curl -H "Authorization: Bearer $TOKEN" https://api.example.com/me

curl -X DELETE https://api.example.com/users/42

Consulta el código de estado que has recibido →

-c

reanuda una descarga incompleta

-O file

guarda como (usa -O- para la salida estándar)

-q

silencioso

-r -np

recursivo, sin subir nunca al directorio padre

wget -c https://example.com/big.iso

wget -qO- https://example.com/data.json | jq .

macOS/BSD: No viene en macOS de serie; usa curl -LO (curl -C - -LO para reanudar).

dig +short example.com

dig MX example.com

dig @1.1.1.1 example.com

dig -x 8.8.8.8

dig +trace example.com

Nombre del paquete: dnsutils (Debian/Ubuntu) o bind-utils (Fedora/RHEL).

resolvectl status

sudo resolvectl flush-caches

macOS/BSD: macOS: sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder.

Solo en sistemas que usan systemd-resolved (Ubuntu y Fedora por defecto).

-c N

para tras N paquetes

-i sec

intervalo entre paquetes

-4 / -6

fuerza IPv4 / IPv6

ping -c 4 example.com

En Linux y macOS, ping sigue hasta que pulsas Ctrl+C, salvo que uses -c (Windows para tras 4). Que no responda no siempre significa que esté caído: muchos hosts bloquean ICMP.

traceroute -n example.com

tracepath example.com

macOS/BSD: macOS tiene traceroute pero no tracepath.

En Linux puede que haya que instalar traceroute; tracepath (iputils) suele estar disponible.

mtr -rw -c 100 example.com

Combina ping y traceroute. Si la pérdida aparece solo en un salto intermedio, suele ser que ese router da baja prioridad a ICMP; la pérdida que continúa hasta el final es real.

-L 5432:localhost:5432

el puerto local 5432 llega al puerto 5432 del servidor

-R 8080:localhost:3000

el puerto 8080 del servidor llega a tu 3000 local

-D 1080

proxy SOCKS en el puerto local 1080

-N

sin comando remoto, solo el túnel

ssh -N -L 5432:localhost:5432 alice@db-host

ssh -N -D 1080 alice@host

-r

copia directorios

-P port

puerto (P mayúscula; ssh usa -p minúscula)

-i key

archivo de identidad

scp report.pdf alice@host:/tmp/

scp alice@host:/var/log/app.log .

scp -r -P 2222 site/ alice@host:~/

Desde OpenSSH 9.0, scp usa por debajo el protocolo SFTP. Para copias grandes o repetidas, rsync es más rápido porque solo envía los cambios.

-a

archivo: recursivo, conserva permisos, fechas y enlaces

-v

detallado

-z

comprime durante la transferencia

-P

muestra el progreso y reanuda archivos incompletos

-n

simulación: muestra lo que pasaría

--exclude 'pattern'

omite archivos

-e 'ssh -p 2222'

opciones de SSH personalizadas

rsync -avzP site/ deploy@host:/srv/site/

rsync -av --exclude 'node_modules' ./ /backup/app/

macOS/BSD: Las versiones recientes de macOS incluyen openrsync en lugar de rsync; las opciones habituales funcionan, algunas menos comunes no.

src/ significa "el contenido de src"; src sin barra significa "la carpeta src". Si te equivocas, acabas con carpetas anidadas (dest/src/…).

rsync -avn --delete site/ /srv/site/

rsync -av --delete site/ /srv/site/

Peligro: Borra todo lo que hay en el destino y no está en el origen. Intercambiar origen y destino, o una ruta de origen vacía o equivocada, vacía el destino. Ejecútalo siempre antes con -n.

nc -zv db.internal 5432

nc -l 9000

Las opciones cambian según la variante de netcat: la tradicional necesita nc -l -p 9000.

sudo ufw status verbose

sudo ufw allow 22/tcp

sudo ufw allow from 10.0.0.0/8 to any port 5432

Peligro: Si ejecutas sudo ufw enable en un servidor remoto sin haber permitido antes SSH (ufw allow OpenSSH o 22/tcp), te quedas fuera.

sudo firewall-cmd --list-all

sudo firewall-cmd --permanent --add-service=https && sudo firewall-cmd --reload

sudo firewall-cmd --permanent --add-port=8080/tcp

Sin --permanent, una regla dura hasta la siguiente recarga o reinicio.

-m

crea el directorio personal (no es lo predeterminado en todas las distribuciones)

-s /bin/bash

shell de inicio de sesión

-G group1,group2

grupos secundarios

sudo useradd -m -s /bin/bash alice && sudo passwd alice

En Debian/Ubuntu, adduser alice es el asistente interactivo más amigable, que configura el directorio personal y la contraseña.

sudo usermod -aG docker alice

sudo usermod -aG sudo alice

Peligro: Sin -a, usermod -G reemplaza todos los grupos secundarios del usuario, lo que puede quitarle el acceso a sudo. Los cambios de grupo se aplican en el siguiente inicio de sesión (o ejecuta newgrp docker).

sudo userdel -r olduser

Peligro: -r borra para siempre el directorio personal y sus archivos. Haz antes una copia de seguridad o, en su lugar, bloquea la cuenta (passwd -l).

sudo visudo -f /etc/sudoers.d/deploy

deploy ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart myapp

visudo comprueba la sintaxis antes de guardar. Editar /etc/sudoers con un editor normal y cometer una errata puede dejar a todo el mundo sin sudo.

-c

crear

-z / -j / -J

compresión gzip / bzip2 / xz

-f file

nombre del archivo (ponlo justo después de f)

-v

lista los archivos a medida que se añaden

--exclude='pattern'

deja fuera archivos

tar -czf site-2026-10-18.tar.gz site/

tar -cJf logs.tar.xz --exclude='*.tmp' logs/

-x

extraer

-C dir

extrae en dir (debe existir)

--strip-components=1

quita la carpeta de primer nivel

tar -xf archive.tar.gz

tar -xzf app.tar.gz -C /opt/app --strip-components=1

tar --zstd -cf data.tar.zst data/

zstd -d file.zst

Requiere GNU tar 1.31+ (o un bsdtar reciente) y el programa zstd.

-k

conserva el original

-d

descomprime (igual que gunzip)

-9

máxima compresión

gzip -k access.log

zcat access.log.gz | grep 404

zgrep 500 access.log.*.gz

Sin -k, gzip sustituye el archivo por la versión .gz.

zip -r site.zip site/

zip -r site.zip site/ -x '*.git*' '*/node_modules/*'

zip -e cifra con el antiguo esquema ZipCrypto, que es débil. Para una confidencialidad real, usa 7z o gpg.

7z x archive.7z

7z a -p backup.7z docs/

7z l archive.rar

Paquete: p7zip-full / 7zip en Debian/Ubuntu, p7zip o 7zip en Fedora/Arch.

sha256sum ubuntu.iso

sha256sum -c SHA256SUMS --ignore-missing

macOS/BSD: macOS: shasum -a 256 file (y shasum -a 256 -c SUMSFILE).

Calcula el hash de un texto o un archivo en el navegador →

-name

glob que distingue mayúsculas y minúsculas

-iname

sin distinguir mayúsculas y minúsculas

-path

busca en la ruta completa

find . -name '*.log'

find / -iname 'nginx.conf' 2>/dev/null

-mtime -1

modificados en las últimas 24 horas

-mtime +30

hace más de 30 días

-mmin -60

en los últimos 60 minutos

-newer ref

más recientes que el archivo ref

find /var/log -type f -mtime +30

find . -type f -mmin -15

find /tmp/app -name '*.tmp' -mtime +7 -print

find /tmp/app -name '*.tmp' -mtime +7 -delete

Peligro: El orden importa: -delete actúa allí donde aparece, así que find . -delete -name "*.tmp" borra todo lo que hay bajo . antes de que se llegue a aplicar el filtro por nombre. Pon -delete al final y ejecútalo antes con -print.

locate -i nginx.conf

sudo updatedb

Lo proporciona plocate o mlocate; el índice se reconstruye a diario, así que puede que los archivos creados hoy no aparezcan hasta que se ejecute updatedb.

-i

no distingue mayúsculas y minúsculas

-n

muestra los números de línea

-v

invierte: las líneas que no coinciden

-w

solo palabras completas

-c

cuenta las líneas que coinciden

-o

muestra solo la parte que coincide

-F

cadena literal, sin regex

grep -n 'ERROR' app.log

grep -v '^#' nginx.conf | grep -v '^$'

grep -c 'Failed password' /var/log/auth.log

-r

recursivo

-l

solo los nombres de archivo

--include='*.py'

solo estos archivos

--exclude-dir=node_modules

omite carpetas

grep -rn 'TODO' src/

grep -rl --include='*.php' 'mysql_connect' .

grep -rn --exclude-dir={.git,node_modules} 'apiKey' .

grep -E 'error|warn' app.log

grep -Eo '[0-9]{1,3}(\.[0-9]{1,3}){3}' access.log | sort | uniq -c | sort -rn | head

grep -P '\d{4}-\d{2}-\d{2}' file

macOS/BSD: -E funciona en todas partes; -P (PCRE) es una función de GNU y no está disponible en todas las versiones de macOS.

Prueba el patrón en el probador de regex →

g

reemplaza todas las coincidencias de la línea, no solo la primera

-E

regex extendida (grupos sin barras invertidas)

I

sin distinguir mayúsculas y minúsculas (GNU)

sed 's/http:/https:/g' links.txt

sed 's|/usr/local|/opt|g' paths.txt

sed -E 's/([0-9]+)px/\1rem/g' style.css

sed -i 's/^#Port 22/Port 2222/' /etc/ssh/sshd_config

sed -i.bak 's/foo/bar/g' config.ini

macOS/BSD: sed de macOS exige un argumento después de -i: sed -i '' 's/foo/bar/g' file. sed de GNU interpreta '' como el script, así que la única forma que funciona en ambos es -i.bak.

-F sep

separador de campos (por defecto: secuencias de espacios/tabuladores)

$1 … $NF

campos; $NF es el último y $0 la línea entera

NR

número de línea

awk '{print $1}' access.log

awk -F: '{print $1, $7}' /etc/passwd

awk -F, 'NR>1 {print $2}' data.csv

cut -d, -f1,3 data.csv

cut -d: -f1 /etc/passwd

cut -c1-10 file

cut trata cada delimitador como un corte de campo, así que dos espacios equivalen a un campo vacío. Para salidas alineadas con espacios, usa awk.

-n

numérico

-r

orden inverso

-h

tamaños legibles: 2K < 1M < 3G

-k 2,2

ordena solo por el campo 2

-t ,

separador de campos

-u

elimina duplicados

-V

orden de versiones: 1.9 < 1.10

du -sh * | sort -h

sort -t, -k3,3nr data.csv

sort -u emails.txt > unique.txt

-c

antepone a cada línea su número de apariciones

-d

solo las líneas que se repiten

-u

solo las líneas que aparecen una vez

sort ips.txt | uniq -c | sort -rn | head

uniq solo agrupa duplicados contiguos, así que ordena primero.

wc -l access.log

ls | wc -l

grep -c '' file

Cuenta palabras y caracteres en el navegador →

tr 'a-z' 'A-Z' < in.txt

tr -d '\r' < windows.txt > unix.txt

tr -s ' ' < file

tr '\n' ',' < list.txt

tr solo lee la entrada estándar, así que redirige el archivo con <.

-0

la entrada está separada por NUL (combínalo con find -print0); seguro con espacios

-n N

como máximo N argumentos por comando

-P N

ejecuta N comandos en paralelo

-I {}

sustituye {} por cada línea de entrada

-r

no ejecuta el comando si la entrada está vacía (GNU)

find . -name '*.log' -print0 | xargs -0 rm -f

cat urls.txt | xargs -n 1 -P 4 curl -sO

ls *.png | xargs -I {} cp {} /backup/{}

macOS/BSD: xargs de GNU ejecuta el comando una vez aunque la entrada esté vacía, salvo que uses -r; xargs de macOS omite la entrada vacía por defecto y acepta -r por compatibilidad.

.

formatea de forma legible

-r

cadenas en bruto, sin comillas

-c

compacto, una línea por resultado

.[]

recorre un array

select(cond)

conserva los elementos que coinciden

jq . response.json

jq -r '.items[].name' data.json

jq -r '.[] | select(.active) | .email' users.json

curl -s https://api.github.com/repos/jqlang/jq | jq '.stargazers_count'

Instálalo con apt/dnf install jq. Viene incluido en las versiones recientes de macOS.

Formatea y valida JSON en el navegador →

printf '%s' 'user:pass' | base64

echo dXNlcjpwYXNz | base64 -d

base64 -w 0 image.png > image.b64

macOS/BSD: base64 de macOS no corta las líneas por defecto y no tiene -w. Usa -d para decodificar (las versiones antiguas de macOS usaban -D).

Codifica o decodifica Base64 en el navegador →

sudo systemctl restart nginx

sudo systemctl reload nginx

Siempre que puedas, prueba la configuración antes de reiniciar (p. ej. sudo nginx -t), para que una errata no tumbe el sitio.

-u unit

un servicio

-f

seguir

-n N

las últimas N líneas

--since '1 hour ago'

también: today, yesterday, 2026-10-18 09:00

-p err

prioridad err y superiores

-b / -b -1

este arranque / el arranque anterior

-e

salta al final

journalctl -u nginx -f

journalctl -u myapp --since '10 min ago'

journalctl -b -1 -p err

journalctl --disk-usage

sudo journalctl --vacuum-size=500M

sudo journalctl --vacuum-time=14d

Para un límite permanente, define SystemMaxUse= en /etc/systemd/journald.conf.

sudo tail -f /var/log/syslog

sudo tail -f /var/log/auth.log

Algunas distribuciones (Fedora, Arch) solo guardan los logs en el journal, salvo que esté instalado rsyslog.

crontab -e

crontab -l

crontab -l > crontab.bak

Crea y entiende la programación con el generador de expresiones cron →

30 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

*/15 * * * * /usr/local/bin/check.sh

0 9 * * 1-5 /usr/local/bin/report.sh

@reboot /usr/local/bin/startup.sh

cron se ejecuta con un PATH mínimo y sin el perfil del shell: usa rutas absolutas. Un % en el comando debe escaparse como \%.

Comprueba qué significa una expresión cron →

crontab -l > ~/crontab.bak && crontab -r

crontab ~/crontab.bak

Peligro: Borra todas tus tareas de cron sin preguntar, y la r está justo al lado de la e en el teclado. Algunas implementaciones de cron ofrecen -i para preguntar antes (crontab -ri).

0 3 * * * root /usr/local/bin/cleanup.sh

ls /etc/cron.daily/

En Debian y Ubuntu se ignoran los archivos de /etc/cron.d cuyo nombre contiene un punto, así que llámalo backup, no backup.cron.

echo 'systemctl restart myapp' | sudo at 02:00

echo './report.sh' | at now + 30 minutes

atq

atrm 3

Requiere el paquete at y que el servicio atd esté en ejecución.

ls -l > listing.txt

echo 'done' >> progress.log

set -o noclobber

El shell vacía el archivo antes de ejecutar el comando, así que sort file > file te deja un archivo vacío. Escribe en un nombre nuevo y luego usa mv.

echo "Today is $(date +%A)"

echo $(( 1024 * 4 ))

diff <(ls dir1) <(ls dir2)

Las comillas invertidas `command` son la forma antigua de $(command); $( ) se puede anidar y se lee mejor.

ls *.jpg

rm photo-??.png

cp config.{yml,yml.bak}

shopt -s globstar; ls **/*.md

Los comodines no incluyen por defecto los archivos que empiezan por punto (shopt -s dotglob lo cambia). Si nada coincide, bash pasa el patrón literalmente, salvo que esté activado shopt -s nullglob.

export NODE_ENV=production

DEBUG=1 ./app

printenv | sort

unset DEBUG

Se pierden al cerrar el shell. Para conservarlas, pon los export en ~/.bashrc (shells interactivos) o en ~/.profile (shells de inicio de sesión).

sudo !!

cd !$

!42

^foo^bar

Con HISTCONTROL=ignorespace (activo por defecto en Ubuntu como parte de ignoreboth), un comando escrito con un espacio delante no se guarda: útil para comandos con secretos.

Ctrl+R

busca hacia atrás en el historial; vuelve a pulsar para coincidencias más antiguas

Ctrl+A / Ctrl+E

principio / final de la línea

Ctrl+U / Ctrl+K

corta hasta el principio / hasta el final de la línea

Ctrl+W

corta la palabra anterior

Ctrl+Y

pega lo que has cortado

Alt+B / Alt+F

una palabra atrás / adelante

Alt+.

inserta el último argumento del comando anterior

Ctrl+L

limpia la pantalla

Ctrl+C

cancela el comando en ejecución

Ctrl+D

fin de la entrada; en una línea vacía, cierra el shell

Tab Tab

muestra las opciones de autocompletado

bind -P | less

Guía rápida de atajos de teclado de Mac →

#!/usr/bin/env bash
set -euo pipefail
name="${1:-world}"
if [[ -f "$name.txt" ]]; then
  echo "found $name.txt"
fi
for f in *.log; do
  echo "$f"
done

chmod +x script.sh && ./script.sh Ada

bash -x script.sh

$1 … $9 son los argumentos, "$@" son todos ellos y $# cuántos hay. [[ ]] es de bash; usa [ ] en scripts POSIX sh.

Bucles y condicionales de Bash junto a CMD y PowerShell →