Como posso executar scripts automaticamente quando o Ubuntu é iniciado, para que eu não precise executá-los manualmente após a inicialização?

Dependendo do tipo de script que você precisa executar. Para serviços e afins, você deve usar o upstart . Mas para um script de usuário, eles devem ser lançados como scripts de sessão pelo gnome! Dê uma olhada em Sistema> Preferências> Aplicativos de Inicialização.

Além disso, se você precisar que alguns scripts sejam executados no logon do terminal, poderá adicioná-los ao arquivo .bash_login no diretório inicial.

Para 14.04 e mais velhos

Um comando simples (que não precisa permanecer em execução) pode usar um trabalho Upstart como:

start on startup
task
exec /path/to/command

Salve isso em um .confarquivo /etc/init(se você precisar executar como root quando o sistema inicializar) ou em ~/.config/upstart(se você precisar executar como seu usuário ao efetuar login).

Uma abordagem é adicionar uma tarefa cron do @reboot :

1. A execução crontab -epermitirá que você edite seu cron.

2. Adicionando uma linha como esta a ela:

   @reboot /path/to/script
   

   executará esse script assim que o computador for inicializado.

Que tal adicionar o comando /etc/rc.local? você terá que usar o acesso sudo para editar este arquivo.

sudo nano /etc/rc.local

Para 15.04 e posterior:

Para executar um comando (de curta duração) ¹ na inicialização systemd, você pode usar uma unidade do tipo systemd OneShot. Por exemplo, crie /etc/systemd/system/foo.servicecontendo:

[Unit]
Description=Job that runs your user script

[Service]
ExecStart=/some/command
Type=oneshot
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

Então corra:

sudo systemctl daemon-reload
sudo systemctl enable foo.service

Essencialmente, isso está apenas convertendo um trabalho Upstart típico em um systemd (consulte Systemd para usuários do Upstart ).

Você pode executar vários comandos no mesmo arquivo de serviço, usando várias ExecStartlinhas:

[Service]
ExecStart=/some/command
ExecStart=/another/command some args
ExecStart=-/a/third/command ignore failure

O comando sempre deve ser fornecido com o caminho completo. Se algum comando falhar, o restante não será executado. A -antes do caminho diz ao systemd para ignorar um status de saída diferente de zero (em vez de considerá-lo uma falha).

Relevante:

• Entrada do Arch Wiki no systemd
• man 5 systemd.service

Para sessões do usuário, você pode criar a unidade systemd ~/.config/systemd. Isso deve funcionar a partir do 16.04, mas não das versões anteriores do Ubuntu com systemd (já que elas ainda usavam o Upstart para sessões do usuário). As unidades de sessão do usuário podem ser controladas com os mesmos comandos dos serviços do sistema, mas com a --useropção adicionada:

systemctl --user daemon-reload
systemctl --user status foo.service

Sintaxe do shell

Observe que, ao contrário do Upstart, o systemd não executa os Exec*comandos através de um shell. Ele realiza alguma expansão limitada de variáveis ​​e vários comandos (separados por ;) em si, mas é isso que diz respeito à sintaxe do shell. Para algo mais complicado, como redirecionamento ou pipes, coloque seu comando em sh -c '...'ou bash -c '...'.

¹ Ao contrário de demônios de longa vida.

Existem diferentes maneiras de executar comandos automaticamente:

1. O novo-rico sistema executará todos os scripts a partir do qual ele encontra uma configuração no diretório /etc/init. Esses scripts serão executados durante a inicialização do sistema (ou em resposta a determinados eventos, por exemplo, uma solicitação de desligamento) e, portanto, são o local para executar comandos que não interagem com o usuário; todos os servidores são iniciados usando esse mecanismo.

   Você pode encontrar uma introdução legível em: http://upstart.ubuntu.com/getting-started.html nas páginas de manual man 5 inite man 8 initfornecendo todos os detalhes.

2. Um script de shell nomeado .gnomercem seu diretório pessoal é originado automaticamente sempre que você faz login em uma sessão do GNOME. Você pode colocar comandos arbitrários lá; As variáveis ​​de ambiente que você definir neste script serão vistas por qualquer programa executado em sua sessão.

   Observe que a sessão não inicia até que o .gnomercscript seja finalizado; portanto, se você deseja iniciar automaticamente algum programa de longa execução, é necessário anexar &à invocação do programa para desanexá-lo do shell em execução.

3. A opção de menu Sistema -> Preferências -> Aplicativos de inicialização permite definir quais aplicativos devem ser iniciados quando a sessão gráfica é iniciada (o Ubuntu pré-define alguns) e adicioná-los ou removê-los a seu gosto. Isso tem quase o mesmo objetivo e escopo do .gnomercscript, exceto que você não precisa conhecer a shsintaxe (mas também não pode usar nenhuma shconstrução de programação).

$HOME/.config/autostart

• Este local contém a lista de aplicativos de inicialização.
• .desktop arquivo pode ser colocado aqui, o qual será executado na inicialização.

Exemplo de exemplo para o .desktoparquivo:

Colocando o seguinte .desktoparquivo $HOME/.config/autostarte fornecido chmod +x:

[Desktop Entry]
Type=Application
Exec="</path/to/script>"
Hidden=false
NoDisplay=false
X-GNOME-Autostart-enabled=true
Name=Startup Script

Aqui "</path/to/script>"é substituído pelo caminho para o seu script.sh
(geralmente recomendado para /usr/local/binque possa ser executado pelo comando diretamente, diga myscriptsubstituído por "</path/to/script>").

Exemplo de exemplo de script.sh:

#!/bin/bash
<commands to be executed>
exit

Resultado: o .desktoparquivo será iniciado a partir do $HOME/.config/autostartqual executar o scriptExec=

Portanto, você pode executar o script de shell desejado na inicialização!

Para coisas simples, você pode adicionar um comando em Sistema-> Preferências-> Sessões, apontando para o local do seu script.

Como alternativa, você pode adicioná-lo ao /etc/init.d/rc.local ou fazer um trabalho inicial se for algo de nível mais baixo .

Dê uma olhada em https://help.ubuntu.com/community/UbuntuBootupHowto para obter mais informações

cron resposta implementada diferente do top votado

Essa resposta ainda usa, cronmas usa um método diferente do que a resposta votada principal. Isso funciona desde o Ubuntu 16.04, mas provavelmente é suportado muito mais cedo. Só que comecei a usar cronpara executar trabalhos quando o computador é inicializado desde 16.04.

Quando cronfunciona?

Nos comentários, alguém perguntou "quando eles correm?". Você pode dizer no syslog / journalctl:

$ journalctl -b | grep cron
Jan 02 16:54:40 alien cron[919]: (CRON) INFO (pidfile fd = 3)
Jan 02 16:54:40 alien cron[919]: (CRON) INFO (Running @reboot jobs)
Jan 02 16:54:40 alien systemd[1]: Started Run anacron jobs.
Jan 02 16:54:40 alien anacron[949]: Anacron 2.3 started on 2018-01-02
Jan 02 16:54:40 alien anacron[949]: Normal exit (0 jobs run)
Jan 02 16:54:40 alien CRON[952]: pam_unix(cron:session): session opened for user root by (uid=0)
Jan 02 16:54:40 alien CRON[954]: pam_unix(cron:session): session opened for user root by (uid=0)
Jan 02 16:54:40 alien CRON[951]: pam_unix(cron:session): session opened for user root by (uid=0)
Jan 02 16:54:40 alien CRON[950]: pam_unix(cron:session): session opened for user root by (uid=0)
Jan 02 16:54:40 alien CRON[985]: (root) CMD (   /usr/local/bin/cron-reboot-cycle-grub-background)
Jan 02 16:54:40 alien CRON[954]: pam_unix(cron:session): session closed for user root
Jan 02 16:54:40 alien cron[919]: sendmail: Cannot open smtp.gmail.com:587
Jan 02 16:54:40 alien CRON[952]: pam_unix(cron:session): session closed for user root
Jan 02 16:54:40 alien cron[919]: sendmail: Cannot open smtp.gmail.com:587
Jan 02 16:54:40 alien CRON[950]: pam_unix(cron:session): session closed for user root

Uma coisa a observar é cronque você pode enviar por e-mail o status dos trabalhos executados e os @reboottrabalhos executados para que o gerente de rede e o email iniciais não sejam executados, a menos que você insira um sleepcomando no (s) script (s).

Onde colocar seus scripts

Coloque seus scripts no diretório /etc/cron.d:

$ ll /etc/cron.d
total 44
drwxr-xr-x   2 root root  4096 Nov 26 19:53 ./
drwxr-xr-x 139 root root 12288 Dec 31 13:58 ../
-rw-r--r--   1 root root   244 Dec 28  2014 anacron
-rw-r--r--   1 root root   148 Feb 18  2017 cycle-grub-background
-rw-r--r--   1 root root   138 Mar  5  2017 display-auto-brightness
-rw-r--r--   1 root root   460 Nov 26 19:53 nvidia-hdmi-sound
-rw-r--r--   1 root root   102 Feb  9  2013 .placeholder
-rw-r--r--   1 root root   224 Nov 19  2016 touch-vmlinuz
-rw-r--r--   1 root root   700 Aug  5 11:15 turn-off-hyper-threading

Como é um script?

Aqui estão alguns scripts que eu configurei para executar cada inicialização:

$ cat /etc/cron.d/cycle-grub-background SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin 
@reboot   root    /usr/local/bin/cron-reboot-cycle-grub-background

$ cat /etc/cron.d/touch-vmlinuz
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
@reboot   root    touch "/boot/vmlinuz-"`uname -r`

Você deve usar o iniciante para isso. O Upstart é usado para processos do Ubuntu que são iniciados automaticamente. É uma solução aprimorada como os scripts init.d antigos do System-V. Também permite que você coloque pré-requisitos para o início do seu script (ou seja, você precisa da rede em execução? Etc.)