ARCHINSTALL(1) python-archinstall ARCHINSTALL(1)

archinstall - Documentação do archinstall

archinstall is library which can be used to install Arch Linux. The library comes packaged with different pre-configured installers, such as the default Guided installation installer.

A demo of the Guided installation installer can be seen here: 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, swiss, 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 is a separate configuration file to separate normal options from more sensitive data like passwords. Below is an example of how to set the root password and below that are description of other values that can be set.

{
    "!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.

Some issues are out of the archinstall projects scope, and the ones we know of are listed below.

The usual root cause of this is the network topology. More specifically timedatectl show cannot perform a proper time sync against the default servers.

Restarting systemd-timesyncd.service might work but most often you need to configure /etc/systemd/timesyncd.conf to match your network design.

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.

In some instances, the nvidia driver might not have all the necessary packages installed. This is due to the kernel selection and/or hardware setups requiring additional packages to work properly.

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

#2185"

This is a bit of a catch-all known issue. Officially x86_64 is only supported by Arch Linux. Hence little effort have been put into supporting other platforms.

In theory, other architectures should work but small quirks might arise.

PR's are welcome but please be respectful of the delays in merging. Other fixes, issues or features will be prioritized for the above reasons.

Missing key-issues tend to be that the archlinux-keyring package is out of date, usually as a result of an outdated ISO. There is an attempt from upstream to fix this issue, and it's the archlinux-keyring-wkd-sync.service

The service starts almost immediately during boot, and if network is not configured in time — the service will fail. Subsequently the archinstall run might operate on a old keyring despite there being an update service for this.

There is really no way to reliably over time work around this issue in archinstall. Instead, efforts to the upstream service should be considered the way forward. And/or keys not expiring between a sane amount of ISO's.

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.

This is also a catch-all issue. AUR is unsupported, and until that changes we cannot use AUR packages to solve feature requests in archinstall.

This means that feature requests like supporting filesystems such as ZFS can not be added, and issues cannot be solved by using AUR packages either.

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.

Issues and bugs should be reported over at 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.

When submitting a help ticket, please include the /var/log/archinstall/install.log. It can be found both on the live ISO but also in the installed filesystem if the base packages were strapped in.

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!

There are additional log files under /var/log/archinstall/ that can be useful:

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

To join the server, head over to https://discord.gg/aDeMffrxNg and join in. There's not many rules other than common sense and to treat others with respect. The general chat is for off-topic things as well.

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

You can also install using the source code. For sake of simplicity we will use git clone in this example.

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.

November 23, 2024