¿Cómo Iniciar Automáticamente un Programa en Raspberry Pi?

Es posible que tu quieras lanzar un script o programa al iniciar, pero no ves una opción para ello en Raspberry Pi OS. Es una pregunta que escucho a menudo, y los métodos no son muy intuitivos. En esta publicación, te mostraré varias formas de lograrlo.

En Raspberry Pi OS, la solución más fácil para iniciar automáticamente un programa al iniciar es usar el crontab con el evento @reboot. También hay otros métodos usando los sistemas de inicio de Linux.

Así que sí, es posible, pero necesitarás optar por la solución que se adapte mejor a tus necesidades. Puedes elegir seguir las “best practices” o simplemente recordar la solución más simple (esa es a menudo mi favorita). ¡Vamos a esto!

Métodos para Ejecutar un Programa en el Inicio

En esta primera parte, iré directamente al punto principal: cómo iniciar cualquier script o programa al iniciar.
Para el ejemplo, usaré mi script de prueba que está en la carpeta Desktop, así que /home/pat/Desktop/test.sh.

Necesitarás cambiar esta línea al script o programa que quieras ejecutar. Si no tienes idea de qué comando necesitas introducir, lee la segunda parte de esta guía :).

1 – Usar Crontab

Cron es un servicio que se inicia automáticamente al arrancar y permite al usuario ejecutar tareas programadas. Un crontab es un archivo que nos permitirá listar qué queremos ejecutar y cuándo iniciarlo, en un formato comprensible por el servicio cron.

El crontab tiene muchas configuraciones para iniciar un script a una hora o programa específicos (diariamente, semanalmente, 3 veces al mes, etc.). Escribí otro post sobre programación de tareas que puedes consultar para aprender más.

El crontab también nos da la opción de iniciar un programa al arrancar, con la opción @reboot.
Esta es nuestra primera solución para iniciar un programa automáticamente, y probablemente sea la más fácil de recordar de esta lista.

Aquí te comparto cómo iniciar un programa al arrancar con crontab:

• Abrir una terminal.
• Abrir el archivo crontab:
  crontab -e
  Si es tu primera vez en el crontab, necesitas seleccionar un editor (presiona Enter para nano).
  
• Comenzarás con un archivo de crontab vacío que se ve así:
  
• Agregat una línea comenzando con @reboot, seguida de tu comando de script, así:
  @reboot /home/pat/Desktop/test.sh
• Guardar y salir (CTRL+O, CTRL+X con nano).
  (Si eres nuevo en esto, tengo una guía que te muestra los comandos y atajos más importantes en Nano.)

Tu comando ahora está programado para ejecutarse en cada arranque.

2 – Colocar tu script en /etc/init.d

La segunda solución que puedes usar es colocar tu script en el directorio /etc/init.d.

Generalmente prefiero este método para algo como un servicio (como para mi script de firewall, como se explica aquí). Como te mencioné anteriormente, no es la mejor práctica si quieres respetar las directrices de Linux, pero funciona :).

Sin embargo, todavía hay un formato a seguir para que funcione correctamente al arrancar.
Aqui te muestro como se hace:

• Crear un nuevo archivo en /etc/init.d:
  sudo nano /etc/init.d/myservice
  Cambiar el nombre del archivo para hacerlo explícito.
• Pegar estas líneas (por ejemplo):

#!/bin/bash
### BEGIN INIT INFO
# Provides: MyService
# Required-Start:    $all
# Required-Stop: 
# Default-Start:     5 
# Default-Stop:      6 
# Short-Description: Your service description
### END INIT INFO

touch /home/pat/myservice_test

• Los comentarios al principio son obligatorios para que se inicie al arrancar (runlevel 5).
  Cambiar el nombre del servicio y la descripción para explicar lo que debe hacer tu script.
• Guardar & salir (CTRL+X).
• Agregar permiso de ejecución a tu script:
  sudo chmod +x /etc/init.d/myservice
• Finalmente, decirle al sistema que lo inicie al arrancar usando este comando:
  sudo update-rc.d myservice defaults

Eso es lo mínimo para que funcione. El objetivo aquí es simplemente ejecutar un script al iniciar. Reinicia para probar. Si todo es correcto, tu script debería ejecutarse una vez cada vez que inicias tu Raspberry Pi.

Si quieres configurar esto de manera más adecuada, puedes agregar opciones de inicio, detención y reinicio a tu servicio. Puedes encontrar una documentación detallada aquí si eso es lo que quieres hacer.

3 – Crear un Servicio Systemd

La tercera opción es crear un servicio systemd.

Algunos podrían considerar esto como la forma más adecuada. Te permite controlar tu programa usando el comando ‘systemctl’, como lo harías con otros servicios como VNC, Nginx (en inglés), o cloudflared (en inglés). Sin embargo, este tiene un formato específico que necesitas seguir a continuación.

Aquí tienes cómo crear un servicio systemd que se ejecute al iniciar:

• Crear un archivo en /lib/systemd/system:
  sudo nano /lib/systemd/system/mytest.service
• Pegar las siguientes líneas:

[Unit]
Description=MyService
After=multi-user.target

[Service]
Type=idle
ExecStart=/home/pat/Desktop/test.sh

[Install]
WantedBy=multi-user.target

• Cambiar ExecStart al camino completo a tu comando, y Description para recordar qué es.
• Guardar y salir (CTRL+X).
• Modificar los permisos del archivo del servicio para que coincidan con otros servicios del sistema:
  sudo chmod 644 /lib/systemd/system/mytest.service
• Finalmente, decirle a systemd que lo ejecute al inicio:
  sudo systemctl enable mytest.service
  
  

¡Eso es todo! Cuando reinicies, tu programa debería ejecutarse después de que todos los servicios clave del sistema hayan iniciado.

4 – Agregar una Línea a /etc/rc.local

Finalmente, el método rc.local es probablemente el más fácil ya que sólo necesitas recordar el nombre del archivo para saber qué hacer :).

El archivo rc.local es un script destinado para el administrador del sistema (¡tú!).
Al arrancar, es una de las últimas cosas que se ejecutan (al final del nivel de ejecución multiusuario).
Así que, es exactamente lo que necesitas para ejecutar un servicio personalizado.

Aquí tienes cómo usarlo:

• Abrir el archivo rc.local:
  sudo nano /etc/rc.local
• Insertar script o servicio justo antes de la línea “exit 0”
  Algo como esto:
  
• No olvidar el símbolo de ampersand (&) al final, o ¡podría no funcionar!
• Guardar y salir (CTRL+X).

Ya terminaste—no hay nada más que hacer. Puedes reiniciar ahora para probarlo si quieres.

Encontrar el Comando para Iniciar Automáticamente

Antes de intentar iniciar un programa automáticamente al arrancar, puede que necesites ayuda para saber exactamente qué ejecutar.

Por desgracia, Raspberry Pi OS no incluye una herramienta para iniciar aplicaciones al arrancar, así que tendrás que encontrar el comando que lanza el programa. En esta sección, te mostraré tres formas de encontrarlo.

Proveer la Ruta de tu Script

Si tu objetivo es ejecutar un script al arrancar, el comando es fácil de encontrar: es la ruta al script.

Por ejemplo, digamos que creaste un script que reside en /usr/local/bin con el nombre start_script.sh.

Para que se ejecute al arrancar, asegúrate de que tu script sea ejecutable. Puedes añadir el permiso con:
chmod +x /usr/local/bin/start_script.sh

Ahora puedes introducir este comando en una de las soluciones anteriores para que se ejecute al arrancar:
/usr/local/bin/start_script.sh

Encontrar el Ejecutable

Una segunda opción es ejecutar un comando ejecutable al iniciar. Esta es una solución fácil si sabes exactamente lo que quieres hacer. La única dificultad que puedes encontrar implica la ruta.

Cada comando (htop, nano, mail, etc.) se instala en una ubicación específica en tu sistema (/usr/local/bin, /usr/bin, etc.). La mayoría de los comandos del sistema se ejecutarán correctamente al iniciar incluso si no especificas una ruta.

Pero para algunos programas, como proyectos de GitHub menos conocidos o cosas así (estoy pensando en Log2Ram, en inglés, por ejemplo), este no es el caso. En su lugar, tienes que proporcionar la ruta completa.

Si no tienes idea de dónde está la ubicación del ejecutable, aquí hay algunos consejos.

Puedes usar el comando “which” para encontrarlo:
which <COMMAND>

Aquí tienes un ejemplo:

Ahora que has encontrado la ruta, puedes ingresar “/usr/bin/php” en tu archivo de autoarranque.

Si “which” no funcionó, el comando “find” puede ser útil para encontrar un programa:
sudo find / -iname php

Si necesitas más detalles sobre esto, probablemente deberías leer mi otro artículo aquí: 3 Commands to Search For a File on Raspberry Pi (and find it!) (en inglés)

Ver el Acceso Directo del Menú

Mi último método funciona para programas gráficos que ejecutas directamente desde el menú principal de Raspberry Pi OS. Dado que no puedes ver la ubicación del acceso directo, es difícil encontrar el archivo ejecutable.

Pero hay una manera fácil de localizarlo:

• En el Menú Principal, Ir a Preferences > Main Menu Editor.
• Seleccionar la aplicación que deseas iniciar.
  Están ordenadas de la misma manera que en el menú principal, así que navega por las categorías principales si es necesario.
• Luego hacer clic en “Properties” a la derecha.
• Aparece una ventana con las propiedades del iniciador.
  
  En el campo Command, puedes ver el comando exacto utilizado cuando haces clic en él en el menú principal.

Ahora tienes todo lo que necesitas para aplicar una de las cuatro soluciones que discutimos anteriormente.
Si necesitas la ubicación del path, revisa mi consejo anterior con el comando which.

Conclusión

Eso es todo—ahora sabes cuatro formas de iniciar automáticamente un programa al arrancar. Elige tu solución preferida dependiendo de cuál sea tu programa, o tal vez solo elige el método que recuerdes más fácilmente.

Si conoces otros métodos, más fáciles o no, me gustaría saber sobre ellos. Por favor, deja un mensaje en la comunidad.

¡Ahora estás listo para crear tus propios scripts y programarlos para que se ejecuten al arrancar! Si necesitas más ayuda en el lado de la programación, tengo algunos artículos esperando por ti:

• Los 7 Mejores Editores de Texto para Programar en Raspberry Pi (en inglés)
• ¿Deberías aprender Linux o Python primero? (en inglés)
• 15 Proyectos divertidos de Raspberry Pi para experimentar con Python (en inglés)