Come installare Arch Linux

Arch Linux ha la fama di essere difficile da installare perché non nasconde le scelte dietro a una procedura grafica. In realtà il processo diventa comprensibile quando lo si divide in passaggi: preparare il disco, installare il sistema minimo, configurarlo e renderlo avviabile.

Questa guida parte da una configurazione semplice e affidabile. Più avanti trovi anche un percorso avanzato con cifratura LUKS2, Btrfs, snapshot Snapper, Unified Kernel Image, Secure Boot e sblocco tramite TPM2.

Aggiornamento del 23 luglio 2026: ho rivisto l’intera procedura sulle indicazioni correnti di Arch Linux. Sono stati aggiornati il controllo UEFI, la rete, pacstrap, arch-chroot, NetworkManager, la gestione degli utenti, systemd-boot e mkinitcpio. La vecchia procedura LVM cifrata, incompleta nella fase di boot, è stata sostituita da un percorso LUKS2, Btrfs, Snapper e UKI separato e verificabile.

La procedura principale è pensata per un PC x86-64 avviato in modalità UEFI, con un disco dedicato ad Arch Linux. Il partizionamento cancella i dati del disco scelto. Fai un backup e non usare i comandi su un sistema dual boot senza adattarli alla tua disposizione delle partizioni.

L’ISO include anche archinstall, l’installer guidato ufficiale. È una buona alternativa se vuoi arrivare prima a un sistema funzionante; questa guida usa il metodo manuale perché permette di capire ogni componente. Prima di esportare o condividere configurazioni e log di installazione, controlla sempre che non contengano dati sensibili.

Download Arch Linux

Arch Linux Progetto internazionale Open source Rolling release Distribuzione GNU/Linux rolling release orientata a semplicità, controllo e configurazione manuale, con pacchetti aggiornati e una documentazione particolarmente completa.

Scarica l’ISO e la relativa firma dalla pagina ufficiale di download e verifica. Le immagini sono destinate alle nuove installazioni: un sistema Arch già installato si aggiorna con pacman -Syu, senza reinstallare una ISO più recente.

Verificare l’immagine

La firma PGP autentica l’immagine; il solo checksum rileva un file corrotto, ma non sostituisce la verifica della firma. Un esempio con GnuPG è:

gpg --keyserver-options auto-key-retrieve \
  --verify archlinux-YYYY.MM.DD-x86_64.iso.sig \
  archlinux-YYYY.MM.DD-x86_64.iso

Sostituisci YYYY.MM.DD con la versione scaricata e confronta l’impronta della chiave mostrata da GnuPG con quella del developer indicato nella pagina ufficiale.

Per scrivere la ISO su una chiavetta, puoi usare un’applicazione grafica affidabile oppure dd. Prima individua con precisione il dispositivo:

lsblk
sudo dd bs=4M if=archlinux-YYYY.MM.DD-x86_64.iso of=/dev/sdX conv=fsync oflag=direct status=progress

/dev/sdX deve indicare l’intera chiavetta, non una sua partizione. Un dispositivo errato viene sovrascritto senza possibilità di recupero.

Avviare l’ambiente live

L’ISO ufficiale non si avvia con Secure Boot attivo. Disabilitalo temporaneamente nel firmware, seleziona la chiavetta dal menu di boot e scegli Arch Linux install medium.

Imposta il layout italiano:

loadkeys it

Controlla che il sistema sia stato avviato in UEFI:

cat /sys/firmware/efi/fw_platform_size

Il valore atteso è 64. Se il file non esiste, probabilmente hai avviato la macchina in modalità BIOS o CSM e devi correggere l’impostazione nel firmware o nell’hypervisor.

Verifica anche data e sincronizzazione:

timedatectl

Collegarsi a Internet

Con Ethernet, DHCP dovrebbe funzionare automaticamente nell’ambiente live. Controlla le interfacce e la connettività:

ip link
ping -c 3 archlinux.org

Per il Wi-Fi entra nella console di iwd:

iwctl

Poi sostituisci wlan0 e NomeRete con i valori reali:

device list
station wlan0 scan
station wlan0 get-networks
station wlan0 connect "NomeRete"
exit

Ripeti il ping prima di continuare. La configurazione della rete presente nella ISO non viene copiata automaticamente nel sistema installato: per questo installeremo NetworkManager.

Individuare e partizionare il disco

Elenca i dischi mostrando modello, dimensione, filesystem e punti di mount:

lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS,MODEL

Negli esempi userò un SSD NVMe chiamato /dev/nvme0n1. Su un disco SATA potresti avere /dev/sda, con partizioni /dev/sda1 e /dev/sda2.

Non scegliere il disco in base al solo nome. Controlla anche capacità e modello, poi esegui nuovamente lsblk dopo il partizionamento.

Per una nuova installazione UEFI useremo una tabella GPT con due partizioni:

Partizione	Tipo	Dimensione	Mount point
/dev/nvme0n1p1	EFI System Partition	1 GiB	/boot
/dev/nvme0n1p2	Linux filesystem	spazio restante	/

Lo schema non riserva una partizione swap. Dopo l’installazione puoi usare zram o uno swap file; se vuoi l’ibernazione, pianifica invece una swap persistente abbastanza grande e configura anche il parametro di resume.

Avvia fdisk:

fdisk /dev/nvme0n1

All’interno di fdisk:

1. premi g per creare una tabella GPT;
2. premi n, accetta numero e settore iniziale, poi usa +1G;
3. premi t e seleziona il tipo EFI System;
4. premi di nuovo n e accetta i valori predefiniti per usare lo spazio restante;
5. premi p per controllare il risultato;
6. premi w soltanto quando sei certo del disco e del layout.

In dual boot non devi formattare una EFI System Partition già usata dagli altri sistemi. Questa guida considera invece un disco nuovo e dedicato.

Formattare e montare

Formatta la nuova ESP in FAT32 e la root in ext4:

mkfs.fat -F 32 /dev/nvme0n1p1
mkfs.ext4 /dev/nvme0n1p2

Monta prima la root e poi la ESP:

mount /dev/nvme0n1p2 /mnt
mount --mkdir /dev/nvme0n1p1 /mnt/boot

Controlla un’ultima volta:

findmnt /mnt
lsblk -f

Installare il sistema di base

Installa il sistema minimo, il kernel, i firmware, NetworkManager, sudo, un editor e le pagine di manuale:

pacstrap -K /mnt base linux linux-firmware networkmanager sudo nano man-db man-pages

Installa anche il microcode adatto alla CPU, scegliendo un solo pacchetto:

# CPU Intel
pacstrap -K /mnt intel-ucode

# CPU AMD
pacstrap -K /mnt amd-ucode

Su alcuni portatili può servire anche sof-firmware per l’audio. In una macchina virtuale, invece, microcode e gran parte dei firmware non sono necessari.

Con la configurazione predefinita, l’hook microcode di mkinitcpio incorpora l’aggiornamento CPU nell’initramfs principale. Le voci di systemd-boot useranno quindi soltanto initramfs-linux.img, senza caricare una seconda immagine intel-ucode.img o amd-ucode.img.

Genera fstab usando identificatori persistenti e controllalo:

genfstab -U /mnt >> /mnt/etc/fstab
less /mnt/etc/fstab

Non devono esserci righe duplicate. Entra quindi nel nuovo sistema:

arch-chroot -S /mnt

L’opzione -S, introdotta negli arch-install-scripts recenti, esegue il chroot in modalità systemd.

Configurare Arch Linux

Fuso orario e lingua

Imposta il fuso orario italiano:

ln -sf /usr/share/zoneinfo/Europe/Rome /etc/localtime
hwclock --systohc

Apri /etc/locale.gen:

nano /etc/locale.gen

Decommenta almeno:

en_US.UTF-8 UTF-8
it_IT.UTF-8 UTF-8

Genera le locale:

locale-gen

Crea /etc/locale.conf:

LANG=it_IT.UTF-8

E rendi permanente il layout della console in /etc/vconsole.conf:

KEYMAP=it

Hostname e rete

Inserisci in /etc/hostname un nome semplice, per esempio:

archbox

Abilita rete e sincronizzazione dell’orologio al prossimo avvio:

systemctl enable NetworkManager
systemctl enable systemd-timesyncd

Creare l’utente

Imposta prima una password robusta per l’utente root:

passwd

Crea poi l’utente normale, sostituendo nomeutente:

useradd -m -G wheel -s /bin/bash nomeutente
passwd nomeutente

Non è più necessario aggiungerlo manualmente ai vecchi gruppi audio, video, storage e optical: systemd-logind gestisce normalmente l’accesso ai dispositivi per la sessione attiva.

Apri sudoers con il controllo sintattico di visudo:

EDITOR=nano visudo

Decommenta questa riga:

%wheel ALL=(ALL:ALL) ALL

Dopo il primo avvio verifica davvero i privilegi:

sudo -v
sudo whoami

Il secondo comando deve restituire root.

Installare systemd-boot

Con la ESP montata in /boot, installa systemd-boot:

bootctl install
mkdir -p /boot/loader/entries

Recupera l’UUID della root:

blkid -s UUID -o value /dev/nvme0n1p2

Crea /boot/loader/loader.conf:

default arch.conf
timeout 3
console-mode max
editor no

Crea /boot/loader/entries/arch.conf, sostituendo UUID_ROOT:

title   Arch Linux
linux   /vmlinuz-linux
initrd  /initramfs-linux.img
options root=UUID=UUID_ROOT rw

È utile aggiungere anche /boot/loader/entries/arch-fallback.conf:

title   Arch Linux (fallback initramfs)
linux   /vmlinuz-linux
initrd  /initramfs-linux-fallback.img
options root=UUID=UUID_ROOT rw

Rigenera tutte le immagini initramfs e controlla le voci:

mkinitcpio -P
bootctl list

Primo riavvio

Esci dal chroot, smonta ricorsivamente e riavvia:

exit
umount -R /mnt
reboot

Rimuovi la chiavetta quando il firmware riparte. Dopo il login prova rete, sudo e aggiornamenti:

ping -c 3 archlinux.org
sudo -v
sudo pacman -Syu

Arch è una rolling release: usa sempre pacman -Syu per aggiornare database e pacchetti insieme. Gli aggiornamenti parziali, per esempio pacman -Sy seguito dall’installazione di un singolo pacchetto, non sono supportati.

Installare un desktop

Arch non impone un ambiente grafico. Per un desktop XFCE essenziale:

sudo pacman -S xorg-server xfce4 xfce4-goodies lightdm lightdm-gtk-greeter network-manager-applet pipewire pipewire-alsa pipewire-pulse wireplumber
sudo systemctl enable --now lightdm

Per grafica Intel o AMD, Mesa è la base più comune:

# Intel
sudo pacman -S mesa vulkan-intel

# AMD
sudo pacman -S mesa vulkan-radeon

Il vecchio consiglio di installare sempre xf86-video-intel non è più un buon default per l’hardware moderno. Per NVIDIA, invece, scegli il pacchetto in base alla GPU e al kernel consultando la guida NVIDIA di ArchWiki, perché una riga universale rischia di essere sbagliata.

In VirtualBox usa virtualbox-guest-utils; xf86-video-vmware riguarda VMware e non deve essere installato come generico driver VirtualBox.

Percorso avanzato: LUKS2, Btrfs, Snapper, UKI e Secure Boot

La configurazione seguente riunisce in un unico percorso tecnologie documentate separatamente da ArchWiki. I passaggi che dipendono dall’hardware restano evidenziati e non vanno applicati senza verificarli sul proprio sistema.

Questo percorso sostituisce formattazione, mount e boot della procedura base: non va eseguito sopra un’installazione ext4 già completata. Prima prova il flusso in una macchina virtuale e conserva una chiavetta Arch avviabile.

La catena ha obiettivi distinti:

Componente	Cosa protegge
LUKS2	i dati quando il disco è spento o rimosso
Btrfs	subvolume, compressione e snapshot, che non sostituiscono un backup
Snapper	creazione, catalogazione e pulizia degli snapshot Btrfs
UKI	kernel, initramfs e parametri riuniti in un singolo eseguibile EFI
Secure Boot	l’integrità della catena di avvio tramite firme
TPM2	lo sblocco condizionato allo stato misurato della macchina

Layout cifrato

Mantieni la ESP da 1 GiB come prima partizione e usa il resto come contenitore LUKS2. Prima di salvare la tabella con fdisk, imposta il tipo della seconda partizione su Linux LUKS invece di Linux filesystem. Dopo il partizionamento:

mkfs.fat -F 32 /dev/nvme0n1p1
cryptsetup luksFormat --type luks2 /dev/nvme0n1p2
cryptsetup open /dev/nvme0n1p2 cryptroot
mkfs.btrfs -L archroot /dev/mapper/cryptroot

Crea i subvolume per il sistema, la home e gli snapshot:

mount /dev/mapper/cryptroot /mnt
btrfs subvolume create /mnt/@
btrfs subvolume create /mnt/@home
btrfs subvolume create /mnt/@snapshots
umount /mnt

Montali con compressione e monta la ESP in /efi. Il subvolume @snapshots resta separato da @: in questo modo gli snapshot sopravvivono anche quando il subvolume di sistema viene sostituito durante un recupero.

mount -o subvol=@,compress=zstd /dev/mapper/cryptroot /mnt
mount --mkdir -o subvol=@home,compress=zstd /dev/mapper/cryptroot /mnt/home
mount --mkdir -o subvol=@snapshots,compress=zstd /dev/mapper/cryptroot /mnt/.snapshots
chmod 750 /mnt/.snapshots
mount --mkdir /dev/nvme0n1p1 /mnt/efi

Se non intendi usare Snapper puoi omettere @snapshots e il relativo mount. Non è necessario per avviare il sistema.

Nel pacstrap aggiungi i tool necessari:

pacstrap -K /mnt base linux linux-firmware btrfs-progs cryptsetup networkmanager sudo nano man-db man-pages intel-ucode

Su CPU AMD sostituisci intel-ucode con amd-ucode. Prosegui poi con genfstab, chroot, lingua, rete e utente come nella procedura base.

Dopo genfstab, controlla le righe Btrfs in /mnt/etc/fstab: devono identificare i mount tramite subvol=/@, subvol=/@home e, se lo hai creato, subvol=/@snapshots. La barra iniziale può essere omessa. Se è presente anche un’opzione subvolid=NUMERO, rimuovi soltanto quella dalle righe Btrfs. Il nome resta valido dopo un ripristino, mentre l’ID numerico cambia quando uno snapshot viene ricreato come nuovo @.

Initramfs systemd e UKI

In /etc/mkinitcpio.conf usa gli hook systemd e sd-encrypt:

HOOKS=(base systemd autodetect microcode modconf kms keyboard sd-vconsole block sd-encrypt filesystems fsck)

Recupera l’UUID del contenitore LUKS, non quello del filesystem Btrfs:

blkid -s UUID -o value /dev/nvme0n1p2

Crea /etc/kernel/cmdline su una sola riga:

rd.luks.name=UUID_LUKS=cryptroot root=/dev/mapper/cryptroot rootflags=subvol=@ rw

Apri /etc/mkinitcpio.d/linux.preset, commenta le righe default_image e fallback_image, quindi configura le UKI:

ALL_kver="/boot/vmlinuz-linux"
PRESETS=('default' 'fallback')

default_uki="/efi/EFI/Linux/arch-linux.efi"
fallback_uki="/efi/EFI/Linux/arch-linux-fallback.efi"
fallback_options="-S autodetect"

Genera le immagini e installa systemd-boot nella ESP:

mkdir -p /efi/EFI/Linux
mkinitcpio -P
bootctl --esp-path=/efi install

systemd-boot rileva automaticamente le UKI presenti in /efi/EFI/Linux, quindi non serve una voce manuale in loader/entries. Imposta però l’immagine normale come predefinita in /efi/loader/loader.conf:

default arch-linux.efi
timeout 3
console-mode max
editor no

Controlla infine che entrambe le UKI siano riconosciute:

bootctl --esp-path=/efi list

Attivare Secure Boot con sbctl

Prima completa un riavvio con Secure Boot ancora disattivato e verifica che entrambe le UKI funzionino. Poi installa sbctl:

sudo pacman -S sbctl

L’iscrizione di chiavi personalizzate dipende dal firmware. Su alcuni portatili la rimozione delle chiavi del produttore o Microsoft può impedire l’avvio di Option ROM e perfino l’accesso al firmware. Salva le chiavi correnti, consulta la documentazione del produttore e usa Setup Mode solo dopo avere verificato la procedura di recupero.

Porta Secure Boot in Setup Mode dal firmware, poi:

sudo sbctl status
sudo sbctl create-keys
sudo sbctl enroll-keys -m

L’opzione -m conserva anche i certificati Microsoft, necessari su molti sistemi per firmware e Option ROM. Firma le UKI e prepara una copia firmata di systemd-boot:

sudo sbctl sign -s /efi/EFI/Linux/arch-linux.efi
sudo sbctl sign -s /efi/EFI/Linux/arch-linux-fallback.efi
sudo sbctl sign -s -o /usr/lib/systemd/boot/efi/systemd-bootx64.efi.signed /usr/lib/systemd/boot/efi/systemd-bootx64.efi
sudo bootctl --esp-path=/efi update
sudo sbctl verify

Solo quando sbctl verify non segnala file necessari non firmati, riavvia, abilita Secure Boot e controlla:

bootctl status
sudo sbctl status

TPM2: sblocco con PIN e chiave di recupero

Il TPM2 è opzionale e va configurato dopo avere avviato con Secure Boot attivo. Prima aggiungi una recovery key LUKS e conservala offline in forma cifrata:

sudo systemd-cryptenroll --recovery-key /dev/nvme0n1p2

Testa subito la recovery key, senza aprire un nuovo mapping:

sudo cryptsetup open --test-passphrase /dev/nvme0n1p2

Poi puoi iscrivere il TPM legandolo almeno allo stato di Secure Boot, con verifica tramite PIN:

sudo systemd-cryptenroll --tpm2-device=auto --tpm2-pcrs=7 --tpm2-with-pin=yes /dev/nvme0n1p2

In /etc/kernel/cmdline aggiungi, usando lo stesso UUID LUKS:

rd.luks.options=UUID_LUKS=tpm2-device=auto

Rigenera e ricontrolla le firme:

sudo mkinitcpio -P
sudo sbctl verify

Il TPM non riconosce chi ha premuto il pulsante di accensione. Senza PIN, un portatile rubato intero può sbloccare automaticamente il disco e affidare la protezione alla schermata di login. Il TPM aumenta inoltre l’esposizione agli attacchi cold boot. Non cancellare la passphrase o la recovery key finché non hai testato aggiornamenti, firmware, fallback e recupero.

Il binding statico al PCR 7 controlla lo stato e i certificati di Secure Boot, ma non identifica da solo una specifica UKI. Per una protezione più completa e meno fragile durante gli aggiornamenti, Arch documenta le signed PCR policy sul PCR 11. È una configurazione più avanzata: segui la sezione PCR policies di ArchWiki invece di copiare combinazioni di PCR scelte per un altro computer.

Quando passphrase, recovery key e TPM sono stati verificati, salva anche una copia dell’header LUKS su un supporto esterno protetto:

sudo cryptsetup luksHeaderBackup /dev/nvme0n1p2 --header-backup-file /percorso/esterno/arch-luks-header.img

Il backup dell’header contiene i keyslot presenti al momento della creazione. Proteggilo come materiale sensibile e rigeneralo dopo modifiche importanti ai metodi di sblocco.

Snapper: snapshot opzionali ma consigliati

Snapper non è indispensabile, ma è una scelta particolarmente coerente con Btrfs. Invece di copiare tutti i file, gestisce gli snapshot nativi dei subvolume tramite il meccanismo copy-on-write di Btrfs: la creazione è rapida, lo spazio iniziale richiesto è ridotto e puoi applicare regole automatiche di conservazione e pulizia. Con snap-pac puoi inoltre creare una coppia di snapshot prima e dopo le operazioni di pacman.

Uno snapshot non è un backup: resta sullo stesso disco e non protegge da guasti, furto o perdita del contenitore LUKS. Inoltre questa configurazione fotografa @, ma non @home, @snapshots o la ESP montata in /efi, perché sono subvolume o filesystem separati.

Dopo il primo avvio riuscito, installa Snapper:

sudo pacman -S snapper

Il subvolume @snapshots esiste già. Per farlo gestire da Snapper bisogna quindi creare la configurazione root, eliminare il subvolume temporaneo generato dal comando e rimontare quello preparato durante l’installazione:

sudo umount /.snapshots
sudo rmdir /.snapshots
sudo snapper -c root create-config /
sudo btrfs subvolume delete /.snapshots
sudo mkdir /.snapshots
sudo mount /.snapshots
sudo chmod 750 /.snapshots

Imposta una conservazione moderata e abilita i timer di creazione e pulizia:

sudo snapper -c root set-config \
  TIMELINE_CREATE=yes TIMELINE_CLEANUP=yes \
  TIMELINE_LIMIT_HOURLY=5 TIMELINE_LIMIT_DAILY=7 \
  TIMELINE_LIMIT_WEEKLY=4 TIMELINE_LIMIT_MONTHLY=3 \
  TIMELINE_LIMIT_YEARLY=0
sudo systemctl enable --now snapper-timeline.timer snapper-cleanup.timer

Puoi verificare il funzionamento con uno snapshot manuale:

sudo snapper -c root create \
  --description "snapshot di prova" --cleanup-algorithm number
sudo snapper -c root list

Infine installa l’integrazione con pacman:

sudo pacman -S snap-pac

snap-pac usa hook di pacman e non richiede un servizio da abilitare. Dalla transazione successiva crea snapshot pre e post aggiornamento, utili per confrontare o annullare modifiche ai file di sistema.

Snapper non aggiunge automaticamente gli snapshot al menu di systemd-boot. In questo layout evita anche snapper rollback: la UKI forza l’avvio da subvol=@, mentre quel comando si basa sul subvolume Btrfs predefinito. Per un ripristino completo usa la ISO e la procedura manuale riportata di seguito.

Recuperare un sistema non avviabile

Per la configurazione ext4 base, avvia la ISO e monta:

mount /dev/nvme0n1p2 /mnt
mount --mkdir /dev/nvme0n1p1 /mnt/boot
arch-chroot -S /mnt

Per il layout LUKS2 e Btrfs:

cryptsetup open /dev/nvme0n1p2 cryptroot
mount -o subvol=@ /dev/mapper/cryptroot /mnt
mount --mkdir /dev/nvme0n1p1 /mnt/efi

Se hai configurato Snapper, monta anche il subvolume degli snapshot:

mount --mkdir -o subvol=@snapshots /dev/mapper/cryptroot /mnt/.snapshots

Entra quindi nel sistema:

arch-chroot -S /mnt

Da qui puoi correggere fstab, mkinitcpio.conf, /etc/kernel/cmdline, rigenerare le UKI o reinstallare il bootloader.

Per sostituire interamente @ con uno snapshot Snapper, avvia la ISO, apri il contenitore e monta il livello superiore di Btrfs:

cryptsetup open /dev/nvme0n1p2 cryptroot
mount -o subvolid=5 /dev/mapper/cryptroot /mnt
btrfs subvolume list /mnt
grep -r '<date>' /mnt/@snapshots/*/info.xml
mv /mnt/@ /mnt/@.prima-del-ripristino
btrfs subvolume snapshot /mnt/@snapshots/NUMERO/snapshot /mnt/@

Il comando grep mostra date e numeri disponibili; gli orari salvati nei metadati sono in UTC. Sostituisci NUMERO con lo snapshot scelto e conserva temporaneamente @.prima-del-ripristino. Prima di continuare, verifica che /mnt/@/etc/fstab non contenga un vecchio subvolid per la root ripristinata:

grep -n 'subvolid=' /mnt/@/etc/fstab

Se compare, rimuovi l’opzione numerica dalle righe Btrfs e conserva i rispettivi subvol=@.... Poi rimonta il sistema ripristinato e riallinea la UKI conservata nella ESP, che non faceva parte dello snapshot:

umount /mnt
mount -o subvol=@ /dev/mapper/cryptroot /mnt
mount --mkdir -o subvol=@snapshots /dev/mapper/cryptroot /mnt/.snapshots
mount --mkdir /dev/nvme0n1p1 /mnt/efi
arch-chroot -S /mnt
mkinitcpio -P
sbctl sign-all
sbctl verify

Se non usi Secure Boot ometti gli ultimi due comandi. Elimina @.prima-del-ripristino soltanto dopo avere verificato avvio, dati e servizi.

Fonti e approfondimenti

• Installation guide di ArchWiki
• Documentazione ufficiale di archinstall
• Unified Kernel Image
• Secure Boot
• Configurazione dm-crypt
• Trusted Platform Module
• Snapper
• Pacchetto ufficiale snap-pac
• Btrfs