ARCHINSTALL(1) python-archinstall ARCHINSTALL(1)

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.

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.

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.

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 0.0 3.5 { "username": "<USUÁRIO>", "!password": "<SENHA>", "sudo": false } 168u 168u 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.

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

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.

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

#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.

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.

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.

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.

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!

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á! : )

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.

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.

The basic concept of PyPI applies using pip.

pip install archinstall

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

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

Anton Hvornum

2022, Anton Hvornum

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 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.

23 de janeiro de 2025