Como executar um script de shell na inicialização

Em uma instância do Amazon S3 Linux, tenho dois scripts chamados start_my_appe stop_my_appque iniciam e param para sempre (que, por sua vez, executa meu aplicativo Node.js.). Eu uso esses scripts para iniciar e parar manualmente meu aplicativo Node.js. Por enquanto, tudo bem.

Meu problema: também quero configurá-lo para que start_my_appseja executado sempre que o sistema inicializar. Sei que preciso adicionar um arquivo init.de sei como vinculá-lo ao diretório apropriado rc.d, mas não consigo descobrir o que realmente precisa ser inserido no arquivo em que coloco init.d. Estou pensando que deveria ser apenas uma linha, tipo start_my_app, mas que não tem funcionado para mim.

No arquivo que você colocou, /etc/init.d/você deve configurá-lo como executável:

chmod +x /etc/init.d/start_my_app

Graças a @meetamit, se isso não funcionar, você deverá criar um link simbólico para /etc/rc.d/

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

Observe que no Debian mais recente, isso não funcionará, pois seu script deve ser compatível com LSB (forneça, pelo menos, as seguintes ações: iniciar, parar, reiniciar, forçar recarregar e status): https: //wiki.debian .org / LSBInitScripts

Como uma observação, você deve colocar o caminho absoluto do seu script em vez de um relativo, pois ele resolve problemas inesperados:

/var/myscripts/start_my_app

E não se esqueça de adicionar em cima desse arquivo:

#!/bin/sh

Defina um crontab para isso

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

após cada inicialização, ele executa o script de teste.

Uma abordagem simples é adicionar uma linha em /etc/rc.local:

/PATH/TO/MY_APP &

ou se você deseja executar o comando como um usuário especial:

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

(o e comercial final embasa o processo e permite que o rc.local continue executando)

Se você deseja um script init completo, a distribuição debian tem um arquivo de modelo, então:

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

e adapte um pouco.

É assim que eu faço no Red Hat Linux sistemas .

Coloque seu script /etc/init.d, de propriedade de raiz e executável. Na parte superior do script, você pode fornecer uma diretiva parachkconfig . Exemplo, o script a seguir é usado para iniciar um aplicativo Java como usuário oracle.

O nome do script é /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

Isso indica que o script deve ser executado nos níveis 3, 4 e 5, e a prioridade para iniciar / parar é 99 e 10.

Em seguida, como usuário, rootvocê pode usar chkconfigpara ativar ou desativar o script na inicialização:

chkconfig --list apex
chkconfig --add apex

E você pode usar service start/stop apex.

Entre cronusando sudo:

sudo crontab -e

Adicione um comando para executar na inicialização, neste caso, um script:

@reboot sh /home/user/test.sh

Salve :

Pressione ESC então: x para salvar e sair ou pressione ESC e ZZ (que é shift + zz)

Teste Teste Teste :

1. Execute seu script de teste sem cron para garantir que ele realmente funcione.

2. Certifique-se de salvar seu comando no cron, use sudo crontab -e

3. Reinicie o servidor para confirmar que tudo funciona sudo @reboot

Basta adicionar uma linha ao seu crontab.

Verifique se o arquivo é executável:

chmod +x /path_to_you_file/your_file

Para editar o arquivo crontab:

crontab -e

Linha que você precisa adicionar:

@reboot  /path_to_you_file/your_file

Que simples!

Outra opção é ter um comando @reboot no seu crontab.

Nem todas as versões do cron suportam isso, mas se sua instância for baseada na Amazon Linux AMI, ela funcionará.

Você consegue :

chmod +x PATH_TO_YOUR_SCRIPT/start_my_app 

então use este comando

update-rc.d start_my_app defaults 100

Por favor, veja esta página na Cyberciti .

Crie seu próprio / init executável

Não é isso que você quer, mas é divertido!

Basta escolher um arquivo executável arbitrário, mesmo um script de shell , e inicializar o kernel com o parâmetro de linha de comando:

init=/path/to/myinit

No final da inicialização, o kernel do Linux executa o primeiro espaço de usuário executável no caminho especificado.

Vários projetos fornecem serviços populares init executáveis usados ​​pelas principais distribuições, por exemplo, systemd, e na maioria das distribuições o init bifurca um monte de processos usados ​​na operação normal do sistema.

Mas podemos sequestrar /init lo para executar nossos próprios scripts mínimos para entender melhor nosso sistema.

Aqui está uma configuração mínima reproduzível: https://github.com/cirosantilli/linux-kernel-module-cheat/tree/f96d4d55c9caa7c0862991025e1291c48c33e3d9/README.md#custom-init

Essa solução simples funcionou para mim em uma instância do Amazon Linux executando o CentOS. Edite seu /etc/rc.d/rc.localarquivo e coloque o comando lá. É mencionado neste arquivo que será executado após todos os outros scripts de inicialização. Portanto, tenha cuidado a esse respeito. É assim que o arquivo está para mim atualmente. . Última linha é o nome do meu script.

O método mais fácil absoluto, se tudo o que você deseja executar é um script simples (ou qualquer outra coisa), é se você tiver uma interface gráfica para usar as preferências do sistema e os aplicativos de inicialização.

basta procurar o script que você deseja e pronto. (torne o script executável)

Para o Debian 9, consulte /ubuntu/228304/how-do-i-run-a-script-at-start-up . Isso me ajudou. Versão curta para o Debian 9: adicione comandos (como root) ao /etc/rc.local

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

Provavelmente, /path_to_file/filename.sh deve ser executável (acho que sim).

No Lubuntu, tive que lidar com a situação oposta. O Skype começa a funcionar após a inicialização e eu encontrei no ~/.config/autostart/arquivo skypeforlinux.desktop. O conteúdo do arquivo é o seguinte:

[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

A exclusão deste arquivo me ajudou.

• Adicione seu script ao diretório /etc/init.d/
• Atualize seus níveis de execução rc: em $ update-rc.d myScript.sh defaults NNque NN é a ordem em que deve ser executado. 99, por exemplo, significa que seria executado após 98 e antes de 100.

Trabalhando com microsserviços ou shell do Python 3; usando o Ubuntu Server 18.04 (Bionic Beaver) ou Ubuntu 19.10 (Eoan Ermine) ou Ubuntu 18.10 (Cosmic Cuttlefish), eu sempre gosto dessas etapas e funcionou sempre :

1. Criando um microsserviço chamado p exemplo "brain_microservice1.service" no meu caso:

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

2. Dentro deste novo serviço em que você está:

   [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. Dê as permissões:

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

4. Conceda a permissão de execução:

   $ systemctl daemon-reload

5. Habilite então, isso fará com que sempre inicie na inicialização

   $ systemctl enable brain_microservice1.service

6. Então você pode testá-lo;

   $ sudo reinicie agora

7. Concluir = SUCESSO !!

Isso pode ser feito com o mesmo script do corpo para executar o shell, reagir ... script de inicialização do banco de dados ... qualquer tipo de código OS ... espero que isso ajude ...

...

Eu me referi a este blog, sempre soa uma boa escolha

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

Aqui está um método mais simples!

Primeiro: escreva um shell script e salve-o como .sh, aqui está um exemplo

#!/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";

esse script desativará o teclado interno na inicialização.

Segundo: abra o aplicativo "Preferências do aplicativo de inicialização"

insira a descrição da imagem aqui

insira a descrição da imagem aqui

Terceiro: clique em Adicionar. quarto: na seção NAME, dê um nome. quinto: Na seção de comando, navegue até o seu .sh. sexta: edite sua seção de comando para:

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

sétimo: clique em Adicionar. É isso aí! Acabado!

Agora confirme reiniciando o seu PC.

Felicidades!

O método indolor, mais fácil e mais universal é simplesmente executá-lo com ~.bash_profileou ~.profile (se você não tiver o arquivo bash_profile) .

Basta adicionar o comando de execução na parte inferior desse arquivo e ele será executado quando o sistema for iniciado.

Eu tenho este na parte inferior um exemplo; ~\Desktop\sound_fixer.sh

Para algumas pessoas, isso funcionará:

Você pode simplesmente adicionar o seguinte comando em Sistema → Preferências → Aplicativos de Inicialização :

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