Come eseguire uno script di shell all'avvio

Su un'istanza di Amazon S3 Linux, ho due script chiamati start_my_appe stop_my_appche si avviano e si fermano per sempre (che a sua volta esegue la mia applicazione Node.js). Uso questi script per avviare e arrestare manualmente la mia applicazione Node.js. Fin qui tutto bene.

Il mio problema: voglio anche configurarlo in modo che start_my_appvenga eseguito ogni volta che il sistema si avvia. So che devo aggiungere un file all'interno init.de so come collegarlo alla directory corretta all'interno rc.d, ma non riesco a capire cosa debba effettivamente andare all'interno del file che inserisco init.d. Sto pensando che dovrebbe essere solo una linea, tipo start_my_app, ma non ha funzionato per me.

Nel file che hai inserito /etc/init.d/devi impostarlo come eseguibile con:

chmod +x /etc/init.d/start_my_app

Grazie a @meetamit, se questo non funziona devi creare un link simbolico a /etc/rc.d/

ln -s /etc/init.d/start_my_app /etc/rc.d/

Nota che l'ultima versione di Debian non funzionerà poiché lo script deve essere conforme a LSB (fornire almeno le seguenti azioni: avvio, arresto, riavvio, ricarica forzata e stato): https: //wiki.debian .org / LSBInitScripts

Come nota, dovresti inserire il percorso assoluto del tuo script anziché uno relativo, potrebbe risolvere problemi imprevisti:

/var/myscripts/start_my_app

E non dimenticare di aggiungere sopra quel file:

#!/bin/sh

Imposta un crontab per questo

#crontab -e
@reboot  /home/user/test.sh

dopo ogni avvio eseguirà lo script di test.

Un approccio semplice è quello di aggiungere una riga in /etc/rc.local:

/PATH/TO/MY_APP &

o se si desidera eseguire il comando come utente speciale:

su - USER_FOOBAR -c /PATH/TO/MY_APP &

(la e commerciale finale fa da sfondo al processo e consente a rc.local di continuare l'esecuzione)

Se vuoi uno script init completo, la distro debian ha un file modello, quindi:

cp /etc/init.d/skeleton /etc/init.d/your_app

e adattalo un po '.

Questo è il modo in cui lo faccio su Red Hat Linux sistemi .

Inserisci il tuo script /etc/init.d, di proprietà di root ed eseguibile. Nella parte superiore dello script, puoi dare una direttiva perchkconfig . Esempio, il seguente script viene utilizzato per avviare un'applicazione Java come oracolo utente.

Il nome della sceneggiatura è /etc/init.d/apex

#!/bin/bash
# chkconfig: 345 99 10
# Description: auto start apex listener
#
case "$1" in
 'start')
   su - oracle -c "cd /opt/apex ; java -jar apex.war > logs/apex.log 2>logs/apex_error.log &";;
 'stop')
   echo "put something to shutdown or kill the process here";;
esac

Questo dice che lo script deve essere eseguito ai livelli 3, 4 e 5 e la priorità per start / stop è 99 e 10.

Quindi, come utente rootè possibile utilizzare chkconfigper abilitare o disabilitare lo script all'avvio:

chkconfig --list apex
chkconfig --add apex

E puoi usare service start/stop apex.

Accedi cronusando sudo:

sudo crontab -e

Aggiungi un comando da eseguire all'avvio, in questo caso uno script:

@reboot sh /home/user/test.sh

Salva:

Premi ESC quindi: x per salvare ed uscire, oppure premi ESC quindi ZZ (ovvero maiusc + zz)

Test Test Test :

1. Esegui lo script di test senza cron per assicurarti che funzioni davvero.

2. Assicurati di aver salvato il tuo comando in cron, usa sudo crontab -e

3. Riavvia il server per confermare che tutto funzioni sudo @reboot

Basta aggiungere una riga al tuo crontab ..

Assicurarsi che il file sia eseguibile:

chmod +x /path_to_you_file/your_file

Per modificare il file crontab:

crontab -e

Riga che devi aggiungere:

@reboot  /path_to_you_file/your_file

Così semplice!

Un'altra opzione è avere un comando @reboot nel tuo crontab.

Non tutte le versioni di cron supportano questo, ma se la tua istanza è basata sull'AMI Amazon Linux, allora funzionerà.

Puoi farlo :

chmod +x PATH_TO_YOUR_SCRIPT/start_my_app 

quindi utilizzare questo comando

update-rc.d start_my_app defaults 100

Si prega di consultare questa pagina su Cyberciti .

Crea il tuo eseguibile / init

Questo non è quello che vuoi, ma è divertente!

Basta scegliere un file eseguibile arbitrario, anche uno script di shell , e avviare il kernel con il parametro della riga di comando:

init=/path/to/myinit

Verso la fine dell'avvio, il kernel di Linux esegue il primo eseguibile di spazio utente nel percorso indicato.

Diversi progetti forniscono popolare init eseguibili utilizzati dalle principali distribuzioni, ad esempio systemd, e nella maggior parte delle distribuzioni init eseguirà una serie di processi utilizzati nel normale funzionamento del sistema.

Ma possiamo dirottarlo /initper eseguire i nostri script minimi per comprendere meglio il nostro sistema.

Ecco un'impostazione riproducibile minima: https://github.com/cirosantilli/linux-kernel-module-cheat/tree/f96d4d55c9caa7c0862991025e1291c48c33e3d9/README.md#custom-init

Questa semplice soluzione ha funzionato per me su un'istanza di Amazon Linux con CentOS. Modifica il tuo /etc/rc.d/rc.localfile e inserisci il comando lì. In questo file viene menzionato che verrà eseguito dopo tutti gli altri script init. Quindi stai attento a questo proposito. Ecco come il file mi cerca attualmente. . L'ultima riga è il nome della mia sceneggiatura.

Il metodo più semplice in assoluto se tutto ciò che vuoi eseguire è uno script semplice (o qualsiasi altra cosa) è se hai una GUI per usare le preferenze di sistema> quindi le app di avvio.

basta cercare lo script desiderato e il gioco è fatto. (rendere eseguibile lo script)

Per Debian 9 consultare /ubuntu/228304/how-do-i-run-a-script-at-start-up . Mi ha aiutato Versione breve per Debian 9: aggiungi comandi (come root) a /etc/rc.local

/path_to_file/filename.sh ||  exit 1   # Added by me
exit 0

Probabilmente, /path_to_file/filename.sh dovrebbe essere eseguibile (penso di sì).

In Lubuntu ho dovuto affrontare la situazione opposta. Skype inizia a funzionare dopo l'avvio e l'ho trovato nel ~/.config/autostart/file skypeforlinux.desktop. Il contenuto del file è il seguente:

[Desktop Entry]
Name=Skype for Linux
Comment=Skype Internet Telephony
Exec=/usr/bin/skypeforlinux
Icon=skypeforlinux
Terminal=false
Type=Application
StartupNotify=false
X-GNOME-Autostart-enabled=true

L'eliminazione di questo file mi ha aiutato.

• Aggiungi il tuo script alla directory /etc/init.d/
• Aggiorna i tuoi livelli di esecuzione rc: $ update-rc.d myScript.sh defaults NNdove NN è l'ordine in cui dovrebbe essere eseguito. 99 per esempio significa che verrebbe eseguito dopo 98 e prima di 100.

Lavorare con microservizi o shell Python 3; usando Ubuntu Server 18.04 (Bionic Beaver) o Ubuntu 19.10 (Eoan Ermine) o Ubuntu 18.10 (Cosmic Cuttlefish) mi piacciono sempre questi passaggi e ha funzionato sempre :

1. Creare un microservizio chiamato p esempio "brain_microservice1.service" nel mio caso:

   $ nano /lib/systemd/system/brain_microservice1.service

2. All'interno di questo nuovo servizio in cui ti trovi:

   [Unit]
   Description=brain_microservice_1
   After=multi-user.target
   
   [Service]
   Type=simple
   ExecStart=/usr/bin/python3.7 /root/scriptsPython/RUN_SERVICES/microservices    /microservice_1.py -k start -DFOREGROUND
   ExecStop=/usr/bin/python3.7 /root/scriptsPython/RUN_SERVICES/microservices/microservice_1.py -k graceful-stop
   ExecReload=/usr/bin/python3.7 /root/scriptsPython/RUN_SERVICES/microservices/microservice_1.py -k graceful
   PrivateTmp=true
   LimitNOFILE=infinity
   KillMode=mixed
   Restart=on-failure
   RestartSec=5s
   
   [Install]
   WantedBy=multi-user.target

3. Dare le autorizzazioni:

   $ chmod -X /lib/systemd/system/brain_microservice*
   $ chmod -R 775 /lib/systemd/system/brain_microservice*

4. Dare il permesso di esecuzione quindi:

   $ systemctl daemon-reload

5. Abilita quindi, questo farà quindi iniziare sempre all'avvio

   $ systemctl enable brain_microservice1.service

6. Quindi puoi provarlo;

   $ sudo riavvia ora

7. Finitura = SUCCESSO !!

Questo può essere fatto con lo stesso script body per eseguire shell, reagire ... script di avvio del database ... qualsiasi tipo di codice os ... spero che questo ti aiuti ...

...

Mi sono riferito a questo blog, sembra sempre una buona scelta

https://blog.xyzio.com/2016/06/14/setting-up-a-golang-website-to-autorun-on-ubuntu-using-systemd/

vim /lib/systemd/system/gosite.service

Description=A simple go website
ConditionPathExists=/home/user/bin/gosite

[Service]
Restart=always
RestartSec=3
ExecStart=/home/user/bin/gosite

[Install]
WantedBy=multi-user.target

systemctl enable gosite.service

Ecco un metodo più semplice!

Primo: scrivere uno script di shell e salvarlo in .sh ecco un esempio

#!/bin/bash
Icoff='/home/akbar/keyboardONOFF/icon/Dt6hQ.png'
id=13
fconfig=".keyboard"
echo "disabled" > $fconfig
xinput float $id
notify-send -i $Icoff "Internal Keyboard disabled";

questo script disabiliterà la tastiera interna all'avvio.

Secondo: Aprire l'applicazione "Preferenze dell'applicazione di avvio"

inserisci qui la descrizione dell'immagine

inserisci qui la descrizione dell'immagine

Terzo: fai clic su Aggiungi. quarto: nella sezione NOME dare un nome. quinto: nella sezione comandi vai al tuo .sh. sesto: modifica la sezione comandi in:

bash <space> path/to/file/<filename>.sh <space> --start

settimo: fare clic su Aggiungi. Questo è tutto! Finito!

Ora conferma riavviando il PC.

Saluti!

Il metodo indolore, più semplice e universale è semplicemente eseguirlo con ~.bash_profileo ~.profile (se non si dispone del file bash_profile) .

Basta aggiungere il comando di esecuzione nella parte inferiore di quel file e verrà eseguito all'avvio del sistema.

Ho questo in fondo un esempio; ~\Desktop\sound_fixer.sh

Per alcune persone, questo funzionerà:

Puoi semplicemente aggiungere il seguente comando in Sistema → Preferenze → Applicazioni di avvio :

bash /full/path/to/your/script.sh