Uma abordagem é adicionar uma tarefa cron @reboot :

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

2. Adicionando uma linha assim:

   @reboot /path/to/script
   

   executará esse script assim que o computador inicializar.

Dependendo do tipo de script que você precisa executar.. Para serviços e similares, você deve usar 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.

Em uma nota lateral, se você precisar que alguns scripts sejam executados no login do terminal, você pode adicioná-los ao arquivo .bash_login em seu diretório inicial.

Para 14.04 e mais velhos

Um comando simples (um 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 em /etc/init(se você precisar que ele seja executado como root quando o sistema inicializar) ou em ~/.config/upstart(se você precisar que ele seja executado como seu usuário quando você efetuar login).

Você pode adicionar comandos a /etc/rc.local:

sudo nano /etc/rc.local

Isso executa os comandos como root.

Para executar comandos como um usuário específico, use sudo -i -u( -ipara também executar o shell de login). Por exemplo, para estabelecer um túnel SSH persistente, onde myhosté definido no arquivo johndoes ~/.ssh/config:

sudo -i -u johndoe autossh -nNT -L 1234:localhost:1234 myhost

Observe que, se /etc/rc.localnão existir (como é o caso do Ubuntu desde 16.04), você precisa adicionar uma linha shebang no topo (por exemplo #!/bin/bash, ), e garantir que o arquivo seja executável:

sudo chmod a+x /etc/rc.local

Para 15.04 e posteriores:

^{Para executar um comando 1} (de curta duração) na inicialização usando systemd, você pode usar uma unidade systemd do tipo 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 é apenas converter um trabalho típico do Upstart em um systemd (consulte Systemd para usuários do Upstart ).

Você pode executar vários comandos do 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 deve sempre ser dado com o caminho completo. Se algum comando falhar, o restante não será executado. Um -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 de usuário, você pode criar a unidade systemd em ~/.config/systemd/uservez disso. Isso deve funcionar com 16.04 em diante, mas não versões anteriores do Ubuntu com systemd (já que ainda usavam o Upstart para sessões de 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 por meio de um shell. Ele executa alguma expansão de variável limitada e comando múltiplo (separado por ;) em si, mas é isso no que diz respeito à sintaxe semelhante ao shell. Para algo mais complicado, como redirecionamento ou pipes, envolva seu comando em sh -c '...'ou bash -c '...'.

¹ Ao contrário de daemons de vida longa.

Existem diferentes maneiras de executar comandos automaticamente:

1. O sistema upstart executará todos os scripts dos quais encontrar 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 as páginas man man 5 inite man 8 initfornecer os detalhes completos.

2. Um script de shell nomeado .gnomercem seu diretório inicial é gerado automaticamente toda vez que você efetua 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 concluído; portanto, se você deseja iniciar automaticamente algum programa de longa duração, você precisa anexar &à invocação do programa, a fim de 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 sua sessão gráfica iniciar (o Ubuntu predefine alguns) e adicioná-los ou removê-los ao seu gosto. Isso tem quase o mesmo propósito e escopo do .gnomercscript, exceto que você não precisa saber shsintaxe (mas também não pode usar qualquer shconstrução de programação).

$HOME/.config/autostartcontém a lista de aplicativos de inicialização. .desktoparquivos nesta pasta serão executados na inicialização. Pode precisar de permissão executável ( chmod +x startup.desktop).

Exemplo de exemplo para .desktoparquivo:

[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 Se você colocar seu script myscriptpara /usr/local/binque ele possa ser executado diretamente pelo comando, você pode escrever myscriptem vez de "</path/to/script>".

Exemplo de exemplo de myscript.sh:

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

Resultado: .desktopo arquivo será lançado a partir do $HOME/.config/autostartqual execute o script porExec=

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

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

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

cronresposta implementada diferente da mais votada

Esta resposta ainda usa cron, mas usa um método diferente da resposta mais votada. Isso funciona desde o Ubuntu 16.04, mas provavelmente suportado muito antes. É que comecei a usar cronpara executar jobs quando o computador inicializa desde 16.04.

Quando croncorre?

Nos comentários alguém perguntou "quando eles correm?". Você pode dizer em 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 notar é cronque você pode enviar por e-mail o status dos trabalhos executados e @rebootos trabalhos executados para que o gerenciador de rede e o e-mail não estejam em execução, a menos que você coloque um sleepcomando em seu(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 roteiro?

Aqui estão alguns scripts que 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 upstart para isso. Upstart é usado para processos do Ubuntu que são iniciados automaticamente. É uma solução aprimorada como os antigos scripts init.d do System-V. Ele 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.)

Se você deseja que seu script seja executado antes do systemd logo após o início do kernel, o modo AFAIK é adicionar init=/path/to/scriptà linha de comando do kernel /boot/grub/grub.cfgou, mais à prova de futuro, criar sua própria entrada /etc/grub.d/40_customde menu copiando uma entrada de menu /boot/grub/grub.cfge fazendo as alterações necessárias (e executando update-grubdepois disso para grubadicionar seu arquivo personalizado a /boot/grub/grub.cfg).

linux   /boot/vmlinuz-5.4.0-26-generic ... ro  quiet splash 

mudar para

linux   /boot/vmlinuz-5.4.0-26-generic ... ro  quiet splash init=/path/to/script

Tome cuidado para colocar corretamente, por exemplo #!/bin/bash, na primeira linha e exec /sbin/init(se /sbin/initexistir em seu sistema - no meu aponta para systemd) no final para evitar o pânico do kernel.