O Ubuntu possui 2 níveis principais de execução automática - no sistema de inicialização do systemd e no ambiente de trabalho. Para software personalizado, a inicialização no Ubuntu pode ser configurada em um utilitário gráfico conveniente. Você pode adicionar um programa ou seu próprio script para execução automática.

Inicialização automática no Ubuntu

O Ubuntu 18.04 atual usa GnomeShell como ambiente de trabalho por padrão. Para configurar a execução automática nesta versão do sistema operacional, você precisa:

Conselho! Para garantir que o comando está correto, você precisa instalar o utilitário “Menu Principal” do UbuntuSoftwareCenter.

Nele, selecione o item de interesse e abra suas propriedades. Comando correto copiado da linha de mesmo nome.

Os aplicativos do Ubuntu presentes na lista e marcados com uma marca serão iniciados sempre que o sistema operacional for iniciado. Todos esses são aplicativos determinado usuário, programas do sistema e serviços, o utilitário não é exibido. EM versões anteriores sistema operacional com shell gráfico Unity, o utilitário para configurar a inicialização também pode ser encontrado pesquisando no menu Dash ou aberto usando o comando no terminal:

propriedades da sessão do gnome.

Como adicionar um script à inicialização do Ubuntu

Além de software específico, é fácil adicionar um script escrito por você mesmo na inicialização do Linux para otimizar seu trabalho no computador. Para fazer isso você precisa:

1. Torne o script executável usando o comando:
   

   sudochmodugo+x /home/user/script.sh

   (onde usuário é o nome do usuário e script é o nome do script, mas o caminho para o seu arquivo .sh pode ser diferente: ele deve ser escrito por extenso, caso contrário o script não será executado).

2. Abra "Iniciar aplicativos automaticamente" e clique em "Adicionar".
3. Digite o nome do script e como comando - o nome completo com o caminho para o arquivo, por exemplo, /home/user/script.sh.
4. Clique em “Adicionar”.

Existe outra maneira clássica, mas considerada desatualizada, de configurar a execução automática de scripts no Ubuntu. Para completá-lo você precisa de:

Este método também é adequado para inicialização automática no UbuntuServer, onde não há gráficos.

Atrasando programas de inicialização no Ubuntu

Se houver muitos programas na inicialização do Ubuntu, eles precisam ser carregados em uma determinada ordem ou iniciados algum tempo após a inicialização do sistema - a função de atraso ajudará. Para ativá-lo, use o utilitário unix sleep. Você pode aproveitar os recursos desta ferramenta no já familiar programa Startup Applications. Para fazer isso você precisa:

1. Abra a janela de configurações do aplicativo de inicialização.
2. Selecione com o cursor o programa cuja execução automática deseja atrasar e use o botão “Alterar”.
3. Na linha “Comando”, antes da entrada existente, digite:
   

onde o número após a palavra “sleep” é igual ao número de segundos que o aplicativo fica ocioso imediatamente após a inicialização do sistema, antes de iniciar. Deve haver um espaço entre esta fórmula, que deve ter ponto e vírgula no final, e o comando para iniciar o aplicativo.

No exemplo dado de inicialização lenta de programas no Ubuntu, o aplicativo permanece em estado de “suspensão” por 2 minutos antes de ser aberto. Por exemplo, iniciar meia hora após o início do sistema operacional será semelhante a sleep 3h “nome do programa”. Exemplo onde a transmissão começa após 1 hora:

dormir 1h; transmissão-gtk %U

De maneira semelhante, você pode adicionar a execução adiada de um script personalizado ou o lançamento de um arquivo de mídia para inicialização no Linux.

Removendo da inicialização do Ubuntu

Para remover software da inicialização do Ubuntu, você pode usar um dos 2 métodos: por meio de “Aplicativos iniciados automaticamente” ou manualmente. No primeiro caso, basta executar o utilitário, selecionar o programa desejado e clique em "Excluir". Simplesmente desmarcar a caixa desativa o programa e ele não será iniciado quando o sistema for iniciado.

O método manual envolve o uso da pasta autostart no Ubuntu. Ele está localizado em /home/username/.config/autostart/ (para ver isto pasta oculta, você deve abrir seu diretório inicial em gerenciador de arquivos e pressione Ctrl+H ao mesmo tempo). Ele contém arquivos com extensão .desktop para cada programa de execução automática, que são gerados automaticamente quando adicionados por meio de um utilitário gráfico. Basta deletar o arquivo para que o programa não abra mais ao ligar o computador.

Conclusão

Existem muitas maneiras de inicialização automática no Ubuntu afinação. Suas capacidades são difíceis de compreender. O uso adequado desta ferramenta torna o Linux mais prático nas tarefas do dia a dia.

O objetivo deste artigo é familiarizar-se com os princípios de inicialização do sistema operacional Ubuntu em Exemplo de Ubuntu Servidor 10.04 LTS, bem como uma demonstração das configurações de inicialização máquina virtual, rodando no VirtualBox, e correto desligamento deste último em modo automático ao desligar o Ubuntu Server.

Atenção! O exemplo descrito abaixo não pode ser aplicado à configuração de inicialização aplicações gráficas para um usuário específico do sistema em versões desktop do Ubuntu. Para fazer isso, use o item “Aplicativos de inicialização” do menu principal do Ubuntu.

Organização da inicialização no Ubuntu Server.
Claro que para iniciar/parar corretamente o serviço, é necessário descrever um script com comandos para iniciar/parar. Dê uma olhada no conteúdo do diretório /etc/init.d: ​​ele contém scripts que controlam o início/interrupção de serviços em sua máquina. Portanto, o primeiro, mas não o último ponto de uma configuração bem-sucedida, é a presença de um script em /etc/init.d. O script não descreve quando um script específico deve ser executado. Só pode aceitar os parâmetros iniciar, parar, reiniciar e assim por diante. Como o Ubuntu sabe quando chamar o script? A resposta está nos diretórios /etc/rcN.d, onde N é um número de 0 a 6. Esses diretórios armazenam links simbólicos para scripts de /etc/init.d. Vejamos o que cada diretório significa e tudo ficará imediatamente claro:
- rc0.d – execução do script quando o sistema está desligado;
- rc1.d – execução do script quando o sistema inicia em modo monousuário;
- rc2.d – execução do script quando o sistema inicia em modo multiusuário;
- rc3.d – rc5.d – reservado;
- rc6.d – execução do script quando o sistema é reinicializado.

Por exemplo, se houver uma reinicialização, todos os scripts do diretório /etc/rc6.d serão executados, ao desligar - de /etc/rc0.d e assim por diante. O número no nome do diretório é chamado de nível de execução. Ou seja, o diretório /etc/rc0.d será chamado de nível de execução zero e assim por diante.
Há mais um ponto importante que você precisa saber: esta é a ordem em que os scripts dos diretórios rcN.d são executados. Afinal, para organizar adequadamente o início/parada do Ubuntu, pode ser necessário iniciar/parar os serviços em uma determinada ordem. Este ponto é resolvido pela nomeação especial de arquivos em diretórios de nível de execução. Os arquivos têm os seguintes nomes: NN[nome], onde é um caractere (“S” significa que o script inicia o serviço, “K” o interrompe), NN é um número de sequência, [nome] é o nome do arquivo. Você não precisa escolher o caractere “S” ou “K”, pois todos os scripts nos diretórios rc1.d-rc5.d devem começar com o caractere “S”, e nos diretórios rc0.d e rc6.d diretórios - com o caractere “K”. O número “NN” determina a ordem de lançamento dos scripts, do menor para o maior. Quanto menor o número de execução do script, mais cedo ele será iniciado na inicialização do sistema; Quanto maior o número do script de parada de serviço, mais tarde ele será executado.

Se você precisar iniciar algum serviço ou aplicativo antes ou depois de um serviço específico existente, basta procurar seu número de série no diretório rcN.d correspondente e levá-lo em consideração ao escolher um número de série para seu script.

Bem, onde armazenar os scripts e como chamá-los é claro, mas como escrevê-los?
O diretório /etc/init.d contém um script de exemplo para controlar o início/parada de serviços. O arquivo é /etc/init.d/skeleton, e no exemplo abaixo será simplificado. Para criar um novo script, você precisa fazer uma cópia do exemplo e editá-lo de acordo com suas necessidades. Vamos usar o seguinte comando:
sudo cp /etc/init.d/skeleton /etc/init.d/myscript && vi /etc/init.d/myscript

Ao criar um novo script, não se esqueça de conceder direitos de execução a ele. Para adicionar permissões de execução a um script, use o comando sudo chmod +x /etc/init.d/myscript

O roteiro está pronto. O que vem a seguir?
Algumas fontes contêm recomendações para a criação manual de links simbólicos usando o comando ln, apesar da existência utilitários especiais. Antes de adicionar um script, o utilitário verifica sua validade e o comando ln criará um link mesmo se houver erros. É melhor dar preferência a utilitários especializados como update-rc.d, que vem com o Ubuntu. Com sua ajuda, você pode adicionar um novo script a qualquer nível de carregamento, excluir um existente e assim por diante. Aqui está um exemplo de uso:
sudo update-rc.d myscript start 99 2 3 4 5 . pare 01 0 1 6 .

Este comando adicionará um novo script “myscript” a todos os níveis de carregamento. O serviço será iniciado nos níveis 2 a 5 com prioridade 99 (último) e o serviço será interrompido nos níveis 0, 1 e 6 com prioridade 01 (o primeiro).
Para remover o script da inicialização, use o comando:
sudo update-rc.d -f myscript remover

Vejamos um exemplo de configuração do carregamento automático.
Tarefa: configure o lançamento automático de uma máquina virtual rodando VirtualBox, que deve iniciar dois minutos após o início do sistema operacional Ubuntu Server. Ao desligar ou reiniciar o Ubuntu Server, a máquina virtual deve desligar normalmente.
Vamos supor que o Ubuntu Server tenha o VirtualBox instalado e haja uma máquina virtual chamada “Slave” cujo sistema operacional suporta a capacidade de desligar normalmente quando você pressiona o botão de desligamento (suporte ACPI).

Primeiro, vamos escrever um script que estará localizado no diretório /etc/init.d:
sudo cp /etc/init.d/skeleton /etc/init.d/slave && sudo vi /etc/init.d/slave

Após editar o script e deixar apenas o mínimo necessário, obtemos um arquivo com o seguinte conteúdo:
#!/bin/sh ### BEGIN INIT INFO # Fornece: escravo # Início obrigatório: # Parada obrigatória: # Início padrão: 2 3 4 5 # Parada padrão: 0 1 6 # Descrição curta: capacidade para iniciando e salvando o estado de execução das máquinas virtuais VBox # Descrição: Este script é usado para iniciar e salvar o estado de execução das máquinas virtuais VBox usando System-V no Ubuntu Server. Este arquivo deve ser colocado em /etc/init.d ### END INIT INFO # Autor: Fuks Alexander . /lib/lsb/init-functions # Execute o início da máquina virtual do Slave com atraso de 2 minutos perform_start() ( log_daemon_msg "Iniciando máquina Vbox Slave" sleep 120 && su -l -c "VboxHeadless –startvm Slave &" kungfux log_end_msg 0 return 0) # Envia sinal POWEROFF ACPI para a máquina virtual do Slave perform_save() ( log_daemon_msg "Enviando sinal ACPI POWER OFF para a máquina Vbox Slave" su -l -c "VboxManage controlvm Slave acpipowerbutton" kungfux log_end_msg 0 return 0) case "$1 ”no início) perform_start ;;

parar) executar_save ;;

Kungfux@itworks:~$ sudo update-rc.d escravo start 99 2 3 4 5 . pare 01 0 1 6 . Adicionando inicialização do sistema para /etc/init.d/slave ... /etc/rc0.d/K01slave -> ../init.d/slave /etc/rc1.d/K01slave -> ../init.d/ escravo /etc/rc6.d/K01slave -> ../init.d/slave /etc/rc2.d/S99slave -> ../init.d/slave /etc/rc3.d/S99slave -> ../ init.d/slave /etc/rc4.d/S99slave -> ../init.d/slave /etc/rc5.d/S99slave -> ../init.d/slave

Após a reinicialização, você pode verificar se o comando de inicialização da máquina virtual foi concluído. Vejamos o relatório de lançamento:

Kungfux@itworks:~$ cat /var/log/boot.log fsck from util-linux-ng 2.17.2 /dev/sda1: clean, 92526/4751360 arquivos, 2565789/18975488 blocos * Iniciando Jenkins Continuous Integration Server jenkins * Iniciando Atualização de endereço dinâmico No-IP.com noip2 * Não iniciando o superservidor de internet: nenhum serviço habilitado * Iniciando o postfix do Postfix Mail Transport Agent * Iniciando o daemon de transmissão bittorrent * Iniciando os módulos do kernel do VirtualBox * Iniciando o servidor NTP ntpd * Iniciando o servidor ftp proftpd * Iniciando o web servidor apache2 * Iniciando máquina Vbox Slave

A última linha contém o texto que foi gerado pelo script “escravo”.
Além disso, os scripts escritos para init.d podem ser usados ​​a partir do terminal a qualquer momento. Por exemplo, para iniciar uma máquina virtual, execute o comando:
kungfux@itworks:~$ /etc/init.d/slave start

Como pode ser visto no exemplo, o sistema operacional Ubuntu oferece recursos avançados para controlar o início/parada de serviços/programas. Em scripts de inicialização, você pode descrever as dependências de serviços que são iniciados/parados em outros serviços usando as seções “Início/Parada obrigatória”, e o script em si pode ser de qualquer complexidade, o que permite organizar até mesmo os mais inicialização “delicada”.

Este material foi escrito para o “Primeiro concurso de artigos em russo para o Ubuntu OS 2011” (konkurs.ubuntu.ru).

Usamos muitos programas constantemente e os iniciamos sempre que o sistema é inicializado, e alguns, como mensageiros instantâneos ou vários utilitários, devem ser executados constantemente em segundo plano para executar adequadamente sua tarefa. Para este efeito em sistemas operacionais há carregamento automático. Os programas são iniciados automaticamente após o sistema operacional ou shell gráfico ser iniciado.

Neste artigo falaremos sobre como funciona a inicialização automática no Ubuntu, quais métodos de inicialização existem neste sistema e como adicionar programas lá.

INICIALIZAÇÃO AUTOMÁTICA NO UBUNTU

A primeira coisa a dizer é que existem vários níveis de inicialização no Ubuntu. Não vou falar sobre systemd e , pois já abordei isso em um dos primeiros artigos. Um programa ou script pode ser adicionado à inicialização das seguintes maneiras:

• Utilitário "Aplicativos iniciados automaticamente";
• Pasta "Inicialização";
• Arquivo rc.local;
• Arquivo Xinitrc;

Consideraremos os dois primeiros métodos, já que os dois últimos são mais projetados para scripts do que para programas. Primeiro, inicialize automaticamente no Ubuntu usando um utilitário padrão.

Abra o menu do sistema e digite "Auto" e abra o programa que será o primeiro da lista, Aplicativos de inicialização:

Todos os aplicativos que atualmente são iniciados automaticamente serão listados aqui. Para adicionar outro aplicativo à inicialização do Ubuntu, clique no botão "Adicionar":

Aqui você precisa inserir o nome do novo item, bem como o comando para iniciar o aplicativo. Você pode selecionar o aplicativo em sistema de arquivos, se você não se lembra do caminho, pressione o botão "Análise":

Você pode especificar parâmetros no comando, se necessário. Você também pode preencher o campo "Descrição", mas isso não é mais necessário. Se você precisar programa específico no menu principal, mas não sabe onde encontrá-lo e como escrever seu comando, pode procurá-lo no mesmo menu. Mas para isso precisamos primeiro instalar o utilitário "Menu Principal" do App Center:

Aqui você precisa prestar atenção na linha "Equipe", copie-o e você poderá usá-lo para inicialização.

O próximo método é a pasta de inicialização. Ele está localizado em ~/.config/autostart. Essencialmente, este é o mesmo método, só que pode ser feito sem uma interface gráfica. Ao configurar a inicialização por meio de um aplicativo, os arquivos de configurações denominados desktop são criados nesta pasta. Aqui, por exemplo:

Lembro que para olhar arquivos ocultos você precisa pressionar a combinação de teclas Ctrl + H. Agora vamos tentar criar um novo arquivo de configuração para outro programa. Esta é a sua sintaxe:

Tipo = Aplicativo
Nome = nome_do_item_novo
Exec = comando
Ícone = caminho_completo_para_icon
Comentário = comentário
X-GNOME-Autostart habilitado= verdadeiro

Por exemplo, vamos criar um arquivo para iniciar o player VLC, ficará assim:

vi ~/.config/autostart/vlc.desktop

Tipo=Aplicativo
Nome=VLC
Exec=vlc
Ícone=/usr/share/icons/hicolor/16x16/apps/vlc.png
Comentário=VLC Media Player
X-GNOME-Autostart-enabled=true

Pronto, e a parte divertida é que se você abrir o aplicativo de inicialização. Este item também aparecerá lá. Esta é uma forma de configurar sem interface gráfica.

CONCLUSÕES

Neste breve artigo, vimos como o carregamento automático é configurado programas Ubuntu de várias maneiras- através GUI e terminais. Você pode usar esse conhecimento para melhorar sua experiência com o sistema. Embora o Ubuntu tenha mudado para o Gnome, a inicialização no Ubuntu 16.04 ainda parece quase a mesma. Se você tiver alguma dúvida, pergunte nos comentários!

Postagens relacionadas:

Depois de iniciar o computador, via de regra, temos que iniciar alguns programas. que usamos com mais frequência. Além disso, após iniciar o sistema, poderemos precisar realizar alguns esforços específicos, por exemplo, criar arquivos necessários ou defina alguns parâmetros. Neste artigo, veremos como funciona o autoload do Linux, como adicionar programas de inicialização, onde seria mais apropriado adicioná-los e também quais tipos de autoload existem neste sistema operacional.

O procedimento para incluir um serviço na inicialização do Linux pressupõe que o programa necessário já esteja instalado por meio de um gerenciador de pacotes ou compilado. Visão geral da chamada os comandos necessários apresentado no exemplo abaixo.

systemctl habilitar service_name.service
padrões update.rc service_name
chkconfig --add nome_serviço

Adicionando programas para inicialização no Linux

Este exemplo descreve como adicionar o nginx à inicialização. Da mesma forma, estamos adicionando outros programas! Primeiro você precisa definir os direitos de execução do arquivo:

chmod +x /etc/init.d/nginx

Então escrevemos no carregamento automático:

/usr/sbin/update-rc.d -f padrões do nginx

Adicionando programas para inicialização no Linux

Crie um arquivo em /etc/init.d/

sudo nano /etc/init.d/

No início do script você precisa adicionar:

Defina direitos de execução para /etc/init.d/local:

sudo chmod +x /etc/init.d/local

Adicione o script /etc/init.d/local à execução automática:

sudo update-rc.d padrões locais 80

Agora podemos adicionar comandos ao nosso script local que devem ser executados quando o sistema for iniciado.

Crie um arquivo vazio.

Na primeira linha escrevemos:

#!/bin/sh

Esta linha especifica qual shell de comando usar. Em seguida estão suas equipes.

Vamos salvá-lo com o nome original (para não coincidir com os existentes) no diretório /usr/sbin/.

Para que o script seja executado na inicialização, você precisa registrá-lo no arquivo /etc/rc.local até a linha exit 0. Se você não tiver este arquivo, crie-o e cole o seguinte conteúdo nele:

#!/bin/sh -e #Aqui inserimos uma linha indicando seu script. /usr/sbin/mescripts saída 0

Uma maneira um pouco mais complicada

Permite definir a sequência de carregamento e o comportamento do script em diferentes níveis de execução.

Estudamos /etc/init.d/skeleton, com base nele criamos um script /etc/init.d/my_script que irá iniciar/parar nossa aplicação.

Esses diretórios contêm scripts para interromper serviços:

/etc/rc0.d/ /etc/rc1.d/ /etc/rc6.d/

Estes são scripts de inicialização de serviço:

/etc/rc2.d/ /etc/rc3.d/ /etc/rc4.d/ /etc/rc5.d/

Nós os estudamos quanto à consistência (quanto menor o primeiro dígito no início do script, mais cedo o aplicativo inicia/para). Isto pode ser crítico se a sua aplicação depender de alguns serviços.

Depois de decidirmos o script e a sequência de lançamento, realizamos o seguinte:

Sudo update-rc.d my_script start 70 2 3 4 5 . parar 20 0 1 6 .

Aqui determinei que meu script deveria começar mais tarde que os outros (70) e parar mais cedo (20). Os números 2 3 4 5 0 1 6 indicam níveis de carga.

Se você não gosta de algo, você pode deletar tudo

Sudo update-rc.d -f my_script remover

Consulte man update-rc.d para obter detalhes.

Executando um script quando a rede está ligada/desligada

Existe um diretório /etc/network/ com subdiretórios if-down.d , if-pre-up.d , if-post-down.d , if-up.d . Se você colocar o script em um desses subdiretórios, ele será executado respectivamente ao desligar, antes de ligar, após desligar ou ao ligar a rede.

Outra maneira é especificar uma das seguintes diretivas no arquivo /etc/network/interfaces: up , pre-up , post-up , down , pre-down , post-down . Por exemplo, a linha

Postagem /path/to/script.sh

depois de ligar a rede irá executar o script script.sh. Você pode ler mais em interfaces man.

Em qualquer caso, o script deve ter permissões para permitir a execução, caso contrário não poderá ser executado.