Comandos básicos de Linux explicados al detalle

Informatec Digital » Recursos » Comandos básicos de Linux explicados al detalle

Si trabajas con servidores, desarrollo web o simplemente quieres exprimir tu PC al máximo, tarde o temprano vas a acabar en la terminal de Linux. Y ahí, o conoces los comandos básicos, o te quedas mirando el cursor parpadeando sin saber muy bien qué hacer. La buena noticia es que no necesitas memorizar cientos de órdenes: con dominar un conjunto sólido de comandos cubres el 90% de las tareas del día a día.

En esta guía vas a encontrar una recopilación unificada y muy completa de los comandos básicos de Linux, mezclando lo mejor de varias guías de referencia: gestión de archivos, procesos, red, paquetes, permisos, automatización… Todo explicado en español de España, con ejemplos reales de administración de servidores, hosting y trabajo en local, y organizado para que puedas usarlo como chuleta cuando lo necesites.

Qué son los comandos de Linux y por qué importan tanto

Un comando de Linux es un programa o utilidad que se ejecuta en la línea de comandos. En lugar de hacer clic en botones, escribes el nombre del comando, opcionalmente algunas opciones (o flags) y uno o varios argumentos como rutas de archivo, patrones o nombres de servicio.

La idea es sencilla: la terminal es una interfaz de texto muy eficiente. Hacer en un clic está bien, pero encadenar comandos, automatizar backups con cron, revisar logs enormes con filtros o gestionar un servidor remoto vía SSH es infinitamente más cómodo escribiendo unas cuantas órdenes que peleando con menús gráficos.

En casi cualquier distribución moderna (Ubuntu, Debian, CentOS, Fedora, Arch, etc.) abrirás un terminal con Ctrl+Alt+T o buscándolo como “Terminal” en el menú de aplicaciones. En un servidor, lo normal es entrar por SSH desde tu equipo local.

Comandos esenciales de navegación por directorios

Lo primero que necesitas dominar es cómo moverte por el sistema de archivos: saber dónde estás, qué hay en cada sitio y cómo cambiar de carpeta con rapidez.

ls: listar archivos y directorios

El comando ls muestra el contenido del directorio actual (o de la ruta que le indiques). Es uno de los comandos que más vas a usar:

• ls – Lista archivos y carpetas visibles del directorio actual.
• ls -l – Muestra detalles: permisos, propietario, tamaño, fecha.
• ls -a – Incluye archivos ocultos (los que empiezan por punto).
• ls -lh – Igual que -l, pero con tamaños legibles (K, M, G).
• ls -lah – Combina largo, ocultos y tamaños legibles.
• ls -R – Listado recursivo de subdirectorios.
• ls -t – Ordena por fecha de modificación.
• ls -S – Ordena por tamaño.

En servidores web es habitual hacer algo como ls -lah /var/www/html para ver todos los archivos del proyecto, incluidos archivos ocultos de configuración como .htaccess o la carpeta .git.

pwd: saber en qué carpeta estás

Cuando llevas un rato saltando entre rutas, es muy fácil perderse. Con pwd (print working directory) obtienes la ruta completa del directorio actual, por ejemplo:

/home/usuario/proyectos/mi-sitio

Es especialmente útil en scripts, cuando necesitas saber dónde estás para trabajar con rutas relativas con seguridad.

cd: cambiar de directorio

Para moverte por el sistema de archivos se usa cd (change directory). Algunas variantes imprescindibles:

• cd /ruta/completa – Va a una ruta absoluta.
• cd carpeta – Entra en una carpeta relativa al directorio actual.
• cd ~ – Salta al directorio personal del usuario.
• cd - – Vuelve al directorio anterior (muy útil, parece una tontería hasta que lo usas).
• cd .. – Sube un nivel en la jerarquía.
• cd ../.. – Sube dos niveles, y así sucesivamente.

Si trabajas con hosting Linux, te hartarás de usar cd /var/www/html o rutas parecidas para entrar en el directorio raíz de tu web.

Comandos básicos de archivos y directorios

Una vez dominas cómo moverte, toca aprender a crear, copiar, borrar y ver archivos y carpetas. Esto es el pan de cada día tanto en un PC como en un VPS.

mkdir y rmdir: crear y borrar directorios vacíos

Con mkdir creas carpetas nuevas. Admite varias rutas a la vez y tiene opciones muy prácticas:

• mkdir nuevo_directorio – Crea una carpeta simple.
• mkdir dir1 dir2 – Crea varias de golpe.
• mkdir -p padre/hijo/nieto – Crea una estructura anidada completa, sin quejarse si ya existe parte.
• mkdir -m 755 carpeta_web – Crea la carpeta con permisos específicos.

Un patrón típico al montar un proyecto es algo como mkdir -p /var/www/mi-sitio/{public_html,logs,backups} para dejar todo organizado desde el minuto uno.

Para borrar directorios vacíos está rmdir:

• rmdir carpeta_vacia – Elimina una carpeta siempre que no tenga nada dentro.
• rmdir -p dir1/dir2/dir3 – Elimina la cadena completa si todos los niveles están vacíos.

Si el directorio tiene contenido, tendrás que usar rm -r, que veremos enseguida.

touch: crear archivos vacíos o actualizar fechas

El comando touch sirve principalmente para crear archivos vacíos o actualizar la fecha de modificación sin tocar su contenido:

• touch archivo.txt – Crea el archivo si no existe.
• touch archivo1 archivo2 – Crea varios de una tacada.
• touch -t 202501010000 archivo.txt – Fuerza una marca de tiempo concreta.

Es muy cómodo para generar archivos de configuración o marcadores de posición tipo touch .env o touch index.html.

rm: borrar archivos (y directorios) con cuidado

Con rm eliminas archivos y, con las opciones adecuadas, árboles de directorios. No hay papelera: si te equivocas, recuperar algo puede ser complicado o imposible.

• rm archivo.txt – Borra un archivo.
• rm archivo1 archivo2 – Borra varios.
• rm -i archivo.txt – Pide confirmación, ideal mientras aprendes.
• rm -r carpeta – Elimina recursivamente una carpeta y todo su contenido.
• rm -rf carpeta – Fuerza borrado recursivo sin preguntar; úsalo solo cuando tengas clarísimo lo que haces.
• rm *.tmp – Borra todos los ficheros con esa extensión en el directorio actual.

Combinaciones como rm -rf / o similares son recetas rápidas para dejar un sistema inservible, así que ojito con mezclar rm -rf con rutas generales o comodines.

cp y mv: copiar, mover y renombrar

Para duplicar archivos usas cp y para mover o renombrar usas mv. Entre ambos te apañas cualquier reorganización de ficheros.

Algunos usos típicos de cp:

• cp origen.txt destino.txt – Copia un archivo.
• cp archivo.txt /otra/ruta/ – Copia a otro directorio.
• cp -i archivo.txt copia.txt – Pregunta antes de machacar.
• cp -p archivo.txt backup.txt – Conserva permisos, propietario y fecha.
• cp -r carpeta_origen carpeta_destino – Copia recursiva de un directorio.

Para copias completas de webs es muy habitual algo como cp -rp /var/www/html /backup/html-$(date +%Y%m%d), que deja un backup con fecha manteniendo permisos y propiedad.

Con mv puedes tanto mover como renombrar:

• mv archivo.txt nuevo_nombre.txt – Renombra.
• mv archivo.txt /otra/ruta/ – Mueve de sitio.
• mv directorio nuevo_nombre – Renombra una carpeta.
• mv *.log /var/log/backups/ – Reubica todos los logs.

Un patrón muy usado al desplegar proyectos es mv sitio-nuevo/* /var/www/html/ para sustituir la versión antigua de la web por la nueva.

cat, less, head y tail: ver el contenido de archivos

Para inspeccionar el contenido de un archivo de texto tienes varias herramientas, cada una con su gracia.

• cat archivo.txt muestra el archivo entero en la terminal. Ideal para archivos pequeños o concatenar varios: cat archivo1 archivo2.
• less archivo.log sirve para archivos grandes, porque te deja navegar página a página, buscar (/texto), ir atrás y adelante y salir con q.
• head archivo enseña por defecto las 10 primeras líneas; con head -n 50 eliges cuántas.
• tail archivo muestra las últimas líneas; con tail -f archivo.log ves cómo el log se va actualizando en tiempo real, muy útil mientras reproduces un error en la web.

En depuración de servidores web verás constantemente combinaciones tipo tail -f /var/log/nginx/error.log o less /var/log/apache2/access.log para entender qué está pasando.

Comandos para buscar archivos y texto

Cuando el sistema crece y se llena de proyectos, logs y configuraciones, se vuelve clave saber localizar archivos y cadenas de texto rápidamente.

find y locate: buscar archivos por nombre, tamaño o fecha

El comando find recorre el sistema de archivos y te permite buscar por nombre, tipo, tamaño, fecha de modificación, etc., e incluso ejecutar acciones sobre los resultados:

• find /ruta -name "nombre_archivo" – Busca por nombre exacto.
• find /var/www -name "*.php" – Localiza todos los PHP de esa zona.
• find /home -type f -size +100M – Archivos de más de 100 MB.
• find /var/log -mtime -7 – Archivos modificados en los últimos 7 días.
• find . -name "*.tmp" -delete – Busca y elimina temporales.
• find /var/www -type f -exec chmod 644 {} \; – Ajusta permisos a todos los ficheros.

Por su parte, locate tira de una base de datos indexada, por lo que es mucho más rápido para búsquedas sencillas por nombre:

• locate nombre_archivo
• locate -i "*.php" – Ignora mayúsculas/minúsculas.
• sudo updatedb – Actualiza el índice (importante en servidores).

La pega de locate es que no ve archivos recién creados hasta que se actualiza la base de datos, mientras que find siempre mira el sistema real.

grep, sed y awk: buscar, filtrar y transformar texto

Para trabajar con logs, configuraciones o cualquier texto plano, los reyes son grep, sed y awk.

• grep busca líneas que casan con un patrón:
  grep "ERROR" /var/log/apache2/error.log
grep -i "texto" archivo.txt – Ignora mayúsculas.
  grep -r "cadena" /directorio – Búsqueda recursiva.
  grep -n "texto" archivo.txt – Muestra número de línea.
• sed permite sustituir o borrar texto sin abrir el archivo en un editor:
  sed 's/viejo/nuevo/g' archivo.txt – Sustituye todas las apariciones.
  sed -i 's/old_database/new_database/g' wp-config.php – Edita en sitio (mucho cuidado con esto).
• awk es perfecto para procesar columnas (por ejemplo, logs):
  awk '{print $1}' access.log – Saca la primera columna (típicamente IP).
  awk '{print $1}' access.log | sort | uniq -c | sort -nr | head -10 – Tus 10 IPs más activas.

Aunque al principio intimidan, una vez pillas el truco a estas herramientas puedes hacer en segundos análisis que en un editor serían un infierno.

Gestión de permisos, propietarios y seguridad básica

Linux se basa en un sistema de permisos muy claro que te permite controlar quién puede leer, escribir o ejecutar qué. Esto es crítico en entornos multiusuario y, sobre todo, en servidores web.

ls -l: ver permisos y propietarios

Ya lo hemos mencionado, pero conviene recalcarlo: ls -l te enseña, además de nombres de archivos, los permisos, propietario, grupo y tamaño. Un ejemplo típico:

-rw-r--r-- 1 usuario grupo 12345 Jan 1 12:34 archivo.txt
drwxr-xr-x 2 usuario grupo 4096 Jan 1 12:34 carpeta/

La primera columna se lee así: tipo (- archivo, d directorio) y luego tres tríos de permisos: usuario, grupo y otros (r lectura, w escritura, x ejecución).

chmod: cambiar permisos

Con chmod ajustas los permisos de un archivo o carpeta. Lo puedes hacer con notación numérica o simbólica:

• chmod 755 script.sh – rwxr-xr-x (propietario todo, el resto solo lectura/ejecución).
• chmod 644 index.html – rw-r–r–, muy común para archivos web.
• chmod u+x backup.sh – Añade ejecución al usuario.
• chmod g-w archivo.txt – Quita escritura al grupo.
• chmod -R 755 directorio – Cambia permisos recursivamente.

Los valores numéricos se suman: 4 lectura, 2 escritura, 1 ejecución. Por eso 7 = 4+2+1 (rwx), 6 = 4+2 (rw-), 5 = 4+1 (r-x), etc.

chown y chgrp: propietario y grupo

Además de permisos, cada archivo tiene un propietario y un grupo asociado. Con esto puedes hacer que, por ejemplo, el servidor web sea dueño de los ficheros que tiene que servir.

• chown usuario archivo.txt – Cambia el propietario.
• chown usuario:grupo archivo.txt – Cambia propietario y grupo.
• chown -R www-data:www-data /var/www/html – Típico en servidores Apache/Nginx en Debian/Ubuntu.
• chgrp grupo archivo.txt – Cambia solo el grupo.

Cuando subes archivos por FTP con un usuario y luego el servidor web (otro usuario) no puede leerlos o escribir, casi siempre lo arreglas con un chown o un chmod bien puesto.

sudo: ejecutar como administrador sin ser root

El comando sudo (superuser do) es la forma recomendada de ejecutar tareas administrativas sin loguearte directamente como root, que es peligroso.

Simplemente antepones sudo a lo que quieras ejecutar con permisos elevados:

• sudo apt update – Actualiza la lista de paquetes (Debian/Ubuntu).
• sudo systemctl restart nginx – Reinicia Nginx.
• sudo useradd nuevo_usuario – Crea un usuario.

Te pedirá tu contraseña y, si tu usuario está en el grupo adecuado, ejecutarás el comando con privilegios de root. Esto evita que estés todo el rato como root, con riesgo de borrar o modificar cosas críticas sin querer.

Gestión de procesos y rendimiento del sistema

Cuando algo va lento o raro, toca mirar qué procesos se están ejecutando y cómo están usando los recursos. Estos comandos son tus mejores amigos para eso.

ps, top y htop: ver qué se está ejecutando

El comando ps saca una fotografía de los procesos activos en ese momento. Con ps aux ves todos los procesos del sistema, con usuario, consumo de CPU y RAM, etc. Puedes filtrar con grep:

• ps aux | grep nginx – Ver solo los procesos de Nginx.
• ps -u usuario – Procesos de un usuario concreto.

Si quieres algo dinámico, en tiempo real, usas top o su versión vitaminada htop:

• top – Lista procesos ordenados por uso de CPU y se va actualizando.
• Dentro de top puedes ordenar por memoria (M), matar procesos (k), etc.
• htop – Igual pero con colores, barras de CPU, soporte de ratón, árbol de procesos… en muchos sistemas hay que instalarlo primero (sudo apt install htop o similar).

En un servidor que se arrastra, abrir htop suele ser el primer paso para ver qué se está comiendo la CPU o la RAM.

kill y killall: terminar procesos rebeldes

Si un proceso se queda colgado o se dispara y no reacciona, puedes detenerlo con kill o killall.

• kill 1234 – Envía la señal TERM (15) al proceso con PID 1234, pidiéndole que termine “de buenas”.
• kill -9 1234 – Señal KILL (9), mata el proceso de inmediato; úsala como último recurso.
• killall nombre_proceso – Termina todos los procesos que tengan ese nombre, por ejemplo killall php-fpm.

Lo habitual es localizar el PID con ps o top y luego pasarle un kill suave. Si no obedece, ya tiras del -9.

df y du: controlar el espacio en disco

Cuando un servidor se queda sin espacio, todo empieza a fallar: bases de datos que no pueden escribir, logs que no crecen, servicios que se caen. Para vigilarlo usas df y du.

• df -h – Muestra espacio usado y libre en cada sistema de archivos montado, en formato legible.
• df -h /var – Información solo de esa partición.
• du -sh /var/www/* – Tamaño de cada proyecto web dentro de esa ruta.
• du -h --max-depth=1 / – Qué directorios de la raíz ocupan más.

Un comando muy práctico para localizar las carpetas más pesadas es algo como du -h --max-depth=1 /var | sort -hr | head -5, que te lista las cinco más grandes ordenadas de mayor a menor.

Comandos de red imprescindibles

En cuanto trabajas con servidores, dominios y tráfico web, necesitas saber si hay conectividad, qué IP tienes, qué puertos están abiertos y cómo responde tu sitio.

ip, ifconfig, ping y route

En sistemas modernos, el comando estrella es ip, especialmente ip a (o ip addr), que muestra todas las interfaces de red, sus IPs, estado, etc. Donde antes se usaba ifconfig, hoy se recomienda ip, aunque ifconfig sigue existiendo en muchos sistemas via paquete net-tools.

• ip a – Todas las interfaces e IPs.
• ip addr show dev eth0 – Detalle de una interfaz concreta.
• ping google.com – Comprueba si resuelves y llegas a Google, mostrando tiempos.
• ping -c 4 8.8.8.8 – Envía solo 4 paquetes a esa IP.
• route -n o ip route show – Tabla de rutas, para ver por dónde sale el tráfico.

Si un servidor “no se ve”, los primeros pasos son siempre ping al dominio, ping a la IP, mirar la IP del servidor y su gateway con ip route.

netstat/ss y curl: puertos abiertos y respuesta HTTP

Para ver qué puertos están abiertos y qué procesos escuchan en ellos, tienes netstat (clásico) y ss (moderno, más rápido):

• ss -tuln – Puertos TCP/UDP en escucha sin resolver nombres.
• ss -tlnp | grep :80 – ¿Hay algo escuchando en el puerto 80?
• netstat -tuln – Equivalente en sistemas que lo tengan.

Para probar rápidamente cómo responde un sitio web desde el propio servidor, nada como curl:

• curl -I https://tu-dominio.com – Solo cabeceras HTTP (código de estado, servidor, etc.).
• curl https://tu-dominio.com – Descarga el HTML en bruto.

Combinando ping, ip, ss y curl puedes diagnosticar casi cualquier problema básico de conectividad o de servicio caído.

Gestión de paquetes: instalar, actualizar y limpiar software

Cada familia de distribuciones Linux tiene su gestor de paquetes. Dominarlo te permite instalar y actualizar software sin pelearte con binarios manuales.

apt y apt-get en Debian/Ubuntu

En Debian, Ubuntu y derivadas, el estándar es apt (o su versión clásica apt-get):

• sudo apt update – Actualiza la lista de paquetes disponibles.
• sudo apt upgrade – Actualiza todos los paquetes instalados a la última versión.
• sudo apt install nombre_paquete – Instala uno o varios paquetes.
• sudo apt remove nombre_paquete – Desinstala el paquete pero deja su configuración.
• sudo apt purge nombre_paquete – Lo borra todo, incluida la configuración.
• sudo apt autoremove – Quita dependencias que ya no se usan.

También tienes apt-cache o directamente apt show para ver información de un paquete, sus dependencias y versiones:

• apt show nginx
• apt search php

yum/dnf y pacman: otras familias

En sistemas basados en Red Hat como CentOS o RHEL tendrás yum o su sucesor dnf:

• sudo yum install httpd – Instala Apache.
• sudo dnf update – Actualiza todo en versiones nuevas.

En Arch Linux y derivados, el gestor es pacman:

• sudo pacman -S gimp – Instala GIMP.
• sudo pacman -Syu – Sincroniza y actualiza el sistema.

Aunque cambie la sintaxis, la filosofía es la misma: actualizar índices, instalar paquetes, quitarlos y limpiar dependencias sobrantes.

Comprimir, descomprimir y transferir archivos

La gestión de archivos grandes o conjuntos de ficheros se simplifica mucho con archivos comprimidos y con utilidades de descarga y copia remota.

tar, zip/unzip: empaquetar y comprimir

El comando tar es el estándar en Linux para crear y extraer tarballs (archivos .tar, .tar.gz, .tar.bz2, etc.):

• tar -czvf backup.tar.gz carpeta/ – Crea un .tar.gz comprimido con gzip.
• tar -xzvf backup.tar.gz – Extrae el contenido.
• tar -tzvf backup.tar.gz – Lista lo que hay dentro sin extraer.

Los flags más habituales son c (crear), x (extraer), t (listar), v (verbose), f (fichero), z (gzip), j (bzip2), J (xz).

Para trabajar con archivos ZIP (muy comunes en entornos Windows) tienes zip y unzip:

• zip archivo.zip fichero1 fichero2
• unzip archivo.zip

wget, curl y scp: descargar y copiar entre máquinas

Además de navegar con curl, puedes usar wget para descargar archivos desde HTTP, HTTPS o FTP:

• wget https://wordpress.org/latest.zip – Descarga la última versión de WordPress.
• wget -c URL – Reanuda una descarga interrumpida.

Para copiar archivos de forma segura entre tu equipo y un servidor vía SSH tienes scp:

• scp archivo.txt usuario@servidor:/ruta/destino/ – Sube un archivo.
• scp -r carpeta usuario@servidor:/ruta/ – Copia recursivamente una carpeta.
• scp usuario@servidor:/ruta/archivo.txt ./ – Descarga desde el servidor.

Detrás de todo esto está SSH, que es también lo que usas para conectarte a la terminal remota (comando ssh usuario@servidor).

Automatización, historial y pequeños trucos de productividad

Cuando ya dominas lo básico, el siguiente salto es empezar a combinar comandos y automatizar tareas repetitivas. Aquí es donde Linux empieza a brillar de verdad.

history, alias y which: atajos y referencias rápidas

Con history puedes ver los últimos comandos que has ejecutado y reusarlos sin reescribirlos:

• history – Lista con número de línea.
• !255 – Vuelve a ejecutar el comando número 255.

Para crear atajos temporales está alias:

• alias ll="ls -lah" – A partir de aquí ll equivale a ls -lah.
• unalias ll – Quita el alias.

Y si quieres saber dónde está instalado un programa y qué ejecutable se está llamando, usas which:

• which php – Muestra la ruta a php, por ejemplo /usr/bin/php.
• which -a python – Todas las coincidencias en el PATH.

Redirecciones y tuberías: combinar comandos como un pro

La verdadera potencia de la línea de comandos viene de poder encadenar herramientas pequeñas. Esto se hace con tuberías (|) y redirecciones (>, >>, 2>, etc.).

• comando1 | comando2 – La salida de comando1 entra como entrada en comando2.
  Ejemplo: ls -la | grep ".php" – Lista solo archivos que contengan “.php”.
• ls > listado.txt – Guarda la salida en un archivo (sobrescribe).
• echo "línea" >> archivo.txt – Añade al final de un archivo.
• comando > todo.log 2>&1 – Redirige salida normal y errores al mismo archivo.
• comando &> /dev/null – Manda todo al “agujero negro”.

Con esto puedes hacer auténticas virguerías, como contar errores 404 en un log con un comando como grep " 404 " access.log | wc -l, o limpiar ficheros viejos con find y -delete.

Si has llegado hasta aquí, ya tienes un mapa bastante completo de los comandos básicos (y no tan básicos) de Linux que se usan a diario en administración de sistemas, desarrollo y hosting: desde navegar por directorios, gestionar archivos, permisos y procesos, hasta vigilar la red, instalar paquetes y automatizar tareas combinando órdenes con tuberías y redirecciones; a partir de ahora, cada vez que abras una terminal dejará de ser una pantalla negra intimidante y se convertirá en una herramienta con la que trabajar más rápido y con más control que con cualquier interfaz gráfica.