ARCHINSTALL(1)

NOME
archinstall - Documentação do archinstall

archinstall é uma biblioteca que pode ser usada para instalar o Arch Linux. A biblioteca vem empacotada com diferentes instaladores pré-configurados, como o instalador padrão Instalação guiada.

Uma demonstração do instalador de Instalação guiada pode ser vista aqui: https://www.youtube.com/watch?v=9Xt7X_Iqg6E.

Alguns dos recursos do Archinstall são:

•   Separação em contextos. A biblioteca sempre executa chamadas em ordem sequencial para garantir que as etapas de instalação não se sobreponham ou sejam executadas na ordem errada. Ela também oferece suporte a (e usa) envoltórios de contexto para garantir que tarefas de limpeza e final, como mkinitcpio, sejam chamadas quando necessário.

•   Transparência total Logs e insights podem ser encontrados em /var/log/archinstall tanto no ISO ativo quanto parcialmente no sistema instalado.

•   Acessível O Archinstall funciona com espeakup e outras ferramentas de acessibilidade graças ao uso de um TUI.

INSTALAÇÃO GUIADA

O Archinstall vem com um Instalador Guiado pré-programado que guia você pelas etapas obrigatórias, bem como algumas configurações opcionais que podem ser feitas.

NOTA: Outros scripts pré-programados podem ser invocados executando archinstall <script> (sem .py). Para ver uma lista completa de scripts, execute archinstall --script list ou verifique o diretório scripts do código-fonte.

NOTA: É recomendável executar o archinstall a partir do ISO oficial do Arch Linux.

AVISO: O instalador não configurará o WiFi antes do início da instalação. Você precisa ler sobre conectividade no Arch Linux antes de continuar.

  Executando a instalação guiada

Para iniciar o instalador, execute o seguinte no ISO mais recente do Arch Linux:

    archinstall

Como o Instalador Guiado é o script padrão, isso é o equivalente a executar archinstall guided

A instalação guiada também oferece suporte a instalação com respostas pré-configuradas para todas as etapas guiadas. Esta pode ser uma maneira rápida e conveniente de executar novamente uma ou várias instalações.

Há dois arquivos de configuração, ambos opcionais.

  --config

Este parâmetro recebe um arquivo .json local ou remoto como argumento e contém a configuração geral e as respostas do menu para o instalador guiado.

NOTA: Você sempre pode obter as opções mais recentes para este arquivo com archinstall --dry-run, que executa o instalador guiado em um modo seguro, onde nenhuma ação permanente será tomada no seu sistema, mas simula uma execução e salva a configuração no disco.

  Exemplo de uso

    archinstall --config https://domain.lan/config.json

O conteúdo de https://domain.lan/config.json:

    {
        "__separator__": null,
        "additional-repositories": [],
        "archinstall-language": "English",
        "audio_config": null,
        "bootloader": "Systemd-boot",
        "config_version": "2.6.0",
        "debug": false,
        "disk_config": {
            "config_type": "manual_partitioning",
            "device_modifications": [
                {
                    "device": "/dev/sda",
                    "partitions": [
                        {
                            "btrfs": [],
                            "flags": [
                                "boot"
                            ],
                            "fs_type": "fat32",
                            "length": {
                                "sector_size": null,
                                "total_size": null,
                                "unit": "B",
                                "value": 99982592
                            },
                            "mount_options": [],
                            "mountpoint": "/boot",
                            "obj_id": "369f31a8-2781-4d6b-96e7-75680552b7c9",
                            "start": {
                                "sector_size": {
                                    "sector_size": null,
                                    "total_size": null,
                                    "unit": "B",
                                    "value": 512
                                },
                                "total_size": null,
                                "unit": "sectors",
                                "value": 34
                            },
                            "status": "create",
                            "type": "primary"
                        },
                        {
                            "btrfs": [],
                            "flags": [],
                            "fs_type": "fat32",
                            "length": {
                                "sector_size": null,
                                "total_size": null,
                                "unit": "B",
                                "value": 100000000
                            },
                            "mount_options": [],
                            "mountpoint": "/efi",
                            "obj_id": "13cf2c96-8b0f-4ade-abaa-c530be589aad",
                            "start": {
                                "sector_size": {
                                    "sector_size": null,
                                    "total_size": null,
                                    "unit": "B",
                                    "value": 512
                                },
                                "total_size": {
                                    "sector_size": null,
                                    "total_size": null,
                                    "unit": "B",
                                    "value": 16106127360
                                },
                                "unit": "MB",
                                "value": 100
                            },
                            "status": "create",
                            "type": "primary"
                        },
                        {
                            "btrfs": [],
                            "flags": [],
                            "fs_type": "ext4",
                            "length": {
                                "sector_size": null,
                                "total_size": null,
                                "unit": "B",
                                "value": 15805127360
                            },
                            "mount_options": [],
                            "mountpoint": "/",
                            "obj_id": "3e75d045-21a4-429d-897e-8ec19a006e8b",
                            "start": {
                                "sector_size": {
                                    "sector_size": null,
                                    "total_size": null,
                                    "unit": "B",
                                    "value": 512
                                },
                                "total_size": {
                                    "sector_size": null,
                                    "total_size": null,
                                    "unit": "B",
                                    "value": 16106127360
                                },
                                "unit": "MB",
                                "value": 301
                            },
                            "status": "create",
                            "type": "primary"
                        }
                    ],
                    "wipe": false
                }
            ]
        },
        "disk_encryption": {
            "encryption_type": "luks",
            "partitions": [
                "3e75d045-21a4-429d-897e-8ec19a006e8b"
            ]
        },
        "hostname": "archlinux",
        "kernels": [
            "linux"
        ],
        "locale_config": {
            "kb_layout": "us",
            "sys_enc": "UTF-8",
            "sys_lang": "en_US"
        },
        "mirror_config": {
            "custom_mirrors": [],
            "mirror_regions": {
                "Sweden": [
                    "https://mirror.osbeck.com/archlinux/$repo/os/$arch",
                    "https://mirror.bahnhof.net/pub/archlinux/$repo/os/$arch",
                    "https://ftp.myrveln.se/pub/linux/archlinux/$repo/os/$arch",
                    "https://ftp.lysator.liu.se/pub/archlinux/$repo/os/$arch",
                    "https://ftp.ludd.ltu.se/mirrors/archlinux/$repo/os/$arch",
                    "https://ftp.acc.umu.se/mirror/archlinux/$repo/os/$arch",
                    "http://mirror.bahnhof.net/pub/archlinux/$repo/os/$arch",
                    "http://ftpmirror.infania.net/mirror/archlinux/$repo/os/$arch",
                    "http://ftp.myrveln.se/pub/linux/archlinux/$repo/os/$arch",
                    "http://ftp.lysator.liu.se/pub/archlinux/$repo/os/$arch",
                    "http://ftp.acc.umu.se/mirror/archlinux/$repo/os/$arch"
                ]
            }
        },
        "network_config": {},
        "no_pkg_lookups": false,
        "ntp": true,
        "offline": false,
        "packages": [],
        "parallel downloads": 0,
        "profile_config": null,
        "save_config": null,
        "script": "guided",
        "silent": false,
        "swap": true,
        "timezone": "UTC",
        "version": "2.6.0"
    }

  Opções de --config

AVISO: Todas as entradas de chave e valor devem estar em conformidade com o padrão JSON. Abaixo estão exemplos legíveis por humanos com links, quebrando efetivamente a sintaxe. Adapte as descrições abaixo para atender às suas necessidades e ao formato JSON.

NOTA: Role para a direita na tabela para ver as opções necessárias.

  Opções JSON
Chave | Valor(es) | Descrição | Obrigatório
additional-repositories | [ multilib, testing ] | Habilita um ou mais repositórios de teste e multilib antes de prosseguir com a instalação | Não
archinstall-language | lang | Define o idioma da interface de usuário de base texto (TUI) usado (certifique-se de usar o valor ``lang``, e não ``abbr``) | Não
audio_config | pipewire, pulseaudio | Servidor de áudio a ser instalado | Não
bootloader | Systemd-boot, grub | Gerenciador de inicialização a ser instalado (grub sendo obrigatório em máquinas BIOS) | Sim
debug | true, false | Habilita saída de depuração | Não
disk_config | Leia mais em Configuração de disco | Contém a configuração de disco desejada a ser usada durante a instalação | Não
disk_encryption | Leia mais em Criptografia de disco | Parâmetros para criptografia de disco aplicados sobre disk_config | Não
hostname | str | Uma string que define o nome de máquina da sua máquina na rede (o padrão é ``archinstall``) | Não
kernels | [ linux, linux-hardened, linux-lts, linux-rt, linux-rt-lts, linux-zen ] | Define quais kernels devem ser instalados e configurados nas opções do gerenciador de inicialização | Sim
custom-commands | Leia mais em Comandos personalizados | Comandos personalizados que serão executados após a instalação com chroot dentro do sistema instalado | Não
locale_config | {kb_layout: lang, sys_enc: Character encoding, sys_lang: locale} | Define o mapa de teclas do teclado, a codificação do sistema e a localidade do sistema | Não
mirror_config | {custom_mirrors: [ https://... ], mirror_regions: { "Worldwide": [ "https://geo.mirror.pkgbuild.com/$repo/os/$arch" ] } } | Define vários espelhos (o padrão é o ``/etc/pacman.d/mirrors`` da ISO, se não definido) | Não
network_config | `veja as opções em Configuração de rede` | Define qual tipo de configuração de rede (se houver) deve ser usado | Não
no_pkg_lookups | true, false | Desabilita verificação de pacotes em https://archlinux.org/packages/ | Não
ntp | true, false | Habilita ou desabilita NTP durante a instalação | Não
offline | true, false | Habilita ou desabilita certas verificações online tal como alcance de espelhos etc. | Não
packages | [ <pacote1>, <pacote2>, ... ] | Uma lista de pacotes para instalar durante a instalação | Não
parallel downloads | 0-∞ | Define um determinado número de downloads paralelos a serem usados ​​pelo pacman | Não
profile_config | `leia mais na seção de perfis` | Instala um perfil dado se definido | Não
script | guided (padrão), minimal, only_hdd, unattended | Quando usado para executar automaticamente uma instalação, isso define qual script executar automaticamente | Não
silent | true, false | Desabilita ou habilita perguntas do usuário usando o TUI | Não
swap | true, false | Habilita ou desabilita swap | Não
timezone | timezone | Define um fuso horário para o sistema instalado | Não

NOTA: Se nenhuma entrada for encontrada em disk_config, a instalação guiada do archinstall usará o que estiver montado atualmente em /mnt/archinstall sem executar nenhuma operação de disco.

  Opções para --creds

Creds é um arquivo de configuração separado para separar opções normais de dados mais sensíveis, como senhas. Abaixo está um exemplo de como definir a senha de root e abaixo disso estão descrições de outros valores que podem ser definidos.

    {
        "!root-password" : "PapaiNoel2022"
    }

  Opções de --creds
Chave | Valores | Descrição | Obrigatório
!encryption-password | str | Senha para criptografar o disco, não criptografada se a senha não for fornecida | Não
!root-password | str | A senha da conta root | Não
!users | { "username": "<USUÁRIO>", "!password": "<SENHA>", "sudo": false } | Lista de credenciais de usuários regulares, veja a configuração para referência | Talvez

NOTA: !users é opcional somente se !root-password foi definido. !users será imposto caso contrário e a quantidade mínima de usuários com privilégios sudo necessária será definida como 1.

NOTA: As chaves começam com ! porque as funções de log internas mascararão quaisquer chaves que comecem com explicações de logs e configurações irrestritas.

PROBLEMAS CONHECIDOS

Alguns problemas estão fora do escopo do projeto archinstall, e os que conhecemos estão listados abaixo.

  Espera pela sincronização de tempo #2144

A causa raiz usual disso é a topologia da rede. Mais especificamente, timedatectl show não pode executar uma sincronização de tempo adequada com os servidores padrão.

Reiniciar systemd-timesyncd.service pode funcionar, mas na maioria das vezes é necessário configurar /etc/systemd/timesyncd.conf para corresponder ao seu projeto de rede.

NOTA: Se você sabe que a hora na máquina está correta, você pode executar archinstall --skip-ntp para ignorar a sincronização de hora.

  Ausência do driver proprietário da Nvidia #2002

Em alguns casos, o driver nvidia pode não ter todos os pacotes necessários instalados. Isso ocorre devido à seleção do kernel e/ou configurações de hardware que exigem pacotes adicionais para funcionar corretamente.

Uma solução alternativa comum é instalar o pacote linux-headers e nvidia-dkms

  Erro em CPUs ARM, 32 bits e outros tipos #1686, #2185

Este é um problema conhecido e abrangente. Oficialmente apenas X'tty: link https://wiki.archlinux.org/title/Frequently_asked_questions#What_architectures_does_Arch_support?'x86_64 tem suporte no Arch Linux. Portanto, pouco esforço foi feito para dar suporte a outras plataformas.

Em teoria, outras arquiteturas deveriam funcionar, mas pequenas peculiaridades podem surgir.

Pull requests são bem-vindas, mas, por favor, sejam respeitosos com os atrasos em mesclar. Outras correções, problemas ou recursos serão priorizados pelos motivos acima.

  O chaveiro está desatualizado #2213

Problemas de chave ausentes tendem a ser que o pacote archlinux-keyring está desatualizado, geralmente como resultado de uma ISO desatualizada. Há uma tentativa do upstream de corrigir esse problema, que é o archlinux-keyring-wkd-sync.service

O serviço inicia quase imediatamente durante a inicialização e, se a rede não for configurada a tempo, o serviço falhará. Posteriormente, a execução do archinstall pode operar em um chaveiro antigo, apesar de haver um serviço de atualização para isso.

Não há realmente nenhuma maneira de contornar esse problema de forma confiável ao longo do tempo no archinstall. Em vez disso, esforços para o serviço upstream devem ser considerados o caminho a seguir. E/ou chaves não expirando entre uma quantidade sensata de ISOs.

NOTA: O problema também pode acontecer em novas ISOs, mesmo alguns dias após o lançamento, pois algumas chaves podem expirar logo após o chaveiro ser "gravado" na ISO.

NOTA: Outro problema comum relacionado à rede não estar configurada é que o tempo pode não estar definido corretamente - resultando na incapacidade de atualização do chaveiro. Veja Espera pela sincronização de tempo #2144.

  Pacotes AUR

Este também é um problema geral. AUR não é suportado, e até que isso mude, não podemos usar pacotes AUR para resolver solicitações de recursos em archinstall.

Isso significa que solicitações de recursos como suporte a sistemas de arquivos como ZFS não podem ser adicionadas, e problemas também não podem ser resolvidos usando pacotes AUR.

NOTA: Mas com o espírito de dar opções à comunidade, archinstall suporta plugins Python, o que significa que você pode executar archinstall --plugin <url> e obter um plugin do AUR.

torxed/archinstall-aur é uma implementação de referência para plugins:

    # archinstall --plugin https://archlinux.life/aur-plugin

phisch/archinstall-aur é outra alternativa:

    # archinstall --plugin https://raw.githubusercontent.com/phisch/archinstall-aur/master/archinstall-aur.py

AVISO: Isso permitirá o uso não suportado do AUR durante a instalação.

RELATAR PROBLEMAS & BUGS

Problemas e bugs devem ser relatados em https://github.com/archlinux/archinstall/issues.

Perguntas gerais, melhorias e problemas de segurança também podem ser relatados lá. Para problemas rápidos ou se precisar de ajuda, vá até o servidor Discord que tem um canal de ajuda.

  Arquivos log

Ao submeter um pedido de ajuda, inclua o /var/log/archinstall/install.log. Ele pode ser encontrado tanto no ISO ao vivo quanto no sistema de arquivos instalado se os pacotes base foram amarrados.

DICA:
Uma maneira fácil de enviar logs é curl -F'file=@/var/log/archinstall/install.log' https://0x0.st.
Tenha cuidado ao enviar outros arquivos de log, mas archinstall promete manter install.log seguro para publicação pública!

Há arquivos de log adicionais em /var/log/archinstall/ que podem ser úteis:

•   /var/log/archinstall/user_configuration.json - Armazena a maioria das respostas guiadas no instalador

•   /var/log/archinstall/user_credentials.json - Armazena todos os nomes de usuários ou senhas, podem ser passados ​​para --creds

•   /var/log/archinstall/user_disk_layouts.json - Armazena os discos escolhidos e seus layouts

•   /var/log/archinstall/install.log - Um arquivo de log sobre quais etapas foram executadas pelo archinstall

•   /var/log/archinstall/cmd_history.txt - Um histórico completo de comandos, comando por comando, em ordem

•   /var/log/archinstall/cmd_output.txt - Uma saída bruta de todos os comandos que foram executados pelo archinstall

    AVISO: Nós apenas tentamos garantir que /var/log/archinstall/install.log esteja livre de informações sensíveis. Qualquer outro arquivo de log deve ser fornecido com o máximo cuidado!

DISCORD

Há um canal do Discord que é frequentado por alguns colaboradores.

Para entrar no servidor, vá para https://discord.gg/aDeMffrxNg e entre. Não há muitas regras além do bom senso e de tratar os outros com respeito. O bate-papo geral também é para coisas fora do tópico.

Há a função @Party Animals se você quiser notificações de novos lançamentos que são postados no canal #Release Party. Outra coisa é que a função @Contributors pode ser ativada por contribuidores escrevendo !verify e seguindo o processo de verificação.

Entre, esperamos ver você lá! : )

BIBLIOTECA PYTHON

O Archinstall é enviado em PyPi como archinstall. Mas a biblioteca também pode ser instalada manualmente.

AVISO: Essas etapas não são necessárias se você quiser usar o archinstall no ISO oficial do Arch Linux.

  Instalando com pacman

Archinstall está nos link https://wiki.archlinux.org/index.php/Official_repositories'repositórios oficiais. E ele também instalará o archinstall como uma biblioteca python.

Para instalar a biblioteca e o script archinstall:

    pacman -S archinstall

Como alternativa, você pode instalar apenas a biblioteca e não o executável auxiliar usando o pacote python-archinstall.

  Instalando a partir do PyPI

The basic concept of PyPI applies using pip.

    pip install archinstall

  Instalando a partir do código-fonte

Você também pode instalar usando o código-fonte. Para simplificar, usaremos git clone neste exemplo.

    git clone https://github.com/archlinux/archinstall

Você pode mover a pasta para o seu projeto e simplesmente fazer

    import archinstall

Ou você pode usar o build e o installer do PyPA para instalá-lo no caminho do módulo do Python.

    $ cd archinstall
    $ python -m build .
    $ python -m installer dist/*.whl

MÓDULO PYTHON

O Archinstall suporta execução em modo de módulo. A maneira como a biblioteca é invocada no modo de módulo é limitada à execução de scripts na pasta scripts.

Portanto, é importante colocar qualquer script ou perfil que você deseja invocar na pasta de exemplos antes de compilar e instalar.

  Pré-requisitos

Vamos supor que você seguiu o método Instalando a partir do código-fonte. Antes de realmente instalar a biblioteca, você precisará colocar seus scripts de instalação personalizados em scripts como um arquivo python.

Mais sobre como criá-los na próxima seção.

AVISO: Isso está sujeito a alterações no futuro, pois esse método é um pouco rígido no momento. O caminho do script se tornará um parâmetro. Mas, por enquanto, isso é por design.

  Criando um script

Vamos criar um test_installer - instalador como exemplo. Isso pressupõe que a pasta ./archinstall seja um git-clone do repositório principal. Começamos criando "scripts/test_installer.py". O posicionamento aqui é importante mais tarde.

Este script agora já pode ser chamado usando python -m archinstall test_installer após uma instalação bem-sucedida da biblioteca em si. Mas o script não fará muita coisa. Então faremos algo simples como listar todos os discos rígidos como um exemplo.

Para fazer isso, começaremos importando archinstall em nosso "scripts/test_installer.py" e chamaremos uma função em archinstall.

    import archinstall
    print(archinstall.disk.device_handler.devices)

Agora, vá em frente e faça referência ao método de instalação Instalando a partir do código-fonte. Após executar python -m archinstall test_installer, ele deve imprimir algo parecido com:

    [
        BDevice(
            disk=<parted.disk.Disk object at 0x7fbe17156050>,
            device_info=_DeviceInfo(
                model='PC801 NVMe SK hynix 512GB',
                path=PosixPath('/dev/nvme0n1'),
                type='nvme',
                total_size=Size(value=512110190592, unit=<Unit.B: 1>,
                sector_size=SectorSize(value=512, unit=<Unit.B: 1>)),
                free_space_regions=[
                    <archinstall.lib.disk.device_model.DeviceGeometry object at 0x7fbe166c4250>,
                    <archinstall.lib.disk.device_model.DeviceGeometry object at 0x7fbe166c4c50>,
                    <archinstall.lib.disk.device_model.DeviceGeometry object at 0x7fbe166c4a10>],
                sector_size=SectorSize(value=512, unit=<Unit.B: 1>),
                read_only=False,
                dirty=False
            ),
            partition_infos=[
                _PartitionInfo(
                    partition=<parted.partition.Partition object at 0x7fbe166c4a90>,
                    name='primary',
                    type=<PartitionType.Primary: 'primary'>,
                    fs_type=<FilesystemType.Fat32: 'fat32'>,
                    path='/dev/nvme0n1p1',
                    start=Size(value=2048, unit=<Unit.sectors: 'sectors'>, sector_size=SectorSize(value=512, unit=<Unit.B: 1>)),
                    length=Size(value=535822336, unit=<Unit.B: 1>, sector_size=SectorSize(value=512, unit=<Unit.B: 1>)),
                    flags=[
                        <PartitionFlag.BOOT: flag_id=1, alias=None>,
                        <PartitionFlag.ESP: flag_id=18, alias=None>
                    ],
                    partn=1,
                    partuuid='a26be943-c193-41f4-9930-9341cf5f6b19',
                    uuid='6EE9-2C00',
                    disk=<parted.disk.Disk object at 0x7fbe17156050>,
                    mountpoints=[
                        PosixPath('/boot')
                    ],
                    btrfs_subvol_infos=[]
                ),
                _PartitionInfo(...)
            ]
        )
    ]

Isso significa que seu script está no lugar certo e archinstall está funcionando conforme o esperado.

NOTA: A maioria das chamadas, incluindo a acima, requer privilégios de root.

PLUGINS PYTHON

archinstall suporta plugins por meio de dois métodos.

O primeiro método é diretamente via parâmetro --plugin ao executar como uma ferramenta CLI. Isso carregará um plugin específico localmente ou remotamente via um caminho.

O segundo método é via a descoberta de plugins embutida do Python usando pontos de entrada categorizados como archinstall.plugin.

  Parâmetro --plugin

O parâmetro tem o benefício de ser armazenado no estado --conf, o que significa que ao executar novamente uma instalação — o plugin será carregado automaticamente. Sua limitação é que ele requer que um caminho inicial seja conhecido e escrito e seja trabalhoso.

  Descoberta de plugins

Este método permite que vários plugins sejam carregados com a desvantagem de que eles precisam ser instalados previamente no sistema que executa archinstall. Isso tem como alvo principalmente aqueles que constroem seus próprios ISOs e configurações específicas de pacotes para suas necessidades.

  O que é suportado?

Atualmente, a documentação para isso é escassa. Até que isso seja resolvido, a melhor maneira de encontrar recursos suportados é pesquisar o código-fonte para plugin.on_, pois isso dará uma indicação clara de quais chamadas são feitas para plugins.

  Como ela funciona?

Os plugins archinstall usam uma abordagem orientada à descoberta, onde os plugins são consultados para certas funções. Como exemplo, se um plugin tem a seguinte função:

    def on_pacstrap(*packages):
        ...

A função archinstall.Pacman().strap(["alguns pacotes"]) é codificada para iterar plugins e procurar por on_pacstrap no plugin. Se a função existir, .strap() chamará a função do plugin e substituirá a lista de pacotes inicial pelo resultado do plugin.

A melhor maneira de documentar essas chamadas ainda não foi decidida, pois é difícil documentar esse comportamento dinamicamente.

  Escrevendo seu próprio?

A maneira mais simples atualmente é olhar para uma implementação de referência ou para a comunidade. Duas delas são:

•   torxed/archinstall-aur

•   phisch/archinstall-aur

    E procurar por plugin.on_ na base de código para descobrir o que archinstall irá procurar. Pull requests são bem-vindas para ampliar o suporte para isso.

ARCHINSTALL.INSTALLER

O instalador é a classe principal para acessar uma instância de instalação. Você pode olhar para essa classe como a instalação que você tem ou irá executar.

Qualquer coisa relacionada a parte interna da instalação será encontrada nesta classe.

archinstall.Installer(target: Path, disk_config: DiskLayoutConfiguration, disk_encryption: DiskEncryption | None = None, base_packages: list[str] = [], kernels: list[str] | None = None)

AUTOR
Anton Hvornum

DIREITOS AUTORAIS
2022, Anton Hvornum

TRADUÇÃO
A tradução para português brasileiro desta página man foi criada por Rafael Fontenelle <rafaelff@gnome.org>

Esta tradução é uma documentação livre; leia a Licença Pública Geral GNU Versão 3 (https://www.gnu.org/licenses/gpl-3.0.html) ou posterior para as condições de direitos autorais. Nenhuma responsabilidade é aceita.

Se você encontrar algum erro na tradução desta página de manual, envie um e-mail para a lista de discussão de tradutores (debian-l10n-portuguese@lists.debian.org).