Files
novemila/novemila/content/posts/2025-09-08-archlinux.md

363 lines
12 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
---
title: "Installare Arch Linux cifrando la partizione di root"
date: "2025-09-08"
draft: false
url: "/install-archlinux"
summary: "Questa guida offre istruzioni dettagliate per l'installazione di Arch Linux, includendo la preparazione del disco, la configurazione delle partizioni e l'installazione del bootloader."
tags:
- linux
- tutorial
hideBackToTop: false
hidePagination: true
toc: true
readTime: true
autonumber: false
math: true
showTags: true
fediverse: "@dado@social.novemila.org"
---
Arch Linux è una distribuzione Linux creata da Judd Vinet secondo la filosofia `KISS` (*Keep It Simple, Stupid*).
Per la sua filosofia minimalista, l'installazione base non incorpora nessuno strumento di configurazione automatica, nessun ambiente desktop e nessun altro programma o tool che non sia strettamente necessario all'avvio del sistema; per questo non è indicata per coloro che non vogliono avere a che fare con la shell di comando. Inoltre, Arch Linux è una distribuzione `rolling release`: tutti i pacchetti disponibili per l'installazione sono sempre aggiornati all'ultima versione distribuita dagli autori.
In questa guida viene documentato il processo di installazione step-by-step su una VM, cifrando la partizione di root per garantire una maggiore privacy. Al termine, il sistema sarà configurato come segue:
| Opzione | Configurazione adottata |
|--------------------|-------------------------|
| Crittografia disco | Yes |
| Firmware | UEFI |
| Tabella partizioni | GPT |
| Boot loader | GRUB / systemd-boot |
Per ogni dubbio, si rimanda alla guida [ufficiale](https://wiki.archlinux.org/title/Installation_guide).
## Creazione della VM
Per iniziare, procederemo con la creazione di una VM utilizzando [Proxmox](/posts/2025-03-08-proxmox.md) (o qualsiasi HV):
![arch-vm](/images/archlinux/arch-vm.png)
È possibile scaricare limmagine ISO ufficiale direttamente dal sito di [Arch Linux](https://www.archlinux.org/download/).
![live-boot](/images/archlinux/live-boot.png)
## Verifica della modalità di boot
Questa guida presuppone l'uso di `UEFI`. Per verificare la modalità di boot, elencare la directory *efivars* con il comando:
```bash
ls /sys/firmware/efi/efivars
```
Se il comando restituisce `64`, significa che il sistema è avviato in modalità UEFI a 64 bit (x64). Se, invece, il comando restituisce *No such file or directory*, il sistema potrebbe essere avviato in modalità BIOS (o CSM).
## Connessione alla rete internet
Per consentire alla VM di accedere a Internet, seguire i seguenti passaggi. Innanzitutto, verificare il nome dell'interfaccia di rete con il comando `ip -c a`.
Nel nostro caso, l'interfaccia é identificata come `ens18`. Procedere quindi ad assegnare un indirizzo IP statico e un gateway:
```bash
ip a a 10.10.1.11/24 dev ens18
ip r a default via 10.10.1.1 dev ens18
```
I vari parametri, dipendono dalla propria configurazione di rete.
![efi-network](/images/archlinux/efi-network.png)
## Impostare la timezone corretta
Per assicurarsi che l'orologio di sistema sia sincronizzato, utilizzare il comando `timedatectl`:
```bash
timedatectl set-timezone Europe/Rome
timedatectl status
```
## Partizionamento
Quando riconosciuti dal sistema, i dischi vengono assegnati a un dispositivo a blocchi, come `/dev/sda`, `/dev/nvme0n1` o `/dev/mmcblk0`. Per identificare il dispositivo corretto, utilizzare il comando `lsblk -f`.
Il layout finale del disco descritto in questa guida prevede due partizioni:
| Partition | Size | fdisk code | Name |
|---------------------|------------------|--------------|---------------------------|
| Boot (/dev/sda1) | 512.0 MiB | 1 | Partizione EFI |
| Root (/dev/sda2) | Resto del disco | 19 | File system Linux |
Una volta individuato il dispositivo, per creare la tabella e le relative partizioni, si consiglia l'uso di `fdisk`:
![efi-partition](/images/archlinux/partition.png)
La sintassi è la seguente:
```bash
fdisk /dev/sda # Per selezionare il dispositivo a blocchi indicato
```
All'interno di fdisk, è possibile utilizzare i seguenti comandi:
- `g`: per creare una nuova tabella delle partizioni GPT
- `n`: per creare una nuova partizione
- `t`: per cambiare il tipo della partizione
- `w`: per scrivere le modifiche sul disco
### Partizione di root crittografata
Per crittografare la partizione di root, creare un file system e montare la partizione, seguire i passaggi elencati di seguito. Assicurarsi di scegliere una passphrase sicura per la crittografia.
```bash
cryptsetup luksFormat /dev/sda2
cryptsetup open /dev/sda2 cryptroot
mkfs.btrfs /dev/mapper/cryptroot
mount /dev/mapper/cryptroot /mnt
```
### Partizione di boot
Formattare la partizione EFI in `FAT32` utilizzando il comando `mkfs.fat`:
```bash
mkfs.fat -F 32 /dev/sda1
mkdir /mnt/boot
mount /dev/sda1 /mnt/boot
```
## Installazione del sistema base
Eseguire un'installazione di base:
```bash
pacstrap -K /mnt base linux linux-firmware man vim nano sudo dhcpcd udev
```
Questo comando installerà il sistema di base, il kernel Linux e il firmware necessario per supportare l'hardware più comune nella partizione montata. Sono stati aggiunti anche alcune utility, come `man`, `vim`, `sudo` ecc.
## Configurare il sistema
### Generare fstab
Per garantire che i file system necessari siano montati all'avvio, generare il file `fstab`. Utilizzare l'opzione `-U` o `-L` per definire i file system tramite UUID o label, rispettivamente.
```bash
genfstab -U /mnt >> /mnt/etc/fstab
```
![gen-fstab](/images/archlinux/gen-fstab.png)
### chroot
```bash
arch-chroot /mnt
```
Il comando precedente serve a cambiare la root directory in `/mnt`, consentendo di interagire direttamente con il nuovo sistema come se fosse il sistema attualmente in esecuzione.
### Fuso orario
Impostare il fuso orario:
```bash
ln -sf /usr/share/zoneinfo/Europe/Rome /etc/localtime
hwclock --systohc
```
### Impostazione della lingua
Per utilizzare la formattazione corretta specifica per la regione e la lingua (come date, valuta, separatori decimali), modificare il file `/etc/locale.gen`, decommentando le localizzazioni `UTF-8` che si intende utilizzare, per esempio `en_US.UTF-8 UTF-8`.
![locale](/images/archlinux/locale.png)
Quindi eseguire:
```bash
locale-gen
```
Creare il file `/etc/locale.conf` e impostare la variabile `LANG` di conseguenza:
```bash
echo LANG=en_US.UTF-8 > /etc/locale.conf
export LANG=en_US.UTF-8
```
### Network configuration
Innanzitutto, impostare l'hostname della macchina col comando `hostnamectl set-hostname archlinux`. Quindi aggiungere le seguenti righe nel file `/etc/hosts`:
```bash
127.0.0.1 localhost
::1 localhost
127.0.1.1 archlinux
```
Sostituire archlinux con un hostname a scelta.
### initramfs
Modificare il file `/etc/mkinitcpio.conf` per aggiungere gli `hook` per la crittografia. Si tratta di script o comandi che vengono eseguiti durante il processo di creazione dell'immagine initramfs. Questi hook consentono di personalizzare e configurare il comportamento del sistema all'avvio, permettendo di includere o escludere determinati moduli, servizi o funzionalità.
Spostare la funzione `keyboard` prima di `encrypt`, in modo da poter digitare la passphrase.
Dopo questa modifica, la riga `HOOKS` dovrebbe apparire come segue:
```txt
HOOKS=(base udev autodetect modconf block keyboard encrypt filesystems fsck)
```
Poiché sono state apportate modifiche manuali al file `/etc/mkinitcpio.conf`, è necessario rigenerare l'immagine initramfs con le impostazioni aggiornate:
```bash
mkinitcpio -P
```
### CPU microcode
Per garantire che la CPU funzioni in modo ottimale, è importante applicare le patch appropriate:
- Per processori AMD installare il pacchetto `amd-ucode`
- Per processori Intel installare il pacchetto `intel-ucode`
Ad esempio, per installare il microcode per processori Intel, eseguire il seguente comando:
```bash
pacman -S intel-ucode
```
> Nel caso di installazione su VM, questo passaggio puó essere omesso.
### Gestione degli utenti
#### Impostare la password di root
Impostare una password sicura per l'utente root:
```bash
passwd
```
#### Creazione utente standard
Per creare un utente standard, che appartenga al gruppo `sudo`, utilizzare il comando `useradd`:
```bash
useradd -m -G wheel,audio,video,storage,lp,power -s /bin/bash dado
passwd dado
```
Infine, per consentire agli utenti creati di eseguire comandi come root utilizzando sudo, è necessario modificare il file `visudo`. In particolare, la riga che si riferisce al gruppo `wheel` deve essere decommentata. Per aprire il file `visudo`, eseguire semplicemente il comando `visudo`.
Una volta aperto il file, cercare la riga che contiene `%wheel ALL=(ALL) ALL` e decommentarla.
### Bootloader
Un bootloader è un componente fondamentale del sistema operativo. Dopo che il bootloader ha completato il caricamento dell'OS, trasferisce il controllo al sistema operativo, consentendogli di gestire le risorse hardware del computer.
`GRUB` è spesso il bootloader predefinito in molte distribuzioni Linux, grazie alla sua flessibilità e alle sue ampie capacità di configurazione: consente infatti di gestire più sistemi operativi, offre opzioni avanzate di avvio, rendendolo ideale per utenti che necessitano di personalizzazione e controllo.
`systemd-boot` è una scelta più semplice e leggera, progettata per chi cerca un bootloader veloce e robusto, facile da configurare, con meno opzioni rispetto a GRUB.
Di seguito, vedremo come configurare entrambi i bootloader.
#### systemd-boot
Installare `EFI boot manager` col comando:
```bash
bootctl install
```
Creare il file `/boot/loader/entries/arch.conf`. Sostituire `intel-ucode.img` con `amd-ucode.img` se si dispone di una CPU AMD. Sostituire l'UUID con quello del dispositivo a blocchi `/dev/sda2`.
Il contenuto del file dovrebbe apparire come segue:
```txt
title Arch Linux
linux /vmlinuz-linux
initrd /intel-ucode.img
initrd /initramfs-linux.img
options cryptdevice=UUID=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX:cryptroot root=/dev/mapper/cryptroot rw
```
Creare il file `/boot/loader/loader.conf`:
```txt
default arch.conf
timeout 5
console-mode max
editor no
```
Per rivedere la configurazione, torna utile il comando `bootctl list`.
#### GRUB
Installare i pacchetti necessari:
```bash
pacman -S grub efibootmgr
```
Creare la directory in cui verrà montata la partizione EFI:
```bash
mkdir /boot/efi
```
Ora, montare la partizione ESP (EFI System Partition) nella directory appena creata:
```bash
mount /dev/sda1 /boot/efi
```
Installare GRUB con il seguente comando:
```bash
grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi
```
Modificare le seguenti righe nel file `/etc/default/grub`:
```txt
GRUB_CMDLINE_LINUX_DEFAULT="quiet systemd.show_status=1"
GRUB_CMDLINE_LINUX="cryptdevice=UUID=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX:cryptroot root=/dev/mapper/cryptroot rw"
GRUB_ENABLE_CRYPTODISK=y
GRUB_TERMINAL_OUTPUT=console
```
Aggiornare infine la configurazione di GRUB:
```bash
grub-mkconfig -o /boot/grub/grub.cfg
```
## Reboot
Uscire dall'ambiente chroot, digitando `exit` o premendo `Ctrl+d`. Successivamente, smontare la directory `/mnt`. Infine riavviare il sistema col comando `reboot`. Se non ci sono stati errori, ci troveremo dinnanzi alla seguente schermata:
![passphrase](/images/archlinux/passphrase.png)
Adesso é possibile installare un Desktop Environment a scelta, seguendo anche le [General recommendations](https://wiki.archlinux.org/title/General_recommendations) della wiki di Arch Linux.
## Video
Di seguito, alcuni video utili, che riassumono la maggior parte dei passaggi:
{{<youtube C9C1usH7VlI>}}
oppure
{{<youtube qdjs97KRJfI>}}
## Riferimenti
- [Arch Linux](https://it.wikipedia.org/wiki/Arch_Linux)
- [Archlinux Installation guide](https://wiki.archlinux.org/title/Installation_guide)
- [How to Install Arch Linux [Step by Step Guide]](https://itsfoss.com/install-arch-linux/#how-to-install-arch-linux)
- [How to install Arch Linux with Full Disk Encryption](https://www.howtoforge.com/tutorial/how-to-install-arch-linux-with-full-disk-encryption/)
- [Installing Arch Linux with Full Disk Encryption](https://whhone.com/posts/arch-linux-full-disk-encryption/)
- [Getting Started With Pacman Commands](https://itsfoss.com/pacman-command/)