Por qué aprender Linux sigue siendo una inversión segura
Si trabajas en desarrollo de software, tarde o temprano te encontrarás frente a una terminal de Linux. Está en los servidores donde se despliegan las aplicaciones web, dentro de los contenedores Docker, en las máquinas de integración continua, en la mayoría de los servicios de la nube y en dispositivos que van desde un router doméstico hasta un superordenador. Incluso en Windows, el Subsistema de Windows para Linux ha convertido la terminal de Linux en una herramienta habitual del día a día.
Aprender Linux no consiste en memorizar cientos de comandos. Consiste en entender unas pocas ideas fundamentales, como que todo es un archivo, que los programas pequeños se combinan para hacer cosas grandes y que los permisos protegen el sistema, y a partir de ahí construir un repertorio de comandos que usarás a diario.
En esta guía recorrerás ese camino de principio a fin: desde abrir la terminal por primera vez hasta automatizar tareas, administrar usuarios, analizar registros y diagnosticar problemas en un servidor. Todos los ejemplos usan Ubuntu 26.04 LTS, la versión con soporte extendido más reciente, publicada en abril de 2026 con el kernel Linux 7.0 y cinco años de actualizaciones estándar. Casi todo lo que aprenderás funciona igual en otras distribuciones.
Qué es Linux y qué es una distribución
En sentido estricto, Linux es el kernel: la pieza de software que habla con el hardware, reparte la memoria, planifica qué proceso usa la CPU y gestiona los dispositivos. Lo creó Linus Torvalds en 1991 y se distribuye como software libre, lo que significa que cualquiera puede leer, modificar y redistribuir su código.
Un kernel por sí solo no es un sistema que puedas usar. Necesitas una shell, utilidades de línea de comandos, un gestor de paquetes, quizá un entorno gráfico y muchas otras piezas. Una distribución es precisamente eso: un kernel Linux empaquetado junto con todo lo necesario para formar un sistema operativo completo. Algunas de las más conocidas son:
- Ubuntu: la más popular en escritorios y servidores, con versiones LTS cada dos años.
- Debian: la base de Ubuntu, conocida por su estabilidad.
- Fedora y Red Hat Enterprise Linux: muy presentes en entornos empresariales.
- Linux Mint: pensada para quienes vienen de Windows.
- Arch Linux y Manjaro: para quienes quieren control total y versiones muy recientes.
Las distribuciones de la familia Debian, como Ubuntu, usan paquetes .deb y el gestor apt. Las de la familia Red Hat usan paquetes .rpm y el gestor dnf. Los comandos básicos que verás en esta guía son prácticamente idénticos en todas ellas.
Cómo conseguir un entorno Linux para practicar
No necesitas reemplazar tu sistema operativo para aprender. Estas son las opciones más prácticas, de menor a mayor compromiso.
En Windows, WSL instala una distribución Linux completa que se ejecuta junto a Windows. Abre PowerShell como administrador y ejecuta:
wsl --install
Tras reiniciar, tendrás Ubuntu disponible desde el menú de inicio. Es la opción más cómoda para desarrolladores en Windows.
En cualquier sistema puedes usar una máquina virtual con VirtualBox o VMware, o con Multipass, una herramienta de Canonical que crea máquinas virtuales de Ubuntu con un solo comando:
multipass launch --name laboratorio 26.04
multipass shell laboratorio
También puedes alquilar un servidor pequeño en un proveedor de nube por unos pocos dólares al mes. Es la forma más realista de practicar administración de servidores, porque te conectarás por SSH igual que en un trabajo real.
Por último, puedes instalar Ubuntu directamente en tu equipo o en arranque dual junto a otro sistema. Para ello basta con descargar la imagen ISO oficial, grabarla en una memoria USB con una herramienta como Rufus o balenaEtcher y arrancar desde ella.
Una vez dentro, abre la terminal. En el escritorio de Ubuntu el atajo es Ctrl + Alt + T.
La shell, el prompt y la estructura de un comando
La terminal es la ventana donde escribes; la shell es el programa que interpreta lo que escribes. En Ubuntu la shell por defecto es Bash. Puedes comprobarlo así:
echo $SHELL
/bin/bash
Al abrir la terminal verás un prompt parecido a este:
ana@laboratorio:~$
Se lee como usuario ana, en el equipo laboratorio, dentro del directorio ~, que es tu carpeta personal. El símbolo $ indica que eres un usuario normal; si ves #, estás trabajando como administrador y conviene tener especial cuidado.
Casi todos los comandos siguen la misma estructura:
comando [opciones] [argumentos]
Por ejemplo, en ls -l /etc, ls es el comando, -l es una opción que pide formato detallado y /etc es el argumento que indica qué directorio listar. Muchas opciones tienen una forma corta con un guion y una larga con dos, como -a y --all, y las cortas se pueden combinar: ls -la equivale a ls -l -a.
Cuando no recuerdes cómo funciona un comando, consulta su manual con man ls, o su ayuda rápida con ls --help. Dentro del manual te mueves con las flechas, buscas con / y sales con q.
Unos cuantos atajos te harán mucho más rápido:
Tabautocompleta comandos y rutas; púlsalo dos veces para ver las opciones.- La flecha hacia arriba recupera los comandos anteriores.
Ctrl + Rbusca en el historial mientras escribes.Ctrl + AyCtrl + Evan al inicio y al final de la línea.Ctrl + Ccancela el comando en ejecución.Ctrl + Llimpia la pantalla.
Para saber quién eres y en qué sistema estás, usa estos comandos:
whoami
uname -a
lscpu | head -n 5
ana
Linux laboratorio 7.0.0-14-generic #14-Ubuntu SMP PREEMPT_DYNAMIC x86_64 GNU/Linux
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Address sizes: 46 bits physical, 48 bits virtual
Byte Order: Little Endian
CPU(s): 4
El sistema de archivos y cómo moverte por él
En Linux no hay letras de unidad como C:. Todo cuelga de un único directorio raíz, /, y los discos adicionales se montan como carpetas dentro de ese árbol. Estos son los directorios que más usarás:
/
├── bin -> usr/bin # Programas esenciales
├── etc # Archivos de configuración del sistema
├── home # Carpetas personales de los usuarios
│ └── ana
├── root # Carpeta personal del administrador
├── tmp # Archivos temporales
├── usr # Programas y bibliotecas instalados
├── var # Datos variables: registros, cachés, colas
│ └── log
├── run # Datos de ejecución, como medios montados
├── dev # Dispositivos representados como archivos
└── proc # Información del kernel y los procesos
Hay dos cambios recientes en Ubuntu 26.04 que conviene conocer. El directorio /tmp ahora reside en memoria, así que su contenido desaparece al reiniciar. Y las memorias USB y otros medios extraíbles se montan en /run/media en lugar de en /media.
Para moverte por el árbol necesitas tres comandos básicos:
pwd # Muestra el directorio actual
ls -la # Lista el contenido, incluidos archivos ocultos
cd /var/log # Cambia a un directorio con ruta absoluta
cd .. # Sube un nivel
cd ~ # Vuelve a tu carpeta personal
cd - # Vuelve al directorio anterior
Una ruta absoluta empieza por / y describe la ubicación completa desde la raíz, como /home/ana/proyectos. Una ruta relativa parte del directorio actual: si estás en /home/ana, la ruta proyectos/web apunta a /home/ana/proyectos/web. El punto . representa el directorio actual y los dos puntos .. el directorio superior. Los archivos cuyo nombre empieza por punto, como .bashrc, están ocultos y solo aparecen con ls -a.
Crear, copiar, mover y eliminar archivos
Practiquemos con una estructura de ejemplo. Crea un proyecto con varias carpetas de una vez gracias a la opción -p, que crea los directorios intermedios que falten:
mkdir -p ~/practica/{docs,src,backups}
touch ~/practica/src/app.sh ~/practica/docs/notas.txt
cd ~/practica
ls -R
.:
backups docs src
./backups:
./docs:
notas.txt
./src:
app.sh
Las llaves {docs,src,backups} son una expansión de Bash que genera los tres nombres. El comando touch crea archivos vacíos o actualiza la fecha de los existentes.
Para copiar y mover:
cp docs/notas.txt backups/ # Copia un archivo
cp -r src backups/src-copia # Copia un directorio completo
mv docs/notas.txt docs/apuntes.txt # Renombra
mv backups/src-copia /tmp/ # Mueve a otra ubicación
El comando mv sirve tanto para mover como para renombrar: en Linux, renombrar es simplemente mover un archivo a otro nombre en el mismo directorio.
Para eliminar:
rm backups/notas.txt # Elimina un archivo
rmdir backups # Elimina un directorio vacío
rm -r /tmp/src-copia # Elimina un directorio y su contenido
Aquí va la advertencia más importante de esta guía: en la terminal no existe papelera. Lo que borras con rm desaparece. Usa rm -i para que pida confirmación y revisa siempre dos veces cualquier comando con rm -rf, sobre todo si contiene variables o comodines.
Un detalle de Ubuntu 26.04: utilidades básicas como ls, cp o mv ahora proceden de uutils, una reimplementación en Rust de las herramientas clásicas de GNU. Su comportamiento es compatible, así que no notarás diferencias en el uso diario, y las versiones de GNU siguen instaladas como alternativa.
Buscar archivos y leer su contenido
El comando find recorre el árbol de directorios aplicando criterios. Estos son los usos más frecuentes:
find ~ -name "*.txt" # Por nombre
find /var/log -type f -size +10M # Archivos de más de 10 MB
find ~/practica -type d # Solo directorios
find ~ -mtime -2 # Modificados en los últimos 2 días
find /tmp -name "*.log" -delete # Busca y elimina
Para buscar texto dentro de los archivos, el comando clave es grep:
grep "error" /var/log/syslog # Líneas que contienen "error"
grep -i "error" archivo.log # Ignora mayúsculas
grep -r "TODO" ~/practica/src # Busca recursivamente
grep -n "puerto" config.conf # Muestra el número de línea
grep -v "^#" config.conf # Excluye las líneas comentadas
Para leer archivos tienes varias herramientas según el caso:
cat archivo.txt # Muestra todo el contenido
less /var/log/syslog # Lo muestra página a página
head -n 20 archivo.txt # Las primeras 20 líneas
tail -n 50 app.log # Las últimas 50 líneas
tail -f app.log # Sigue el archivo en tiempo real
wc -l archivo.txt # Cuenta las líneas
diff -u viejo.conf nuevo.conf # Compara dos archivos
tail -f es uno de los comandos favoritos de cualquier administrador: deja la terminal mostrando cada línea nueva que se escribe en un registro, ideal para ver qué ocurre mientras reproduces un problema.
Editar archivos desde la terminal
En un servidor no tendrás un editor gráfico, así que necesitas manejar al menos un editor de terminal.
Nano es el más sencillo. Abre un archivo con nano notas.txt y escribe directamente. Los atajos aparecen en la parte inferior: Ctrl + O guarda, Ctrl + X sale, Ctrl + W busca y Ctrl + K corta la línea actual.
Vim es más potente y está disponible en prácticamente cualquier sistema, pero funciona con modos. Al abrir un archivo con vim notas.txt estás en modo normal, donde las teclas son órdenes. Pulsa i para entrar en modo inserción y escribir, y Esc para volver al modo normal. Desde ahí, las órdenes esenciales son:
:w Guardar
:q Salir
:wq Guardar y salir
:q! Salir sin guardar
/texto Buscar "texto"
dd Borrar (cortar) la línea actual
yy Copiar la línea actual
p Pegar
u Deshacer
:%s/viejo/nuevo/g Reemplazar en todo el archivo
Si alguna vez te quedas atrapado en Vim, recuerda la secuencia: Esc, luego :q! y Enter.
Entender los permisos de archivos
Linux es un sistema multiusuario, y los permisos son la base de su seguridad. Ejecuta ls -l en cualquier directorio:
ls -l ~/practica/src
-rw-rw-r-- 1 ana ana 0 oct 31 09:55 app.sh
La primera columna es la clave. El primer carácter indica el tipo: - para archivo, d para directorio, l para enlace simbólico. Los nueve siguientes se agrupan de tres en tres: permisos del propietario, del grupo y del resto de usuarios. Cada grupo puede contener r (lectura), w (escritura) y x (ejecución). En el ejemplo, el propietario ana y su grupo pueden leer y escribir, y el resto solo puede leer. Nadie puede ejecutar el archivo.
En los directorios, r permite listar el contenido, w crear y borrar archivos dentro, y x entrar en él con cd.
Para cambiar permisos se usa chmod, que admite dos notaciones. La simbólica es la más legible:
chmod u+x src/app.sh # Añade ejecución al propietario (user)
chmod g-w src/app.sh # Quita escritura al grupo
chmod o= src/app.sh # Quita todos los permisos al resto (others)
chmod a+r docs/apuntes.txt # Añade lectura a todos (all)
La notación octal asigna un número a cada permiso: lectura vale 4, escritura 2 y ejecución 1. Sumando obtienes el valor de cada grupo:
chmod 755 src/app.sh # rwxr-xr-x: típico de scripts y programas
chmod 644 docs/apuntes.txt # rw-r--r--: típico de archivos normales
chmod 600 ~/.ssh/id_ed25519 # rw-------: archivos privados
Dominar los permisos de archivos en Linux evita dos errores opuestos: dejar archivos sensibles legibles para cualquiera y la tentación de resolverlo todo con chmod 777, que concede todos los permisos a todo el mundo y casi nunca es la respuesta correcta.
Para cambiar el propietario o el grupo de un archivo se usa chown, normalmente con privilegios de administrador:
sudo chown carlos src/app.sh # Cambia el propietario
sudo chown carlos:desarrollo src/app.sh # Propietario y grupo
sudo chown -R www-data:www-data /var/www/sitio # Recursivo
Usuarios, grupos y privilegios de administrador
Linux distingue tres tipos de cuentas: el superusuario root, que puede hacerlo todo; las cuentas de sistema, que usan los servicios como el servidor web; y las cuentas normales de las personas. La información de los usuarios se guarda en /etc/passwd y la de los grupos en /etc/group.
id
uid=1000(ana) gid=1000(ana) groups=1000(ana),4(adm),27(sudo)
La salida muestra tu identificador, tu grupo principal y los grupos a los que perteneces. Pertenecer al grupo sudo es lo que te permite ejecutar comandos como administrador anteponiendo sudo:
sudo apt update
En Ubuntu 26.04, sudo lo proporciona sudo-rs, una implementación en Rust centrada en la seguridad de memoria. Su uso es el mismo; la diferencia más visible es que muestra asteriscos al escribir la contraseña. Si prefieres el comportamiento clásico, sin ninguna señal visual, añade Defaults !pwfeedback editando la configuración con sudo visudo.
Para gestionar usuarios:
sudo useradd -m -s /bin/bash carlos # Crea usuario con carpeta y shell
sudo passwd carlos # Le asigna contraseña
sudo usermod -aG sudo carlos # Lo añade al grupo sudo
sudo usermod -aG desarrollo carlos # Lo añade a otro grupo
sudo userdel -r carlos # Lo elimina junto con su carpeta
En usermod -aG, la opción -a es fundamental: significa añadir. Sin ella, el usuario quedaría solo en el grupo indicado y perdería todos los demás, incluido sudo.
Para cambiar de usuario usa su - carlos, que abre una sesión como ese usuario con su entorno completo. Todo lo que se hace con sudo queda registrado en /var/log/auth.log, lo que permite auditar quién hizo qué.
Instalar y gestionar software con apt
En Linux el software se instala desde repositorios: servidores mantenidos por la distribución que contienen miles de paquetes verificados. El gestor de paquetes descarga cada programa junto con sus dependencias, es decir, las bibliotecas que necesita para funcionar.
Ubuntu 26.04 incluye apt 3.1, que trae un nuevo resolutor de dependencias que entra en acción cuando el clásico no encuentra solución. El flujo básico es este:
sudo apt update # Actualiza la lista de paquetes disponibles
sudo apt upgrade # Instala las actualizaciones
sudo apt install htop tree # Instala paquetes
apt search servidor web # Busca paquetes
apt show nginx # Muestra información de un paquete
sudo apt remove htop # Desinstala un paquete
sudo apt autoremove # Elimina dependencias que ya no se usan
apt list --installed | wc -l # Cuenta los paquetes instalados
Una confusión habitual: apt update no actualiza ningún programa, solo refresca el catálogo. Por eso siempre se ejecuta antes de apt upgrade o de instalar algo nuevo.
Si descargas un paquete .deb desde la web de un fabricante, puedes instalarlo con apt indicando la ruta, lo que resuelve sus dependencias automáticamente:
sudo apt install ./programa_1.0_amd64.deb
También existe dpkg -i, la herramienta de bajo nivel, pero no instala dependencias por sí sola.
Un cambio importante si sigues tutoriales antiguos: el comando apt-key, que muchas guías usan para añadir claves de repositorios de terceros, se eliminó en apt 3.1. El método actual consiste en guardar la clave del repositorio en /etc/apt/keyrings/ y referenciarla en la definición del repositorio con la opción Signed-By. Si un tutorial te pide ejecutar apt-key add, está desactualizado.
Primeros scripts en Bash
Un script de Bash es un archivo de texto con comandos que se ejecutan en orden. Es la forma más directa de automatizar tareas repetitivas. Crea el archivo ~/practica/src/respaldo.sh:
#!/bin/bash
# respaldo.sh: comprime un directorio y guarda el archivo con la fecha.
ORIGEN="${1:-$HOME/practica/docs}"
DESTINO="$HOME/practica/backups"
FECHA=$(date +%Y-%m-%d_%H%M)
ARCHIVO="$DESTINO/respaldo_$FECHA.tar.gz"
if [ ! -d "$ORIGEN" ]; then
echo "Error: el directorio $ORIGEN no existe." >&2
exit 1
fi
mkdir -p "$DESTINO"
tar -czf "$ARCHIVO" -C "$(dirname "$ORIGEN")" "$(basename "$ORIGEN")"
echo "Respaldo creado: $ARCHIVO ($(du -h "$ARCHIVO" | cut -f1))"
# Conserva solo los 5 respaldos más recientes.
ls -1t "$DESTINO"/respaldo_*.tar.gz | tail -n +6 | xargs -r rm --
Hazlo ejecutable y pruébalo:
chmod u+x ~/practica/src/respaldo.sh
~/practica/src/respaldo.sh
Respaldo creado: /home/ana/practica/backups/respaldo_2026-10-31_1012.tar.gz (4,0K)
Repasemos los elementos del script. La primera línea, llamada shebang, indica qué intérprete debe ejecutarlo. ORIGEN="${1:-...}" toma el primer argumento del script y, si no se pasa ninguno, usa un valor por defecto. $(date +%Y-%m-%d_%H%M) es una sustitución de comando: ejecuta date y guarda su salida en la variable. Las comillas alrededor de cada variable evitan problemas con nombres que contienen espacios, uno de los errores más comunes en Bash.
El bloque if comprueba con -d que el directorio existe. Otras pruebas habituales son -f para archivos, -z para cadenas vacías y comparaciones numéricas como -gt (mayor que) o -lt (menor que). Si algo falla, el script escribe el error en la salida de errores con >&2 y termina con exit 1; el código de salida 0 significa éxito y cualquier otro valor, error.
Los bucles completan las herramientas básicas. Este ejemplo recorre archivos y otro lee un archivo línea a línea:
#!/bin/bash
for archivo in ~/practica/docs/*.txt; do
lineas=$(wc -l < "$archivo")
echo "$(basename "$archivo"): $lineas líneas"
done
while read -r servidor; do
ping -c 1 -W 1 "$servidor" > /dev/null && echo "$servidor responde" || echo "$servidor no responde"
done < servidores.txt
Con case puedes manejar varias opciones de forma limpia, por ejemplo para un script que acepte iniciar, detener o estado como argumento. Con estas piezas ya puedes escribir scripts en Bash para Linux que resuelvan buena parte de las tareas cotidianas de administración.
Redirecciones, tuberías y flujos estándar
Todo programa en Linux tiene tres canales: la entrada estándar (stdin, número 0), la salida estándar (stdout, número 1) y la salida de errores (stderr, número 2). Las redirecciones te permiten conectarlos con archivos:
ls -l > listado.txt # Escribe la salida en un archivo (sobrescribe)
date >> registro.txt # Añade al final del archivo
comando 2> errores.txt # Guarda solo los errores
comando > todo.txt 2>&1 # Salida y errores al mismo archivo
comando > /dev/null 2>&1 # Descarta toda la salida
sort < nombres.txt # Usa un archivo como entrada
La tubería | conecta la salida de un comando con la entrada del siguiente, y es donde Linux muestra su verdadera potencia. Este ejemplo muestra las diez direcciones IP que más peticiones han hecho a un servidor web:
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -n 10
1523 203.0.113.42
981 198.51.100.7
455 192.0.2.15
Cada comando hace una sola cosa: awk extrae la primera columna, sort ordena, uniq -c cuenta las repeticiones consecutivas, sort -rn ordena por número de mayor a menor y head se queda con las diez primeras. Ninguno sabe nada de servidores web, pero combinados resuelven un problema real en una línea.
El comando tee es útil cuando quieres ver la salida y guardarla al mismo tiempo:
sudo apt upgrade -y | tee actualizacion.log
Gestionar procesos
Cada programa en ejecución es un proceso con un identificador numérico, el PID. Para ver qué está pasando en el sistema:
ps aux | head -n 5 # Todos los procesos
ps aux | grep nginx # Filtra por nombre
pgrep -a python # Busca procesos por nombre
top # Monitor interactivo
htop # Versión mejorada (instálala con apt)
En top y htop verás el uso de CPU y memoria de cada proceso en tiempo real. Son la primera herramienta cuando un servidor va lento.
Para terminar procesos se envían señales:
kill 4821 # Pide al proceso que termine (SIGTERM)
kill -9 4821 # Lo fuerza a terminar (SIGKILL)
pkill -f "python app.py" # Termina procesos por patrón
Usa primero kill sin opciones, que permite al programa cerrar ordenadamente sus archivos y conexiones. Reserva kill -9 para procesos que no responden.
También puedes controlar procesos desde la propia terminal. Añadir & al final de un comando lo ejecuta en segundo plano; Ctrl + Z suspende el proceso actual; jobs lista los trabajos, y fg y bg los traen al primer plano o los reanudan en segundo plano.
En servidores modernos, los servicios de larga duración los gestiona systemd, el sistema de inicio de Ubuntu:
systemctl status nginx # Estado de un servicio
sudo systemctl restart nginx # Lo reinicia
sudo systemctl enable --now nginx # Lo activa al arrancar y lo inicia ya
systemctl list-units --failed # Servicios que han fallado
Ten en cuenta que la versión de systemd incluida en Ubuntu 26.04 ya no admite los antiguos scripts de servicio de System V, así que cualquier servicio propio debe definirse como una unidad nativa de systemd.
Automatizar tareas con cron y temporizadores
Cron ejecuta comandos de forma periódica. Cada usuario tiene su propia tabla de tareas, que se edita con:
crontab -e
Cada línea tiene cinco campos de tiempo seguidos del comando:
# ┌───── minuto (0-59)
# │ ┌───── hora (0-23)
# │ │ ┌───── día del mes (1-31)
# │ │ │ ┌───── mes (1-12)
# │ │ │ │ ┌───── día de la semana (0-7, 0 y 7 son domingo)
# │ │ │ │ │
30 2 * * * /home/ana/practica/src/respaldo.sh >> /home/ana/respaldo.log 2>&1
*/15 * * * * /home/ana/scripts/comprobar-web.sh
0 9 * * 1 /home/ana/scripts/informe-semanal.sh
La primera tarea ejecuta el respaldo todos los días a las 2:30 y guarda su salida en un registro. La segunda se ejecuta cada quince minutos y la tercera los lunes a las 9:00. Puedes ver tus tareas con crontab -l.
Casi todos los fallos de las tareas programadas con cron se deben a dos detalles. Primero, cron ejecuta los comandos con un entorno mínimo, así que usa siempre rutas absolutas. Segundo, si no rediriges la salida, los errores se pierden; por eso el ejemplo añade >> archivo.log 2>&1.
Como alternativa moderna, systemd ofrece temporizadores, que registran cada ejecución en el diario del sistema y permiten recuperar ejecuciones perdidas si el equipo estaba apagado. Puedes ver los temporizadores activos con systemctl list-timers.
Conectarte a servidores con SSH
SSH permite abrir una terminal en una máquina remota a través de una conexión cifrada, por defecto en el puerto 22. La forma básica es:
Usar contraseñas es cómodo pero inseguro. Lo recomendable es autenticarse con un par de claves. Genera uno con el algoritmo Ed25519, el más recomendado actualmente:
ssh-keygen -t ed25519 -C "ana@portatil"
ssh-copy-id [email protected]
ssh [email protected]
El primer comando crea la clave privada ~/.ssh/id_ed25519, que nunca debe salir de tu equipo, y la pública ~/.ssh/id_ed25519.pub. El segundo copia la clave pública al servidor. A partir de ahí te conectarás sin contraseña.
Para no escribir direcciones y usuarios cada vez, define alias en ~/.ssh/config:
Host produccion
HostName 203.0.113.10
User ana
IdentityFile ~/.ssh/id_ed25519
Ahora basta con ssh produccion. Para copiar archivos entre equipos usa scp o, mejor aún para directorios, rsync:
scp informe.pdf produccion:/home/ana/
rsync -avz ~/practica/ produccion:/home/ana/practica/
Una vez que las claves funcionen, endurece el servidor desactivando el acceso por contraseña y el acceso directo de root en /etc/ssh/sshd_config, con las directivas PasswordAuthentication no y PermitRootLogin no, y reinicia el servicio con sudo systemctl restart ssh. Hazlo siempre manteniendo abierta una sesión, por si algo sale mal y necesitas revertir el cambio.
Fundamentos de redes en la terminal
Estos comandos responden a las preguntas básicas de cualquier problema de red. Fíjate en que las herramientas clásicas como ifconfig y netstat han sido sustituidas por ip y ss, que son las que vienen instaladas por defecto:
ip -br addr # Interfaces y direcciones IP
ip route # Tabla de rutas y puerta de enlace
ping -c 4 8.8.8.8 # ¿Hay conectividad?
ping -c 4 ubuntu.com # ¿Funciona la resolución de nombres?
resolvectl status # Servidores DNS configurados
ss -tulpn # Puertos abiertos y qué proceso los usa
curl -I https://ubuntu.com # Cabeceras de una respuesta HTTP
traceroute ubuntu.com # Ruta hasta un destino
lo UNKNOWN 127.0.0.1/8 ::1/128
enp0s3 UP 10.0.2.15/24 fe80::a00:27ff:fe4e:66a1/64
La estrategia para diagnosticar una conexión que no funciona es avanzar capa a capa: comprobar que la interfaz tiene dirección IP, que hay ruta hacia la puerta de enlace, que se alcanza una IP externa, que los nombres se resuelven y, por último, que el servicio concreto responde. El punto donde falla la cadena te dice dónde está el problema.
Para proteger un servidor, Ubuntu incluye ufw, un cortafuegos sencillo:
sudo ufw allow OpenSSH
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status verbose
Permite siempre SSH antes de activar el cortafuegos en un servidor remoto; de lo contrario, te quedarás fuera.
Leer registros y diagnosticar problemas
Cuando algo falla, la respuesta casi siempre está en los registros. En sistemas con systemd, el diario centralizado se consulta con journalctl:
journalctl -u nginx --since "1 hour ago" # Registros de un servicio
journalctl -p err -b # Errores desde el último arranque
journalctl -f # Sigue el diario en tiempo real
journalctl --disk-usage # Espacio que ocupa el diario
Muchos programas siguen escribiendo además en archivos de texto dentro de /var/log, como auth.log para autenticaciones o los registros de nginx. Aquí es donde las tuberías demuestran su utilidad. Por ejemplo, para ver qué direcciones intentan entrar por SSH con contraseñas incorrectas:
grep "Failed password" /var/log/auth.log | awk '{print $(NF-3)}' | sort | uniq -c | sort -rn | head
Además de los registros, hay un conjunto de comandos de diagnóstico que conviene tener a mano:
df -h # Espacio libre en cada disco
du -sh /var/* | sort -h # Qué directorios ocupan más
free -h # Memoria y swap
uptime # Tiempo encendido y carga media
lsblk # Discos y particiones
dmesg -T | tail # Mensajes del kernel, útiles para fallos de hardware
Una estrategia general para un servidor con problemas sigue este orden: confirmar el síntoma exacto, revisar la carga con uptime y top, comprobar disco y memoria con df -h y free -h, verificar el estado de los servicios con systemctl, leer los registros relevantes con journalctl y, finalmente, comprobar la red. Un disco lleno, por ejemplo, explica una cantidad sorprendente de fallos aparentemente misteriosos, desde bases de datos que dejan de escribir hasta servicios que no arrancan.
Si sospechas de un problema de hardware, dmesg mostrará errores de disco o de memoria, y herramientas como smartctl, del paquete smartmontools, permiten consultar el estado de salud de los discos.
Errores comunes de quien empieza con Linux
Algunos tropiezos se repiten en casi todas las personas que aprenden Linux. Conocerlos te ahorrará disgustos.
Usar sudo para todo. Si un comando falla por permisos, la solución no siempre es anteponer sudo. Crear archivos como root en tu carpeta personal, por ejemplo, provoca después errores porque tu usuario no puede modificarlos.
Resolver permisos con chmod 777. Funciona, pero abre el archivo a cualquier usuario y proceso del sistema. Averigua quién necesita acceso y concede solo ese permiso.
Olvidar las comillas en las variables. Un script que hace rm -rf $DIRECTORIO/ sin comillas puede tener consecuencias graves si la variable está vacía o contiene espacios. Escribe siempre "$DIRECTORIO".
Confundir > con >>. El primero sobrescribe el archivo y el segundo añade al final. Un > por error puede borrar un registro o una configuración completa.
Ejecutar comandos copiados de internet sin entenderlos. Antes de ejecutar algo con sudo o que descargue y ejecute un script, lee qué hace cada parte.
Seguir tutoriales desactualizados. Comandos como apt-key, ifconfig o netstat aparecen en muchas guías antiguas. Comprueba siempre que las instrucciones corresponden a una versión reciente de tu distribución.
Cómo seguir avanzando
Con lo aprendido en esta guía tienes una base sólida para trabajar con cualquier servidor Linux. El siguiente paso depende de tu perfil.
Si eres desarrollador, profundiza en Bash para automatizar tu flujo de trabajo, aprende Git a fondo desde la terminal y familiarízate con Docker, que se apoya directamente en conceptos del kernel como los procesos, los usuarios y los sistemas de archivos.
Si te interesa la administración de sistemas, practica desplegando un servidor web con nginx, configura certificados TLS, automatiza la configuración con Ansible y aprende a escribir tus propias unidades y temporizadores de systemd.
Si te atrae la seguridad, estudia el endurecimiento de servidores, el análisis de registros y herramientas como fail2ban o los perfiles de AppArmor que incluye Ubuntu.
En todos los casos, la clave es la práctica diaria. Crea una máquina virtual, rómpela, arréglala y repite. Cada error que resuelves en la terminal se convierte en conocimiento que no olvidarás.
Conclusiones
Linux puede parecer intimidante al principio por la cantidad de comandos, pero todos se apoyan en un puñado de ideas coherentes: un único árbol de archivos, permisos que separan a los usuarios, programas pequeños que se combinan mediante tuberías y servicios gestionados por systemd. Una vez que interiorizas esas ideas, cada comando nuevo encaja en un modelo mental que ya conoces.
En esta guía has recorrido el camino completo con Ubuntu 26.04 LTS: desde la estructura de un comando y la navegación por el sistema de archivos hasta la gestión de permisos, usuarios y paquetes con apt 3.1, la escritura de scripts en Bash, el control de procesos, la automatización con cron, las conexiones SSH con claves, los fundamentos de redes y el diagnóstico a partir de los registros. También has visto los cambios recientes que conviene tener presentes, como sudo-rs, las utilidades en Rust, /tmp en memoria y la desaparición de apt-key.
Dominar los comandos básicos de Linux es una de las habilidades más rentables en tecnología, porque se aplica a servidores, contenedores, la nube y el desarrollo diario durante toda una carrera profesional. Abre una terminal, practica cada sección de esta guía y convierte la línea de comandos en tu herramienta de trabajo habitual.