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

TIP

Solo Dell — Consenti i certificati di terze parti (Fondamentale): Nel BIOS del tuo Dell, 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 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:

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

NOTE

containers_user è una subvolume nested — va creata post-install, dopo che l’utente esiste, con:

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

Essendo un subvolume figlio di home, viene automaticamente esclusa dagli snapshot Snapper di /home (Btrfs non snapshotta ricorsivamente le subvolume annidate) — perfetto per i layer dei container che non vuoi rollbackare insieme ai dotfile.

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
2
# oppure
3
sudo cryptsetup status $(ls /dev/mapper/ | grep luks)

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

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/nvme0n1p3
3
# Dopo il riavvio post-BIOS, ri-enrolla:
4
sudo systemd-cryptenroll --tpm2-device=auto --tpm2-pcrs=0+7 /dev/nvme0n1p3

NoCoW sulle directory write-heavy#

Da fare prima che qualsiasi servizio scriva dati:

1
sudo chattr +C /var/lib/libvirt/images

NOTE

NOCOW sui container storage (Podman/Docker): con il driver overlay2, le scritture pesanti non avvengono nella directory del container storage — i layer immagine sono per lo più read-only dopo il pull. Il beneficio di chattr +C su /var/lib/containers, /var/lib/docker o ~/.local/share/containers (Podman rootless) è quindi minimo. Non è necessario applicarlo di default.

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

TIP

Docker: crea docker_cont solo se hai specificamente bisogno di Docker-CE. Fedora usa Podman nativamente e rootless di default — la maggior parte dei workflow container non richiede Docker.

1
sudo btrfs subvolume create /docker_cont
2
# aggiungi in fstab: subvol=docker_cont /var/lib/docker

Ottimizzare /etc/fstab#

Aggiungi noatime,compress=zstd:3 a tutte le voci Btrfs. Mantieni ogni opzione subvol= — grub-btrfs gestisce il boot degli snapshot tramite voci di boot separate, non cambiando il subvolume di default.

1
# Prima (default Fedora):
2
UUID=xxxx  /      btrfs  subvol=root,compress=zstd:1          0  0
3
UUID=xxxx  /home  btrfs  subvol=home,compress=zstd:1          0  0
4

5
# Dopo:
6
UUID=xxxx  /      btrfs  subvol=root,noatime,compress=zstd:3,discard=async   0  0
7
UUID=xxxx  /home  btrfs  subvol=home,noatime,compress=zstd:3,discard=async   0  0

Applica le stesse opzioni a tutte le altre voci Btrfs (var_log, var_cache, ecc.).

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:

1
git clone https://github.com/Antynea/grub-btrfs.git
2
cd grub-btrfs
3
config like https://youtu.be/xNokTKdkqqc?si=c2dfDG7jmqsdv-4k&t=2960
4
sudo make install
5
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 Timeline, 3 Boot, 10 Number). 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 Clean install 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 & Terra#

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

1
sudo dnf install \
2
  https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm \
3
  https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm
4
sudo dnf update @core
5
sudo dnf install rpmfusion-\*-appstream-data
6

7
# Opzionale: Terra (repo community Fyra Labs — pacchetti non presenti in RPM Fusion)
8
sudo dnf install --nogpgcheck \
9
  --repofrompath 'terra,https://repos.fyralabs.com/terra$releasever' \
10
  terra-release

NOTE

rpmfusion-\*-appstream-data è necessario su DNF5 (Fedora 41+) — senza di esso i pacchetti RPM Fusion non appaiono in GNOME Software.

Utility di Archivio#

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

NOTE

unrar e p7zip-plugins richiedono RPM Fusion Nonfree abilitato nel passo precedente.

FFmpeg completo#

1
sudo dnf swap 'ffmpeg-free' 'ffmpeg' --allowerasing

GStreamer & gruppi multimediali#

1
sudo dnf update @multimedia --setopt="install_weak_deps=False" --exclude=PackageKit-gstreamer-plugin

OpenH264 per Firefox#

1
sudo dnf config-manager setopt fedora-cisco-openh264.enabled=1
2
sudo dnf install -y openh264 gstreamer1-plugin-openh264 mozilla-openh264

Abilita il plugin in Firefox → Add-ons.

Intel Core Ultra (Target Principale)#

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

Per il compute/AI (OpenCL, Level Zero):

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

AMD Graphics#

Swap ai driver Mesa freeworld per il full hardware encoding:

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.

Google Chrome con accelerazione hardware (VA-API)#

Su Fedora, Google Chrome non sfrutta l’accelerazione hardware per la decodifica e codifica video per impostazione predefinita. Con la VA-API e il driver Intel (iHD) puoi abilitare il decoding/encoding su GPU, riducendo drasticamente il consumo CPU durante la riproduzione video.

Verifica che VA-API funzioni correttamente:

1
LIBVA_DRIVER_NAME=iHD vainfo

Dovresti vedere i profili VAProfileH264, VAProfileHEVC, VAProfileVP9, VAProfileAV1 elencati come disponibili.

1
[Desktop Entry]
2
Version=1.0
3
Name=Google Chrome
4
GenericName=Web Browser
5
Comment=Access the Internet
6
Exec=env LIBVA_DRIVER_NAME=iHD /usr/bin/google-chrome-stable --ozone-platform-hint=auto --enable-features=VaapiVideoDecoder,VaapiVideoEncoder,VaapiVideoDecodeLinuxGL,CanvasOopRasterization --use-gl=angle --use-angle=gl --enable-gpu-rasterization --enable-zero-copy --ignore-gpu-blocklist %U
7
StartupNotify=true
8
Terminal=false
9
Icon=google-chrome
10
Type=Application
11
Categories=Network;WebBrowser;
12
MimeType=application/pdf;application/rss+xml;application/xhtml+xml;application/xhtml_xml;text/html;text/xml;x-scheme-handler/http;x-scheme-handler/https;
13
Actions=new-window;new-private-window;
14

15
[Desktop Action new-window]
16
Name=Nuova finestra
17
Exec=env LIBVA_DRIVER_NAME=iHD /usr/bin/google-chrome-stable --ozone-platform-hint=auto --enable-features=VaapiVideoDecoder,VaapiVideoEncoder,VaapiVideoDecodeLinuxGL,CanvasOopRasterization --use-gl=angle --use-angle=gl --enable-gpu-rasterization --enable-zero-copy --ignore-gpu-blocklist
18

19
[Desktop Action new-private-window]
20
Name=Nuova finestra in incognito
21
Exec=env LIBVA_DRIVER_NAME=iHD /usr/bin/google-chrome-stable --ozone-platform-hint=auto --enable-features=VaapiVideoDecoder,VaapiVideoEncoder,VaapiVideoDecodeLinuxGL,CanvasOopRasterization --use-gl=angle --use-angle=gl --enable-gpu-rasterization --enable-zero-copy --ignore-gpu-blocklist --incognito

1
# Sposta il file scaricato da ~/Downloads
2
cp ~/Downloads/google-chrome.desktop ~/.local/share/applications/
3

4
# Aggiorna il database delle applicazioni desktop
5
update-desktop-database ~/.local/share/applications/

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

File system structure#

1
~/dev/
2
  ├── <company-name>/ # progetti aziendali (subvolume Btrfs)
3
  ├── infra/          # IaC condivisa (terraform, k8s, ansible)
4
  ├── personal/       # progetti personali
5
  ├── tools/          # cloni, esperimenti, utility
6
  ├── learning/       # corsi, esercizi, tutorial
7
  ├── forks/          # fork OSS con PR aperte
8
  └── archive/        # progetti chiusi

Creazione:

Creazione struttura e creazione subvolume btrfs al fine di non fare rollback di progetti git quando torno indietro sulla home. (remoto ma possibile)

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

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

Firewall#

Fedora usa firewalld di default. Verifica zona e regole attive:

1
sudo firewall-cmd --get-default-zone
2
sudo firewall-cmd --list-all

Zone utili: public (default), home (rete domestica trusted), work (LAN azienda).

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)