BIOS/UEFI Prep#

• Mantieni Secure Boot abilitato — il driver NVIDIA funziona tramite MOK enrollment.
• Abilita VT-d — necessario per il passthrough PCI alle VM.
• Imposta SATA/NVMe Operation su AHCI/NVMe, non RAID/RST — Intel VMD nasconde il disco all’installer.

Secure Boot#

Fedora supporta nativamente il Secure Boot — tienilo disabilitato durante l’installazione e dopo averla installata tienilo sempre abilitato. Per i driver proprietari (NVIDIA), l’enrollment dei MOK keys avviene automaticamente al primo riavvio dopo l’installazione del driver.

Per la configurazione completa e aggiornata, segui la guida ufficiale RPM Fusion su Secure Boot.

IMPORTANT

Consenti i certificati di terze parti (Fondamentale): Nel BIOS del tuo Dell o Thinkpad, cerca un’opzione chiamata “Microsoft UEFI CA” o “3rd Party UEFI CA” (di solito si trova sotto le impostazioni del Secure Boot o della sezione sicurezza). Assicurati che sia abilitata.

Questa opzione dice al BIOS di accettare le firme Linux approvate (MOK), non solo quelle di Windows. Senza di essa, i driver firmati come akmod-nvidia o fedora non verranno caricati anche se il MOK enrollment va a buon fine.

Partizionamento (Anaconda Web UI → Cockpit Storage)#

Usa il Cockpit Storage editor (menu a tre punti nella pagina storage) per il partizionamento custom.

Partizioni standard:

LUKS2: seleziona lo spazio libero, crea una partizione cifrata (LUKS2) e imposta la passphrase.

Subvolumi Btrfs (dentro LUKS) — da creare durante l’install: Clicca sulla partizione btrfs e clicca sul top level volume e poi sui 3 puntini crea sottovolume.

Soluzione base:

• root montato su / — il sistema operativo
• home montato su /home — i dati utente

Soluzione avanzata (ogni subvolume non viene snapshottato con root):

Installa Fedora#

• Installa fedora
• Riavvia
• Inserisci password di disco + password fedora

Creazione ulteriori sottovlumi#

Sono volumi che non possono essere creati prima ma solo dopo che la home utente esiste.

1
sudo btrfs subvolume create ~/dev
2
sudo chown $USER:$USER ~/dev
3
mkdir -p ~/dev/{optit,infra,personal,tools,learning,forks,archive}

1
sudo btrfs subvolume create ~/.local/share/containers
2
sudo chown $USER:$USER ~/.local/share/containers

1
# sudo btrfs subvolume create /docker_cont  # Optional if docker is present

NoCoW sulle directory write-heavy#

Da fare prima che qualsiasi servizio scriva dati:

1
sudo chattr +C /var/lib/libvirt/images
2
sudo chattr +C ~/.local/share/containers
3
# sudo chattr +C /var/lib/containers        # Optional if podman is rootfull
4
# sudo chattr +C /var/lib/docker            # Optional if docker is present

WARNING

Database voluminosi in container: se esegui PostgreSQL, MySQL, MongoDB o simili con volumi di dati significativi, applica NOCOW sulla directory del volume prima di avviare il container per la prima volta — le scritture random continue causano frammentazione severa su Btrfs senza di esso:

1
sudo chattr +C /percorso/del/volume/db

Auto-Unlock con TPM2 (nessuna passphrase al boot)#

Dopo l’installazione puoi enrollare la chiave LUKS2 nel chip TPM2 della macchina: il disco si sblocca automaticamente finché il sistema è integro (stessa CPU, stesso firmware, nessuna manomissione). La passphrase manuale rimane come fallback.

Prerequisiti: Secure Boot abilitato e TPM2 presente (verificabile con ls /dev/tpm*).

1. Trova la partizione LUKS:

1
lsblk -f | grep crypto

Prendi nota del device, es. /dev/nvme0n1p6.

2. Enroll la chiave nel TPM2:

1
sudo systemd-cryptenroll --tpm2-device=auto --tpm2-pcrs=0+7 /dev/nvme0n1p3

• PCR 0 — misura il firmware UEFI (rileva modifiche al BIOS)
• PCR 7 — misura lo stato del Secure Boot (rileva se viene disabilitato)

Ti verrà chiesta la passphrase LUKS esistente per autorizzare l’enrollment.

4. Rigenera l’initramfs:

1
sudo dracut --force

Riavvia: il sistema si sbloccherà automaticamente senza chiedere la passphrase. Se il TPM rileva una modifica al firmware o al Secure Boot, tornerà a chiedere la passphrase manuale.

WARNING

Dopo ogni aggiornamento BIOS: le misurazioni PCR cambiano. Esegui di nuovo systemd-cryptenroll con --wipe-slot=tpm2 prima di aggiornare, oppure il sistema si bloccherà al riavvio successivo.

1
# Prima di un aggiornamento BIOS:
2
sudo systemd-cryptenroll --wipe-slot=tpm2 /dev/nvme0n1p6
3
# Dopo il riavvio post-BIOS, ri-enrolla:
4
sudo systemd-cryptenroll --tpm2-device=auto --tpm2-pcrs=0+7 /dev/nvme0n1p6

Installare i tool Btrfs#

1
sudo dnf install snapper libdnf5-plugin-actions btrfs-assistant inotify-tools git make

Integrazione con DNF5 (Autosnapper on dnf install)#

Creiamo una action in modo da agganciarci alle transazioni di dnf5 e quindi poter fare snapshot prima e dopo l’installazione di programmi

1
sudo bash -c "cat > /etc/dnf/libdnf5-plugins/actions.d/snapper.actions" <<'EOF'
2
# Get snapshot description
3
pre_transaction::::/usr/bin/sh -c echo\ "tmp.cmd=$(ps\ -o\ command\ --no-headers\ -p\ '${pid}')"
4

5
# Creates pre snapshot before the transaction and stores the snapshot number in the "tmp.snapper_pre_number"  variable.
6
pre_transaction::::/usr/bin/sh -c echo\ "tmp.snapper_pre_number=$(snapper\ create\ -t\ pre\ -c\ number\ -p\ -d\ '${tmp.cmd}')"
7

8
# If the variable "tmp.snapper_pre_number" exists, it creates post snapshot after the transaction and removes the variable "tmp.snapper_pre_number".
9
post_transaction::::/usr/bin/sh -c [\ -n\ "${tmp.snapper_pre_number}"\ ]\ &&\ snapper\ create\ -t\ post\ --pre-number\ "${tmp.snapper_pre_number}"\ -c\ number\ -d\ "${tmp.cmd}"\ ;\ echo\ tmp.snapper_pre_number\ ;\ echo\ tmp.cmd
10
EOF

Integrazione bootloader GRUB#

Per avere gli snapshot visibili e runnabili da Grub in modalità READ-ONLY!

1
git clone https://github.com/Antynea/grub-btrfs.git
2
cd grub-btrfs
3

4
# Guarda guida per sicurezza config like https://youtu.be/xNokTKdkqqc?si=c2dfDG7jmqsdv-4k&t=2960
5

6
# Config per fedora
7
sed -i 's|^#GRUB_BTRFS_SNAPSHOT_KERNEL_PARAMETERS=.*|GRUB_BTRFS_SNAPSHOT_KERNEL_PARAMETERS="rd.live.overlay.overlayfs=1"|' config
8
sed -i 's|^#GRUB_BTRFS_GRUB_DIRNAME=.*|GRUB_BTRFS_GRUB_DIRNAME="/boot/grub2"|' config
9
sed -i 's|^#GRUB_BTRFS_MKCONFIG=.*|GRUB_BTRFS_MKCONFIG=/usr/bin/grub2-mkconfig|' config
10
sed -i 's|^#GRUB_BTRFS_SCRIPT_CHECK=.*|GRUB_BTRFS_SCRIPT_CHECK=grub2-script-check|' config
11

12
# Installa il tool
13
sudo make install
14
sudo systemctl enable --now grub-btrfsd.service

grub-btrfsd monitora /.snapshots e rigenera automaticamente il menu GRUB ad ogni nuovo snapshot.

WARNING

Nota bene: i rollback fatti da grub sono READ-ONLY. Quello che si deve fare e’ entrare in btrfs assistant e fare il vero rollback.

Inizializzare Snapper (via GUI)#

1. Apri Btrfs Assistant dal menu applicazioni GNOME.
2. Naviga al tab Snapper Settings.
3. Clicca New, chiama la configurazione root, imposta il path su /. Salva.
4. Crea una seconda configurazione chiamata home con path /home.

Configurare la retention#

Nel tab Snapper Settings, imposta i limiti di retention per evitare che il disco si riempia (es. 5, 7, 2, 0, 0, 10). Verifica che i timer snapper-timeline e snapper-cleanup siano Attivi.

Snapshot clean install subito su root e home#

Andare su Btrfs Assistant e fare snapshot chiamato Initial snapshot in modo da avere un fallback pulito

Hostname#

Usa un nome che identifichi la macchina fisica, non l’OS (es. precision-7680, tower-5090) — l’hostname dovrebbe restare valido anche dopo un reinstall o cambio distro.

1
hostnamectl set-hostname YOUR_HOSTNAME

Aggiornare il Firmware (LVFS)#

Aggiorna BIOS e componenti hardware in modo sicuro. Riavvia se vengono applicati aggiornamenti BIOS/UEFI prima di continuare.

1
sudo fwupdmgr refresh --force
2
sudo fwupdmgr update

Aggiornamento di sistema#

1
sudo dnf -y upgrade

Riavvia al termine.

Snapshot post update su root e home#

Andare su Btrfs Assistant e fare snapshot Post big update in modo da avere un fallback a questo punto

Abilitare RPM Fusion#

Sblocca software non-free, driver proprietari e pacchetti community:

1
# Enable RPM fusion
2
sudo dnf install https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm
3
# For Gnome Software/KDE Discover
4
sudo dnf update @core
5
sudo dnf install rpmfusion-\*-appstream-data

Utility di Archivio#

1
sudo dnf install unzip p7zip p7zip-plugins unrar -y

Obiettivo: sostituire le librerie multimediali troncate di Fedora con versioni complete con accelerazione hardware.

FFmpeg completo#

1
# GStreamer & gruppi multimediali
2
sudo dnf swap 'ffmpeg-free' 'ffmpeg' --allowerasing
3
# Multimedia
4
sudo dnf update @multimedia --setopt="install_weak_deps=False" --exclude=PackageKit-gstreamer-plugin

Scheda Video integrata#

TIP

Driver xe per Intel Core Ultra e successivi: il nuovo driver KMS Intel xe sostituisce i915 per le GPU integrate/discrete recenti (Meteor Lake, Lunar Lake, Arrow Lake, Panther Lake, Arc, Battlemage). Su Lunar Lake/Battlemage è già il default. Su Meteor Lake (Core Ultra Serie 1) i915 è ancora il driver di fabbrica ma puoi forzare xe per avere stack grafico più moderno, Vulkan migliore e compute Xe più maturo.

Verifica il driver attivo:

1
lspci -k | grep -EA3 'VGA|3D'   # cerca "Kernel driver in use: i915" o "xe"

Forzare xe via kernel parameter (trova il PCI-ID con lspci -nn | grep -i vga, es. [8086:7d55]):

1
sudo grubby --update-kernel=ALL \
2
  --args="i915.force_probe=!7d55 xe.force_probe=7d55"
3
sudo dracut --force

Riavvia e riverifica con lspci -k. Per tornare indietro: sudo grubby --update-kernel=ALL --remove-args="i915.force_probe xe.force_probe".

1
sudo dnf install libva-utils intel-media-driver

1
sudo dnf install intel-compute-runtime oneapi-level-zero

1
sudo dnf swap mesa-va-drivers mesa-va-drivers-freeworld

NVIDIA Graphics#

Secure Boot rimane abilitato — i MOK keys vengono enrolled automaticamente al primo riavvio. Attendi 5 minuti prima di riavviare per la compilazione del modulo akmods.

1
sudo dnf install akmod-nvidia xorg-x11-drv-nvidia-cuda

Al riavvio apparirà automaticamente la schermata di MOK enrollment. Seleziona Enroll MOK, conferma e riavvia di nuovo.

Boot più veloce#

Elimina 15-20 secondi dal tempo di boot disabilitando l’attesa di rete:

1
sudo systemctl disable NetworkManager-wait-online.service

WARNING

RAM Optimization: il comando seguente impedisce a GNOME Software di consumare memoria in background, ma disabilita il controllo automatico degli aggiornamenti.

1
systemctl --user mask gnome-software-service
2
systemctl --user disable gnome-software-service

DNS personalizzato (Cloudflare over TLS)#

1
sudo mkdir -p /etc/systemd/resolved.conf.d
2
sudoedit /etc/systemd/resolved.conf.d/99-dns-over-tls.conf

Contenuto del file:

1
[Resolve]
2
DNS=1.1.1.2#security.cloudflare-dns.com 1.0.0.2#security.cloudflare-dns.com 2606:4700:4700::1112#security.cloudflare-dns.com 2606:4700:4700::1002#security.cloudflare-dns.com
3
DNSOverTLS=yes
4
Domains=~.

Riavvia il resolver:

1
sudo systemctl restart systemd-resolved

Rimuovere la pagina default Firefox di Red Hat#

1
sudo rm -f /usr/lib64/firefox/browser/defaults/preferences/firefox-redhat-default-prefs.js

Podman e Docker Compose configurazione#

Setup di Podman compatibile con docker CLI e docker compose.

WARNING

Se in futuro installi Docker CE (moby-engine o docker-ce): si scontra con podman-docker su /usr/bin/docker — disinstalla uno dei due. Ricorda anche di fare unset DOCKER_HOST (o gestirlo per-progetto con direnv) quando vuoi parlare col daemon Docker invece che col socket Podman.

Installazione pacchetti. podman è preinstallato; podman-docker fornisce /usr/bin/docker come wrapper; docker-compose è la v2 upstream che parla con il socket Podman.

1
sudo dnf install podman podman-docker docker-compose

Abilita il socket Podman e configura DOCKER_HOST — rootless, user-level. È ciò che permette a docker compose di parlare con Podman.

1
# Abilita e avvia il socket
2
systemctl --user enable --now podman.socket
3
systemctl --user status podman.socket   # verifica
4

5
# Esporta DOCKER_HOST in shell config (~/.zshrc, o ~/.bashrc se usi bash)
6
echo 'export DOCKER_HOST=unix:///run/user/$UID/podman/podman.sock' >> ~/.zshrc
7
source ~/.zshrc

Test di funzionamento:

1
docker ps                     # lista vuota = ok
2
docker run --rm hello-world   # pull + run
3
docker compose version        # compose v2

Avvio automatico al boot (lingering). In modalità rootless, i servizi utente vengono terminati al logout e non vengono avviati al boot se nessuno ha effettuato login. Per permettere a podman.socket e ai container con --restart=always (o restart: always in Compose) di partire automaticamente all’accensione del PC, abilita il lingering sul tuo utente:

1
sudo loginctl enable-linger $USER
2
loginctl show-user $USER | grep Linger   # verifica: Linger=yes

Senza enable-linger il socket Podman non è raggiungibile finché non fai login, e i container con restart policy non ripartono al boot.

NOTE

Quadlet (opzionale): per servizi di sistema con dipendenze complesse, considera Quadlet (~/.config/containers/systemd/*.container) — definisce i container come unit systemd native, più pulito di podman generate systemd (deprecato).

Test multi-container con Compose. Crea un file di prova con due servizi (nginx + redis):

1
services:
2
  web:
3
    image: nginx:alpine
4
    ports:
5
      - "8080:80"
6
  cache:
7
    image: redis:alpine
8
    ports:
9
      - "6379:6379"

Avvia e verifica:

1
cd /tmp/compose-test
2
docker compose up -d                      # avvia in background
3
curl -s localhost:8080 | head -5          # nginx risponde
4
docker compose exec cache redis-cli ping  # redis risponde PONG
5
docker compose down                       # stop e pulizia

NOTE

• Modalità rootless di default → no sudo per docker/podman
• docker-compose vecchio (v1, Python) è deprecato: usa sempre docker compose (v2, built-in Go)

Tweaks#

1
sudo dnf install gnome-tweaks

Extension manager#

Installare da Gnome Software visto che è Flatpak

Extensions#

• Blur my Shell — blur-my-shell@aunetx
• Color Picker — color-picker@tuberry
• Dash to Dock — dash-to-dock@micxgx.gmail.com
• Hide Top Bar — hidetopbar@mathieu.bidon.ca
• OBS Zoom To Mouse Remote — obs-zoom-to-mouse-remote@lucagiulianini.com
• Tiling Shell — tilingshell@ferrarodomenico.com
• Vitals — Vitals@CoreCoding.com

Backup e Restore delle estensioni#

Backup:

1
# Estensioni installate
2
cp -r ~/.local/share/gnome-shell/extensions/ ~/backup-extensions/
3

4
# Configurazioni (dconf)
5
dconf dump /org/gnome/shell/extensions/ > ~/backup-extensions-settings.dconf

Restore:

1
  # Ripristina estensioni
2
  cp -r ~/backup-extensions/ ~/.local/share/gnome-shell/extensions/
3

4
  # Ripristina configurazioni
5
  dconf load /org/gnome/shell/extensions/ < ~/backup-extensions-settings.dconf

Dopo il restore, logout/login (Wayland).

Fix Dual Boot Desync (Windows)#

Linux usa UTC di default, che è corretto. Il fix è fare in modo che anche Windows usi UTC — esegui in un Command Prompt elevato:

1
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation" /v RealTimeIsUniversal /t REG_DWORD /d 1 /f

SSH keys#

Chiave moderna ed25519 per GitHub/GitLab/server:

1
ssh-keygen -t ed25519 -C "your_email@example.com"
2
cat ~/.ssh/id_ed25519.pub   # copia su GitHub/GitLab

GPG keys (firma commit, cifratura)#

1
gpg --full-generate-key     # scegli ed25519 (o rsa4096)
2
gpg --list-secret-keys      # ID e' seconda linea

Configura git per firmare i commit:

1
git config --global user.signingkey <KEY-ID>
2
git config --global commit.gpgsign true

Bitbucket e Github ```gpg —armor —export ID`

Fingerprint reader (Dell Broadcom)#

Per lettori Broadcom (ID 5842–5867) usa il COPR dedicato:

1
sudo dnf copr enable grahamwhiteuk/libfprint-tod
2
sudo dnf swap libfprint libfprint-tod
3
sudo dnf install libfprint-2-tod1-broadcom-cv3plus libfprint-tod-selinux

Abilita poi l’impronta da Impostazioni → Utenti → Impronta digitale.

NOTE

Il COPR supporta sia gli ID 5842-5845 (installa libfprint-2-tod1-broadcom) sia i più nuovi 5864-5867 con -cv3plus (sperimentale). Verifica il tuo chip con lsusb | grep -i broadcom.

Shell: zsh + Powerlevel10k#

Setup produttivo con zsh, Oh My Zsh, Powerlevel10k, plugin e Nerd Fonts.

📖 Guida dedicata: Il terminale definitivo: zsh + Oh My Zsh + Powerlevel10k

Dev environment#

• Editor: VSCode, Neovim, JetBrains Toolbox
• Version managers: mise o asdf per Node/Python/Go/Ruby
• Git config globale (user, email, signing key, aliases)
• Dotfiles management: chezmoi o stow

Backup#

• Personale: Borg/Restic su disco esterno + cloud (rclone, Nextcloud, Syncthing)
• Aziendale: spesso gestito centralmente, verifica policy

Power management#

• power-profiles-daemon (default GNOME) o tuned per profili custom
• Battery charge threshold su laptop Dell (via BIOS o tlp)

Virtualizzazione#

• libvirt + virt-manager per VM KVM
• GNOME Boxes come alternativa più semplice

Comunicazione e produttività#

• Office: LibreOffice, OnlyOffice
• Mail: Thunderbird, Evolution (Exchange su aziendale)
• Chat: Slack/Teams/Discord (Flatpak)
• Note: Obsidian, Logseq

Accesso remoto e VPN#

• Tailscale/ZeroTier per mesh VPN personale
• VPN corporate (OpenVPN/WireGuard) se aziendale
• SSH server con config hardened se la macchina va raggiunta da fuori

Hardware specifico#

• Stampante (CUPS, system-config-printer)
• Scanner (SANE, simple-scan)
• Tablet grafico (Wacom drivers)