Introducción a Linux: distribuciones, arranque y terminal

Por qué Linux sigue siendo la base de la infraestructura moderna

Linux está detrás de la mayoría de los servidores web, de los contenedores que se ejecutan en la nube, de los clústeres de Kubernetes, de los routers domésticos y de buena parte de los dispositivos embebidos. Para cualquier persona que desarrolla software, entender cómo funciona este sistema operativo dejó de ser una habilidad opcional: es el entorno donde, tarde o temprano, termina ejecutándose casi cualquier aplicación.

Esta guía recorre los fundamentos que todo desarrollador o administrador debería dominar: qué es una distribución, cómo se organizan las grandes familias, qué ocurre desde que pulsas el botón de encendido hasta que aparece el escritorio, cómo se estructura el sistema de archivos, cómo se instala software y cómo dar los primeros pasos en la terminal con privilegios de administrador. Todo está actualizado al panorama de finales de 2026, con el kernel 7.3 recién publicado, Ubuntu 26.04 LTS como referencia en la familia Debian y systemd consolidado como gestor de servicios universal.

La mejor manera de aprovechar este contenido es practicar. Ten a mano una máquina virtual o un equipo de pruebas y ejecuta cada comando a medida que avanzas.

Qué es realmente una distribución Linux

En sentido estricto, Linux es solo el kernel: el núcleo que gestiona la memoria, los procesos, los dispositivos y la comunicación con el hardware. Por sí solo no permite hacer gran cosa. Lo que la mayoría de la gente llama “Linux” es en realidad una distribución, es decir, el kernel acompañado de un conjunto de herramientas que lo convierten en un sistema operativo completo.

Una distribución típica incluye:

• El kernel, compilado y configurado por el equipo de la distribución.
• Un gestor de arranque, normalmente GRUB o systemd-boot.
• Un sistema de inicio y gestión de servicios, hoy casi siempre systemd.
• Las utilidades básicas del sistema (coreutils, shell, herramientas de red).
• Bibliotecas del sistema como glibc.
• Un sistema de paquetes para instalar, actualizar y eliminar software.
• Opcionalmente, un servidor gráfico y un entorno de escritorio.

Cada una de estas piezas es un proyecto independiente con su propio equipo de desarrollo. La distribución actúa como integrador: elige versiones, las prueba juntas, aplica parches y garantiza que todo funcione como un conjunto coherente.

Un detalle importante es que no todas las distribuciones usan la misma versión del kernel. La rama estable más reciente es Linux 7.3, publicada el 18 de octubre de 2026, mientras que muchas distribuciones empresariales prefieren ramas de soporte extendido como la 6.12 o la 6.18. Además, los mantenedores suelen portar mejoras concretas a kernels antiguos, así que el número de versión no cuenta toda la historia. Puedes comprobar qué kernel usa tu sistema así:

uname -r
cat /etc/os-release

7.0.0-28-generic
PRETTY_NAME="Ubuntu 26.04.1 LTS"
NAME="Ubuntu"
VERSION_ID="26.04"
VERSION_CODENAME=resolute

Las tres grandes familias de distribuciones

Existen cientos de distribuciones, pero casi todas derivan de tres linajes principales. Conocerlos permite trasladar lo aprendido de un sistema a otro con muy poco esfuerzo, porque comparten formato de paquetes, herramientas de administración y convenciones.

La familia Red Hat y sus derivadas

Red Hat Enterprise Linux (RHEL) encabeza esta familia y es una de las distribuciones más utilizadas en entornos corporativos. La versión mayor vigente es RHEL 10, cuya actualización 10.2 alcanzó disponibilidad general en mayo de 2026. Alrededor de RHEL gravitan varios proyectos:

• Fedora, la distribución comunitaria que actúa como laboratorio de pruebas de lo que luego llega a RHEL. Su versión estable actual es Fedora 44, y Fedora 45 está en fase final de estabilización.
• CentOS Stream, que se sitúa justo por delante de RHEL y muestra lo que llegará en la siguiente versión menor.
• AlmaLinux y Rocky Linux, reconstrucciones comunitarias compatibles a nivel binario con RHEL que ocuparon el hueco que dejó el antiguo CentOS Linux, ya descontinuado.
• Oracle Linux, otra derivación con soporte comercial.

Esta familia usa paquetes RPM y el gestor de alto nivel dnf. Fedora ya trabaja con DNF5, una reescritura más rápida de la herramienta clásica. Por defecto, todos estos sistemas activan SELinux como capa de seguridad obligatoria.

La familia SUSE y openSUSE

SUSE Linux Enterprise Server (SLES) es la referencia comercial de esta rama, muy presente en sectores como el comercio minorista, la banca y los entornos SAP. Su contraparte gratuita es openSUSE, que se ofrece en dos sabores: Leap, con ciclos estables alineados con la versión empresarial (la serie actual es Leap 16), y Tumbleweed, una distribución de actualización continua.

SUSE también utiliza paquetes RPM, pero su gestor de alto nivel es zypper. Por lo que respecta a la relación entre versiones, lo aprendido en openSUSE se aplica casi sin cambios en SLES.

La familia Debian, Ubuntu y Mint

Debian es un proyecto puramente comunitario, sin una empresa propietaria detrás, con un enfoque muy marcado en la estabilidad y el repositorio de software más grande del ecosistema. La versión estable actual es Debian 13 “Trixie”, cuya última actualización puntual es la 13.7, publicada en septiembre de 2026.

De Debian deriva Ubuntu, la distribución más popular en la nube y entre desarrolladores, y de Ubuntu derivan a su vez Linux Mint, Pop!_OS y muchas otras. Ubuntu 26.04 LTS “Resolute Raccoon” se publicó el 23 de abril de 2026 y tendrá cinco años de soporte estándar, hasta abril de 2031. Esta familia usa paquetes .deb, gestionados en bajo nivel por dpkg y en alto nivel por APT, que en las versiones actuales ya está en la serie 3.

Cómo elegir la distribución adecuada para tu proyecto

Elegir una distribución se parece a elegir un coche: no hay una opción universalmente mejor, sino una que encaja con tus necesidades. Antes de decidir, conviene responder a estas preguntas:

• ¿El equipo será un servidor, una estación de trabajo o un dispositivo embebido?
• ¿Cuánto tiempo necesitas que la versión reciba parches de seguridad?
• ¿Prefieres estabilidad a largo plazo o acceso a las últimas versiones de cada paquete?
• ¿Tu software comercial exige una distribución certificada concreta?
• ¿Sobre qué arquitectura vas a trabajar: x86_64, ARM64, RISC-V o POWER?
• ¿Necesitas soporte técnico de pago o puedes operar con la comunidad?

Como orientación general, la siguiente tabla resume los casos de uso más habituales:

Hay un matiz que muchos pasan por alto: el ciclo de vida. Una versión LTS de Ubuntu o una versión mayor de RHEL te permite olvidarte de migraciones durante años, mientras que Fedora publica una versión nueva aproximadamente cada seis meses y exige actualizar con frecuencia.

Del botón de encendido al escritorio: el arranque paso a paso

Entender el proceso de arranque en Linux resulta muy útil para diagnosticar equipos que no inician y para ajustar el rendimiento. No necesitas memorizar cada detalle para usar el sistema, pero sí conviene tener una visión clara de las etapas.

Primera etapa del arranque: firmware UEFI o BIOS

Al encender el equipo, el firmware inicializa el hardware y ejecuta una autocomprobación de memoria y dispositivos, conocida como POST. En los equipos modernos este firmware es UEFI; la BIOS tradicional solo sobrevive en hardware antiguo o en máquinas virtuales configuradas en modo heredado. UEFI también ofrece Secure Boot, que verifica la firma digital de cada componente que se carga.

El gestor de arranque y la partición EFI

Con el método antiguo BIOS/MBR, la primera etapa del cargador vive en los 512 bytes del Master Boot Record, examina la tabla de particiones y carga una segunda etapa más completa. Con UEFI, el firmware lee sus entradas de arranque, localiza la partición del sistema EFI (ESP) y ejecuta directamente la aplicación correspondiente, como GRUB o systemd-boot.

El gestor de arranque muestra un menú opcional para elegir sistema operativo o versión del kernel, y después carga en memoria dos elementos: la imagen del kernel y un sistema de archivos inicial en RAM llamado initramfs.

Kernel e initramfs: preparar el sistema raíz

El kernel, que normalmente viene comprimido, se descomprime, inicializa la memoria y detecta el hardware. Después monta el initramfs, que contiene los controladores y herramientas necesarios para encontrar y montar el sistema de archivos raíz real: soporte para discos cifrados, RAID, LVM o controladores de almacenamiento poco comunes. En este punto, udev identifica los dispositivos presentes y carga sus módulos.

Las distribuciones generan el initramfs con herramientas como dracut o mkinitramfs. Un cambio relevante es que Ubuntu 26.04 LTS adoptó dracut como generador por defecto, algo que ya hacían Fedora y RHEL desde hace años. Puedes inspeccionar el contenido de tu initramfs:

# En Fedora, RHEL o Ubuntu 26.04 con dracut
sudo lsinitrd | head -n 20

# En sistemas que usan initramfs-tools
lsinitramfs /boot/initrd.img-$(uname -r) | head -n 20

El primer proceso del sistema: PID 1

Cuando la raíz real está montada, el kernel ejecuta /sbin/init, que hoy es simplemente un enlace a systemd. Este proceso recibe el identificador PID 1 y es el antepasado de casi todos los demás procesos del sistema. Se encarga de arrancar servicios, montar sistemas de archivos adicionales, iniciar las pantallas de acceso y, al final, apagar el equipo de forma ordenada.

ls -l /sbin/init
ps -p 1 -o pid,comm

lrwxrwxrwx 1 root root 22 abr 23 10:12 /sbin/init -> ../lib/systemd/systemd
    PID COMMAND
      1 systemd

systemd y la gestión de servicios

Durante décadas, Linux arrancó con SysVinit, un modelo heredado de UNIX System V que ejecutaba scripts en secuencia agrupados en niveles de ejecución o runlevels. Era lento, porque cada etapa esperaba a la anterior, y los scripts eran difíciles de mantener entre distribuciones. Ubuntu intentó una alternativa llamada Upstart, pero systemd terminó imponiéndose en todas las distribuciones principales.

systemd arranca más rápido gracias a la paralelización: inicia simultáneamente todos los servicios cuyas dependencias ya están satisfechas. Además, sustituye los scripts por archivos de unidad declarativos, mucho más sencillos de leer. La compatibilidad con scripts de SysV, que se mantuvo durante años como capa de transición, fue eliminada en systemd 260, así que cualquier servicio que todavía dependa de ellos debe migrarse a unidades nativas.

La herramienta central es systemctl. Estos son los comandos que usarás a diario, tomando como ejemplo el servidor web nginx:

# Iniciar, detener y reiniciar un servicio
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx

# Recargar la configuración sin cortar conexiones
sudo systemctl reload nginx

# Activar o desactivar el arranque automático
sudo systemctl enable --now nginx
sudo systemctl disable nginx

# Consultar el estado y los registros
systemctl status nginx
journalctl -u nginx --since "1 hour ago"

El sufijo .service puede omitirse en la mayoría de los casos. Crear tu propio servicio también es sencillo. Supón que tienes una API interna escrita en Python que quieres mantener siempre activa:

# /etc/systemd/system/api-inventario.service
[Unit]
Description=API de inventario interno
After=network-online.target
Wants=network-online.target

[Service]
User=inventario
WorkingDirectory=/opt/api-inventario
ExecStart=/opt/api-inventario/venv/bin/python -m servidor
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now api-inventario

Los antiguos runlevels tienen su equivalente en los targets de systemd: multi-user.target corresponde a un sistema multiusuario sin interfaz gráfica y graphical.target a uno con escritorio. Puedes consultar y cambiar el target predeterminado con systemctl get-default y systemctl set-default.

Particiones, sistemas de archivos y puntos de montaje

Una partición es una sección contigua de un disco. Un sistema de archivos es el método que se usa para organizar y localizar los datos dentro de esa partición. Una forma útil de imaginarlo es pensar en la partición como un armario y en el sistema de archivos como el sistema de estantes y etiquetas que decide dónde se guarda cada cosa.

Linux admite una gran variedad de sistemas de archivos:

• De disco convencionales: ext4, XFS, Btrfs, además de NTFS, vfat y exFAT para compatibilidad con otros sistemas.
• Para memoria flash sin controlador: UBIFS o JFFS2.
• Especiales o virtuales: procfs, sysfs, tmpfs, squashfs o FUSE.

Ext4 sigue siendo la opción por defecto en Debian y Ubuntu, XFS lo es en RHEL y Btrfs se usa por defecto en Fedora Workstation y openSUSE, donde aprovecha sus instantáneas para revertir actualizaciones problemáticas.

La gran diferencia con Windows es que Linux no usa letras de unidad. Todo cuelga de un único árbol que empieza en /, y cada partición o dispositivo se monta en un directorio de ese árbol, llamado punto de montaje:

Para ver cómo está organizado tu almacenamiento:

lsblk -f
df -hT
findmnt /

NAME        FSTYPE FSVER LABEL UUID                                 MOUNTPOINTS
nvme0n1
├─nvme0n1p1 vfat   FAT32       7A1B-3C2D                            /boot/efi
├─nvme0n1p2 ext4   1.0         0f3a9c1e-...                         /boot
└─nvme0n1p3 ext4   1.0         5d82b7aa-...                         /

La jerarquía de directorios estándar

Linux organiza sus archivos según el Filesystem Hierarchy Standard (FHS), mantenido por la Linux Foundation. Gracias a este estándar, quien aprende la jerarquía del sistema de archivos en una distribución puede orientarse sin problemas en cualquier otra. Este es un resumen de los directorios más importantes:

/
├── bin -> usr/bin        # Ejecutables esenciales
├── boot                  # Kernel, initramfs y archivos del cargador
├── dev                   # Archivos de dispositivo
├── etc                   # Configuración del sistema
├── home                  # Directorios personales de los usuarios
│   └── laura
├── lib -> usr/lib        # Bibliotecas compartidas
├── media                 # Montaje de medios extraíbles (sistemas antiguos)
├── mnt                   # Montajes temporales manuales
├── opt                   # Software de terceros
├── proc                  # Información de procesos (virtual)
├── root                  # Directorio personal del administrador
├── run                   # Datos de ejecución; incluye /run/media
├── srv                   # Datos servidos por el sistema
├── sys                   # Información del kernel y dispositivos (virtual)
├── tmp                   # Archivos temporales
├── usr                   # Programas y datos de solo lectura
│   ├── bin
│   ├── lib
│   ├── local
│   └── share
└── var                   # Datos variables: logs, cachés, colas
    ├── cache
    ├── lib
    └── log

Fíjate en que /bin y /lib aparecen como enlaces a /usr. La mayoría de las distribuciones modernas completaron la llamada fusión de /usr, que unifica los ejecutables en un solo lugar.

Dos detalles prácticos: los nombres distinguen mayúsculas de minúsculas, de modo que /boot, /Boot y /BOOT serían tres directorios distintos, y las memorias USB se montan automáticamente en /run/media/usuario/etiqueta o en /media/usuario/etiqueta, según la distribución.

Planificar una instalación sin perder datos

El esquema de particiones se decide durante la instalación y cambiarlo después es posible, pero laborioso. Los instaladores actuales proponen esquemas razonables: una partición EFI, una raíz grande y, según la distribución, un archivo o partición de intercambio. En servidores conviene separar /var y /home, porque así un log desbocado no llena la partición raíz y deja el sistema inutilizable.

La advertencia más importante es esta: una instalación estándar sobre todo el disco borra todo lo que había. Si quieres conservar tus datos, tienes tres caminos más seguros:

1. Usar una máquina virtual con VirtualBox, VMware, GNOME Boxes o virt-manager. Es la opción más segura para aprender.
2. Arrancar desde una memoria USB en modo live, que permite probar el sistema sin escribir en el disco.
3. Configurar un arranque dual junto a tu sistema actual, reduciendo una partición existente. Es la opción más delicada y conviene hacer copia de seguridad antes.

Para preparar la memoria USB de instalación desde Linux puedes usar dd, comprobando antes cuál es el dispositivo correcto, ya que un error aquí borra el disco equivocado:

lsblk
sha256sum ubuntu-26.04.1-desktop-amd64.iso
sudo dd if=ubuntu-26.04.1-desktop-amd64.iso of=/dev/sdX bs=4M status=progress oflag=sync

Las instalaciones también pueden automatizarse con archivos de respuestas: Kickstart en la familia Red Hat, AutoYaST en SUSE, preseed en Debian y autoinstall en Ubuntu Server. En entornos con muchos servidores, esta automatización es imprescindible para que todas las máquinas queden configuradas de forma idéntica.

Escritorio gráfico, Wayland y entornos de escritorio

En un equipo con interfaz gráfica, el último paso del arranque es el gestor de pantalla, que muestra la pantalla de acceso y lanza el entorno de escritorio elegido. GNOME usa GDM, KDE Plasma usa SDDM y otros entornos más ligeros suelen usar LightDM.

Durante décadas, la capa gráfica se apoyó en el sistema X Window, diseñado a mediados de los ochenta y con limitaciones de seguridad propias de su época. Su sustituto, Wayland, ya es el estándar: GNOME 50, incluido en Ubuntu 26.04 LTS, solo ofrece sesión Wayland, y Fedora lleva varias versiones en la misma línea. Las aplicaciones antiguas que requieren X siguen funcionando mediante XWayland.

Puedes comprobar qué tipo de sesión estás usando:

echo $XDG_SESSION_TYPE
loginctl show-session "$XDG_SESSION_ID" -p Type

wayland
Type=wayland

Entre los entornos de escritorio más populares están GNOME, KDE Plasma, Xfce, Cinnamon y LXQt. Todos comparten los mismos conceptos: un gestor de sesión, un gestor de ventanas, un panel o barra de tareas y un conjunto de aplicaciones integradas. Para personalizar GNOME más allá de los ajustes básicos existen herramientas como GNOME Tweaks y la aplicación Extensiones.

Instalar y actualizar software con los gestores de paquetes

En Linux el software se distribuye en paquetes, archivos que contienen los programas, su configuración por defecto y los metadatos sobre sus dependencias. Los gestores de paquetes en Linux trabajan en dos niveles: uno bajo, que instala archivos individuales (dpkg o rpm), y uno alto, que descarga desde repositorios y resuelve dependencias automáticamente (apt, dnf o zypper).

Esta tabla muestra las operaciones equivalentes en cada familia:

Un flujo típico en Ubuntu 26.04 sería:

sudo apt update
sudo apt upgrade
sudo apt install git curl build-essential
apt list --installed | grep -i curl

Y en Fedora:

sudo dnf upgrade --refresh
sudo dnf install git curl gcc make
dnf repoquery --installed curl

Además de los repositorios tradicionales, existen formatos universales como Flatpak y Snap, que empaquetan la aplicación con sus dependencias y funcionan en cualquier distribución. Son muy prácticos para aplicaciones de escritorio, aunque ocupan más espacio y no sustituyen a los paquetes nativos para componentes del sistema.

Si prefieres no usar la terminal, cada distribución ofrece una tienda gráfica: GNOME Software, Discover en KDE o el centro de aplicaciones de Ubuntu.

Primeros pasos en la línea de comandos

La interfaz gráfica facilita las tareas sencillas, pero la terminal convierte en posibles las complejas. Los administradores pasan buena parte de su tiempo en ella porque permite automatizar procesos con scripts, trabajar en servidores remotos por SSH y realizar operaciones idénticas en cualquier distribución.

Para abrir una terminal en GNOME, pulsa la tecla Super y escribe “Terminal”, o usa el atajo Ctrl+Alt+T en Ubuntu. La shell por defecto suele ser Bash, aunque Zsh y Fish son alternativas muy populares.

Cada línea de comando tiene tres elementos: el comando, las opciones que modifican su comportamiento y los argumentos sobre los que actúa:

ls -lh /var/log
#  │   │     └── argumento
#  │   └──────── opciones
#  └──────────── comando

Estos son algunos comandos básicos de la terminal que conviene dominar desde el primer día:

pwd                          # Directorio actual
cd ~/proyectos               # Cambiar de directorio
ls -la                       # Listar, incluidos los ocultos
mkdir -p notas/2026          # Crear directorios anidados
cp informe.txt notas/        # Copiar
mv borrador.txt final.txt    # Mover o renombrar
cat final.txt                # Mostrar un archivo
head -n 5 /etc/passwd        # Primeras líneas
tail -f /var/log/syslog      # Seguir un log en tiempo real
man ls                       # Consultar el manual

Las tuberías, representadas por el símbolo |, conectan la salida de un comando con la entrada de otro y son una de las ideas más poderosas de la filosofía UNIX:

journalctl -b --no-pager | grep -i error | tail -n 10
ps aux --sort=-%mem | head -n 6

Recuerda que casi toda la documentación está en el propio sistema. man muestra el manual completo de cualquier comando y la opción --help ofrece un resumen rápido.

Configurar sudo de forma segura

En Linux, el usuario root tiene control absoluto sobre el sistema. Trabajar siempre como root es peligroso, porque cualquier error tipográfico puede tener consecuencias graves. La práctica recomendada es usar una cuenta normal y elevar privilegios solo cuando hace falta mediante sudo, que ejecuta un comando concreto con permisos de administrador y deja constancia en los registros.

Ubuntu configura sudo durante la instalación y no habilita el acceso directo de root. Desde la versión 26.04, además, utiliza por defecto sudo-rs, una reimplementación en Rust, más segura en memoria, que mantiene la misma sintaxis. En otras distribuciones puede que tengas que configurarlo tú. La forma más limpia es añadir tu usuario al grupo administrativo:

# Debian y Ubuntu: grupo sudo
su -
usermod -aG sudo laura

# Fedora, RHEL y openSUSE: grupo wheel
su -
usermod -aG wheel laura

Si necesitas una regla personalizada, crea un archivo en /etc/sudoers.d/ y edítalo siempre con visudo, que valida la sintaxis antes de guardar. Un error en estos archivos puede dejarte sin acceso administrativo:

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

# Permite al usuario deploy reiniciar solo la API, sin contraseña
deploy ALL=(root) NOPASSWD: /usr/bin/systemctl restart api-inventario

Después, verifica los permisos y lo que puede hacer cada usuario:

sudo chmod 440 /etc/sudoers.d/despliegues
sudo -l -U deploy

Evita reglas genéricas del tipo ALL=(ALL) NOPASSWD: ALL: son cómodas, pero equivalen a dar acceso root sin ninguna barrera.

Terminales virtuales y modo sin interfaz gráfica

Además de las ventanas de terminal dentro del escritorio, Linux ofrece terminales virtuales: sesiones de texto a pantalla completa que funcionan aunque la interfaz gráfica falle. Puedes cambiar entre ellas con Ctrl+Alt+F1 hasta F6, según la distribución. Si el escritorio se congela, saltar a una terminal virtual permite iniciar sesión, revisar los registros y reiniciar el gestor de pantalla sin reiniciar todo el equipo.

En servidores de producción lo habitual es prescindir por completo del entorno gráfico. Un sistema sin escritorio consume menos recursos, expone menos superficie de ataque y requiere menos actualizaciones. Si tienes un equipo con escritorio y quieres detenerlo temporalmente:

sudo systemctl stop gdm          # Detiene la sesión gráfica
sudo systemctl isolate multi-user.target
sudo systemctl start gdm         # Vuelve a iniciarla

Y para que el equipo arranque siempre en modo texto:

sudo systemctl set-default multi-user.target

Errores comunes de quienes empiezan con Linux

Algunos tropiezos se repiten una y otra vez. Conocerlos de antemano ahorra horas de frustración:

• Usar sudo por costumbre. Ejecutar comandos de usuario como root puede dejar archivos en tu directorio personal con un propietario incorrecto, provocando errores de permisos más adelante.
• Copiar comandos de internet sin entenderlos. Un rm -rf o un curl | bash de origen dudoso puede destruir datos o comprometer el sistema.
• Mezclar repositorios de distintas versiones. Añadir repositorios de Debian en Ubuntu, o de otra versión mayor, es la vía más rápida hacia el conflicto de dependencias.
• Ignorar las actualizaciones. Posponer los parches de seguridad indefinidamente es uno de los principales vectores de ataque en servidores expuestos.
• Confundir el nombre del dispositivo con dd. Escribir en /dev/sda en lugar de /dev/sdb borra el disco equivocado sin preguntar.
• Desactivar SELinux o AppArmor ante el primer error. Casi siempre es mejor revisar el registro de denegaciones y ajustar la política.

Solución de problemas frecuentes

Cuando algo falla, el método es casi siempre el mismo: leer el mensaje de error completo, consultar los registros y comprobar el estado del servicio implicado. Estos son algunos casos típicos.

Error de permisos al ejecutar un script:

bash: ./desplegar.sh: Permission denied

El archivo no tiene permiso de ejecución. Se soluciona así:

chmod +x desplegar.sh
./desplegar.sh

Bloqueo del gestor de paquetes en Debian o Ubuntu:

E: Could not get lock /var/lib/dpkg/lock-frontend. It is held by process 2143 (unattended-upgr)

Otra instancia, normalmente las actualizaciones automáticas, está usando APT. Lo correcto es esperar a que termine; borrar el archivo de bloqueo a mano puede corromper la base de datos de paquetes.

Un servicio no arranca:

systemctl status api-inventario
journalctl -u api-inventario -b --no-pager | tail -n 30
systemctl --failed

Disco lleno:

df -h
sudo du -xh /var --max-depth=2 | sort -h | tail -n 10
sudo journalctl --vacuum-size=500M

Arranque lento o problemático:

systemd-analyze
systemd-analyze blame | head -n 10
journalctl -b -1 -p err

La última línea muestra los errores del arranque anterior, algo muy útil cuando el sistema se reinició tras un fallo.

Buenas prácticas para servidores en producción

Pasar de una máquina de pruebas a un servidor real exige algunos hábitos adicionales:

• Elige versiones con soporte largo, como Ubuntu LTS, Debian estable, RHEL o sus reconstrucciones, y planifica las migraciones antes del fin de soporte.
• Instala solo lo necesario. Una instalación mínima sin entorno gráfico reduce la superficie de ataque.
• Automatiza las actualizaciones de seguridad con unattended-upgrades en Debian y Ubuntu o dnf-automatic en la familia Red Hat.
• Desactiva el acceso SSH con contraseña y el inicio de sesión directo de root; usa claves y cuentas con sudo.
• Activa un cortafuegos con ufw o firewalld y abre únicamente los puertos imprescindibles.
• Mantén SELinux o AppArmor en modo de aplicación.
• Centraliza los registros y vigila métricas básicas como disco, memoria y carga.
• Gestiona la configuración como código con herramientas como Ansible, para poder reconstruir cualquier servidor de forma reproducible.

Un ejemplo de endurecimiento básico de SSH:

sudo tee /etc/ssh/sshd_config.d/10-endurecimiento.conf > /dev/null <<'EOF'
PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
EOF
sudo sshd -t && sudo systemctl reload ssh

En la familia Red Hat el servicio se llama sshd en lugar de ssh. Antes de recargar, asegúrate de tener una clave pública funcionando en tu cuenta para no quedarte fuera del servidor.

Conclusiones

Linux puede parecer intimidante al principio por la cantidad de distribuciones y herramientas disponibles, pero sus fundamentos son sorprendentemente coherentes. Las tres grandes familias, Red Hat, SUSE y Debian, comparten el mismo kernel, el mismo gestor de servicios y la misma jerarquía de directorios, y se diferencian sobre todo en el formato de paquetes y en sus ciclos de soporte.

Comprender el arranque, desde el firmware UEFI hasta systemd, te permitirá diagnosticar equipos que no inician. Dominar la jerarquía de directorios y los puntos de montaje te ayudará a encontrar cualquier archivo de configuración o registro. Y manejar con soltura apt, dnf o zypper, junto con systemctl, journalctl y sudo, cubre la mayor parte del trabajo diario de un administrador.

El ecosistema sigue evolucionando: Wayland ya sustituyó a X11 en los escritorios principales, systemd abandonó la compatibilidad con los scripts de SysV, herramientas reescritas en Rust como sudo-rs llegan a las versiones LTS y el kernel avanza a buen ritmo por la serie 7. Aun así, los conceptos que has visto aquí se mantienen estables. El siguiente paso natural es profundizar en permisos de archivos, gestión de usuarios, redes y scripting en Bash, siempre practicando en una máquina virtual donde equivocarse no tenga consecuencias.