¿Cómo ejecutar comandos o scripts de terminal al iniciar Linux?

Una de las cosas que más me gusta de Linux es que siempre hay alguna forma de automatizar tareas. Da igual si hablamos de montar discos, lanzar chequeos, generar logs o configurar red: casi todo se puede dejar hecho para que ocurra solo al arrancar el sistema.

En más de una ocasión he necesitado que ciertos comandos o scripts se ejecuten de forma automática y transparente, sin tener que acordarme de lanzarlos a mano después de cada reinicio. Y aunque hoy en día todo gira alrededor de systemd, siguen existiendo varias formas válidas de ejecutar comandos al iniciar Linux.

En esta guía te explico qué métodos existen, cuándo usar cada uno y qué errores evitar, basándome tanto en documentación como en uso real.

Una de mis cosas favoritas en Linux es que siempre existe alguna función o configuración o programas que permite automatizar tareas o procesos, como por ejemplo, cuando se necesita ejecutar scripts o cualquier otro comando (montar unidades de manera automática, ejecutar un chequeo, log, etc) al iniciar nuestra distribución Linux de manera automática y transparente.

Automatizar tareas al arrancar Linux: por qué y cuándo hacerlo

Automatizar el arranque no es solo comodidad: en muchos casos es necesario.

Arranque del sistema vs inicio de sesión

Antes de nada conviene aclarar algo que genera mucha confusión:

• Arranque del sistema: ocurre cuando Linux inicia, incluso antes de que ningún usuario haga login.
• Inicio de sesión: ocurre cuando un usuario entra al sistema (terminal, entorno gráfico, SSH, etc.).

No es lo mismo ejecutar un script al arrancar el sistema que al iniciar sesión. En mi caso, por ejemplo, necesitaba que ciertos scripts se ejecutaran aunque nadie iniciara sesión, como montar unidades o aplicar reglas de red.

Casos reales donde tiene sentido automatizar

Algunos escenarios muy habituales:

• Montar discos o volúmenes automáticamente
• Ejecutar chequeos de integridad o estado
• Aplicar reglas de firewall o NAT
• Lanzar demonios o servicios auxiliares
• Generar logs desde el arranque

Si alguna vez has tenido que repetir el mismo comando tras cada reinicio, probablemente debería ejecutarse automáticamente.

El archivo rc.local: el método clásico que aún sigue siendo útil

Existen muchas maneras de ejecutar comandos del terminal al iniciar sesión en nuestro Linux, una de ellas es mediante el archivo rc.local el cual se encuentra ubicado en: /etc/rc.local.

Por defecto fedora no incluye este archivo; aunque el mismo puede ser creado y será tomado por el SO sin ningún inconveniente.

Qué es /etc/rc.local y cómo funciona

En sistemas tradicionales basados en System V, el archivo /etc/rc.local era un script que se ejecutaba al final del proceso de arranque. Ahí se colocaban comandos que debían ejecutarse automáticamente.

El archivo es de texto plano y puede ser abierto por programas para tal fin como Nano, Vim o Gedit; al abrir el archivo veremos el siguiente contenido:

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
exit 0

Si quisiéramos correr un script sh llamado script.sh al momento de que inicia Linux agregamos:

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
sh <ruta>/script.sh
exit 0

En donde <ruta> es la ruta de nuestro archivo.

Y esto es todo, al iniciar nuestro sistema conseguiremos que el archivo especificado anteriormente se ejecute.

Compatibilidad con systemd (rc-local.service)

Aunque systemd no tiene un equivalente directo, mantiene compatibilidad mediante rc-local.service.

Cuando arrancas un sistema con systemd, se comprueba que:

1. Exista /etc/rc.local
2. Sea ejecutable

Si se cumplen ambas condiciones, systemd genera automáticamente la unidad rc-local.service y ejecuta el script al alcanzar network.target.

Esto lo he usado, por ejemplo, en Fedora (donde el archivo no existe por defecto) creando manualmente /etc/rc.local sin ningún problema.

Ejemplo práctico: ejecutar un script al iniciar Linux

Supongamos que queremos ejecutar un script script.sh al arrancar:

#!/bin/sh -e
sh /ruta/script.sh
exit 0

No olvides hacerlo ejecutable:

chmod +x /etc/rc.local

Este método es ideal para scripts simples, rápidos y sin dependencias complejas.

Ventajas y limitaciones reales de rc.local hoy

Ventajas

• Simple y rápido
• Ideal para tareas puntuales
• Se ejecuta como root

Limitaciones

• Es un método de compatibilidad, no recomendado para servicios
• Poco control del orden de ejecución
• Difícil de depurar

Ejecutar scripts al inicio usando cron (@reboot)

Otra opción muy útil es usar cron con la directiva @reboot.

Cómo funciona la directiva @reboot

Cron permite ejecutar comandos automáticamente cuando el demonio cron se inicia, usando:

@reboot /ruta/script.sh

Esto se configura editando el crontab:

crontab -e

Ejecutar comandos como usuario vs como root

Los comandos en cron se ejecutan con un entorno mínimo.

• Si usas crontab -e, se ejecutan como tu usuario
• Si usas sudo crontab -e, se ejecutan como root

Para scripts críticos del sistema, lo normal es usar el crontab de root.

Cuándo usar cron y cuándo evitarlo

Úsalo si:

• El script es sencillo
• No depende del orden de arranque
• No necesita servicios específicos activos

Evítalo si:

• Necesitas controlar dependencias
• El script debe ejecutarse tras otro servicio
• Quieres gestión avanzada del servicio

Ejecutar comandos al iniciar Linux con systemd (método recomendado)

Si hablamos de distribuciones modernas, systemd es la mejor opción.

Por qué systemd es la mejor opción hoy

systemd permite:

• Controlar el orden de ejecución
• Definir dependencias
• Reiniciar servicios automáticamente
• Ver logs con journalctl

Cuando necesito algo robusto y mantenible, siempre termino usando systemd.

Crear un servicio systemd paso a paso

Primero, crea tu script:

#!/bin/bash
pgrep dunst || setsid -f dunst

Hazlo ejecutable:

chmod +x /root/startup.sh

Luego crea el servicio:

sudo nano /etc/systemd/system/startup.service

Contenido:

[Unit]
Description=Startup Script
[Service]
ExecStart=/root/startup.sh
[Install]
WantedBy=multi-user.target

Actívalo:

systemctl enable startup.service --now

Control del orden de arranque y dependencias

Aquí está la gran ventaja: puedes usar After=, Requires= o network.target para asegurarte de que todo ocurra en el momento correcto.

Ventajas frente a rc.local y cron

• Más control
• Mejor depuración
• Recomendado oficialmente
• Escala mejor

Problemas comunes al ejecutar scripts al iniciar Linux

El script no se ejecuta

• Falta de permisos
• Ruta incorrecta
• Variables de entorno inexistentes

Entorno interactivo vs arranque

El entorno al arrancar no es el mismo que una terminal interactiva. Evita rutas relativas y define todo explícitamente.

Errores silenciosos y cómo depurarlos

• Usa logs
• Redirige salida a archivos
• Con systemd, revisa journalctl -u servicio

Qué método elegir para ejecutar scripts al iniciar Linux

Comparativa:

• Método    Simplicidad    Control    Recomendado
• rc.local    Alta    Bajo    Casos simples
• cron    Media    Bajo    Scripts puntuales
• systemd    Media    Alto    Producción

Recomendaciones prácticas

• Script simple → rc.local
• Tarea de usuario → cron @reboot
• Servicio serio → systemd

Preguntas frecuentes sobre scripts de inicio en Linux

• ¿Sigue funcionando rc.local?
  • Sí, gracias a systemd, pero solo como compatibilidad.
• ¿Cuál es la mejor forma hoy?
  • systemd, salvo que el caso sea trivial.
• ¿Puedo ejecutar comandos como root?
  • Sí, usando rc.local, cron de root o servicios systemd.
• ¿Y al iniciar sesión?
  • Para eso existen .bash_profile, .bashrc o scripts de sesión gráfica.

Conclusión

Ejecutar comandos o scripts al iniciar Linux sigue siendo una tarea común y totalmente válida. Aunque hoy el estándar es systemd, métodos como rc.local o cron siguen teniendo su lugar si sabes cuándo usarlos.

En mi experiencia, la clave no es el método, sino elegir el adecuado según el contexto. Con eso en mente, evitarás errores, ganarás tiempo y tendrás sistemas mucho más limpios y automatizados.