Capítulo 3. A inicialização do sistema

# Capítulo 3. A inicialização do sistema

É inteligente para si como o administrador do sistema ter uma ideia como o sistema Debian é arranca e é configurado. Apesar dos detalhes exactos estarem nos ficheiros de código-fonte dos pacotes instalados e nas suas documentações, é um pouco exagerado para a maioria de nós.

Aqui está uma visão geral aproximada dos pontos chave da inicialização do sistema Debian. Dado que o sistema Debian é um alvo em movimento, deve consultar a documentação mais recente.

- Manual do Kernel Linux Debian é a fonte primária de informação sobre o kernel Debian.

- bootup(7) descreve o processo de arranque do sistema baseado no `systemd` . (Debian Recente)

- boot(7) descreve o processo de arranque do sistema baseado em UNIX System V Release 4. (Debian Antiga)

## 3.1. Uma visão geral do processo de arranque

O sistema do computador passa por várias fases de processos de arranque desde o ligar da energia até que oferece, ao utilizador, o sistema operativo (SO) totalmente funcional.

Para simplicidade, limito a discussão à plataforma PC típico com a instalação por omissão.

O processo típico de arranque é como um foguete de quatro etapas. Cada etapa do foguete entrega o controle do sistema à próxima etapa.

- Seção 3.1.1, “Estágio 1: a UEFI”

- Seção 3.1.2, “Estágio 2: o gestor de arranque”

- Seção 3.1.3, “Estágio 3: o mini-sistema Debian”

- Seção 3.1.4, “Estágio 4: o sistema Debian normal”

É claro que, estes podem ser configurados de modo diferente. Por exemplo, se compilou o seu próprio kernel, pode estar a saltar o passo com o mini sistema Debian. Portanto por favor não assuma que é este o caso para o seu sistema até que o verifique por si próprio.

### 3.1.1. Estágio 1: a UEFI

A Unified Extensible Firmware Interface (UEFI) define um gestor de arranque como parte da especificação UEFI. Quando um computador é ligado, o gestor de arranque é a primeira fase do processo de arranque que verifica a configuração de arranque e, com base nas suas definições, executa o gestor de arranque do SO ou o kernel do sistema operativo especificado (normalmente o gestor de arranque). A configuração de arranque é definida por variáveis armazenadas na NVRAM, incluindo variáveis que indicam os caminhos do sistema de ficheiros para os carregadores ou kernels do SO.

Uma partição de sistema EFI (ESP) é uma partição de dispositivo de armazenamento de dados que é utilizada em computadores que aderem à especificação UEFI. Acedida pelo firmware UEFI quando um computador é ligado, armazena as aplicações UEFI e os ficheiros de que estas aplicações necessitam para funcionar, incluindo os gestores de arranque do sistema operativo. (No sistema legado do PC, pode ser usada a BIOS armazenada na MBR.)

### 3.1.2. Estágio 2: o gestor de arranque

O gestor de arranque é o 2º estágio do processo de arranque que é iniciado pela UEFI. Ele carrega a imagem de kernel do sistema e a imagem initrd na memória e passa-lhes o controle. Esta imagem initrd é a imagem do sistema de ficheiros raiz e o suporte dele depende do gestor de arranque utilizado.

O sistema Debian normalmente usa o kernel Linux como o kernel predefinido do sistema. A imagem initrd para o atual kernel Linux 5.x é tecnicamente a imagem initramfs (initial RAM filesystem).

Existem muitos gestores de arranque e opções de configuração disponíveis.

Tabela 3.1. Lista de gestores de arranque

pacote | popcon | tamanho | initrd | gestor de arranque | descrição
--- | --- | --- | --- | --- | ---
grub-efi-amd64 | I:459 | 142 | Suportado | GRUB UEFI | É suficientemente inteligente para compreender partições de disco e sistemas de ficheiros como vfat, ext4, .... (UEFI)
grub-pc | V:16, I:518 | 479 | Suportado | GRUB 2 | É suficientemente inteligente para compreender partições de disco e sistemas de ficheiros como vfat, ext4, .... (BIOS)
grub-rescue-pc | V:0.06, I:0.63 | 7273 | Suportado | GRUB 2 | Isto são imagens de arranque de recuperação do GRUB 2 (CD ou disquete) (Versão PC/BIOS)
grml-rescueboot | V:0.1, I:1.1 | 36 | N/D | plug-in do GRUB 2 | grml-rescueboot adiciona imagens ISO de Linux Live ao menu de arranque do grub2
syslinux | V:3, I:31 | 325 | Suportado | Isolinux | Isto compreende o sistema de ficheiros ISO9660. É utilizado pelo CD de arranque.
syslinux | V:3, I:31 | 325 | Suportado | Syslinux | Isto compreende o sistema de ficheiros MSDOS (FAT). É utilizado pela disquete de arranque.
loadlin | V:0.04, I:0.42 | 87 | Suportado | Loadlin | Novo sistema é iniciado a partir do sistema FreeDOS/MSDOS.
mbr | V:0.2, I:2.8 | 47 | Não suportado | MBR por Neil Turton | Isto é software livre que substitui o MBR do MSDOS. Apenas compreende partições de disco.

Para o sistema UEFI, o GRUB2 lê primeiro a partição ESP e utiliza o UUID especificado para `search.fs_uuid` em "`/boot/efi/EFI/debian/grub.cfg`" para determinar a partição do ficheiro de configuração do menu GRUB2 "`/boot/grub/grub.cfg`".

A parte principal do ficheiro de configuração do menu do GRUB2 tem o seguinte aspeto:

    menuentry 'Debian GNU/Linux' ... {
            load_video
            insmod gzio
            insmod part_gpt
            insmod ext2
            search --no-floppy --fs-uuid --set=root fe3e1db5-6454-46d6-a14c-071208ebe4b1
            echo    'Loading Linux 5.10.0-6-amd64 ...'
            linux   /boot/vmlinuz-5.10.0-6-amd64 root=UUID=fe3e1db5-6454-46d6-a14c-071208ebe4b1 ro quiet
            echo    'Loading initial ramdisk ...'
            initrd  /boot/initrd.img-5.10.0-6-amd64
    }

Para esta parte de `/boot/grub/grub.cfg`, esta entrada de menu significa o seguinte.

Tabela 3.2. O significado da entrada de menu da parte acima de `/boot/grub/grub.cfg`

configuração | valor
--- | ---
Módulos do GRUB2 carregados | `gzio`, `part_gpt`, `ext2`
utilizada a partição raiz do sistema de ficheiros | partição identificada por `UUID=fe3e1db5-6454-46d6-a14c-071208ebe4b1`
caminho da imagem do kernel no sistema de ficheiros raiz | `/boot/vmlinuz-5.10.0-6-amd64`
utilizado parâmetro de arranque do kernel | "`root=UUID=fe3e1db5-6454-46d6-a14c-071208ebe4b1 ro quiet`"
caminho da imagem initrd no sistema de ficheiros raiz | `/boot/initrd.img-5.10.0-6-amd64`

No sistema Debian, "`/boot/grub/grub.cfg`" é gerido pelo pacote GRUB instalado (ex. `grub-efi-amd64`) e a modificação direta do utilizador a este ficheiro está descontinuada. Em vez disto, você deve personalizar os ficheiros de configuração em "`/etc/grub.d/`" e "`/etc/default/grub`". Depois configure os ficheiros de configuração do GRUB e atualize as variáveis NVRAM para arrancar automaticamente em Debian por:

    # dpkg-reconfigure grub-efi-amd64

| Dica
Você pode mostrar as mensagens de registo de arranque do kernel removendo "`quiet`" do valor "`GRUB_CMDLINE_LINUX_DEFAULT`" em "`/etc/default/grub`".

| Dica
Você pode adicionar um fundo no GRUB ao colocar o seu ficheiro de imagem em "`/boot/grub/`".

Veja "`info grub`", grub-install(8), grub-mkconfig(8).

### 3.1.3. Estágio 3: o mini-sistema Debian

O mini-sistema Debian é o 3º estágio do processo de arranque que é iniciado pelo gestor de arranque. Corre o kernel do sistema com o sistema de ficheiros raiz dele na memória. Este é um estágio preparatório opcional do processo de arranque.

| Nota
O termo "mini-sistema Debian" é cunhado pelo autor para descrever este 3º estágio do processo de arranque para este documento. Este sistema é geralmente referido como o initrd ou sistema initramfs. É utilizado pelo Instalador de Debian um sistema semelhante em memória .

O programa "`/init`" é executado como o primeiro programa neste sistema de ficheiros raiz em memória. É um programa que inicializa o kernel no espaço de utilizador e entrega o controle ao próximo estágio. Este mini-sistema Debian oferece flexibilidade ao processo de arranque tal como adicionar módulos de kernel antes do processo de arranque principal ou montar o sistema de ficheiros raiz como um encriptado.

- O programa "`/init`" é um programa de script de shell se a initramfs for criada pelo `initramfs-tools`.

  - Pode interromper esta parte do processo de arranque para obter a shell de root ao fornecer "`break=init`" etc. ao parâmetro de arranque do kernel. Veja o script "`/init`" para mais condições de interrupção. Este ambiente shell é suficientemente sofisticado para fazer uma boa inspecção do hardware da sua máquina.

  - Os comandos disponíveis neste mini-sistema Debian são versões reduzidas e disponibilizados principalmente por uma ferramenta GNU chamada busybox(1).

- O programa "`/init`" é um programa binário do `systemd` se a initramfs for criada pelo `dracut`.

  - Os comandos disponíveis neste mini-sistema Debian são versões reduzidas do ambiente systemd(1).

| Cuidado
Precisa de utilizar a opção "`-n`" para o comando `mount` quando está no sistema de ficheiros raiz apenas de leitura.

### 3.1.4. Estágio 4: o sistema Debian normal

O sistema Debian normal é o 4º estágio do processo de arranque que é iniciado pelo mini-sistema Debian. O kernel do sistema para o mini-sistema Debian continua a correr nesse ambiente. O sistema de ficheiros raiz é mudado daquele na memória para o que está no sistema de ficheiros do dispositivo de armazenamento físico.

O programa init é executado como o primeiro programa com PID=1 para executar o processo de arranque principal de arrancar muitos programas. O caminho de ficheiro predefinido ao programa init é "`/usr/sbin/init`" mas pode ser alterado pelo parâmetro de arranque do kernel como "`init=/path/to/init_program`".

"`/usr/sbin/init`" é uma ligação simbólica para "`/lib/systemd/systemd`" após Debian 8 Jessie (Lançada em 2015).

| Dica
O comando de iniciação atual do seu sistema pode ser verificado pelo comando "`ps --pid 1 -f`".

Tabela 3.3. Lista de utilitários de arranque para o sistema Debian

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`systemd` | V:920, I:979 | 11013 | daemon de eventos baseado em init(8) para a concorrência (alternativa a `sysvinit`)
`cloud-init` | V:3.6, I:6.7 | 3267 | sistema de inicialização de instâncias de infra-estruturas na nuvem
`systemd-sysv` | V:912, I:981 | 76 | os manuais e ligações necessárias pelo `systemd` para substituir o `sysvinit`
`init-system-helpers` | V:585, I:988 | 131 | ferramentas de ajuda para mudar entre `sysvinit` e `systemd`
`initscripts` | V:16, I:59 | 197 | scripts para inicializar e desligar o sistema
`sysvinit-core` | V:3.4, I:3.8 | 365 | utilitários de init(8) estilo System-V
`sysv-rc` | V:31, I:63 | 85 | mecanismo de mudança de runlevel estilo System-V
`sysvinit-utils` | V:722, I:1000 | 100 | utilitários estilo System-V (startpar(8), bootlogd(8), …)
`lsb-base` | V:217, I:320 | 12 | Linux Standard Base funcionalidade de script de init 3.2
`insserv` | V:35, I:62 | 132 | ferramenta para organizar a sequência de arranque a usar dependências dos scripts init.d LSB
`kexec-tools` | V:1.4, I:5.4 | 320 | ferramenta kexec para re-arranques kexec(8) (re-arranque a quente)
`systemd-bootchart` | V:0.20, I:0.60 | 131 | analisador de performance do processo de arranque
`mingetty` | V:0.1, I:2.5 | 36 | getty(8) apenas de consola
`mgetty` | V:0.15, I:0.50 | 318 | substituto inteligente de modem getty(8)

| Dica
Veja Debian wiki: BootProcessSpeedup para as dicas mais recentes em como acelerar o processo de arranque.

## 3.2. O sistema de salvamento

| Atenção
Não execute tarefas de administração do sistema sobre o processo de arranque sem ter um sistema de recuperação ou salvamento.

A disponibilidade dum sistema de salvamento permite-nos executar tarefas desafiantes tais como:

- Arrancar um sistema a partir de uma instalação de carregador de arranque quebrada

- Corrigir uma instalação de carregador de arranque quebrada

- Extrair dados de um sistema quebrado que não arranca

- Editar sistemas de ficheiros, partições de disco, e volumes LVM envolvendo o sistema de ficheiros raiz

Tipicamente, um sistema de salvamento é fornecido como um ficheiro de imagem ISO escrito numa média de armazenamento amovível tal como:

- Memória flash USB preparada como Seção 9.7.2, “Escrever directamente no disco”

- CD / DVD preparado como Seção 9.7.7, “Escrever directamente ao CD/DVD-R/RW”

Para simplicidade, os casos com dispositivos flash USB são mencionados como exemplos, mas CD ou DVD também pode ser usado.

| Dica
Você pode precisar de alterar algumas variáveis UEFI NVRAM para arrancar carregadores de arranque arbitrários na média de armazenamento amovível.

### 3.2.1. Sistema de salvamento GRUB UEFI em USB

O sistema de salvamento GRUB UEFI com menu pode ser arrancado ao ligar a energia do sistema com o "Sistema de salvamento GRUB UEFI em USB" inserido.

Este "Sistema de salvamento GRUB UEFI em USB" é preparado a escrever a imagem ISO Super Grub2 Disk numa Pen flash USB antecipadamente.

No caso de configuração de carregador de arranque quebrada pela instalação de outro sistema operativo etc., você pode corrigir isto por:

- Arranque o sistema de salvamento GRUB UEFI para descobrir automaticamente sistemas instalados com arranque.

- Arranque o sistema Debian instalado a partir do menu do GRUB.

- Na linha de comandos shell do root em Linux:

      # dpkg-reconfigure grub-efi-amd64

| Nota
A imagem ISO de arranque de salvamento do GRUB também pode ser gerada seguindo "`info grub-mkrescue`". Oferece uma linha de comandos shell CLI GRUB mas não oferece descoberta automática de sistemas instalados com arranque.

### 3.2.2. Sistema de salvamento Linux live em USB

O sistema de salvamento Linux live pode ser arrancado ao ligar a energia do sistema com o "Sistema de salvamento Linux live em USB" inserido.

Este "Sistema de salvamento Linux live em USB" pode ser preparado a escrever uma das imagens ISO Linux live baseadas em Debian Pen flash USB antecipadamente. Aqui estão alguns exemplos de tais imagens Linux live.

- Imagens Live de Debian

- Kali Linux Live

- Grml Live Linux

Aqui estão alguns casos de utilização deste sistema de salvamento Linux live:

- Corrigir a configuração de carregador de arranque danificada causado pela instalação de outro sistema operativo, etc.:

  - Arranque o sistema de salvamento Linux live.

  - Monte a partição que contém o sistema de ficheiros raiz do sistema Debian instalado que não arranca em "`/mnt`".

  - Na linha de comandos shell do root em Linux:

        # chroot /mnt; dpkg-reconfigure grub-efi-amd64

- Corrigir o pacote `dpkg` quebrado:

  - Arranque o sistema de salvamento Linux live.

  - Monte a partição que contém o sistema de ficheiros raiz do sistema Debian instalado com o pacote `dpkg` quebrado em "`/mnt`".

  - Na linha de comandos shell do root em Linux:

        # dpkg --root /mnt -i /mnt/var/cache/apt/archives/dpkg_old_version_amd64.deb

- Executar alterações normalmente proibidas tais como operações no sistema de ficheiros no sistema instalado (veja Seção 9.6, “Dicas de armazenamento de dados”).

| Atenção
O sue ecrã GUI do sistema Linux live pode ficar trancado após inatividade.

| Dica

- É uma boa ideia definir a sua palavra passe assim que arranca um sistema Linux live.

- Você pode definir a sua palavra passe fazendo "`sudo passwd utilizador`" a partir do aviso de shell do utilizador nas consolas virtuais de Linux (veja Seção 1.1.6, “Consolas virtuais”).

- Alguns sistemas Linux live podem definir os seus "utilizador/palavra passe" predefinidos: "Debian Live" = "user/live", "Kali Linux Live" = "kali/kali"

### 3.2.3. Sistema de salvamento Linux live a partir do GRUB

O sistema de salvamento Linux live pode ser arrancado a partir duma entrada de menu do GRUB. A configuração do GRUB para isto é preparada pelo seguinte:

- Instalar o pacote `grml-rescueboot`.

- Encontre uma imagem ISO Linux live que tenha "`/boot/grub/loopback.cfg`" na sua imagem.

  - As imagens ISO mencionadas em Seção 3.2.2, “Sistema de salvamento Linux live em USB” têm "`/boot/grub/loopback.cfg`" na sua imagem.

- Copie algumas destas imagens ISO Linux live para o directório "`/boot/grml/`".

- Atualize o menu do GRUB com:

      # dpkg-reconfigure grub-efi-amd64

Após ligar a energia do sistema, o GRUB mostra um menu com candidatos para sistemas de salvamento Linux live.

## 3.3. Systemd

### 3.3.1. init do Systemd

Quando o sistema Debian arranca, `/usr/sbin/init` com uma ligação simbólica a `/usr/lib/systemd` é iniciado como o processo do sistema init (`PID=1`) cujo dono é o root (`UID=0`). Veja systemd(1).

O processo init do `systemd` espalha processos em paralelo com base nos arquivos de configuração do unit (veja systemd.unit(5)) os quais são escritos em estilo declarativo em vez do estilo processual tipo SysV.

Os processos gerados são colocados em grupos de controlo individuais do Linux com o nome da unidade a que pertencem na hierarquia privada do systemd (ver cgroups e Seção 4.7.5, “Caraterísticas de segurança do Linux”).

As unidades para o modo de sistema são carregadas a partir do "Caminho de pesquisa de unidade de sistema" descrito em systemd.unit(5). As principais são as seguintes, por ordem de prioridade:

- "`/etc/systemd/system/*`": Unidades de sistema criadas pelo administrador

- "`/run/systemd/system/*`": Unidades de tempo de execução

- "`/lib/systemd/system/*`": Unidades de sistema instaladas pelo gestor de pacotes da distribuição

As suas inter-dependências são especificadas pelas directivas "`Wants=`", "`Requires=`", "`Before=`", "`After=`", … (veja "MAPPING OF UNIT PROPERTIES TO THEIR INVERSES" em systemd.unit(5)). Os controlos de recursos estão também definidos (veja systemd.resource-control(5)).

O sufixo do ficheiro de configuração da unidade codifica os seus tipos como:

- *.service descreve o processo controlado e supervisionado pelo `systemd`. Veja systemd.service(5).

- *.device descreve o aparelho exposto em sysfs(5) como uma árvore de aparelhos do udev(7). Veja systemd.device(5).

- *.mount descreve o ponto de montagem do sistema de ficheiros controlado e supervisionado pelo `systemd`. Veja systemd.mount(5).

- *.automount Descreve o ponto de montagem automático do sistema de ficheiros controlado e supervisionado pelo `systemd`. Veja systemd.automount(5).

- *.swap descreve o aparelho ou ficheiro de memória virtual (swap) controlado e supervisionado pelo `systemd`. Veja systemd.swap(5).

- *.path descreve o caminho monitorizado pelo `systemd` para activação baseada-no-caminho. Veja systemd.path(5).

- *.socket descreve o socket controlado e supervisionado pelo `systemd` para activação baseada-em-socket. Veja systemd.socket(5).

- *.timer descreve o temporizador controlado e supervisionado pelo `systemd` para activação baseada-em-temporização. Veja systemd.timer(5).

- *.slice gere recursos com cgroups(7). Veja systemd.slice(5).

- *.scope é criado programaticamente a usar as interfaces de barramento do `systemd` para gerir um conjunto de processos do sistema. Veja systemd.scope(5).

- *.target agrupa outros ficheiros de configuração de unit para criar o ponto de sincronização durante o arranque. Veja systemd.target(5).

Após o arranque do sistema (o, init), o processo `systemd` tenta arrancar o "`/lib/systemd/system/default.target` (que normalmente é uma ligaö#ao simbólica para "`graphical.target`"). Primeiro, algumas unidades alvo especiais (veja systemd.special(7)) tais como "`local-fs.target`", "`swap.target`" e "`cryptsetup.target`" são puxadas para montar os sistemas de ficheiros. Depois, outras unidades alvo são também puxadas pelas dependências da unidade alvo. Para mais detalhes. leia bootup(7).

O `systemd` oferece funcionalidades de compatibilidade regressiva. Os scripts de arranque estilo SysV em "`/etc/init.d/rc[0123456S].d/[KS]name`" são ainda analisados e telinit(8) é traduzido em pedidos activação de unidade do systemd.

| Cuidado
Os runlevel 2 a 4 emulados são todos direccionados por uma ligação simbólica ao mesmo "`alvo de multi-utilizador`".

### 3.3.2. Inicio de sessão Systemd

Quando um utilizador se liga ao sistema Debian via gdm3(8), sshd(8), etc., `/lib/systemd/system --user` é iniciado como o processo gestor de serviços de utilizador pertencente ao utilizador correspondente. Veja systemd(1).

O processo do gestor de serviços do utilizador `systemd` gera processos em paralelo com base nos ficheiros de configuração da unidade declarativa (ver systemd.unit(5) e `user@.service`(5)).

As unidades para o modo de utilizador são carregadas a partir do "Caminho de pesquisa de unidade de sistema" descrito em systemd.unit(5). As principais são as seguintes, por ordem de prioridade:

- "`~/.config/systemd/user/*`": Unidades de configuração do utilizador

- "`/etc/systemd/user/*`": Unidades de utilizador criadas pelo administrador

- "`/run/systemd/user/*`": Unidades de tempo de execução

- "`/lib/systemd/user/*`": Unidades de utilizador instaladas pelo gestor de pacotes de distribuição

Estes são geridos da mesma forma que os Seção 3.3.1, “init do Systemd”.

## 3.4. A mensagem do kernel

As mensagens de erros do kernel mostradas na consola podem ser configuradas ao definir o nível de limiar dele.

    # dmesg -n3

Tabela 3.4. Lista de níveis de erro do kernel

valor de nível de erro | nome de nível de erro | significado
--- | --- | ---
0 | KERN_EMERG | sistema está inutilizável
1 | KERN_ALERT | acção tem de ser tomada imediatamente
2 | KERN_CRIT | condições críticas
3 | KERN_ERR | condições de erro
4 | KERN_WARNING | condições de aviso
5 | KERN_NOTICE | condição normal mas significante
6 | KERN_INFO | informativa
7 | KERN_DEBUG | mensagens de nível de depuração

## 3.5. A mensagem do sistema

Sob `systemd`, ambas mensagens de kernel e sistema são registadas pelo serviço journal `systemd-journald.service` (também conhecido por `journald`) seja em dados binários persistentes em "`/var/log/journal`" ou em dados binários voláteis em "`/run/log/journal/`". Estes dados de relatório binários são acedidos pelo comando journalctl(1). Por exemplo, pode apresentar o registo do último arranque como:

    $ journalctl -b

Tabela 3.5. Lista de trechos típicos do comando `journalctl`

Operação | Fragmentos de comando
--- | ---
Ver o registo dos serviços do sistema e do kernel desde o último arranque | "`journalctl -b --system`"
Ver o registo dos serviços do utilizador atual desde o último arranque | "`journalctl -b --user`"
Ver o registo de tarefas de" `$unit`" do último arranque | "`journalctl -b -u $unit`"
Ver o registo do trabalho de "`$unit`" (estilo "`tail -f`") desde o último arranque | "`journalctl -b -u $unit -f`"

Sob o `systemd`, o utilitário de registo do sistema rsyslogd(8) pode ser desinstalado. Se for instalado, altera o seu comportamento para ler os dados de registo binários voláteis (em vez do padrão pré-systemd "`/dev/log`") e para criar dados de registo do sistema ASCII permanentes tradicionais. Isto pode ser personalizado por "`/etc/default/rsyslog`" e "`/etc/rsyslog.conf`" tanto para o ficheiro de registos como para a apresentação no ecrã. Veja rsyslogd(8) e rsyslog.conf(5). Veja também Seção 9.3.2, “Analisador de relatório (Log)”.

## 3.6. Gestão do sistema

O `systemd` oferece não apenas o sistema init, mas também operações genéricas de gestão de sistema com o comando systemctl(1).

Tabela 3.6. Lista de trechos de comandos típicos de gestão do `systemctl`

Operação | Fragmentos de comando
--- | ---
Lista todos os tipos de unidades disponíveis | "`systemctl list-units --type=help`"
Lista todas as unidades alvo na memória | "`systemctl list-units --type=target`"
Lista todas as unidades de serviço na memória | "`systemctl list-units --type=service`"
Lista todas as unidades de dispositivo na memória | "`systemctl list-units --type=device`"
Lista todas as unidades de montagem na memória | "`systemctl list-units --type=mount`"
Lista todas unidades de socket em memória | "`systemctl list-sockets`"
Lista todas as unidades de temporizador em memória | "`systemctl list-timers`"
Iniciar o "`$unit`" | "`systemctl start $unit`"
Parar o "`$unit`" | "`systemctl stop $unit`"
Recarregar configuração específica do serviço | "`systemctl reload $unit`"
Parar e iniciar todo "`$unit`" | "`systemctl restart $unit`"
Iniciar o "`$unit`" e parar todos os outros | "`systemctl isolate $unit`"
Mudar para "`gráfico`" (sistema GUI) | "`systemctl isolate graphical`"
Mudar para "`multi-utilizador`" (sistema CLI) | "`systemctl isolate multi-user`"
Mudar para "`recuperação`" (sistema CLI de único utilizador) | "`systemctl isolate rescue`"
Enviar sinal kill ao "`$unit`" | "`systemctl kill $unit`"
Verificar se o serviço "`$unit`" está ativo | "`systemctl is-active $unit`"
Verificar se o serviço "`$unit`" falhou | "`systemctl is-failed $unit`"
Verifica o estado de "`$unit|$PID|aparelho`" | "`systemctl status $unit|$PID|$device`"
Mostra propriedades de 1"`$unit|$job`" | "`systemctl show $unit|$job`"
Reinicia um "`$unit`" falhado | "`systemctl reset-failed $unit"`
List dependências de todos os serviços unit | "`systemctl list-dependencies --all`"
Lista ficheiros unit instalados no sistema | "`systemctl list-unit-files`"
Ativa "`$unit`" (adicionar ligação simbólica) | "`systemctl enable $unit`"
Desactiva "`$unit`" (remove ligação simbólica) | "`systemctl disable $unit`"
Desmascara "`$unit`" (remove ligação simbólica para "`/dev/null`") | "`systemctl unmask $unit`"
Mascara "`$unit`" (adicionar ligação simbólica para "`/dev/null`") | "`systemctl mask $unit`"
Obter definição de alvo-predefinido | "`systemctl get-default`"
Define alvo-predefinido para "`graphical`" (sistema GUI) | "`systemctl set-default graphical`"
Define alvo-predefinido para "`multi-user`" (sistema CLI) | "`systemctl set-default multi-user`"
Mostra ambiente da função | "`systemctl show-environment`"
Define "`variável`" de ambiente de função para "`valor`" | "`systemctl set-environment variável=valor`"
Remove a definição da "`variável`" de ambiente de função | "`systemctl unset-environment variável`"
Reinicia todos os ficheiros unit e os daemons | "`systemctl daemon-reload`"
Desligar o sistema | "`systemctl poweroff`"
Desligar e reiniciar o sistema | "`systemctl reboot`"
Suspender o sistema | "`systemctl suspend`"
Hibernar o sistema | "`systemctl hibernate`"

Aqui, "`$unit`" nos exemplos em cima pode ser um único nome de unidade (sufixos como `.service` e `.target` são opcionais) ou, em muitos casos, especificações de múltiplas unidades (a simbologia da shell "`*`", "`?`", "`[]`" a utilizar fnmatch(3) serão correspondidos aos nomes primários de todas as unidades presentemente em memória).

Os comandos de alteração do estado do sistema nos exemplos em cima são tipicamente precedidos por "`sudo`" para obter os privilégios administrativos necessários.

Os resultados de "`systemctl status $unit|$PID|$aparelho`" usam cores no ponto ("●") para sumarizar rapidamente o estado da unidade.

- Ponto "●" branco indica estado "inativo" ou "desactivado".

- Ponto "●" vermelho indica um estado de "falha" ou "erro".

- Ponto "●" verde indica um estado "ativo", "a reiniciar" ou "a ativar".

## 3.7. Outros monitores de sistema

Aqui está uma lista de outros trechos de comandos de monitorização sob o `systemd`. Por favor, leia as páginas de manual pertinentes, incluindo cgroups(7).

Tabela 3.7. Lista de outros trechos de comandos de monitorização `systemd`

Operação | Fragmentos de comando
--- | ---
Mostra o tempo gasto em cada passo de inicialização | "`systemd-analyze time`"
Lista de todas as unidades pelo tempo de inicialização | "`systemd-analyze blame`"
Carrega e detecta erros no ficheiro "`$unit`" | "`systemd-analyze verify $unit`"
Apresentar informações breves sobre o estado do tempo de execução do utilizador que efectua a chamada | "`loginctl user-status`"
Mostrar informação concisa sobre o estado do tempo de execução da sessão do utilizador | "`loginctl session-status`"
Acompanhar o processo de arranque através dos cgroups | "`systemd-cgls`"
Acompanhar o processo de arranque através dos cgroups | "`ps xawf -eo pid,user,cgroup,args`"
Acompanhar o processo de arranque através dos cgroups | Lê sysfs sob "`/sys/fs/cgroup/`"

## 3.8. Configuração do sistema

### 3.8.1. O nome da máquina

O kernel mantém o nome-de-máquina do sistema. A unidade do sistema arrancado por `systemd-hostnamed.service` define o nome de máquina do sistema durante o arranque ao nome armazenado em "`/etc/hostname`". Este ficheiro deve conter apenas o nome de máquina do sistema e não um nome de domínio totalmente qualificado.

Para escrever o nome de máquina atual corra hostname(1) sem argumentos.

### 3.8.2. O sistema de ficheiros

As opções de montagem de sistemas de ficheiros de discos normais e de rede são definidas em "`/etc/fstab`". Veja fstab(5) e Seção 9.6.7, “Optimização do sistema de ficheiros por opções de montagem”.

A configuração do sistema de ficheiros encriptado é definida em "`/etc/crypttab`". Veja crypttab(5)

A configuração do software RAID com mdadm(8) é definida em "`/etc/mdadm/mdadm.conf`". Veja mdadm.conf(5).

| Atenção
Após montar todos os sistemas de ficheiros, os ficheiros temporários em "`/tmp`", "`/var/lock`" e "`/var/run`" são limpos para cada arranque.

### 3.8.3. Inicialização da interface de rede

As interfaces de rede são tipicamente iniciadas em "`networking.service`" para a interface `lo` e "`NetworkManager.service`" para as outras interfaces em sistemas Debian modernos sob `systemd`.

Veja Capítulo 5, Configuração de rede para saber como os configurar.

### 3.8.4. Inicialização do sistema de nuvem

A instância do sistema de nuvem pode ser lançada como um clone de "Debian Official Cloud Images" ou imagens semelhantes. Para essa instância do sistema, personalidades como nome de máquina, sistema de ficheiros, rede, localidade, chaves SSH, utilizadores e grupos podem ser configurados usando funcionalidades fornecidas pelos pacotes `cloud-init` e `netplan.io` com várias fontes de dados, como ficheiros colocados na imagem original do sistema e dados externos fornecidos durante seu lançamento. Esses pacotes permitem a configuração declarativa do sistema usando dados YAML.

Veja mais em "Computação em nuvem com Debian e seus descendentes", "Documentação de iniciação na Nuvem" e Seção 5.4, “A configuração moderna de rede para nuvem”.

### 3.8.5. Exemplo de personalização para ajustar o serviço sshd

Com uma instalação predefinida, muitos serviços de rede (veja Capítulo 6, Aplicações de rede) são arrancados como processos daemon após `network.target` durante o arranque do sistema pelo `systemd`. O "`sshd`" não é excepção. Vamos mudar isto para arranque a-pedido do "`sshd`" como um exemplo de personalização.

Primeiro, desativar a unidade de serviço instalada no sistema.

     $ sudo systemctl stop sshd.service
     $ sudo systemctl mask sshd.service

O sistema de ativação de sockets a pedido dos serviços Unix clássicos era feito através do superservidor `inetd` (ou `xinetd`). No `systemd`, o equivalente pode ser ativado adicionando ficheiros de configuração de unidades *.socket e *.service.

`sshd.socket` para especificar um socket onde escutar

    [Unit]
    Description=SSH Socket for Per-Connection Servers

    [Socket]
    ListenStream=22
    Accept=yes

    [Install]
    WantedBy=sockets.target

`sshd@.service` como o ficheiro de serviço correspondente do `sshd.socket`

    [Unit]
    Description=SSH Per-Connection Server

    [Service]
    ExecStart=-/usr/sbin/sshd -i
    StandardInput=socket

Depois reinicie.

     $ sudo systemctl daemon-reload

## 3.9. O sistema udev

O sistema udev fornece um mecanismo para a descoberta e inicialização automática de hardware (veja udev(7)) desde o kernel Linux 2.6. Após a descoberta de cada dispositivo pelo kernel, o sistema udev inicia um processo de utilizador que usa informação do sistema de ficheiros sysfs (ver Seção 1.2.12, “procfs e sysfs”), carrega os módulos necessários do kernel que o suportam usando o programa modprobe(8) (ver Seção 3.10, “A inicialização de módulos do kernel”), e cria os nós de dispositivos correspondentes.

| Dica

Se "`/lib/modules/versão-de-kernel/modules.dep`" não foi gerado de modo apropriado pelo depmod(8) por alguma razão, os módulos podem não carregar como esperado pelo sistema udev. Execute "`depmod -a`" para o corrigir.

Para regras de montagem em "`/etc/fstab`", os nós de aparelhos não precisam de ser os estáticos. Pode usar o UUID para montar os aparelhos em vez dos nomes de aparelho como "`/dev/sda`". Veja Seção 9.6.3, “Aceder a partição a usar UUID”.

Como o sistema udev é de certa forma um alvo em movimento, deixo os detalhes para outras documentações e descrevo a informação mínima aqui.

| Atenção
Não tente executar programas de longa duração como o script de backup com `RUN` nas regras do udev como mencionado em udev(7). Por favor, crie um ficheiro systemd.service(5) adequado e active-o. Veja Seção 10.2.3.2, “Cópia de segurança acionada por evento de montagem”.

## 3.10. A inicialização de módulos do kernel

O programa modprobe(8) permite-nos configurar o kernel Linux em execução a partir do processo de utilizador ao adicionar e remover módulos do kernel. O sistema udev (veja Seção 3.9, “O sistema udev”) automatiza a invocação dele para ajudar na inicialização dos módulos de kernel.

Existem módulos de não-hardware e módulos driver de hardware especial como os seguintes que precisam de ser pré-carregados ao listá-los no ficheiro "`/etc/modules`" (veja modules(5)).

- módulos TUN/TAP que disponibilizam aparelhos de rede Point-to-Point virtuais (TUN) e aparelhos de rede Ethernet virtuais (TAP),

- módulos netfilter que disponibilizam capacidades de firewall netfilter (iptables(8), Seção 5.7, “Infraestrutura netfilter”) e

- módulos de driver watchdog timer.

Os ficheiros de configuração para o programa modprobe(8) estão localizados sob o diretório "`/etc/modprobes.d/`" como explicado em modprobe.conf(5). (Se deseja evitar que alguns módulos do kernel sejam carregados automaticamente, considere metê-los em lista negra no ficheiro "`/etc/modprobes.d/blacklist`".)

O ficheiro "`/lib/modules/version/modules.dep`" gerado pelo programa depmod(8) descreve as dependências dos módulos usados pelo programa modprobe(8).

| Nota
Se tiver problemas com o carregamento de módulos durante o arranque ou com o modprobe(8), "`depmod -a`" pode resolver esses problemas ao reconstruir "`modules.dep`".

O programa modinfo(8) mostra informação sobre um módulo do kernel Linux.

O programa lsmod(8) formata lindamente o conteúdo de "`/proc/modules`" e mostra que módulos do kernel que estão atualmente carregados.

| Dica
Pode identificar o hardware exacto no seu sistema. Veja Seção 9.5.3, “Identificação do hardware”. Pode configurar o hardware durante o arranque para ativar as funcionalidades esperadas do hardware. Veja Seção 9.5.4, “Configuração do hardware”. Pode provavelmente adicionar suporte para o seu aparelho especial ao recompilar o kernel. Veja Seção 9.10, “O kernel”.

Capítulo 2. Gestão de pacotes Debian |  | Capítulo 4. Autenticação e controlos de acesso