Los comandos de Linux que de verdad se usan

La terminal de Linux tiene miles de órdenes, pero en el día a día se usan unas cuarenta. Esta guía recoge esas cuarenta, agrupadas por lo que quieres hacer y no por orden alfabético, con la salida real de cada una. Todo lo que aparece aquí se ejecutó en un Debian 13 limpio antes de publicarlo.

1. La forma de una orden

Antes de memorizar nada conviene ver el patrón, porque se repite en todas. Una orden tiene hasta tres partes: el programa que se ejecuta, unas opciones que cambian su comportamiento y los argumentos sobre los que actúa.

Las opciones vienen en dos formatos. Las cortas son una letra con un guion, -l, y se pueden pegar unas a otras: -lh es lo mismo que -l -h. Las largas son una palabra con dos guiones, --human-readable, y son más fáciles de leer cuando escribes un script que alguien tendrá que entender dentro de seis meses.

Un detalle que ahorra muchos disgustos: en Linux las mayúsculas cuentan. -r y -R son opciones distintas en varias órdenes, y Datos y datos son dos carpetas diferentes.

2. Moverse por el sistema

En Linux no hay unidades C: ni D:. Hay un único árbol que empieza en /, y todo lo demás cuelga de ahí, incluidos los discos externos y los pendrives.

pwd — dónde estoy

Responde a la única pregunta que importa cuando te has perdido:

pwd

salida/home/ana/proyecto

ls — qué hay aquí

Sin opciones lista los nombres y poco más. Las opciones son lo que la hace útil:

ls -l

salidatotal 16
drwxr-xr-x 2 ana ana 4096 Oct  5 18:32 datos
-rw-r--r-- 1 ana ana   14 Oct  5 18:32 notas.txt
drwxr-xr-x 2 ana ana 4096 Oct  5 18:32 registros
drwxr-xr-x 2 ana ana 4096 Oct  5 18:32 respaldo

Con -h los tamaños dejan de venir en bytes y pasan a leerse de un vistazo:

ls -lh datos

salidatotal 8.0K
-rw-r--r-- 1 ana ana   79 Oct  5 18:32 clientes.csv
-rw-r--r-- 1 ana ana 2.0K Oct  5 18:32 imagen.bin

La combinación que más se teclea en el mundo es ls -lah, y merece la pena que te salga sin pensar.

cd — cambiar de carpeta

Admite cuatro atajos que conviene saberse, porque sustituyen a escribir rutas enteras:

tree — verlo todo de golpe

tree

salida.
|-- datos
|   |-- clientes.csv
|   `-- imagen.bin
|-- notas.txt
|-- registros
|   `-- app.log
`-- respaldo
    `-- copiar.sh

4 directories, 5 files

No viene instalado por defecto en casi ninguna distribución; más abajo está cómo instalarlo. Para árboles grandes, tree -L 2 se queda en dos niveles.

3. Mirar lo que hay dentro

cat, head y tail

cat vuelca el archivo entero por pantalla. Perfecto para algo corto, mala idea para un registro de 300 000 líneas:

cat datos/clientes.csv

salidanombre,ciudad,pedidos
Ana,Madrid,12
Luis,Lima,7
Marta,Bogota,23
Pedro,Madrid,4

Para archivos grandes se usan los recortes. head -2 da las dos primeras líneas y tail -3 las tres últimas:

tail -3 registros/app.log

salidaWARN disco al 81%
INFO tarea terminada
ERROR conexion rechazada

less — leer sin saturar la pantalla

less archivo abre un visor donde puedes subir y bajar. Dentro: flechas o Espacio para avanzar, /palabra para buscar, n para la siguiente coincidencia, G para el final, g para el principio y q para salir. Esos mismos atajos funcionan en man, porque por dentro es el mismo programa.

wc — contar

wc registros/app.log

salida  6  19 133 registros/app.log

Tres números: líneas, palabras y bytes. Casi siempre interesa solo el primero, y para eso está wc -l.

file y stat

La extensión de un archivo en Linux no significa nada; es parte del nombre y ya está. file mira dentro y te dice qué es de verdad:

file datos/clientes.csv datos/imagen.bin respaldo/copiar.sh

salidadatos/clientes.csv: CSV ASCII text
datos/imagen.bin:   data
respaldo/copiar.sh: Bourne-Again shell script, ASCII text executable

stat da la ficha completa: tamaño exacto, permisos en las dos notaciones, dueño y las cuatro fechas que guarda el sistema.

stat notas.txt

salida  File: notas.txt
  Size: 14        	Blocks: 8          IO Block: 4096   regular file
Device: 0,127	Inode: 26631171    Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1000/     ana)   Gid: ( 1000/     ana)
Access: 2026-10-05 18:32:16.265945220 +0000
Modify: 2026-10-05 18:32:16.265945220 +0000
Change: 2026-10-05 18:32:16.266945233 +0000
 Birth: 2026-10-05 18:32:16.265945220 +0000

4. Crear, copiar, mover y borrar

mkdir -p crea toda la rama de una vez, sin quejarse de los niveles intermedios:

mkdir -p informes/2026/octubre
tree informes

salidainformes
`-- 2026
    `-- octubre

3 directories, 0 files

Un enlace simbólico se ve en ls -l con una flecha, y la primera letra de los permisos es una l:

ln -s datos/clientes.csv ultimo.csv
ls -l ultimo.csv

salidalrwxrwxrwx 1 ana ana 18 Oct  5 18:32 ultimo.csv -> datos/clientes.csv

5. Buscar archivos y texto

Son dos problemas distintos y dos órdenes distintas: find busca archivos por sus características, grep busca texto dentro de ellos.

grep — buscar dentro

grep ERROR registros/app.log

salidaERROR conexion rechazada
ERROR tiempo agotado
ERROR conexion rechazada

Con -n dice en qué línea está cada una, que es lo que necesitas para ir a corregirla:

grep -n ERROR registros/app.log

salida1:ERROR conexion rechazada
3:ERROR tiempo agotado
6:ERROR conexion rechazada

Y con -r rastrea un árbol entero, sin importar cuántas carpetas tenga. Aquí, además, -i ignora mayúsculas, así que «madrid» encuentra «Madrid»:

grep -ri madrid .

salida./datos/clientes.csv:Ana,Madrid,12
./datos/clientes.csv:Pedro,Madrid,4

find — buscar archivos

La sintaxis desconcierta al principio porque el orden es find, dónde buscar, y luego las condiciones:

find . -name "*.csv"

salida./ultimo.csv
./datos/clientes.csv

Fíjate en que ha encontrado también el enlace simbólico. Las condiciones se combinan: -type f solo archivos, -type d solo directorios, -size +1k los que pasen de un kilobyte, -mtime -7 los modificados en la última semana.

find . -type f -size +1k

salida./datos/imagen.bin

Y -exec ejecuta algo con cada resultado. Las llaves son el hueco donde se sustituye cada nombre, y el \; cierra la orden:

find . -name "*.log" -exec wc -l {} \;

salida6 ./registros/app.log

which y type — dónde está un programa

type -a cd ls

salidacd is a shell builtin
ls is /usr/bin/ls
ls is /bin/ls

Interesante: cd no es un programa. Está dentro del propio intérprete, y por eso no existe un archivo que buscar. ls sí, y aparece dos veces porque /bin es un enlace a /usr/bin en las distribuciones modernas.

6. Tuberías y redirección

Aquí está la idea que hace que Linux sea Linux. Cada orden hace una cosa pequeña, y se encadenan unas con otras para resolver el problema completo. Para entenderlo hay que saber que toda orden tiene tres canales, no uno.

La tubería |

Conecta la salida de una orden con la entrada de la siguiente. Aquí se leen las líneas del registro, se filtran las que contienen ERROR y se cuentan:

cat registros/app.log | grep ERROR | wc -l

salida3

Se lee de izquierda a derecha, como una cinta transportadora. Ninguna de las tres órdenes sabe que las otras existen.

Guardar en un archivo

> escribe la salida en un archivo, borrando lo que hubiera. >> la añade al final:

grep ERROR registros/app.log > errores.txt
echo "ERROR anadido a mano" >> errores.txt
cat errores.txt

salidaERROR conexion rechazada
ERROR tiempo agotado
ERROR conexion rechazada
ERROR anadido a mano

Separar los errores

Los mensajes de error no viajan por el mismo canal que el resultado. Por eso > no los captura y hay que usar 2>:

ls noexiste.txt 2> aviso.txt
cat aviso.txt

salidals: cannot access 'noexiste.txt': No such file or directory

Esa separación es lo que permite, en un script, guardar el resultado en un sitio y los problemas en otro. Si quieres las dos cosas en el mismo archivo, &> todo.txt. Y si quieres tirar los errores a la basura, 2> /dev/null, que es un archivo especial que se traga todo lo que le mandes.

tee — ver y guardar a la vez

Una tubería se lo lleva todo y no deja nada por pantalla. tee duplica el flujo: escribe en el archivo y además deja pasar:

grep INFO registros/app.log | tee info.txt | wc -l

salida2

xargs — convertir una lista en argumentos

Algunas órdenes no leen de la entrada, solo aceptan argumentos. xargs hace de traductor:

find . -name "*.txt" | xargs wc -l

salida  1 ./notas.txt
  4 ./errores.txt
  2 ./info.txt
  1 ./aviso.txt
  8 total

7. Filtros de texto

Son las piezas que se encadenan con tuberías. Cada una transforma el texto que le llega.

sort y uniq

uniq solo elimina duplicados consecutivos, así que casi siempre va detrás de sort. Juntos, con -c, cuentan cuántas veces aparece cada línea:

sort registros/app.log | uniq -c

salida      2 ERROR conexion rechazada
      1 ERROR tiempo agotado
      1 INFO arranque correcto
      1 INFO tarea terminada
      1 WARN disco al 81%

sort -n ordena como números y no como texto, que es la diferencia entre que el 10 vaya después del 9 o entre el 1 y el 2. sort -r invierte el orden.

cut — quedarse con unas columnas

Con -d se indica el separador y con -f qué campos quieres:

cut -d, -f1,3 datos/clientes.csv

salidanombre,pedidos
Ana,12
Luis,7
Marta,23
Pedro,4

Encadenado con el resto, sale un recuento por ciudad. El tail -n +2 del principio descarta la línea de cabecera:

tail -n +2 datos/clientes.csv | cut -d, -f2 | sort | uniq -c

salida      1 Bogota
      1 Lima
      2 Madrid

sed — sustituir

Hace muchas cosas, pero el 95 % de las veces se usa para una sola: reemplazar texto. La s es de sustituir:

sed "s/ERROR/FALLO/" registros/app.log | head -3

salidaFALLO conexion rechazada
INFO arranque correcto
FALLO tiempo agotado

Así no toca el archivo, solo la salida. Para modificarlo de verdad está sed -i, y conviene probar primero sin la -i.

awk — cuando hay columnas y cuentas

Es un lenguaje entero, pero con dos patrones se cubre casi todo. Sumar una columna:

awk -F, 'NR>1 {suma+=$3} END {print "total de pedidos:", suma}' datos/clientes.csv

salidatotal de pedidos: 46

Y filtrar por el valor de una columna:

awk -F, 'NR>1 && $3 > 10 {print $1, $3}' datos/clientes.csv

salidaAna 12
Marta 23

-F, fija la coma como separador, $1 y $3 son la primera y la tercera columna, y NR es el número de línea, así que NR>1 se salta la cabecera.

tr — cambiar caracteres

echo "hola mundo" | tr a-z A-Z

salidaHOLA MUNDO

8. Permisos y propiedad

Esas diez letras del principio de ls -l son lo que más desconcierta al llegar desde Windows. En realidad son cuatro bloques:

chmod — cambiar permisos

Aquí está el error clásico, con su mensaje real. Un script recién creado no es ejecutable:

./respaldo/copiar.sh

salidabash: ./respaldo/copiar.sh: Permission denied
codigo de salida: 126

Se arregla dando permiso de ejecución:

chmod +x respaldo/copiar.sh
ls -l respaldo/copiar.sh
./respaldo/copiar.sh

salida-rwxr-xr-x 1 ana ana 35 Oct  5 18:32 respaldo/copiar.sh
copia terminada

Hay dos notaciones y las dos se usan. La simbólica modifica lo que ya hay: chmod g+w archivo añade escritura al grupo, chmod o-r archivo se la quita a los demás. La octal lo fija todo de golpe:

chmod 640 notas.txt
ls -l notas.txt

salida-rw-r----- 1 ana ana 14 Oct  5 18:32 notas.txt

chown y sudo

chown ana:ana archivo cambia el dueño y el grupo, y casi siempre necesita privilegios. sudo ejecuta una sola orden como administrador y pide tu contraseña, no la de root.

Para saber quién eres y a qué grupos perteneces:

id

salidauid=1000(ana) gid=1000(ana) groups=1000(ana)

9. Procesos

Ver qué se está ejecutando

ps a secas solo muestra lo tuyo en esta terminal. La forma que se usa de verdad es ps aux, que lo lista todo:

ps

salida    PID TTY          TIME CMD
   3581 ?        00:00:00 bash
   3589 ?        00:00:00 ps

Ese PID es el número que identifica al proceso, y es lo que necesitas para hacer cualquier cosa con él. Para encontrarlo sin leer listas enteras:

pgrep -a sleep

salida1 sleep 36000
3592 sleep 120

top da la misma información pero actualizándose sola, ordenada por consumo de CPU. Se sale con q. Si está disponible, htop es la misma idea con colores y se maneja mucho mejor.

Segundo plano y cómo terminar algo

Un & al final lanza la orden sin bloquear la terminal. jobs lista lo que tienes así:

sleep 120 &
jobs

salida[1]+  Running                 sleep 120 &

kill %1
jobs

salida[1]+  Terminated              sleep 120

10. Disco, memoria y sistema

df -h dice cuánto queda en cada sistema de archivos montado. Aquí, sobre un disco de 512 MB con 120 MB ocupados:

df -h /datos

salidaFilesystem      Size  Used Avail Use% Mounted on
tmpfs           512M  120M  392M  24% /datos

du responde a la otra pregunta: no cuánto queda, sino quién se lo está comiendo.

du -h --max-depth=1 .

salida8.0K	./registros
8.0K	./respaldo
12K	./datos
36K	.

La combinación que se usa para encontrar al culpable de un disco lleno es du -h --max-depth=1 . | sort -h: lista el peso de cada subcarpeta y lo ordena de menor a mayor, dejando al final el que más ocupa.

11. Red

ip -brief address

salidalo               UNKNOWN        127.0.0.1/8 ::1/128
eth0@if634       UP             172.17.0.4/16

ip a es la forma larga y la que verás en todas partes; -brief deja solo lo legible. La orden ifconfig que aparece en los tutoriales antiguos está retirada y en muchas distribuciones ya ni se instala.

ping comprueba si hay camino hasta una máquina. Con -c se le dice cuántos paquetes mandar, porque si no, no para:

ping -c 2 1.1.1.1

salida--- 1.1.1.1 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 50.589/50.731/50.873/0.142 ms

curl habla HTTP. Para comprobar si un servicio responde, sin descargar la página entera:

curl -sI https://example.com | head -4

salidaHTTP/2 200
date: Mon, 05 Oct 2026 18:34:06 GMT
content-type: text/html; charset=utf-8
server: cloudflare

Y ss -tlnp enseña qué puertos están abiertos y escuchando en tu máquina, que es la primera comprobación cuando un servicio «no arranca».

12. Comprimir y descomprimir

tar tiene fama de incomprensible por sus opciones de una letra. Son tres las que importan y se leen así: c de create, x de extract, t de list. La z añade compresión gzip y la f siempre va la última, justo antes del nombre del archivo.

tar -czf respaldo.tar.gz datos registros
tar -tzf respaldo.tar.gz

salidadatos/
datos/imagen.bin
datos/clientes.csv
registros/
registros/app.log

Mira siempre el contenido con -t antes de extraer: así sabes si el archivo trae una carpeta dentro o va a vomitar cincuenta ficheros en el directorio actual. Para extraer, -C elige dónde:

tar -xzf respaldo.tar.gz -C /tmp/ex

13. Instalar programas

Aquí es donde las distribuciones se separan. La idea es la misma en todas: hay un repositorio central, y pides el programa por su nombre en vez de descargar nada de una web.

En Debian y Ubuntu, apt update no actualiza nada: solo refresca el catálogo. Lo que instala las versiones nuevas es apt upgrade, y hay que lanzar las dos en ese orden.

14. Atajos que ahorran horas

Esto no son órdenes, pero separan a quien pelea con la terminal de quien va rápido.

El historial también se consulta como una lista. history las numera todas:

history 3

salida    1  ls -l
    2  grep ERROR registros/app.log
    3  cd proyecto

Y dos abreviaturas que se usan mucho: !! repite la orden anterior, y sudo !! la repite con privilegios, que es exactamente lo que necesitas cada vez que se te ha olvidado el sudo.

15. Cuando no te acuerdas

Nadie memoriza las opciones. Lo que hay que saber es dónde mirar, y la respuesta está en la propia máquina, sin internet:

Y una recomendación que no viene instalada: tldr. Da tres o cuatro ejemplos prácticos de cada orden en vez de la especificación entera, que suele ser justo lo que buscabas cuando abriste el manual. Se instala con el gestor de paquetes de tu distribución.

16. La chuleta

Si solo te quedas con una parte de esta guía, que sea esta tabla.

Todas las órdenes y todas las salidas de esta página se ejecutaron en un contenedor Debian 13 (trixie) limpio con bash 5.2 antes de publicarla, con un usuario normal y no como root; están copiadas de esa ejecución, no redactadas. Las diferencias con otras distribuciones se han anotado donde existen. El pingüino de la portada es Tux, creado por Larry Ewing; se usa la versión en dominio público (CC0) publicada en Wikimedia Commons. En la misma sección están las órdenes de Git y la guía de Docker.