Differenze tra le versioni di "Appunti Arch Linux"

Da GolemWiki.
Jump to navigation Jump to search
 
(172 versioni intermedie di uno stesso utente non sono mostrate)
Riga 1: Riga 1:
[https://archlinux.org/ Arch Linux] è una distribuzione Linux leggera ed improntata alla riga di comando.
+
[https://archlinux.org/ Arch Linux] è una distribuzione Linux leggera e veloce; ma la cui installazione, configurazione e amministrazione avviene prevalentemente da terminale attraverso la modifica manuale di file di configurazione testuali.
Ufficialmente non è dotata di un installer grafico e perciò non è considerata adatta ai principianti, l'installazione di default consiste in un sistema base sul quale l'utente potrà manualmente aggiungere e configurare tutto quello di cui necessita.
 
  
Fornisce l'ultima versione stabile della maggior parte del software opensource disponibile per Linux e lo fa seguendo un modello di distribuzione detto "rolling-release", il suo aggiornamento è quindi continuo e non richiede periodici passaggi da una versione stabile alla successiva.
+
Fornisce, seguendo un modello di distribuzione detto "rolling-release", l'ultima versione stabile della maggior parte del software opensource disponibile per Linux. Dato che è in costante aggiornamento non richiede periodici passaggi da una versione stabile alla successiva. Il lato negativo è che aggiornamenti di componenti importanti come quelli di: '''kernel, boot loader, driver video, librerie...''' potrebbero determinare problemi tali da rendere il sistema inutilizzabile. Accorgimenti come lo snapshot periodico del filesystem riescono, per fortuna, a contrastare l'impatto di questi inconvenienti.
 
 
Il prezzo da pagare è che talvolta gli aggiornamenti (soprattutto: '''kernel, driver video e librerie''') possono determinare problemi talmente gravi al sistema da renderlo inutilizzabile. Per fortuna accorgimenti come lo snapshot del filesystem che, se utilizzati correttamente dall'utente, sono capaci di ovviare a tali problematiche.
 
  
 
= Installazione =
 
= Installazione =
 +
== Guida ==
 +
[https://wiki.archlinux.org/title/Installation_guide Guida ufficiale]
  
 
== Supporti ==
 
== Supporti ==
 
 
* ISO ufficiale [http://archlinux.mirror.garr.it/archlinux/iso/latest/archlinux-x86_64.iso archlinux-x86_64.iso]
 
* ISO ufficiale [http://archlinux.mirror.garr.it/archlinux/iso/latest/archlinux-x86_64.iso archlinux-x86_64.iso]
  
Riga 16: Riga 14:
 
* ISO con installer grafico Calamares [https://sourceforge.net/projects/alci/files/alci-iso/ ALCI]
 
* ISO con installer grafico Calamares [https://sourceforge.net/projects/alci/files/alci-iso/ ALCI]
  
== Guida ==
+
* ISO live CD/USB con interfaccia Xfce, utile per operazioni di ripristino o installazione [https://www.system-rescue.org/Download/ SystemRescue]:
[https://wiki.archlinux.org/title/Installation_guide Guida ufficiale]
+
 
 +
 
 +
== ISO personalizzata ==
 +
Con '''archiso''' è possibile creare un'immagine con pacchetti aggiuntivi rispetto a quelli contenuti nella versione ufficiale.
 +
 
 +
# pacman -S archiso
 +
 
 +
Copiare il contenuto del pacchetto in una directory di lavoro, es.: ''/root/media''
 +
# cp -r /usr/share/archiso/configs/releng /root/media
 +
 
 +
Se volessimo aggiungere il supporto ad un pacchetto non contenuto nei repository ufficiali come, per esempio, lo ZFS occorrerebbe:
 +
 
 +
* Importare la chiave pubblica del suo repository
 +
# pacman-key -r DDF7DB817396A49B2A2723F7403BD972F75D9D76
 +
# pacman-key --lsign-key DDF7DB817396A49B2A2723F7403BD972F75D9D76
 +
 +
* Modificare le seguenti righe al file '''pacman.conf''' di archiso per aggiungere il repository
 +
[archzfs]
 +
SigLevel = Never
 +
Server = https://archzfs.com/$repo/$arch
 +
 
 +
* Aggiungere le seguenti righe al file ''packages.x86_64'' per aggiungere i pacchetti che ci interessa installare
 +
zfs-utils
 +
zfs-dkms
 +
net-tools
 +
 
 +
* Se volessimo creare una versione live di una macchina, comprensiva di tutti i suoi pacchetti, potremmo semplicemente aggiungerli al file ''packages.x86_64''
 +
 
 +
# pacman -Qq >> ''/path/packages.x86_64''
 +
 
 +
* Lanciare lo script per creare l'ISO
 +
# ./build.sh -v
 +
L'immagine sarà generata nella directory /root/media/out
  
= Preparazione del disco =
+
== Preparazione del disco ==
 
Su Linux si può scegliere (salvo casi estremamente [https://wiki.archlinux.org/title/partitioning#Partitionless_disk particolari]) tra due [https://unix.stackexchange.com/questions/289389/what-are-the-differences-between-the-various-partition-tables tipi] di tabella delle partizioni
 
Su Linux si può scegliere (salvo casi estremamente [https://wiki.archlinux.org/title/partitioning#Partitionless_disk particolari]) tra due [https://unix.stackexchange.com/questions/289389/what-are-the-differences-between-the-various-partition-tables tipi] di tabella delle partizioni
  
Riga 44: Riga 74:
  
  
== Schede madri BIOS ==
+
=== Schede madri BIOS ===
 
Creare due partizioni.
 
Creare due partizioni.
  
Riga 50: Riga 80:
 
# '''Linux filesystem''': successivamente da formattare col filesystem di nostra scelta: BTRFS, ZFS, ext4, XFS, JFS.
 
# '''Linux filesystem''': successivamente da formattare col filesystem di nostra scelta: BTRFS, ZFS, ext4, XFS, JFS.
  
=== Partizionamento ===
+
==== Partizionamento ====
Col seguente comando verrà creata la partizione BIOS GRUB (EF02) a partire dal 1MB, della grandezza di 64MB; il resto del disco resterà disponibile per il filesystem di Linux.
+
Col seguente comando verrà creata la partizione BIOS GRUB (EF02) a partire dal 1MB, della grandezza di 64MB, 8GB per la SWAP ed il resto del disco resterà disponibile per il filesystem di Linux.
  
 
Se avete più dischi da utilizzare in raid, questa operazione andrà ripetuta per ciascun disco.
 
Se avete più dischi da utilizzare in raid, questa operazione andrà ripetuta per ciascun disco.
Riga 57: Riga 87:
 
  # sgdisk \
 
  # sgdisk \
 
  --new=1:2048:133120 --typecode=1:EF02 --change-name=1:"GRUB" \
 
  --new=1:2048:133120 --typecode=1:EF02 --change-name=1:"GRUB" \
  --largest-new=2 --typecode=2:8300 --change-name=2:"ROOT" /dev/sda
+
--new=2:0:+8000M ---typecode 2:8200 --change-name=2:"SWAP" \
 +
  --largest-new=3 --typecode=3:8300 --change-name=3:"ROOT" /dev/sda
  
 
La seconda partizione dovrà poi essere formattata con uno dei filesystem supportati da Linux (ext4, btrfs, xfs...)
 
La seconda partizione dovrà poi essere formattata con uno dei filesystem supportati da Linux (ext4, btrfs, xfs...)
  # mkfs.btrfs /dev/sda2
+
  # mkfs.btrfs /dev/sda3
  
  
== Schede madri UEFI ==
+
=== Schede madri UEFI ===
 
Creare due partizioni.
 
Creare due partizioni.
  
Riga 69: Riga 100:
 
# '''Linux filesystem''': successivamente da formattare col filesystem di nostra scelta: BTRFS, ZFS, ext4, XFS, JFS.
 
# '''Linux filesystem''': successivamente da formattare col filesystem di nostra scelta: BTRFS, ZFS, ext4, XFS, JFS.
  
=== Partizionamento ===
+
==== Partizionamento ====
 
+
Col seguente comando verrà creata la partizione EFI (EF00) a partire dal 1MB, della grandezza di 512MB, 8Gb per la SWAP ed il resto del disco per il filesystem di Linux.
Col seguente comando verrà creata la partizione EFI (EF00) a partire dal 1MB, della grandezza di 512MB; il resto del disco resterà disponibile il filesystem di Linux.
 
 
  # sgdisk \
 
  # sgdisk \
 
  --new=1:2048:1064960 --typecode=1:EF00 --change-name=1:"efi" \
 
  --new=1:2048:1064960 --typecode=1:EF00 --change-name=1:"efi" \
  --largest-new=2 --typecode=2:8300 --change-name=2:"ROOT" /dev/sda
+
--new=2:0:+8000M ---typecode 2:8200 --change-name=2:"SWAP" \
 +
  --largest-new=3 --typecode=3:8300 --change-name=3:"ROOT" /dev/sda
  
 
La partizione '''EFI''' dovrà poi essere formattata in FAT32
 
La partizione '''EFI''' dovrà poi essere formattata in FAT32
  # mkfs.vfat -T32 /dev/sda1
+
  # mkfs.vfat -F 32 /dev/sda1
  
 
La seconda partizione dovrà poi essere formattata con uno dei filesystem supportati da Linux (ext4, btrfs, xfs...)
 
La seconda partizione dovrà poi essere formattata con uno dei filesystem supportati da Linux (ext4, btrfs, xfs...)
  # mkfs.btrfs /dev/sda2
+
  # mkfs.btrfs /dev/sda3
 +
 
 +
== Montaggio del filesystem ==
 +
Formattazione ed attivazione della SWAP
 +
# mkswap /dev/sda2
 +
# swapon /dev/sda2
 +
 
 +
Montaggio del filesystem di ROOT nei sistemi BIOS
 +
# mount /dev/sda3 /mnt
 +
 
 +
Montaggio del filesystem di ROOT nei sistemi UEFI
 +
# mount /dev/sda3 /mnt
 +
# mount --mkdir /dev/sda1 /mnt/boot
 +
 
 +
== Pacchetti base ==
 +
Per l'installazione di base si consigliano i seguenti meta-pacchetti
 +
# pacstrap -K /mnt base base-devel linux linux-headers linux-firmware
 +
 
 +
== Configurazione ==
 +
Creazione del file fstab
 +
# genfstab -U /mnt >> /mnt/etc/fstab
 +
 
 +
Chroot nel nuovo sistema
 +
# arch-chroot /mnt
 +
 
 +
Timezone
 +
# ln -sf /usr/share/zoneinfo/Europe/Rome /etc/localtime
 +
 
 +
Editare il file <code>/etc/systemd/timesyncd.conf</code> ed abilitare il servizio per la sincronizzazione automatica dell'orario
 +
# systemctl enable systemd-timesyncd.service
 +
 
 +
Editare il file <code>/etc/locale.gen</code> e togliere il commento agli argomenti che interessano, es.: ''en_US.UTF-8'', ''it_IT.UTF-8''. E successivamente generare la localizzazione eseguendo
 +
# locale-gen
 +
 
 +
Configurare la lingua che vogliamo usare per il nostro sistema editando il file <code>/etc/locale.conf</code> oppure lanciando il comando
 +
# localectl set-locale LANG=en_US.UTF-8
 +
 
 +
Selezioniamo il layout della tastiera editando il file <code>/etc/vconsole.conf</code>
 +
# echo "KEYMAP=it" >> /etc/vconsole.conf
 +
 
 +
Scegliere un home host (es.: ''archstar'')
 +
# echo '''archstar''' >> /etc/hostname
  
 +
Impostare una password per l'utente root
 +
# passwd
  
 +
Installare e configurare il bootloader
  
 
= Filesystem =
 
= Filesystem =
Riga 94: Riga 169:
  
 
- [https://access.redhat.com/documentation/it-it/red_hat_enterprise_linux/9/html-single/configuring_and_managing_logical_volumes/index XFS + LVM]: accoppiare il filesystem xfs al gestore di volumi di LVM è il modo con cui RedHat (IBM) ha scelto di implementare le funzionalità di raid e snapshots nella propria distribuzione.
 
- [https://access.redhat.com/documentation/it-it/red_hat_enterprise_linux/9/html-single/configuring_and_managing_logical_volumes/index XFS + LVM]: accoppiare il filesystem xfs al gestore di volumi di LVM è il modo con cui RedHat (IBM) ha scelto di implementare le funzionalità di raid e snapshots nella propria distribuzione.
 +
 +
== IMG ==
 +
Per fare esperimenti con i filesystem può essere utile creare dei file immagine
 +
 +
Creare un file immagine di una specifica grandezza (es.: 10G)
 +
$ truncate -s 10g disk.img
 +
 +
Formattarlo con un filesystem (es.: btrfs)
 +
$ mkfs.btrfs disk.img
 +
 +
Montarlo in loop
 +
$ sudo mount -o loop disk.img /mnt
  
  
Riga 152: Riga 239:
 
* Sul disco smontato
 
* Sul disco smontato
 
  # btrfs check --repair /dev/partizione
 
  # btrfs check --repair /dev/partizione
 +
 +
Per non dover ricorrere ad un dispositivo di avvio alternativo, dato che btrfs-check non può essere utilizzato su un filesystem montato, si consiglia di aggiungerlo al ramdisk modificando in questo mmodo il file <code>/etc/mkinitcpio.conf</code>
 +
 +
BINARIES=(btrfs)
  
 
=== Quote ===
 
=== Quote ===
Riga 186: Riga 277:
 
* Cancellare un subvolume/snapshot
 
* Cancellare un subvolume/snapshot
 
  # btrfs subvolume delete rootsnap
 
  # btrfs subvolume delete rootsnap
 +
 +
==== Integrazione con GRUB ====
 +
È possibile caricare automaticamente all'avvio gli snapshot dei filesystem di root attraverso il programma '''grub-btrfs'''
 +
# pacman -S grub-btrfs
 +
 +
Con questo tool ogni volta che rigeneriamo il file di configurazione di GRUB il sistema rileva eventuali sottovolumi avviabili (snapshot comprese) aggiungendoli al menu di avvio del GRUB
 +
# grub-mkconfig -o /boot/grub/grub.cfg
  
 
=== Backup ===
 
=== Backup ===
Riga 203: Riga 301:
 
  btrfs property set /mnt/btrfs/@root ro false
 
  btrfs property set /mnt/btrfs/@root ro false
  
=== Cifratura ===
 
[https://wiki.golem.linux.it/Installare_Arch_Linux_in_una_partizione_cifrata Partizione cifrata]
 
  
==== Alternative ====
+
=== RAID ===
 +
Tipologie e caratteristiche dei raid [https://btrfs.readthedocs.io/en/latest/mkfs.btrfs.html#profiles supportati]
 +
 
 +
Confronto tra varie tecnologie di [https://blog.jenningsga.com/status-of-storage-within-linux/ raid]
  
* Ext4 gestisce la cifratura di una directory tramite l'utility [https://wiki.archlinux.org/title/Fscrypt Fscrypt]
+
{| class="wikitable"
 +
! RAID !! Redundancy Copies !! Redundancy Parity !! Redundancy Striping !! Spazio utilizzato !! Min/max n. dischi
 +
|-
 +
| disco singolo || 1 || || || 100% || 1/N
 +
|-
 +
| RAID0 || 1 || || 1 to N || 100% || 1/N
 +
|-
 +
| RAID1 || 2 || || ||  50% || 2/N
 +
|-
 +
| RAID1C3 || 3 || || || 33% || 3/N
 +
|-
 +
| RAID1C4 || 4 || || || 25% || 4/N
 +
|-
 +
| RAID10 || 2 || || 1 to N || 50%  || 2/N
 +
|-
 +
| RAID5 || 1 || 1 || 2 to N-1 || (N-1)/N || 2/N
 +
|-
 +
| RAID6 || 1 || 2 || 3 to N-2 || (N-2)/N || 3/N
 +
|}
  
* ZFS supporta la cifratura dei [https://wiki.archlinux.org/title/ZFS#Native_encryption pool]
 
  
=== RAID ===
 
  
 
====RAID 0====
 
====RAID 0====
Riga 241: Riga 356:
  
 
Adesso è necessario effettuare una redistribuzione dei dati sui tre dischi
 
Adesso è necessario effettuare una redistribuzione dei dati sui tre dischi
 +
# btrfs balance start -d -m /mnt
  
  # btrfs balance start -d -m /mnt
+
Per vedere a che punto del bilanciamento è arrivato il sistema
 +
  # btrfs fi balance status /
  
 
  # btrfs filesystem show /mnt
 
  # btrfs filesystem show /mnt
Riga 257: Riga 374:
  
 
==== RAID 1 ====
 
==== RAID 1 ====
 +
=====Creazione di un raid1 ex novo=====
 +
Copiare la tabella delle partizioni da sda a sdb
 +
# sfdisk -d /dev/sda | sfdisk /dev/sdb
 +
 +
Creare il raid
 
  # mkfs.btrfs -d raid1 -m raid1 /dev/sda1 /dev/sdb1
 
  # mkfs.btrfs -d raid1 -m raid1 /dev/sda1 /dev/sdb1
  
==== RAID 5 ====
+
===== Aggiungere un mirror ad un disco esistente =====
===== Conversione a RAID5=====
+
# btrfs device add /dev/sdb1 ''/punto_di_mount''
  # btrfs balance start -dconvert=raid5 -mconvert=raid5 ''/punto_di_mount''
+
  # btrfs balance start -dconvert=raid1 -mconvert=raid1 ''/punto_di_mount''
 +
 
 +
===== GRUB =====
 +
Se si utilizza un raid1 per la partizione di sistema '''/''' e si vuole rendere Linux avviabile automaticamente anche in caso di danneggiamento o mancanza di uno dei due dischi del raid occorrerà che sul secondo disco sia clonata la partizione EFI o BIOS GRUB (es.: /dev/sda1) e che vi sia installato il bootloader.
 +
# dd if=/dev/sda1 of=/dev/sdb1
 +
# grub-install /dev/sdb
  
 
=====Sostituzione device danneggiato=====
 
=====Sostituzione device danneggiato=====
  # btrfs replace start /dev/sdb1 /dev/sdc1 ''/punto_di_mount''
+
Verificare qual è il disco che dà dei problemi
 +
# mount /dev/sda1 ''/punto_di_mount'' -o degraded
 +
# btrfs device stats ''/punto_di_mount''
 +
# btrfs filesystem show ''/punto_di_mount''
 +
# btrfs device usage ''/punto_di_mount''
 +
 
 +
Ipotizzando che '''1''' sia l'ID del disco danneggiato secondo i comandi dati in precedenza
 +
  # btrfs replace start '''1''' /dev/sdc1 ''/punto_di_mount''
 +
 
 +
Per monitorare lo stato di ripristino del raid
 +
# btrfs replace status ''/punto_di_mount''
  
 
In alcuni casi potrebbe essere necessario montare il filesystem in modalità '''degraded''' (con l'opzione ''-o degraded'') e lanciare il successivo comando per eliminare definitivamente il device dal raid.
 
In alcuni casi potrebbe essere necessario montare il filesystem in modalità '''degraded''' (con l'opzione ''-o degraded'') e lanciare il successivo comando per eliminare definitivamente il device dal raid.
 
  # btrfs device delete missing /mnt
 
  # btrfs device delete missing /mnt
 +
 +
==== RAID 5 ====
 +
{{Note
 +
|type=warning
 +
| text= '''ATTENZIONE il raid5 su BTRFS è considerato [https://btrfs.readthedocs.io/en/latest/btrfs-man5.html#raid56-status-and-recommended-practices non sicuro] e se ne sconsiglia il suo utilizzo'''
 +
}}
 +
==== RAID 1C ====
 +
 +
===== RAID 1C3 =====
 +
Se si desidera duplicare i dati rispettivamente 2 volte in modo da poter perdere fino a due dischi su 3 senza perdere dati è possibile utilizzare una modalità chiamata raid1c3
 +
 +
Per creare ex novo il raid1c3
 +
# mkfs.btrfs -d raid1c3 -m raid1c3 /dev/sda1 /dev/sdb1 /dev/sdc1
 +
 +
Per convertire a raid1c3
 +
# btrfs balance start -dconvert=raid1c3 -mconvert=raid1c3 /storage-btrfs/
 +
 +
===== RAID 1C4 =====
 +
Se si desidera duplicare i dati rispettivamente 3 volte in modo da poter perdere fino a 3 dischi su 4 senza perdere dati è possibile utilizzare una modalità chiamata raid1c4
 +
 +
Per creare ex novo il raid1c3
 +
# mkfs.btrfs -d raid1c4 -m raid1c4 /dev/sda1 /dev/sdb1 /dev/sdc1
 +
 +
Per convertire a raid1c4
 +
# btrfs balance start -dconvert=raid1c4 -mconvert=raid1c4 /storage-btrfs/
  
 
== ZFS ==
 
== ZFS ==
* Installare Arch Linux su [https://wiki.golem.linux.it/Installare_Arch_Linux_su_ZFS ZFS]
+
===Installazione di modulo e le utility da AUR===
 +
# pacman-key -r F75D9D76
 +
# pacman-key --lsign-key F75D9D76
 +
$ pikaur -S zfs-utils zfs-dkms
 +
 
 +
===Installazione di modulo e utility da archzfs===
 +
Modificare le seguenti righe al file '''pacman.conf''' di archiso
 +
[archzfs-testing]
 +
Server = https://archzfs.com/$repo/$arch
 +
 
 +
# pacman-key -r DDF7DB817396A49B2A2723F7403BD972F75D9D76
 +
# pacman-key --lsign-key DDF7DB817396A49B2A2723F7403BD972F75D9D76
 +
# pacman -S zfs-utils zfs-linux
 +
 
 +
===Configurare il FS===
 +
[https://wiki.archlinux.org/title/ZFS Comandi] per ottenere informazioni utili sul filesystem e sui pool
 +
# zfs list -t  all
 +
# zpool status
 +
# zpool list
  
Comandi per ottenere informazioni utili sul filesystem e sui pool
+
Abilitare i vari servizi sul filesystem
  zfs list
+
  # systemctl enable zfs-zed.service
  zpool status
+
  # systemctl enable zfs-mount.service
  zpool list
+
# systemctl enable zfs-share.service
 +
# systemctl enable zfs-import.target
 +
  # systemctl enable zfs.target
  
 
Creare un pool su un disco
 
Creare un pool su un disco
  zpool create "pool" sda
+
  # zpool create "pool" sda
  
 
Creare un pool su una partizione
 
Creare un pool su una partizione
  zpool create "pool" sda2
+
  # zpool create "pool" sda2
 +
 
 +
Importare un pool
 +
# zpool import "pool"
 +
 
 +
Aggiungere pool alla cache per auto-import e mount (abilitare i vari demoni zfs)
 +
# zpool set cachefile=/etc/zfs/zpool.cache "pool"
 +
 
 +
oppure si possono caricare i mountpoint in modalità legacy dall'fstab
 +
# zfs create -o mountpoint=legacy ''pool''/directory
 +
 
 +
Aggiungere la compressione
 +
# zfs get compression ''pool''
 +
# zfs set compression=lz4 ''pool''
 +
 
 +
Vedere le proprietà di un ''pool''
 +
# zfs get all ''zpool''
  
 +
==== RAID ====
 
Creare un pool in raid0
 
Creare un pool in raid0
  zpool create "pool" /dev/sdb /dev/sdc
+
  # zpool create "pool" /dev/sdb /dev/sdc
  
 
Creare un pool in raid1
 
Creare un pool in raid1
  zpool create "pool" mirror /dev/sdb /dev/sc
+
  # zpool create "pool" mirror /dev/sdb /dev/sc
  
 
Creare un pool ''raid5'' su più dischi
 
Creare un pool ''raid5'' su più dischi
  zpool create "pool" raidz /dev/sdb /dev/sdc /dev/sdd
+
  # zpool create "pool" raidz /dev/sdb /dev/sdc /dev/sdd
  
 
Creare un pool raid5 su immagini
 
Creare un pool raid5 su immagini
  zpool create "pool" raidz /path/1.img /path/2.img /path/3.img
+
  # zpool create "pool" raidz /path/1.img /path/2.img /path/3.img
 +
 
 +
* [https://docs.oracle.com/cd/E19253-01/819-5461/gbbvf/index.html Sostituire] disco in raid
 +
 
 +
Rimuovere il disco da sostituire
 +
# zpool offline disco1
  
[https://docs.oracle.com/cd/E19253-01/819-5461/gbbvf/index.html Sostituire] disco in raid
+
Inserire il nuovo disco
zpool offline disco1
+
  # zpool replace "pool" disco1
''Rimuovere il disco da sostituire''
+
  # zpool online disco1
''Inserire il nuovo disco''
 
  zpool replace "pool" disco1
 
  zpool online disco1
 
  
Utilizza un altro disco montato al posto di quello danneggiato
+
* Utilizza un altro disco montato al posto di quello danneggiato
  zpool replace "pool" disco1 disco2
+
  # zpool replace "pool" disco1 disco2
  
 
Aggiungere uno o più dischi ad un pool
 
Aggiungere uno o più dischi ad un pool
  zpool add "pool" mirror disco3 disco4
+
  # zpool add "pool" mirror disco3 disco4
  zpool add "pool" raidz disco3 disco4 disco5
+
  # zpool add "pool" raidz disco3 disco4 disco5
  
 
Rimuovere disco1 da pool se aggiunto erroneamente
 
Rimuovere disco1 da pool se aggiunto erroneamente
  zpool remove "pool" disco1
+
  # zpool remove "pool" disco1
 +
 
 +
Controllare lo stato di un pool
 +
# zpool status
 +
 
 +
Correggere eventuali errori
 +
# zpool clear ''pool'' ''disco''
 +
# zpool scrub  ''pool''
 +
 
 +
=== Root filesystem ===
 +
* Guida ufficiale [https://openzfs.github.io/openzfs-docs/Getting%20Started/Arch%20Linux/Root%20on%20ZFS/1-preparation.html Root on ZFS]
 +
 
 +
Per prima cosa organizzare la tabella delle partizioni del [[#Preparazione_del_disco | disco]]
 +
 
 +
Formattare la partizione e creare il dataset (senza mountpoint)
 +
# zpool create -m none rpool ''sda2''
 +
 +
Smontare il pool e rimontarlo in modalità legacy
 +
# zfs create -o mountpoint=none rpool/ROOT
 +
# zfs create -o mountpoint=legacy rpool/ROOT/arch
 +
# zpool set bootfs=rpool/ROOT/arch rpool
 +
# mount -t zfs rpool/ROOT /mnt
 +
''rpool'' è il nome che abbiamo voluto dare al volume contenente il filesystem di sistema
 +
 
 +
NB: se NON si usa il mountpoint in modalità legacy occorrerà impostare <code>canmount=noauto</code> su tutti i dataset con <code>mountpoint=/</code> (es.: zfs create -o mountpoint=/ -o canmount=noauto rpool/ROOT/arch) altrimenti il sistema cercherà di eseguirne automaticamente l'automount e fallirà se esistono più filesystem da montare su /
  
Importare un pool
+
Se volessimo aggiungere altri pool es.:
  zpool import "pool"
+
  # zfs create rpool/home
 +
# zfs create rpool/arch/pkg
 +
# zfs create rpool/var
 +
# zfs create rpool/srv
  
Aggiungere pool alla cache per auto-import e mount (abilitare i vari demoni zfs)
+
Configurare la cache degli zpool
  zpool set cachefile=/etc/zfs/zpool.cache "pool"
+
  # zpool set cachefile=/etc/zfs/rpool.cache rpool
  
oppure si possono caricare i mountpoint in modalità egacy dall'fstab
+
Copiare il file di cache nel sistema dove dovremo eseguire il chroot per l'installazione.
  zfs create -o mountpoint=legacy "pool"/directory
+
  # mkdir -p /mnt/etc/zfs
 +
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
  
Aggiungere la compressione
+
Installare il sistema di base
  zfs get compression "pool"
+
  # pacstrap -K /mnt base linux linux-firmware zfs-utils zfs-linux
zfs set compression=lz4 "pool"
 
  
Vedere le proprietà di uno zpool
+
Altri pacchetti consigliati
  zfs get all zpool
+
  # pacstrap -K /mnt base-devel net-tools networkmanager nano zsh grml-zsh-config busybox
  
Per installazione da chroot con zfs su /
+
Eseguire il chroot per procedere con l'installazione
  zfs create -o mountpoint=legacy "pool"/ROOT
+
  # arch-chroot /mnt
zpool set bootfs="pool"/ROOT "pool"
 
mount -t zfs "pool"/ROOT /mnt
 
  
 +
Configurare il mountpoint su fstab
 
/etc/fstab  
 
/etc/fstab  
"pool"/ROOT      /      zfs        noatime    0 0
+
rpool/ROOT/arch     /      zfs        noatime    0 0
 +
 
 +
Editare il file /etc/mkinitcpio.conf aggiungendo zfs prima del filesystem
 +
HOOKS="base udev autodetect modconf block keyboard zfs filesystems"
 +
 
 +
Abilitare i servizi per ZFS all'avvio
 +
# systemctl enable zfs-zed.service
 +
# systemctl enable zfs-mount.service
 +
# systemctl enable zfs-share.service
 +
# systemctl enable zfs-import.target
 +
# systemctl enable zfs.target
 +
 
 +
Impostare una password di root
 +
# passwd
 +
 
 +
Ricreare il ramdisk col supporto per ZFS
 +
# mkinitcpio -p linux
 +
 
 +
Installare il [[Appunti_Arch_Linux#BOOT_LOADER|Boot Loader]]
 +
 
 +
Uscire dal chroot e terminazione dell'installazione
 +
# exit
 +
# zfs unmount -a
 +
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
 +
# zpool export rpool
 +
# reboot
 +
 
 +
==== BOOT LOADER ====
 +
===== ZFSBootMenu =====
 +
Per gestire a meglio gli snapshot e la clonazione dei pool è consigliabile, su PC che supportano UEFI, utilizzare il boot loader [https://docs.zfsbootmenu.org/en/latest/guides/alpine/uefi.html ZFSBootMenu].
 +
 
 +
Esportiamo le variabile per configurare il primo disco /dev/sda come disco di avvio
 +
# export BOOT_DISK="/dev/sda"
 +
# export BOOT_PART="1"
 +
# export BOOT_DEVICE="${BOOT_DISK}${BOOT_PART}"
 +
 
 +
Assicuriamoci che il nostro pool di root sia configurato come avviabile
 +
# zpool set bootfs=''rpool/ROOT/'' ''rpool''
 +
 
 +
Formattiamo sda1 per creare la partizione EFI di boot
 +
# mkfs.vfat -F32 "$BOOT_DEVICE"
 +
 
 +
Aggiungiamola all'fstab e montiamola
 +
# cat << EOF >> /etc/fstab
 +
$BOOT_DEVICE /boot/efi vfat defaults 0 0
 +
EOF
 +
 
 +
# mkdir -p /boot/efi
 +
# mount /boot/efi
 +
 
 +
Scarichiamo ed installiamo il boot loader
 +
# mkdir -p /boot/efi/EFI/ZBM
 +
# curl -o /boot/efi/EFI/ZBM/VMLINUZ.EFI -L https://get.zfsbootmenu.org/efi
 +
# cp /boot/efi/EFI/ZBM/VMLINUZ.EFI /boot/efi/EFI/ZBM/VMLINUZ-BACKUP.EFI
 +
 
 +
Forziamo zfsbootmenu a montare il nostro dataset con i permessi di scrittura
 +
# zfs set org.zfsbootmenu:commandline="quiet loglevel=4 rw" rpool/ROOT
 +
 
 +
Installiamo e configuriamo  ''efibootmgr''
 +
# pacman -S efibootmgr
 +
 
 +
# efibootmgr -c -d "$BOOT_DISK" -p "$BOOT_PART" \
 +
  -L "ZFSBootMenu (Backup)" \
 +
  -l \\EFI\\ZBM\\VMLINUZ-BACKUP.EFI
 +
 
 +
# efibootmgr -c -d "$BOOT_DISK" -p "$BOOT_PART" \
 +
  -L "ZFSBootMenu" \
 +
  -l \\EFI\\ZBM\\VMLINUZ.EFI
 +
 
 +
 
 +
* Se si utilizza un pool distribuito su più dischi (RAID1 o RAIDZ) occorrerà installare il bootloader anche sugli altri dispositivi (nel caso del disco /dev/sdb).
 +
 
 +
# mount /dev/sdb1 /boot/efi
 +
# curl -o /boot/efi/EFI/ZBM/VMLINUZ.EFI -L https://get.zfsbootmenu.org/efi
 +
# efibootmgr -c -d "$BOOT_DISK" -p "$BOOT_PART" \
 +
  -L "ZFSBootMenu sdb" \
 +
  -l \\EFI\\ZBM\\VMLINUZ.EFI
  
 +
===== GRUB =====
 +
Se non ci interessa gestire snapshot o utilizziamo un PC con BIOS è possibile optare per GRUB
 +
# pacman -S grub
 +
# grub-install /dev/sda
 +
(se si usa un pool composto da più dischi es. raidz per il filesystem di root è consigliabile installare grub su tutti i dischi: sda, sdb, sdc, sdd...)
 +
# grub-mkconfig -o /boot/grub/grub.cfg
  
=== GRUB ===
+
Esempio
 
  #Grub entry
 
  #Grub entry
 
  menuentry 'Arch Linux'{
 
  menuentry 'Arch Linux'{
Riga 343: Riga 652:
 
       insmod part_gpt
 
       insmod part_gpt
 
       insmod zfs
 
       insmod zfs
       set root='hd0,gpt2'
+
       set root='hd0,gpt3'
      linux  /ROOT@/boot/vmlinuz-linux zfs_force=1 zfs=bootfs root=ZFS=rpool/ROOT rw  quiet
+
        echo    'Loading Linux linux ...'
      initrd  /ROOT@/boot/initramfs-linux.img
+
        linux  /ROOT@/boot/vmlinuz-linux root=ZFS=rpool/ROOT rw  loglevel=3 quiet
  }
+
        echo    'Loading initial ramdisk ...'
 +
        initrd  /ROOT@/boot/initramfs-linux.img
 +
}
 +
 
 +
=== Snapshot ===
 +
Snapshot del dataset ROOT
 +
# zfs snapshot -r rpool/ROOT''@snapshot-2023-03-07''
 +
 
 +
Lista degli snapshot presenti
 +
# zfs list -t snapshot
 +
 
 +
Ripristino dello snapshot
 +
# zfs rollback rpool''@snapshot-2023-03-07''
 +
 
 +
Oltre che servire per il ripristino, possono essere montati per esplorarne il contenuto, ma non è possibile modificarlo.
 +
# mount -t zfs rpool@''2023-04-11'' /mnt/''snapshot''
 +
 
 +
Copia locale di un dataset
 +
# zfs send -R rpool/ROOT''@snapshot-2023-03-07'' | zfs recv -F rpool/ROOT/backup
 +
 
 +
Invio via SSH di una snapshot
 +
# zfs send -R rpool/ROOT''@snapshot-2023-03-07''| ssh ''user@ip_address'' zfs recv tank/backups/rootzfs
 +
 
 +
Backup locale di una snapshot
 +
# zfs send -R rpool/ROOT@snapshot | gzip > /tmp/zfs_backup.gz
 +
 
 +
Restore del backup
 +
# gzcat /tmp/zfs_backup.gz | zfs recv -F rpool/ROOT
 +
 
 +
==== Clone ====
 +
Se vogliamo eseguire operazioni di scrittura su una snapshot occorre effettuare un clone del dataset
 +
# zfs snapshot ''rpool/home''@yesterday
 +
# zfs clone ''rpool/home''@yesterday rpool/new_home
 +
 
 +
Per sostituire il filesystem principale col clone
 +
# zfs promote rpool/new_home
 +
 
 +
=== ZFS Cifrato ===
 +
Creare un dataset cifrato con password
 +
# zfs create -o encryption=on -o keyformat=''password'' ''nomepool''/''nomedataset''
 +
 
 +
Generazione di una chiave di cifratura
 +
# dd if=/dev/random of=/path/to/key bs=1 count=32
 +
 
 +
Creare un dataset cifrato con una chiave di cifratura
 +
# zfs create -o encryption=on -o keyformat=raw -o keylocation=''file:///directory/della/chiave'' ''nomepool''/''nomedataset''
 +
 
 +
Controllare il percorso della chiave per ''nomepool''/''nomedataset''
 +
# zfs get keylocation ''nomepool''/''nomedataset''
 +
 
 +
Cambiare il percorso della chiave
 +
# zfs set keylocation=''file:///nuova/directory/della/chiave'' ''nomepool''/''nomedataset''
 +
 
 +
Caricare manualmente le chiavi di cifratura prima del montaggio
 +
# zfs load-key ''nomepool''/''nomedataset'' # carica la chiave del determinato dataset
 +
# zfs load-key -a # carica tutte le chiavi del filesystem
 +
 
 +
==== Unlock con systemd ====
 +
Creare script per il caricamento delle chiavi all'avvio
 +
 
 +
* Caricando la password dal keyfile
 +
''/etc/systemd/system/zfs-loadkey-file.service''
 +
 
 +
[Unit]
 +
Description=Load ZFS encryption keys
 +
DefaultDependencies=no
 +
After=zfs-import.target
 +
Before=zfs-mount.service
 +
[Service]
 +
Type=oneshot
 +
RemainAfterExit=yes
 +
ExecStart=/usr/sbin/zfs load-key -a
 +
StandardInput=tty-force
 +
[Install]
 +
WantedBy=zfs-mount.service
 +
 
 +
* Digitando la password
 +
 
 +
''/etc/systemd/system/zfs-load-key@.service''
 +
[Unit]
 +
Description=Load %I encryption keys
 +
Before=systemd-user-sessions.service zfs-mount.service
 +
After=zfs-import.target
 +
Requires=zfs-import.target
 +
DefaultDependencies=no
 +
[Service]
 +
Type=oneshot
 +
RemainAfterExit=yes
 +
ExecStart=/bin/sh -c 'until (systemd-ask-password "Encrypted ZFS password for %I" --no-tty | zfs load-key %I); do echo "Try again!"; done'
 +
[Install]
 +
WantedBy=zfs-mount.service
 +
 
 +
==== Unlock al login ====
 +
Impostare il filesystem in modalità legacy così che non sia montato automaticamente all'avvio
 +
# zfs set mountpoint=legacy zroot/data/
 +
 
 +
Modificare il file /etc/fstab
 +
zroot/data/        /home          zfs            rw,xattr,posixacl,noauto        0 0
 +
 
 +
Creare il seguente script: <code>/sbin/mount-zfs-homedir</code>
 +
 
 +
#!/bin/bash
 +
#
 +
set -eu
 +
# Password is given to us via stdin, save it in a variable for later
 +
PASS=$(cat -)
 +
#
 +
VOLNAME="zroot/data/home"
 +
#
 +
# Unlock and mount the volume
 +
zfs load-key "$VOLNAME" <<< "$PASS" || continue
 +
zfs mount "$VOLNAME" || true # ignore errors
 +
 
 +
Aggiungere lo script a PAM: /etc/pam.d/system-auth
 +
 
 +
auth      optional                    pam_exec.so          expose_authtok /sbin/mount-zfs-homedir
 +
 
 +
=== Cache ===
 +
Utilizzare un moderno disco a stato solido può essere una soluzione economica per velocizzare un pool, eventualmente anche raid
 +
 
 +
# zpool add -f ''rpool'' cache /dev/sdd1
 +
# zpool add -f ''rpool'' log /dev/sdd2
 +
 
 +
=== Sharing ===
 +
Non è molto noto, ma ZFS ha integrati dei [https://docs.oracle.com/cd/E36784_01/html/E36835/gayne.html#scrolltoc comandi] per permettere la condivisione del filesystem con altre macchine tramite i protocolli NFS o SMB.
 +
 
 +
Premessa: occorrerà attivare il server NFS
 +
# systemctl start nfs-server.service
 +
# systemctl enable nfs-server.service
 +
 
 +
Condividere tramite NFS l'intero pool ''home''
 +
# zfs set share.nfs=on ''pool''/home
 +
 
 +
Verificare la condivisione
 +
# zfs get -r share.nfs ''pool''/home
 +
NAME            PROPERTY  VALUE  SOURCE
 +
pool/home        share.nfs  on    local
 +
 
 +
Condividere tramite NFS la directory home dell'utente 1, 2...
 +
# zfs create ''pool''/home/'''utente1'''
 +
# zfs create ''pool''/home/'''utente2'''
 +
 
 +
Si possono specificare opzioni di montaggio per i permessi sul mount
 +
# zfs set share.nfs.nosuid=on ''pool''/home/'''utente1'''
 +
# zfs set share.nfs=on ''pool''/home/'''utente1'''
 +
 
 +
Condividere una directory con tutta la rete
 +
# zfs share -o share.nfs=on -o share.nfs.public=on pool/public%pubshare
 +
 
 +
Condividere una directory con una parte della rete
 +
# zfs set share.nfs='rw=@192.0.10.0/16,rw=@192.0.11.0/24' pool/public%pubshare
 +
 
 +
Disabilitare temporaneamente una condivisione
 +
# zfs unshare pool/home/''nomeshare''
 +
 
 +
Rimuovere una condivisione
 +
# zfs set share.nfs=off pool/''share''
 +
 
 +
 
 +
=== Montare share ===
 +
Montare il volume pool1 della macchina con IP 192.168.0.2 su /mnt/pool1
 +
# mount -t nfs 192.168.0.2:/pool1 /mnt/pool1
 +
 
 +
Aggiungere la seguente riga al file '''/etc/fstab''' per automatizzare il montaggio
 +
192.168.0.2:/pool1      /mnt/pool1      nfs      defaults          0          0
 +
 
 +
 
 +
=== SWAP ===
 +
Creare una partizione swap da 8 GiB
 +
# zfs create -V 8G '''<pool>/swap'''
 +
 
 +
Formattazione della partizione
 +
# mkswap -f /dev/zvol/<pool>/swap
 +
 
 +
Attivazione della swap
 +
  # swapon /dev/zvol/<pool>/swap
 +
 
 +
Aggiungere la swap al <code>/etc/fstab</code>
 +
'''/dev/zvol/<pool>/swap''' none swap discard 0 0
 +
 
 +
== Filesystem Cifrato ==
 +
Esistono molti modi per cifrare volumi e file su Linux, come si può vedere da questa [https://wiki.archlinux.org/title/Data-at-rest_encryption#Comparison_table tabella]
 +
 
 +
* Generare una password di 32 caratteri alfanumerici con /dev/random.
 +
cat /dev/random | tr -dc '[:alnum:]' | fold -w 32 | head -n 1
 +
 
 +
=== EncFS ===
 +
Cifrare una directory può essere un'alternativa alla cifratura di un intera partizione come avviene invece con Cryptsetup. EncFS è un filesystem user-space montabile tramite FUSE che permette di effettuare questa operazione. Rispetto ad un filesystem loopback criptato ci sono però diversi pregi e difetti.
 +
 
 +
* Pro
 +
# Selezionare selettivamente i contenuti da cifrare, rispetto ad avere un device completamente cifrato, appesantisce meno il lavoro della CPU specialmente quando si utilizzano processori datati privi del set di istruzioni AES.
 +
# Dimensioni modificabili: un file system vuoto EncFS è composto da qualche dozzina di byte e può crescere a qualsiasi dimensione senza bisogno di essere riformattato. Con un dispositivi di cifratura a blocchi, si alloca un filesystem in anticipo con le dimensioni desiderate.
 +
# Possibilità di backup incrementali: Un filesystem EncFS può essere salvato con una politica per file. Un programma di backup è in grado di rilevare quali file sono cambiati, anche se non sarà in grado di decifrarli.
 +
# Permette di aggiungere la crittografia a qualsiasi filesystem
 +
# Lavora a livello utente, non richiede permessi di amministratore
 +
 
 +
* Contro
 +
# Non permette di cifrare l'intera installazione, ma solo i file selezionati
 +
# Chi ha accesso ai file crittografati può conoscerne i meta-dati (numero di file, permessi, dimensione)
 +
# EncFS sembra non sia più attivamente mantenuto. Un'alternativa molto simile potrebbe essere gocryptfs.
 +
 
 +
==== Montaggio automatico ====
 +
Dato che non è possibile passare opzioni all'eseguibile encfs su fstab è necessario creare un wrapper, cioè uno script da rendere eseguibile (es. <code>/home/user/encfs.sh</code>) che vada a recuperare la password da un file (es. ''encfs_password''), magari contenuto in una chiavetta USB anch'essa montata automaticamente all'avvio.
 +
 
 +
Wrapper
 +
#!/bin/sh
 +
encfs --public --extpass="cat /mnt/USB/encfs_password" $*
 +
 
 +
 
 +
A questo punto è possibile aggiungere all'''/etc/fstab'' le seguenti righe.
 +
# Montaggio automatico della penna USB ''cafebabe-b00b5-deadbee'' all'avvio
 +
UUID=cafebabe-b00b5-deadbeef /mnt/USB auto defaults,auto 0 0
 +
# Richiamo del wrapper
 +
/home/''user''/encfs.sh#/home/''user''/.encrypted /home/''user''/decrypted fuse rw,user,auto 0 0
 +
 
 +
 
 +
=== gocryptfs ===
 +
Creare una directory cifrata ''crypt'' e montarla su ''dati''
 +
$ mkdir crypt dati
 +
$ gocryptfs -init crypt
 +
$ gocryptfs crypt dati
 +
 
 +
Creare una versione cifrata di una preesistente home
 +
 
 +
$ mkdir /home/user.crypt
 +
$ gocryptfs -init -reverse /home/user
 +
$ gocryptfs -reverse /home/user /home/user.crypt
 +
 
 +
È possibile aggiungere una linea simile alle seguente al file '''/etc/fstab''' per automatizzare il sistema di montaggio di una cartella cifrata durante il boot utilizzando un keyfile.
 +
 
 +
/home/user/cipher /home/user/plain fuse./usr/bin/gocryptfs nofail,allow_other,passfile=/tmp/password 0 0
 +
 
 +
=== [https://wiki.archlinux.org/title/ECryptfs ECryptfs] ===
 +
 
 +
=== VeraCrypt ===
 +
[https://www.veracrypt.fr VeraCrypt] (fork di TrueCrypt) è un tool opensource dotato di '''interfaccia grafica''' che permette di configurare la cifratura di volumi reali o file immagini montate in loop. Ha una funzione particolare, chiamata '''Hidden Volume''' che permette di creare un volume nascosto all'interno di un normale volume VeraCrypt al quale si può accedere con una diversa password così da evitare in caso di necessità (ricatto, fidanzata/moglie gelosa, imposizione da parte delle forze dell'ordine) di mostrare il contenuto del reale archivio cifrato.
 +
 
 +
=== Cryptsetup ===
 +
[https://wiki.golem.linux.it/Installare_Arch_Linux_in_una_partizione_cifrata Partizione cifrata]
  
=== Snapshots ===
+
[https://guide.debianizzati.org/index.php/Volumi_criptati_LUKS_-_Creazione_e_uso_con_cryptmount Volumi_criptati_LUKS]
[https://ramsdenj.com/2016/08/29/arch-linux-on-zfs-part-3-followup.html Guida esterna]
 
  
 +
=== [https://wiki.archlinux.org/title/Fscrypt FScrypt] ===
  
== Alternative ==
+
=== [[Appunti_Arch_Linux#ZFS_Cifrato|ZFS]] ===
  
=== RAID mdadm ===
+
= RAID mdadm =
Era possibile effettuare RAID via software su Linux anche prima dell'avvento di filesystem di nuova generazione come btrfs o zfs. Per fare ciò è possibile utilizzare l'utitity <code>mdadm</code>.
+
Su Linux era possibile effettuare RAID via software anche prima dell'avvento di filesystem di nuova generazione come btrfs o zfs. Per fare ciò è possibile utilizzare il comando <code>mdadm</code>.
  
 
Vedere l'organizzazione della tabella delle partizioni dei dischi
 
Vedere l'organizzazione della tabella delle partizioni dei dischi
Riga 372: Riga 919:
 
Nell'esempio ci sono due dischi (sda, sdb) contenenti 3 partizioni: EFI, SWAP e Linux.
 
Nell'esempio ci sono due dischi (sda, sdb) contenenti 3 partizioni: EFI, SWAP e Linux.
  
==== RAID 0 ====
+
== RAID 0 ==
 
Creare un volume ''md3'' che costituito dalla somma delle due partizioni sda3 e sdb3
 
Creare un volume ''md3'' che costituito dalla somma delle due partizioni sda3 e sdb3
 
  # mdadm --create --verbose /dev/md3 --level=0 --raid-devices=2 /dev/sda3 /dev/sdb3
 
  # mdadm --create --verbose /dev/md3 --level=0 --raid-devices=2 /dev/sda3 /dev/sdb3
Riga 383: Riga 930:
 
  # mount /dev/md3 /mnt/
 
  # mount /dev/md3 /mnt/
  
 +
Per memorizzare l'array nel file di configurazione
 +
# mdadm –Es > /etc/mdadm.conf
  
==== RAID 1 ====
+
== RAID 1 ==
 
Creare un volume ''md3'' mirror delle due partizioni sda3 e sdb3
 
Creare un volume ''md3'' mirror delle due partizioni sda3 e sdb3
 
  # mdadm --create /dev/md3 /dev/sda3 /dev/sdb3 --level=1 --raid-devices=2
 
  # mdadm --create /dev/md3 /dev/sda3 /dev/sdb3 --level=1 --raid-devices=2
  
===== Accorgersi del guasto =====
+
== RAID 5 ==
Un ''cat'' di ''/var/log/messages'', ''/var/log/syslog'' o ''/proc/mdstat''' vi sarà di aiuto.
+
Creare un volume ''md3'' con un [https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_5 raid5], ovviamente stavolta occorreranno almeno 3 dischi es.: sda3, sdb3, sdc3.
In particolare, se su /proc/mdstat compare qualcosa di simile a
+
 
 +
Per creare tre partizioni tutte della stessa dimensione è possibile copiare su sdb e sdc la tabella delle partizioni di sda
 +
#  sfdisk -d /dev/sda | sfdisk /dev/sdb
 +
#  sfdisk -d /dev/sda | sfdisk /dev/sdc
 +
 
 +
Creare l'array in raid5
 +
# mdadm --create /dev/md/md3 /dev/sda1 /dev/sdb1 /dev/sdc1 --level=5 --raid-devices=3 --bitmap=internal
 +
 
 +
== Modificare l'array ==
 +
È possibile passare da raid1 a raid5
 +
# mdadm --grow /dev/md3 --level=5
 +
# mdadm --grow /dev/md3 --add /dev/sdc3 --raid-devices=3
 +
 
 +
== Accorgersi di un guasto ==
 +
Nei raid 1 e 5 in caso di danneggiamento di un disco sarà possibile sostituirlo e ricostruire l'array senza perdere dati. Nell'ipotesi di avere un guasto su '''sdb''' in un raid1 comparirà qualcosa di simile a questo eseguendo <code>cat /proc/mdstat</code>
 +
md3 : active raid1 sda3[1]
 
  ''blocks [2/2] [U_]''  
 
  ''blocks [2/2] [U_]''  
 
invece che
 
invece che
  ''blocks [2/2] [UU]''
+
  md3 : active raid1 sda3[1] '''sdb3'''[0]
significa che il vostro RAID 1 ha dei problemi.
+
      262016 blocks [2/2] [UU]
 
 
Nel nostro caso, visti gli altri log, ipotizziamo che il disco sdb si sia guastato e debba essere sostituito.
 
  
=====Rimuovere il disco danneggiato dal RAID=====
+
===Rimuovere il disco danneggiato dal RAID===
 
Si dovrà marcare sdb3 come danneggiata e andrà rimossa dall'array.
 
Si dovrà marcare sdb3 come danneggiata e andrà rimossa dall'array.
 
  # mdadm --manage /dev/md3 --fail /dev/sdb3
 
  # mdadm --manage /dev/md3 --fail /dev/sdb3
Riga 409: Riga 971:
 
  #  cat /proc/mdstat
 
  #  cat /proc/mdstat
 
  Personalities : [linear] [multipath] [raid0] [raid1] [raid5] [raid4] [raid6] [raid10]
 
  Personalities : [linear] [multipath] [raid0] [raid1] [raid5] [raid4] [raid6] [raid10]
  md0 : active raid1 sda1[0]
+
  md0 : active raid1 sda3[0]
 
  24418688 blocks [2/1] [U_]
 
  24418688 blocks [2/1] [U_]
  
 
  unused devices: <none>
 
  unused devices: <none>
  
===== Sostituzione del disco danneggiato =====
+
=== Sostituzione del disco danneggiato ===
 
Spegnere il computer, rimuovere il disco guasto e collegarne al suo posto uno funzionante.
 
Spegnere il computer, rimuovere il disco guasto e collegarne al suo posto uno funzionante.
  
Riga 423: Riga 985:
 
  # fdisk -l ''(per controllare che le partizioni siano uguali)''
 
  # fdisk -l ''(per controllare che le partizioni siano uguali)''
  
===== Ripristino del RAID 1 =====
+
=== Ripristino del RAID 1 ===
 
Aggiungere ''/dev/sdb3'' a ''/dev/md3''
 
Aggiungere ''/dev/sdb3'' a ''/dev/md3''
 
  # mdadm --manage /dev/md3 --add /dev/sdb3
 
  # mdadm --manage /dev/md3 --add /dev/sdb3
Riga 434: Riga 996:
  
 
= LVM =
 
= LVM =
Intro
+
Il [https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html-single/configuring_and_managing_logical_volumes/index#creating-and-managing-thinly-provisioned-volumes_configuring-and-managing-logical-volumes Logical Volume Manager] (LVM o gestore logico dei volumi) è un software per la gestione dei dischi che permette di superare le limitazioni legate al normale partizionamento di questi ultimi. Si tratta di una specie di ''strato'' che si va a frapporre tra il dispositivo fisico ed il filesystem. Permette di gestire dinamicamente aggiunta, rimozione o ridimensionamento dello spazio di archiviazione, il RAID, nonché lo snapshot dei volumi.
https://www.redhat.com/sysadmin/lvm-vs-partitioning
+
 
 +
LVM è un prodotto oltremodo maturo, disponibile per Linux sin dal kernel 2.4, per questa ragione distribuzioni orientate al mercato aziendale come RedHat lo hanno scelto, accoppiandolo a XFS o ext4, come soluzione predefinita per implementare la maggior parte delle caratteristiche fornite dai moderni filesystem come BTRFS o ZFS
 +
 
 +
LVM si basa sui seguenti concetti
 +
 
 +
* '''Physical Volumes (PV)''': rappresentano qualsiasi disco si voglia inizializzare ("formattare") come sottosistema LVM
 +
# pvcreate /dev/sda1
 +
# pvcreate /dev/sdb3
 +
# pvcreate /dev/sdc
 +
# pvdisplay
 +
 
 +
* '''Volume Groups (VG)''': sono costituiti da ''physical volumes'' e rappresentano la capacità totale delle risorse di un LVM
 +
# vgcreate vg0 /dev/sda1 /dev/sdb3 /dev/sdc
 +
# vgdisplay vg0
 +
 
 +
* '''Logical Volumes (LV)''': utilizzano le risorse messe a disposizione dai ''volume groups''. Possono essere inizializzati anche con proprietà di RAID o cache.
 +
# lvcreate -L 10G -n ''home'' vg0
 +
# lvdisplay /dev/vg0/home
 +
 
 +
Oppure nel caso volessimo fare un raid5
 +
# lvcreate -n lvr5 –type raid5 -L 10G -i 3 vg0
 +
 +
-n ''nome del volume''
 +
–type raid5 ''tipo di raid''
 +
-L ''dimensione massima della grandezza del raid''
 +
-i ''numero dei physical volumes che si vogliono utilizzare''
 +
 
 +
Per formattare il volume logico appena creato
 +
# mkfs -t ext4 /dev/vg0/lvr5
 +
 
 +
Per aggiungere un disco ad un Volume Groups
 +
# vgextend vg0 /dev/sdb2
  
Raid and restore
 
https://habr.com/en/company/hetmansoftware/blog/547086/
 
  
Snapshot
+
== Snapshot ==
https://www.html.it/articoli/backup-live-con-gli-snapshot-lvm-su-linux/
+
Creare uno snapshot della del volume logico ''/home'' che potrà contenere fino ad un massimo di 5 GiB di dati modificati rispetto all'originale
 +
# lvcreate --size 5G --snapshot --name homesnap20230306 /dev/vg0/home
  
Cache
+
Ripristinare il volume logico ricaricando lo snapshot
https://blog.golem.linux.it/2020/05/lvm-cache-su-ssd/
+
# lvconvert --merge /dev/vg0/homesnap20230306
  
Guida completa RedHat
+
Nel caso il logical volume sia attivo il merging avverrà col prossimo riavvio e lo snapshot sparirà.
https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html-single/configuring_and_managing_logical_volumes/index#creating-and-managing-thinly-provisioned-volumes_configuring-and-managing-logical-volumes
 
  
Altro
+
== Cache ==
 +
Utilizzare un moderno disco a stato solido può essere una soluzione economica per velocizzare un LV.
  
https://guide.debianizzati.org/index.php/LVM:_introduzione
+
Convertire il disco a PV ed aggiungerlo al preesistente VG
 +
# pvcreate ''/dev/discoSSD''
 +
# vgextend vg0 ''/dev/discoSSD''
  
https://www.lffl.org/2020/04/guida-sysadmin-istruzioni-lvm.html
+
Aggiungere la cache al LV
 +
# lvcreate --type cache --cachemode writethrough -l 100%FREE -n root_cachepool vg0/home ''/dev/discoSSD''
  
https://tldp.org/HOWTO/LVM-HOWTO/snapshots_backup.html
+
Rimuovere la cache dal LV
 +
# lvconvert --uncache vg0/home
  
= Boot loader =
+
= GRUB (Boot loader) =
Anche in questo caso sarebbe possibile scegliere tra più bootloader: GRUB, Lilo, Syslinux o addirittura il bootloader integrato del systemd (systemd-boot). Ma dato che GRUB è utilizzabile pressoché in ogni circostanza: schede madri BIOS, UEFI; Secure Boot, hard disk, floppy, CD-ROM... in questa guida mi limiterò alla sua configurazione, tralasciando le alternative.
+
È possibile scegliere tra più bootloader: GRUB, Lilo, Syslinux o addirittura il bootloader integrato del systemd (systemd-boot). Ma dato che GRUB è utilizzabile pressoché in ogni circostanza: schede madri BIOS, UEFI; Secure Boot, hard disk, floppy, CD-ROM... in questa guida mi limiterò alla sua configurazione, tralasciando le alternative.
  
=== Sistema con BIOS ===
+
== Sistema con BIOS ==
 
  # pacman -S grub
 
  # pacman -S grub
 
  # grub-mkconfig -o /boot/grub/grub.cfg
 
  # grub-mkconfig -o /boot/grub/grub.cfg
 
  # grub-install /dev/sda
 
  # grub-install /dev/sda
  
=== Sistema UEFI ===
+
== Sistema UEFI ==
 +
'''NB: per installare correttamente GRUB su un sistema UEFI occorre che il device di installazione abbia effettuato il boot in modalità UEFI e non Legacy (BIOS)'''
 +
 
 
  # pacman -S grub
 
  # pacman -S grub
 
  # mkdir /boot/EFI
 
  # mkdir /boot/EFI
 
  # mount /dev/sda1 /boot/EFI
 
  # mount /dev/sda1 /boot/EFI
  # grub-install --target=x86_64-efi --efi-directory=$esp --bootloader-id=grub --recheck --debug
+
  # grub-install /dev/sda
 
  # grub-mkconfig -o /boot/grub/grub.cfg
 
  # grub-mkconfig -o /boot/grub/grub.cfg
  
=== Gestione delle snapshot ===
+
== Gestione snapshot BTRFS ==
  
==== Manuale ====
+
=== Manuale ===
 
Editare ''/etc/grub.d/40_custom'' (o crearlo) e aggiungere quanto segue per permettere l'avvio della snapshot ''rootsnap''
 
Editare ''/etc/grub.d/40_custom'' (o crearlo) e aggiungere quanto segue per permettere l'avvio della snapshot ''rootsnap''
  
Riga 489: Riga 1 087:
 
  # grub-mkconfig -o /boot/grub/grub.cfg
 
  # grub-mkconfig -o /boot/grub/grub.cfg
  
==== Automatico ====
+
=== Automatico ===
 
Per facilitare la gestione lei sottovolumi e delle snapshot del BTRFS Arch offre il pacchetto ''grub-btrfs'', la sua installazione provvederà ad aggiungere tutti i sottovolumi contenenti un sistema Linux al menu di grub.
 
Per facilitare la gestione lei sottovolumi e delle snapshot del BTRFS Arch offre il pacchetto ''grub-btrfs'', la sua installazione provvederà ad aggiungere tutti i sottovolumi contenenti un sistema Linux al menu di grub.
 
  # pacman -S grub-btrfs
 
  # pacman -S grub-btrfs
Riga 497: Riga 1 095:
 
  # grub-mkconfig -o /boot/grub/grub.cfg
 
  # grub-mkconfig -o /boot/grub/grub.cfg
  
 
+
== Ripristinare GRUB ==
=== Ripristinare GRUB ===
 
 
Aggiornando la propria distribuzione Linux, il proprio boot loader o installando un altro sistema operativo (es. Windows) può capitare di sovrascrivere il [http://it.wikipedia.org/wiki/Master_boot_record MBR].
 
Aggiornando la propria distribuzione Linux, il proprio boot loader o installando un altro sistema operativo (es. Windows) può capitare di sovrascrivere il [http://it.wikipedia.org/wiki/Master_boot_record MBR].
  
Riga 521: Riga 1 118:
 
   # nano /mnt/sda2/boot/grub/grub.cfg
 
   # nano /mnt/sda2/boot/grub/grub.cfg
  
==== arch-chroot ====
+
=== arch-chroot ===
 
Se stiamo utilizzando un sistema basato su Arch Linux, utilizzando l'utility ''arch-chroot'' presente nel pacchetto ''arch-install-scripts'' potremo automatizzare il processo di chroot con un solo comando
 
Se stiamo utilizzando un sistema basato su Arch Linux, utilizzando l'utility ''arch-chroot'' presente nel pacchetto ''arch-install-scripts'' potremo automatizzare il processo di chroot con un solo comando
  
 
  # arch-chroot /mnt/sda2
 
  # arch-chroot /mnt/sda2
  
==== Manuale ====
+
=== Manuale ===
 
  # mount --rbind /dev /mnt/sda2/dev
 
  # mount --rbind /dev /mnt/sda2/dev
 
  # mount -t proc /proc /mnt/sda2/proc
 
  # mount -t proc /proc /mnt/sda2/proc
Riga 534: Riga 1 131:
 
  # chroot /mnt/sda2
 
  # chroot /mnt/sda2
  
==== Reinstallazione ====
+
=== Reinstallazione ===
 
  # grub-mkconfig -o /boot/grub/grub.cfg
 
  # grub-mkconfig -o /boot/grub/grub.cfg
 
  # grub-install /dev/sda
 
  # grub-install /dev/sda
  
==== Riavvio del sistema ====
+
=== Riavvio del sistema ===
 
Usciamo dal chroot, smontiamo la partizione e riavviamo il sistema
 
Usciamo dal chroot, smontiamo la partizione e riavviamo il sistema
 
  # exit
 
  # exit
Riga 545: Riga 1 142:
 
  # umount /mnt/sda1
 
  # umount /mnt/sda1
 
  # systemctl reboot
 
  # systemctl reboot
 +
 +
== Eliminare il boot loader ==
 +
In caso di errori nell'installazione di GRUB è possibile cancellare il vecchio boot loader di un disco (<code>''devicename'' = sda,sdb,sdc...</code>)
 +
# dd if=/dev/zero of=''/dev/devicename'' bs=446 count=1
 +
 +
== ISOBoot ==
 +
Con GRUB2 è possibile effettuare il boot di iso di LiveCD/USB Linux presenti sul disco aggiungendole su <code>/etc/grub.d/40_custom </code>
 +
 +
* Ubuntu 23.04
 +
menuentry "Ubuntu 23.04 desktop ISO" {
 +
        insmod part_gpt
 +
        insmod ext2
 +
        insmod btrfs
 +
        rmmod tpm
 +
    # es.: terza partizione del primo disco
 +
        set root=(hd0,gpt3)
 +
        set isofile="/home/'''<username>'''/Downloads/ubuntu-23.04-desktop-amd64.iso"
 +
        loopback loop $isofile
 +
        linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile quiet splash
 +
        initrd (loop)/casper/initrd
 +
}
  
 
= Networking =
 
= Networking =
Riga 626: Riga 1 244:
  
 
Aggiungere una rotta che passa per gateway 192.0.2.1
 
Aggiungere una rotta che passa per gateway 192.0.2.1
  #ip route add default via 192.168.0.1
+
  # ip route add default via 192.0.2.1
  
 
Aggiungere una rotta che passa per gateway 192.168.2.1 per l'interfaccia 10.0.2.0
 
Aggiungere una rotta che passa per gateway 192.168.2.1 per l'interfaccia 10.0.2.0
Riga 637: Riga 1 255:
 
  # ip route show
 
  # ip route show
  
== Systemd ==
+
== Systemd-networkd==
 
'''[https://wiki.archlinux.org/title/Systemd-networkd systemd-networkd'''] è un demone, parte di systemd, che gestisce la configurazione della rete.
 
'''[https://wiki.archlinux.org/title/Systemd-networkd systemd-networkd'''] è un demone, parte di systemd, che gestisce la configurazione della rete.
  
 
=== Esempi di configurazione ===
 
=== Esempi di configurazione ===
 
Per prima cosa sarà necessario abilitare il servizio
 
Per prima cosa sarà necessario abilitare il servizio
  # systemctl start systemd-networkd.service
+
  # systemctl enable --now systemd-networkd.service
 +
# systemctl enable --now systemd-resolved.service
 +
# ln -rsf /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf
  
 
==== DHCP ====
 
==== DHCP ====
Riga 661: Riga 1 281:
  
 
==== Wireless adapter ====
 
==== Wireless adapter ====
Per potersi connettere a connessioni WIFI è necessario installare e configurare un'ulteriore applicazione dedicata come '''iwd''' o '''wpa_supplicant]''' per l'autenticazione alla rete.
+
Per potersi connettere a connessioni WIFI è necessario installare e configurare un'ulteriore applicazione dedicata come '''iwd''' o '''wpa_supplicant''' per l'autenticazione alla rete.
  
 
/etc/systemd/network/25-wireless.network
 
/etc/systemd/network/25-wireless.network
Riga 689: Riga 1 309:
 
| [https://wireless.wiki.kernel.org/en/users/documentation/iw iw] || No || Sì || Sì || No
 
| [https://wireless.wiki.kernel.org/en/users/documentation/iw iw] || No || Sì || Sì || No
 
|-
 
|-
| [[wpa_supplicant]] || Sì || Sì || No || Sì
+
| [https://wiki.archlinux.org/title/wpa_supplicant wpa_supplicant] || Sì || Sì || No || Sì
 
|-
 
|-
 
| [https://wiki.archlinux.org/title/Iwd iwd]/iwgtk || No || Sì || No || Sì
 
| [https://wiki.archlinux.org/title/Iwd iwd]/iwgtk || No || Sì || No || Sì
Riga 711: Riga 1 331:
 
* Per chi dovesse prediligere la configurazione manuale: <code>nmcli</code>
 
* Per chi dovesse prediligere la configurazione manuale: <code>nmcli</code>
  
 +
* Per impedire a Network Manager di gestire una certa interfaccia di rete è sufficiente aggiungere il suo MAC Address al file di configurazione <code>/etc/NetworkManager/NetworkManager.conf</code>
 +
 +
[main]
 +
plugins=keyfile
 +
[keyfile]
 +
unmanaged-devices=mac:''00:25:21:73:90:72''
  
 
=== Alternative ===
 
=== Alternative ===
Riga 817: Riga 1 443:
 
  option domain-name-servers 8.8.8.8;
 
  option domain-name-servers 8.8.8.8;
 
  }
 
  }
 +
 +
 +
== VPN ==
 +
=== OpenVPN ===
 +
https://wiki.archlinux.org/title/OpenVPN
 +
 +
===L2TP/IPsec VPN===
 +
https://wiki.archlinux.org/title/Openswan_L2TP/IPsec_VPN_client_setup
  
 
= Container =
 
= Container =
Riga 823: Riga 1 457:
  
 
=== Immagini ===
 
=== Immagini ===
* [https://github.com/toolbx-images/images https://github.com/toolbx-images/images] Container contenenti le principali distribuzioni
+
* [https://github.com/toolbx-images/images https://github.com/toolbx-images/images] Immagini di container delle principali distribuzioni
  
 
=== Comandi ===
 
=== Comandi ===
Riga 887: Riga 1 521:
 
Eseguire un comando dentro il container chiamato ''debian''
 
Eseguire un comando dentro il container chiamato ''debian''
 
  lxc-attach --name debian nano
 
  lxc-attach --name debian nano
 
  
 
=== Rete Bridge ===
 
=== Rete Bridge ===
Riga 894: Riga 1 527:
 
[https://wiki.debian.org/LXC/SimpleBridge Configurazione] rete bridge.
 
[https://wiki.debian.org/LXC/SimpleBridge Configurazione] rete bridge.
  
== Alternative ==
 
  
* [https://wiki.archlinux.org/title/systemd-nspawn systemd-nspawn]
+
== Docker ==
 +
Abilitare ed avviare docker
 +
# systemctl enable --now docker
 +
 
 +
Cercare il container desiderato
 +
# docker search "xxx"
 +
 
 +
Scaricare l'immagine desiderata
 +
# docker pull xxxx:latest
 +
 
 +
Visualizzare le immagini scaricate
 +
# docker images
 +
 
 +
Visualizzare i docker creati
 +
# docker ps -a
 +
 
 +
Avviare docker
 +
# docker start nome_docker
 +
 
 +
Entrare nel docker
 +
# docker attach nome_docker
 +
 
 +
Copiare un file dal sistema host al docker
 +
# docker cp esempio.txt nome_docker: /esempio.txt
 +
 
 +
Copiare un file dal docker.
 +
# docker cp container-id:/path/filename.txt ~/Desktop/filename.txt
 +
 
 +
Rimuovere un docker
 +
# docker rm nome_docker
 +
 
 +
Rimuovere tutti i docker
 +
# docker container stop $(docker container ls -aq)
 +
# docker system prune -a --volumes
 +
 
 +
Avviare automaticamente un docker (da testare)
 +
# docker run --restart=always --name nome_docker
 +
 
 +
Creare script di avvio ''docker-webserver''.service
 +
[Unit]
 +
Description=Some service
 +
Requires=docker.service
 +
After=docker.service
 +
[Service]
 +
Restart=always
 +
ExecStart=/usr/bin/docker start -a container_name
 +
ExecStop=/usr/bin/docker stop -t 2 container_name
 +
[Install]
 +
WantedBy=multi-user.target
 +
 
 +
* [https://wiki.archlinux.org/title/docker Arch Linux Docker WIKI]
  
* [https://wiki.archlinux.org/title/docker Docker]
+
== [https://wiki.archlinux.org/title/systemd-nspawn systemd-nspawn] ==
  
 
= Fonti software alternative =
 
= Fonti software alternative =
Riga 1 026: Riga 1 708:
 
=== Installazione ===
 
=== Installazione ===
 
Installare ed abilitare Snap
 
Installare ed abilitare Snap
  $ yay -S snapd
+
  $ [https://aur.archlinux.org/packages/yay yay] -S snapd
 
  $ sudo ln -s /var/lib/snapd/snap /snap
 
  $ sudo ln -s /var/lib/snapd/snap /snap
 
  $ sudo systemctl start snapd.service
 
  $ sudo systemctl start snapd.service
Riga 1 043: Riga 1 725:
 
Vedere i programmi installati  
 
Vedere i programmi installati  
 
  $ snap list
 
  $ snap list
 +
 +
Rimuovere una determinata versione di un programma
 +
$ sudo snap remove ''nomeprogramma'' --revision
  
 
Aggiornare manualmente i pacchetti snap
 
Aggiornare manualmente i pacchetti snap
  # snap refresh
+
  $ sudo snap refresh
 +
 
 +
= GPG =
 +
[http://it.wikipedia.org/wiki/GNU_Privacy_Guard GNU Privacy Guard (GnuPG o GPG)] è un programma libero pensato per fornire un'alternativa opensource al [http://it.wikipedia.org/wiki/Pretty_Good_Privacy Pretty Good Privacy (PGP)].
 +
Nel PGP sono usate sia la crittografia asimmetrica (a chiave pubblica) che quella simmetrica.
 +
La chiave pubblica del destinatario serve al mittente unicamente per cifrare la chiave comune per un algoritmo di crittografia simmetrica che sarà usata per cifrare il testo in chiaro del messaggio.
 +
Un destinatario decifra un messaggio protetto da GPG usando la chiave di sessione con l'algoritmo simmetrico. Tale chiave di sessione è inclusa nel messaggio in maniera criptata ed è decifrata usando la chiave privata del destinatario.
 +
L'utilizzo di due cifrature oltre che a velocizzare l'esecuzione del programma (la cifratura a chiave simmetrica è molto più veloce di quella asimmetrica) permette di poter cifrare uno stesso messaggio per più destinatari.
 +
 
 +
== Generare una chiave ==
 +
$ gpg --gen-key
 +
 
 +
Controllare che la chiave sia stata correttamente creata
 +
$ gpg --list-keys
 +
 
 +
== Certificato di revoca ==
 +
Il certificato di revoca serve per invalidare la chiave nel caso in cui questa venga compromessa.
 +
Chiunque sia in possesso del certificato di revoca può revocare la chiave corrispondente, per cui è bene tenerlo in un posto sicuro.
 +
Poiché, nel momento in cui si ha bisogno del certificato di revoca, potremmo non essere più in grado di generarlo, conviene generarlo subito dopo la creazione della chiave, e prima di iniziare a utilizzarla pubblicamente.
 +
$ gpg --output certificato-di-revoca.asc --gen-revoke ''ID''
 +
dove <code>ID</code> è dato dalle ultime 8 cifre dell'impronta (fingerprint) della chiave.
 +
 
 +
== Utilizzo pratico ==
 +
=== Criptare un documento ===
 +
$ gpg -o file1.ext.gpg -e -r UserID file1.ext
 +
 
 +
Esempio:
 +
$ gpg -o tesi.odt.gpg -e -r spookyh@gmail.com tesi.odt
 +
 
 +
=== Decriptare un documento ===
 +
$ gpg -o file1.ext -d file1.gpg
 +
 
 +
=== Firmare un documento ===
 +
Il mittente può usare PGP per ''firmare'' un messaggio con l'algoritmo di firma RSA o Digital Signature Algorithm (DSA). Per fare ciò viene calcolato un hash (message digest) dal testo in chiaro e successivamente da questo hash è creata la [http://it.wikipedia.org/wiki/Firma_digitale firma digitale] usando la chiave privata del mittente.
 +
$ gpg -o file1.ext.sig -s file1.ext
 +
 
 +
=== Verificare un documento ===
 +
$ gpg --verify file1.sig
 +
 
 +
== Importare ed esportare chiavi (locali) ==
 +
Importare una chiave (pubblica)
 +
$ gpg --import chiave.asc (o .txt)
 +
 
 +
Esportare la propria chiave pubblica
 +
$ gpg -a -o chiave_pubblica.asc --export
 +
 
 +
=== Esportare la propria chiave privata ===
 +
{{Note
 +
|type=attention
 +
|text= La chiave privata può essere utilizzata per impersonare la vostra identità, '''NON''' inviarla mai a '''nessuno''', ed esportala solo per effettuarne backup, naturalmente da custodire in un luogo sicuro.}}
 +
$ gpg --armor --export-secret-keys <ID> > secret-key.gpg.asc
 +
 
 +
== Condividere le chiavi pubbliche ==
 +
Inviare la chiave ad un keyserver:
 +
$ gpg --keyserver keyserver.linux.it --send-key <ID>
 +
 
 +
Importare una chiave da un keyserver:
 +
$ gpg --keyserver keyserver.linux.it --recv-keys <ID>
 +
 
 +
Se ci fidiamo del proprietario e vogliamo mostrare pubblicamente la nostra fiducia, possiamo firmare la chiave appena importata e esportare la firma su un keyserver (vedere sezioni successive).
 +
 
 +
=== Keyserver ===
 +
Quando si carica una chiave su un keyserver, poi questo la condivide con gli altri keyserver che fanno parte dello stesso circuito.
 +
Non esiste un'entità centralizzata o un circuito di riferimento (per scelta di design), e, a volte, questo può generare confusione nell'utilizzatore.
 +
Inoltre, alcuni keyserver potrebbero non essere sempre accessibili.
 +
 
 +
Tra i keyserver più noti:
 +
* keys.openpgp.org
 +
* keyserver.ubuntu.com
 +
* keys.gnupg.net
 +
* pgp.surfnet.nl
 +
* pgp.circl.lu
 +
* pgp.mit.edu
 +
 
 +
== Editare una chiave ==
 +
Per fare operazioni e modifiche dobbiamo "editare" le chiavi, aprendo l'editor interattivo:
 +
$ gpg --edit-key <ID>
 +
'''NB: Prima di uscire dall'editor, ricordarsi di salvare, altrimenti le modifiche vanno perdute'''
 +
 
 +
* firmare
 +
> sign
 +
* cambiare i valori di fiducia
 +
> trust
 +
* vedere la fingerprint
 +
> fpr
 +
* cambiare la data di scadenza
 +
> expire
 +
* cambiare la password
 +
> passwd
 +
* firmare localmente in modo non esportabile
 +
> lsign
 +
* sempre '''ricordarsi di salvare'''
 +
> save
 +
* oppure uscire
 +
> quit
 +
 
 +
Digitare <code>help</code> per una lista esaustiva.
 +
 
 +
Tutte le modifiche da rendere pubbliche vanno inviate ad un keyserver.
 +
 
 +
== Revocare una chiave ==
 +
Avendo già il certificato di revoca:
 +
$ gpg --import certificato-di-revoca.asc
 +
$ gpg --keyserver pgp.surfnet.nl --send-key ''ID''
 +
 
 +
== Gestione delle chiavi ==
 +
Controllare il database delle chiavi: questo comando mostra tutte le chiavi che abbiamo con molte informazioni.
 +
$ gpg --list-keys --with-colons
 +
 
 +
Fornisce tutti i valori di fiducia assegnati alle varie chiavi. (Informazioni private)
 +
$ gpg --list-ownertrust
 +
 
 +
== Controllo firme ==
 +
$ gpg --check-sigs
 +
$ gpg --list-sigs
 +
 
 +
== Esportare le chiavi altrui ==
 +
Abbiamo importato e firmato la chiave di <ID>.
 +
 
 +
Rimandiamola al proprietario:
 +
$ gpg --armor -export -o firma.sig <ID>
 +
 
 +
Questo comando crea un file di nome ''firma.sig'' nella directory corrente, che contiene la chiave firmata.
 +
Spedire al proprietario ''firma.sig''.
 +
 
 +
Chi riceve la propria chiave firmata da altri può decidere inserirla nel proprio portachiavi, con
 +
$ gpg --import firma.sig
 +
 
 +
Si aggiungono al portachiavi le nuove firme ma anche i nuovi ID che il mittente ha sulla sua chiave, col rispettivo valore di fiducia. Firmare le chiavi degli altri implica dar loro fiducia, e, spesso, anche aver verificato la loro identità in maniera sicura.
 +
Se non ci fidiamo, non firmiamo. Se si firmano a caso tutte le chiavi che capitano a tiro, si perde la reputazione che si ha presso gli altri partecipanti della rete. Se vogliamo fare un uso pubblico di questa fiducia reciproca possiamo mandare la nostra  chiave, contenente la nuova firma, al keyserver:
 +
$ gpg --keyserver pgp.circl.lu --send-key <ID mia chiave>
 +
 
 +
Periodicamente occorre aggiornare il proprio portachiavi digitale, così da venire a conoscenza delle modifiche sulle chiavi degli altri.
 +
$ gpg --keyserver pgp.circl.lu --refresh-keys
 +
 
 +
== Rete di fiducia ==
 +
Una chiave importata può essere firmata con un certo grado di fiducia. Possiamo rispedirla al proprietario o caricare la firma su un keyserver, e se lui la importa nel suo portachiavi, avrà la propria chiave firmata da noi. Ognuno può quindi aggiungere le firme dei conoscenti alla propria chiave, che a loro volta hanno firme di altri.
  
 +
== GUI ==
 +
Esistono vari programmi a interfaccia grafica:
 +
* ''Seahorse'', per gestire le chiavi e i certificati, comprese quelle ssh, per un ambiente GTK
 +
* ''KGPG'', per gestire le chiavi e i certificati, comprese quelle ssh, per un ambiente QT
 +
* ''Pinentry'' (anche da riga di comando) si ricorda la password della chiave per il tempo impostato (default 5 minuti)
  
 
= Systemd =
 
= Systemd =
systemd-resolved — network name resolution;
 
 
  systemd-timesyncd — system time synchronization across the network;
 
  systemd-timesyncd — system time synchronization across the network;
 
  systemd/Journal — system logging
 
  systemd/Journal — system logging
Riga 1 055: Riga 1 880:
  
 
= Link Utili =
 
= Link Utili =
 +
 +
[https://wiki.archlinux.org/ ArchWiki]
  
 
[https://wwwcdf.pd.infn.it/AppuntiLinux/a21.htm Appunti Linux]
 
[https://wwwcdf.pd.infn.it/AppuntiLinux/a21.htm Appunti Linux]

Versione attuale delle 13:06, 20 ott 2024

Arch Linux è una distribuzione Linux leggera e veloce; ma la cui installazione, configurazione e amministrazione avviene prevalentemente da terminale attraverso la modifica manuale di file di configurazione testuali.

Fornisce, seguendo un modello di distribuzione detto "rolling-release", l'ultima versione stabile della maggior parte del software opensource disponibile per Linux. Dato che è in costante aggiornamento non richiede periodici passaggi da una versione stabile alla successiva. Il lato negativo è che aggiornamenti di componenti importanti come quelli di: kernel, boot loader, driver video, librerie... potrebbero determinare problemi tali da rendere il sistema inutilizzabile. Accorgimenti come lo snapshot periodico del filesystem riescono, per fortuna, a contrastare l'impatto di questi inconvenienti.

Installazione

Guida

Guida ufficiale

Supporti

  • ISO con installer grafico Calamares ALCI
  • ISO live CD/USB con interfaccia Xfce, utile per operazioni di ripristino o installazione SystemRescue:


ISO personalizzata

Con archiso è possibile creare un'immagine con pacchetti aggiuntivi rispetto a quelli contenuti nella versione ufficiale.

# pacman -S archiso

Copiare il contenuto del pacchetto in una directory di lavoro, es.: /root/media

# cp -r /usr/share/archiso/configs/releng /root/media

Se volessimo aggiungere il supporto ad un pacchetto non contenuto nei repository ufficiali come, per esempio, lo ZFS occorrerebbe:

  • Importare la chiave pubblica del suo repository
# pacman-key -r DDF7DB817396A49B2A2723F7403BD972F75D9D76
# pacman-key --lsign-key DDF7DB817396A49B2A2723F7403BD972F75D9D76

  • Modificare le seguenti righe al file pacman.conf di archiso per aggiungere il repository
[archzfs]
SigLevel = Never
Server = https://archzfs.com/$repo/$arch
  • Aggiungere le seguenti righe al file packages.x86_64 per aggiungere i pacchetti che ci interessa installare
zfs-utils
zfs-dkms
net-tools
  • Se volessimo creare una versione live di una macchina, comprensiva di tutti i suoi pacchetti, potremmo semplicemente aggiungerli al file packages.x86_64
# pacman -Qq >> /path/packages.x86_64
  • Lanciare lo script per creare l'ISO
# ./build.sh -v

L'immagine sarà generata nella directory /root/media/out

Preparazione del disco

Su Linux si può scegliere (salvo casi estremamente particolari) tra due tipi di tabella delle partizioni

  • msdos (Master Boot Record o più semplicemente MBR)
  • GPT (GUID Partition Table)

In linea generale è consigliabile di scegliere il GPT perché è un formato più moderno ed ha meno limitazioni rispetto all'MBR risalente ai tempi dell'MS-DOS.

I casi in cui è preferibile utilizzare la tabella msdos sono:

  • dual-boot con Windows (32-bit o 64-bit) con la scheda madre in modalità Legacy BIOS
  • in schede madri molto datate il BIOS potrebbe non supportare lo schema GPT (esiste comunque un trucco per aggirare l'ostacolo)

Vantaggi di GPT su MBR:

  • offre un sistema di denominazione delle partizioni indipendente dal filesystem (PARTLABEL, PARTUUID)
  • supera il concetto di partizione primaria ed estesa (su MBR il numero massimo di partizioni primarie, quelle su cui si può installare un sistema operativo è limitato a 4). Su GPT, nella configurazione standard, si possono definire fino a 128 partizioni.
  • la grandezza massima di un disco è di 2 ZiB, mentre su MBR 2 TiB
  • permette di fare a meno della tradizionale partizione di /boot con i filesystem BTRFS e ZFS in modo da semplificare la gestione degli snapshot.


Schede madri BIOS

Creare due partizioni.

  1. BIOS GRUB Partition: concettualmente l'equivalente dell'MBR dei sistemi GPT. A differenza di quest'ultimo, la cui dimensione è di soli 512 byte, la BIOS GRUB Partition può però essere sufficientemente grande da contenere i driver per il supporto di un filesystem come ZFS o BTRFS. Il contenuto di questa partizione cambia esclusivamente nei rari casi di upgrade del GRUB perché non vi risiedono né kernel né ramdisk.
  2. Linux filesystem: successivamente da formattare col filesystem di nostra scelta: BTRFS, ZFS, ext4, XFS, JFS.

Partizionamento

Col seguente comando verrà creata la partizione BIOS GRUB (EF02) a partire dal 1MB, della grandezza di 64MB, 8GB per la SWAP ed il resto del disco resterà disponibile per il filesystem di Linux.

Se avete più dischi da utilizzare in raid, questa operazione andrà ripetuta per ciascun disco.

# sgdisk \
--new=1:2048:133120 --typecode=1:EF02 --change-name=1:"GRUB" \
--new=2:0:+8000M ---typecode 2:8200 --change-name=2:"SWAP" \
--largest-new=3 --typecode=3:8300 --change-name=3:"ROOT" /dev/sda

La seconda partizione dovrà poi essere formattata con uno dei filesystem supportati da Linux (ext4, btrfs, xfs...)

# mkfs.btrfs /dev/sda3


Schede madri UEFI

Creare due partizioni.

  1. EFI: è una partizione in formato FAT32 necessaria per l'avvio dei sistemi operativi nei PC con schede madri UEFI.
  2. Linux filesystem: successivamente da formattare col filesystem di nostra scelta: BTRFS, ZFS, ext4, XFS, JFS.

Partizionamento

Col seguente comando verrà creata la partizione EFI (EF00) a partire dal 1MB, della grandezza di 512MB, 8Gb per la SWAP ed il resto del disco per il filesystem di Linux.

# sgdisk \
--new=1:2048:1064960 --typecode=1:EF00 --change-name=1:"efi" \
--new=2:0:+8000M ---typecode 2:8200 --change-name=2:"SWAP" \
--largest-new=3 --typecode=3:8300 --change-name=3:"ROOT" /dev/sda

La partizione EFI dovrà poi essere formattata in FAT32

# mkfs.vfat -F 32 /dev/sda1

La seconda partizione dovrà poi essere formattata con uno dei filesystem supportati da Linux (ext4, btrfs, xfs...)

# mkfs.btrfs /dev/sda3

Montaggio del filesystem

Formattazione ed attivazione della SWAP

# mkswap /dev/sda2
# swapon /dev/sda2

Montaggio del filesystem di ROOT nei sistemi BIOS

# mount /dev/sda3 /mnt

Montaggio del filesystem di ROOT nei sistemi UEFI

# mount /dev/sda3 /mnt
# mount --mkdir /dev/sda1 /mnt/boot

Pacchetti base

Per l'installazione di base si consigliano i seguenti meta-pacchetti

# pacstrap -K /mnt base base-devel linux linux-headers linux-firmware

Configurazione

Creazione del file fstab

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

Chroot nel nuovo sistema

# arch-chroot /mnt

Timezone

# ln -sf /usr/share/zoneinfo/Europe/Rome /etc/localtime

Editare il file /etc/systemd/timesyncd.conf ed abilitare il servizio per la sincronizzazione automatica dell'orario

# systemctl enable systemd-timesyncd.service

Editare il file /etc/locale.gen e togliere il commento agli argomenti che interessano, es.: en_US.UTF-8, it_IT.UTF-8. E successivamente generare la localizzazione eseguendo

# locale-gen

Configurare la lingua che vogliamo usare per il nostro sistema editando il file /etc/locale.conf oppure lanciando il comando

# localectl set-locale LANG=en_US.UTF-8

Selezioniamo il layout della tastiera editando il file /etc/vconsole.conf

# echo "KEYMAP=it" >> /etc/vconsole.conf

Scegliere un home host (es.: archstar)

# echo archstar >> /etc/hostname

Impostare una password per l'utente root

# passwd

Installare e configurare il bootloader

Filesystem

Su Linux, a seconda di ciò di cui abbiamo bisogno, è possibile scegliere tra numerosi filesystem. Le principali opzioni sono le seguenti:

- BTRFS: supporta nativamente sottovolumi, snapshot ed il raid 0, 1 e 5; ma non la crittografia.

- EXT4: il FS storico di Linux, evoluzione di ext3. Supporta nativamente la crittografia dei dati, ma non gestisce autonomamente né RAID, né snapshots.

- ZFS: non è supportato direttamente da Linux, ha bisogno di un driver esterno per funzionare e ciò, per gli utenti meno smaliziati, potrebbe complicare le operazioni di ripristino di sistema in caso di problemi. Supporta il raid 0, 1 e z (una variante del raid5 che permette, grazie ad un meccanismo di scrittura dei dati detta "write-atomicity" di evitare la perdita di dati anche in caso di improvviso spegnimento improvviso del computer), gli snapshot, i sottovolumi e la cifratura dei dati. Non è però possibile modificare la composizione di un raid una volta creato.

- XFS + LVM: accoppiare il filesystem xfs al gestore di volumi di LVM è il modo con cui RedHat (IBM) ha scelto di implementare le funzionalità di raid e snapshots nella propria distribuzione.

IMG

Per fare esperimenti con i filesystem può essere utile creare dei file immagine

Creare un file immagine di una specifica grandezza (es.: 10G)

$ truncate -s 10g disk.img

Formattarlo con un filesystem (es.: btrfs)

$ mkfs.btrfs disk.img

Montarlo in loop

$ sudo mount -o loop disk.img /mnt


BTRFS

Creazione del filesystem

# mkfs.btrfs /dev/partizione

Montaggio del filesystem

# mount -o compress=lzo /dev/partizione /mnt/punto_mount

(Si consiglia di usare l'opzione di compressione del filesystem per migliorare le performance ed ottimizzare l'utilizzo dello spazio)

Subvolumi

  • Creare un subvolume
# btrfs subvolume create subvolume
  • Controllare i subvolumi presenti sul sistema
# btrfs subvolume list /

In una tipica installazione Ubuntu avremo un output di questo tipo

ID 257 gen 9755 top level 5 path @
ID 292 gen 7624 top level 5 path @home

@ è il nome del subvolume contenente la root / del filesystem @home è il nome del subvolume della /home

Montaggio di un subvolume

# mount -o subvol=subvolume /dev/partizione /mnt/punto_mount

fstab

Normalmente la root di sistema viene collocata in un subvolume (es.: @), per poter effettuare opzioni di snapshot etc e consigliabile montare il filesystem con l'opzione subvolid=0. Nella directory di mount saranno visibili tutti i subvolumi e le snapshot della partizione e sarà quindi possibile effettuare tutte le operazioni indicate nei passaggi successivi.

Ecco un /etc/fstab di esempio

LABEL=ROOT       /             btrfs     defaults,compress=lzo,subvol=@            0 0
LABEL=ROOT       /home         btrfs     defaults,compress=lzo,subvol=@home        0 0
LABEL=ROOT       /mnt/btrfs    btrfs     defaults,noauto,subvolid=0,compress=lzo   0 0

Montando la partizione con label ROOT su /mnt/btrfs saranno visibili tutti i subvolumi.

Conversione da Ext3/4 a Btrfs

# btrfs-convert /dev/partizione

Automaticamente è creata una snapshot contenente il vecchio filesystem (/ext2_saved)

In caso di problemi può essere montata col comando

# mount -t btrfs -o subvol=ext2_saved /dev/xxx /ext2_saved
# mount -t ext3 -o loop,ro /ext2_saved/image /ext3

Se tutto è andato a buon fine può invece essere eliminata

# btrfs subvolume delete /ext2_saved

Riparazione di un filesystem danneggiato

  • Direttamente sul filesystem montato
# btrfs scrub start -B /dev/partizione

o anche direttamente sulla root

# btrfs scrub start -B /
  • Sul disco smontato
# btrfs check --repair /dev/partizione

Per non dover ricorrere ad un dispositivo di avvio alternativo, dato che btrfs-check non può essere utilizzato su un filesystem montato, si consiglia di aggiungerlo al ramdisk modificando in questo mmodo il file /etc/mkinitcpio.conf

BINARIES=(btrfs)

Quote

Per limitare le dimensioni di un subvolume è possibile abilitare la gestione delle quote.

Utilizzare il seguente comando su un filesystem btrfs appena creato e privo di subvolumi

# btrfs quota enable volume

Se invece le quote non sono state abilitate subito su tutto il filesystem è necessario creare un qgroup (quota group) per ogni subvolume utilizzando il rispettivo ID e successivamente fare una scansione delle quote.

# btrfs subvolume list <path> | cut -d' ' -f2 | xargs -I{} -n1 btrfs qgroup create 0/{} <path>
# btrfs quota rescan <path>

Assegnare una quota limite ad un subvolume

# btrfs qgroup limit size /volume/subvolume

Es.:

# btrfs qgroup limit 20g /mnt/@
# btrfs qgroup limit 100g /mnt/@home

Scoprire la quantità di spazio utilizzata da un subvolume

# btrfs qgroup show <path>

Snapshots

Data la natura instabile delle distribuzioni rolling-release come Arch Linux ritengo praticamente obbligatorio per la partizione di / l'utilizzo di un filesystem che supporti gli snapshot.

  • Effettuare uno snapshot
# btrfs subvolume snapshot @ rootsnap

Nell'esempio abbiamo effettuato il backup del filesystem di root e l'abbiamo chiamato rootsnap

  • Montare un subvolume/snapshot
# mount -t btrfs -o subvol=rootsnap /dev/partizione /mnt/snapshot
  • Cancellare un subvolume/snapshot
# btrfs subvolume delete rootsnap

Integrazione con GRUB

È possibile caricare automaticamente all'avvio gli snapshot dei filesystem di root attraverso il programma grub-btrfs

# pacman -S grub-btrfs

Con questo tool ogni volta che rigeneriamo il file di configurazione di GRUB il sistema rileva eventuali sottovolumi avviabili (snapshot comprese) aggiungendoli al menu di avvio del GRUB

# grub-mkconfig -o /boot/grub/grub.cfg

Backup

Le snapshot possono essere salvate su un disco esterno, a patto che questo abbia un file system btrfs. L'operazione di trasferimento può essere effettuata soltanto su snapshot in sola lettura. Si ipotizza che il proprio disco di sistema sia montato in /mnt/btrfs ed il disco esterno in /mnt/ext

  • Creare la snapshot in sola lettura (opzione -r) oppure impostare il flag di sola lettura ad una snapshot già fatta
btrfs subvolume snapshot -r @root @root-yymmdd-ro
btrfs property set /mnt/btrfs/@root-yymmdd-ro ro true
  • Trasferire la snapshot sul disco esterno.
btrfs send /mnt/btrfs/@root-yymmdd-ro | btrfs receive /mnt/ext
  • Quando necessario, ripristinare la snapshot
btrfs send /mnt/ext/@root-yymmdd-ro | btrfs receive /mnt/btrfs/
  • Eventualmente, rinominare la snapshot e reimpostare i privilegi di scrittura
mv /mnt/ext/{@root-yymmdd-ro,@root}
btrfs property set /mnt/btrfs/@root ro false


RAID

Tipologie e caratteristiche dei raid supportati

Confronto tra varie tecnologie di raid

RAID Redundancy Copies Redundancy Parity Redundancy Striping Spazio utilizzato Min/max n. dischi
disco singolo 1 100% 1/N
RAID0 1 1 to N 100% 1/N
RAID1 2 50% 2/N
RAID1C3 3 33% 3/N
RAID1C4 4 25% 4/N
RAID10 2 1 to N 50% 2/N
RAID5 1 1 2 to N-1 (N-1)/N 2/N
RAID6 1 2 3 to N-2 (N-2)/N 3/N


RAID 0

# mkfs.btrfs -d raid0 /dev/sda1 /dev/sdb1
Montare il raid
# mount /dev/sda1 /mnt

(È equivalente a mount /dev/sdb1 /mnt, il sistema riconosce che è presente un raid 0 e provvede al montaggio corretto dei dischi)

Verifica del montaggio

# btrfs filesystem show /mnt
Label: none  uuid: 4714fca3-bfcb-4130-ad2f-f560f2e12f8e
Total devices 2 FS bytes used 27.75GiB
devid    1 size 136.72GiB used 17.03GiB path /dev/sda1
devid    2 size 136.72GiB used 17.01GiB path /dev/sdb1
Aggiungere una partizione
# btrfs device add /dev/sdc1 /mnt
# btrfs filesystem show /mnt
Label: none  uuid: 4714fca3-bfcb-4130-ad2f-f560f2e12f8e
Total devices 3 FS bytes used 27.75GiB
devid    1 size 136.72GiB used 17.03GiB path /dev/sda1
devid    2 size 136.72GiB used 17.01GiB path /dev/sdb1
devid    3 size 136.72GiB used 0.00 path /dev/sdc1

Adesso è necessario effettuare una redistribuzione dei dati sui tre dischi

# btrfs balance start -d -m /mnt

Per vedere a che punto del bilanciamento è arrivato il sistema

# btrfs fi balance status /
# btrfs filesystem show /mnt
Label: none  uuid: 4714fca3-bfcb-4130-ad2f-f560f2e12f8e
Total devices 3 FS bytes used 27.78GiB
devid    1 size 136.72GiB used 10.03GiB path /dev/sda1
devid    2 size 136.72GiB used 10.03GiB path /dev/sdb1
devid    3 size 136.72GiB used 11.00GiB path /dev/sdc1
Rimuovere un device
# btrfs device delete /dev/sdb1 /mnt

L'operazione può impiegare parecchio tempo e per andare a buon fine sui dischi rimanenti deve essere rimasto sufficiente spazio libero da ospitare i dati contenuti nel device che vogliamo togliere dal raid.

RAID 1

Creazione di un raid1 ex novo

Copiare la tabella delle partizioni da sda a sdb

# sfdisk -d /dev/sda | sfdisk /dev/sdb

Creare il raid

# mkfs.btrfs -d raid1 -m raid1 /dev/sda1 /dev/sdb1
Aggiungere un mirror ad un disco esistente
# btrfs device add /dev/sdb1 /punto_di_mount
# btrfs balance start -dconvert=raid1 -mconvert=raid1 /punto_di_mount
GRUB

Se si utilizza un raid1 per la partizione di sistema / e si vuole rendere Linux avviabile automaticamente anche in caso di danneggiamento o mancanza di uno dei due dischi del raid occorrerà che sul secondo disco sia clonata la partizione EFI o BIOS GRUB (es.: /dev/sda1) e che vi sia installato il bootloader.

# dd if=/dev/sda1 of=/dev/sdb1
# grub-install /dev/sdb
Sostituzione device danneggiato

Verificare qual è il disco che dà dei problemi

# mount /dev/sda1 /punto_di_mount -o degraded
# btrfs device stats /punto_di_mount
# btrfs filesystem show /punto_di_mount
# btrfs device usage /punto_di_mount

Ipotizzando che 1 sia l'ID del disco danneggiato secondo i comandi dati in precedenza

# btrfs replace start 1 /dev/sdc1 /punto_di_mount

Per monitorare lo stato di ripristino del raid

# btrfs replace status /punto_di_mount

In alcuni casi potrebbe essere necessario montare il filesystem in modalità degraded (con l'opzione -o degraded) e lanciare il successivo comando per eliminare definitivamente il device dal raid.

# btrfs device delete missing /mnt

RAID 5

Golem-template-note-warning.png ATTENZIONE il raid5 su BTRFS è considerato non sicuro e se ne sconsiglia il suo utilizzo


RAID 1C

RAID 1C3

Se si desidera duplicare i dati rispettivamente 2 volte in modo da poter perdere fino a due dischi su 3 senza perdere dati è possibile utilizzare una modalità chiamata raid1c3

Per creare ex novo il raid1c3

# mkfs.btrfs -d raid1c3 -m raid1c3 /dev/sda1 /dev/sdb1 /dev/sdc1

Per convertire a raid1c3

# btrfs balance start -dconvert=raid1c3 -mconvert=raid1c3 /storage-btrfs/
RAID 1C4

Se si desidera duplicare i dati rispettivamente 3 volte in modo da poter perdere fino a 3 dischi su 4 senza perdere dati è possibile utilizzare una modalità chiamata raid1c4

Per creare ex novo il raid1c3

# mkfs.btrfs -d raid1c4 -m raid1c4 /dev/sda1 /dev/sdb1 /dev/sdc1

Per convertire a raid1c4

# btrfs balance start -dconvert=raid1c4 -mconvert=raid1c4 /storage-btrfs/

ZFS

Installazione di modulo e le utility da AUR

# pacman-key -r F75D9D76
# pacman-key --lsign-key F75D9D76
$ pikaur -S zfs-utils zfs-dkms

Installazione di modulo e utility da archzfs

Modificare le seguenti righe al file pacman.conf di archiso

[archzfs-testing]
Server = https://archzfs.com/$repo/$arch
# pacman-key -r DDF7DB817396A49B2A2723F7403BD972F75D9D76
# pacman-key --lsign-key DDF7DB817396A49B2A2723F7403BD972F75D9D76
# pacman -S zfs-utils zfs-linux

Configurare il FS

Comandi per ottenere informazioni utili sul filesystem e sui pool

# zfs list -t  all
# zpool status
# zpool list

Abilitare i vari servizi sul filesystem

# systemctl enable zfs-zed.service
# systemctl enable zfs-mount.service
# systemctl enable zfs-share.service
# systemctl enable zfs-import.target
# systemctl enable zfs.target

Creare un pool su un disco

# zpool create "pool" sda

Creare un pool su una partizione

# zpool create "pool" sda2

Importare un pool

# zpool import "pool"

Aggiungere pool alla cache per auto-import e mount (abilitare i vari demoni zfs)

# zpool set cachefile=/etc/zfs/zpool.cache "pool"

oppure si possono caricare i mountpoint in modalità legacy dall'fstab

# zfs create -o mountpoint=legacy pool/directory

Aggiungere la compressione

# zfs get compression pool
# zfs set compression=lz4 pool

Vedere le proprietà di un pool

# zfs get all zpool

RAID

Creare un pool in raid0

# zpool create "pool" /dev/sdb /dev/sdc

Creare un pool in raid1

# zpool create "pool" mirror /dev/sdb /dev/sc

Creare un pool raid5 su più dischi

# zpool create "pool" raidz /dev/sdb /dev/sdc /dev/sdd

Creare un pool raid5 su immagini

# zpool create "pool" raidz /path/1.img /path/2.img /path/3.img

Rimuovere il disco da sostituire

# zpool offline disco1

Inserire il nuovo disco

# zpool replace "pool" disco1
# zpool online disco1
  • Utilizza un altro disco montato al posto di quello danneggiato
# zpool replace "pool" disco1 disco2

Aggiungere uno o più dischi ad un pool

# zpool add "pool" mirror disco3 disco4
# zpool add "pool" raidz disco3 disco4 disco5

Rimuovere disco1 da pool se aggiunto erroneamente

# zpool remove "pool" disco1

Controllare lo stato di un pool

# zpool status

Correggere eventuali errori

# zpool clear pool disco
# zpool scrub  pool

Root filesystem

Per prima cosa organizzare la tabella delle partizioni del disco

Formattare la partizione e creare il dataset (senza mountpoint)

# zpool create -m none rpool sda2

Smontare il pool e rimontarlo in modalità legacy

# zfs create -o mountpoint=none rpool/ROOT
# zfs create -o mountpoint=legacy rpool/ROOT/arch
# zpool set bootfs=rpool/ROOT/arch rpool
# mount -t zfs rpool/ROOT /mnt

rpool è il nome che abbiamo voluto dare al volume contenente il filesystem di sistema

NB: se NON si usa il mountpoint in modalità legacy occorrerà impostare canmount=noauto su tutti i dataset con mountpoint=/ (es.: zfs create -o mountpoint=/ -o canmount=noauto rpool/ROOT/arch) altrimenti il sistema cercherà di eseguirne automaticamente l'automount e fallirà se esistono più filesystem da montare su /

Se volessimo aggiungere altri pool es.:

# zfs create rpool/home
# zfs create rpool/arch/pkg
# zfs create rpool/var
# zfs create rpool/srv

Configurare la cache degli zpool

# zpool set cachefile=/etc/zfs/rpool.cache rpool 

Copiare il file di cache nel sistema dove dovremo eseguire il chroot per l'installazione.

# mkdir -p /mnt/etc/zfs
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache

Installare il sistema di base

# pacstrap -K /mnt base linux linux-firmware zfs-utils zfs-linux

Altri pacchetti consigliati

# pacstrap -K /mnt base-devel net-tools networkmanager nano zsh grml-zsh-config busybox

Eseguire il chroot per procedere con l'installazione

# arch-chroot /mnt

Configurare il mountpoint su fstab /etc/fstab

rpool/ROOT/arch      /       zfs         noatime     0 0

Editare il file /etc/mkinitcpio.conf aggiungendo zfs prima del filesystem

HOOKS="base udev autodetect modconf block keyboard zfs filesystems"

Abilitare i servizi per ZFS all'avvio

# systemctl enable zfs-zed.service
# systemctl enable zfs-mount.service
# systemctl enable zfs-share.service
# systemctl enable zfs-import.target
# systemctl enable zfs.target

Impostare una password di root

# passwd

Ricreare il ramdisk col supporto per ZFS

# mkinitcpio -p linux

Installare il Boot Loader

Uscire dal chroot e terminazione dell'installazione

# exit
# zfs unmount -a
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
# zpool export rpool
# reboot

BOOT LOADER

ZFSBootMenu

Per gestire a meglio gli snapshot e la clonazione dei pool è consigliabile, su PC che supportano UEFI, utilizzare il boot loader ZFSBootMenu.

Esportiamo le variabile per configurare il primo disco /dev/sda come disco di avvio

# export BOOT_DISK="/dev/sda"
# export BOOT_PART="1"
# export BOOT_DEVICE="${BOOT_DISK}${BOOT_PART}"

Assicuriamoci che il nostro pool di root sia configurato come avviabile

# zpool set bootfs=rpool/ROOT/ rpool

Formattiamo sda1 per creare la partizione EFI di boot

# mkfs.vfat -F32 "$BOOT_DEVICE"

Aggiungiamola all'fstab e montiamola

# cat << EOF >> /etc/fstab
$BOOT_DEVICE /boot/efi vfat defaults 0 0
EOF
# mkdir -p /boot/efi
# mount /boot/efi

Scarichiamo ed installiamo il boot loader

# mkdir -p /boot/efi/EFI/ZBM
# curl -o /boot/efi/EFI/ZBM/VMLINUZ.EFI -L https://get.zfsbootmenu.org/efi
# cp /boot/efi/EFI/ZBM/VMLINUZ.EFI /boot/efi/EFI/ZBM/VMLINUZ-BACKUP.EFI

Forziamo zfsbootmenu a montare il nostro dataset con i permessi di scrittura

# zfs set org.zfsbootmenu:commandline="quiet loglevel=4 rw" rpool/ROOT

Installiamo e configuriamo efibootmgr

# pacman -S efibootmgr
# efibootmgr -c -d "$BOOT_DISK" -p "$BOOT_PART" \
 -L "ZFSBootMenu (Backup)" \
 -l \\EFI\\ZBM\\VMLINUZ-BACKUP.EFI
# efibootmgr -c -d "$BOOT_DISK" -p "$BOOT_PART" \
 -L "ZFSBootMenu" \
 -l \\EFI\\ZBM\\VMLINUZ.EFI


  • Se si utilizza un pool distribuito su più dischi (RAID1 o RAIDZ) occorrerà installare il bootloader anche sugli altri dispositivi (nel caso del disco /dev/sdb).
# mount /dev/sdb1 /boot/efi
# curl -o /boot/efi/EFI/ZBM/VMLINUZ.EFI -L https://get.zfsbootmenu.org/efi
# efibootmgr -c -d "$BOOT_DISK" -p "$BOOT_PART" \
 -L "ZFSBootMenu sdb" \
 -l \\EFI\\ZBM\\VMLINUZ.EFI
GRUB

Se non ci interessa gestire snapshot o utilizziamo un PC con BIOS è possibile optare per GRUB

# pacman -S grub
# grub-install /dev/sda
(se si usa un pool composto da più dischi es. raidz per il filesystem di root è consigliabile installare grub su tutti i dischi: sda, sdb, sdc, sdd...)
# grub-mkconfig -o /boot/grub/grub.cfg

Esempio

#Grub entry
menuentry 'Arch Linux'{
      insmod gzio
      insmod part_gpt
      insmod zfs
      set root='hd0,gpt3'
       echo    'Loading Linux linux ...'
       linux   /ROOT@/boot/vmlinuz-linux root=ZFS=rpool/ROOT rw  loglevel=3 quiet
       echo    'Loading initial ramdisk ...'
       initrd  /ROOT@/boot/initramfs-linux.img

}

Snapshot

Snapshot del dataset ROOT

# zfs snapshot -r rpool/ROOT@snapshot-2023-03-07

Lista degli snapshot presenti

# zfs list -t snapshot

Ripristino dello snapshot

# zfs rollback rpool@snapshot-2023-03-07

Oltre che servire per il ripristino, possono essere montati per esplorarne il contenuto, ma non è possibile modificarlo.

# mount -t zfs rpool@2023-04-11 /mnt/snapshot

Copia locale di un dataset

# zfs send -R rpool/ROOT@snapshot-2023-03-07 | zfs recv -F rpool/ROOT/backup

Invio via SSH di una snapshot

# zfs send -R rpool/ROOT@snapshot-2023-03-07| ssh user@ip_address zfs recv tank/backups/rootzfs

Backup locale di una snapshot

# zfs send -R rpool/ROOT@snapshot | gzip > /tmp/zfs_backup.gz

Restore del backup

# gzcat /tmp/zfs_backup.gz | zfs recv -F rpool/ROOT

Clone

Se vogliamo eseguire operazioni di scrittura su una snapshot occorre effettuare un clone del dataset

# zfs snapshot rpool/home@yesterday
# zfs clone rpool/home@yesterday rpool/new_home

Per sostituire il filesystem principale col clone

# zfs promote rpool/new_home

ZFS Cifrato

Creare un dataset cifrato con password

# zfs create -o encryption=on -o keyformat=password nomepool/nomedataset

Generazione di una chiave di cifratura

# dd if=/dev/random of=/path/to/key bs=1 count=32

Creare un dataset cifrato con una chiave di cifratura

# zfs create -o encryption=on -o keyformat=raw -o keylocation=file:///directory/della/chiave nomepool/nomedataset

Controllare il percorso della chiave per nomepool/nomedataset

# zfs get keylocation nomepool/nomedataset

Cambiare il percorso della chiave

# zfs set keylocation=file:///nuova/directory/della/chiave nomepool/nomedataset

Caricare manualmente le chiavi di cifratura prima del montaggio

# zfs load-key nomepool/nomedataset # carica la chiave del determinato dataset
# zfs load-key -a # carica tutte le chiavi del filesystem

Unlock con systemd

Creare script per il caricamento delle chiavi all'avvio

  • Caricando la password dal keyfile

/etc/systemd/system/zfs-loadkey-file.service

[Unit]
Description=Load ZFS encryption keys
DefaultDependencies=no
After=zfs-import.target
Before=zfs-mount.service
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/sbin/zfs load-key -a
StandardInput=tty-force
[Install]
WantedBy=zfs-mount.service
  • Digitando la password

/etc/systemd/system/zfs-load-key@.service

[Unit]
Description=Load %I encryption keys
Before=systemd-user-sessions.service zfs-mount.service
After=zfs-import.target
Requires=zfs-import.target
DefaultDependencies=no
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/sh -c 'until (systemd-ask-password "Encrypted ZFS password for %I" --no-tty | zfs load-key %I); do echo "Try again!"; done'
[Install]
WantedBy=zfs-mount.service

Unlock al login

Impostare il filesystem in modalità legacy così che non sia montato automaticamente all'avvio

# zfs set mountpoint=legacy zroot/data/

Modificare il file /etc/fstab

zroot/data/         /home           zfs             rw,xattr,posixacl,noauto        0 0

Creare il seguente script: /sbin/mount-zfs-homedir

#!/bin/bash
#
set -eu
# Password is given to us via stdin, save it in a variable for later
PASS=$(cat -)
#
VOLNAME="zroot/data/home"
#
# Unlock and mount the volume
zfs load-key "$VOLNAME" <<< "$PASS" || continue
zfs mount "$VOLNAME" || true # ignore errors

Aggiungere lo script a PAM: /etc/pam.d/system-auth

auth       optional                    pam_exec.so          expose_authtok /sbin/mount-zfs-homedir

Cache

Utilizzare un moderno disco a stato solido può essere una soluzione economica per velocizzare un pool, eventualmente anche raid

# zpool add -f rpool cache /dev/sdd1
# zpool add -f rpool log /dev/sdd2

Sharing

Non è molto noto, ma ZFS ha integrati dei comandi per permettere la condivisione del filesystem con altre macchine tramite i protocolli NFS o SMB.

Premessa: occorrerà attivare il server NFS

# systemctl start nfs-server.service
# systemctl enable nfs-server.service

Condividere tramite NFS l'intero pool home

# zfs set share.nfs=on pool/home

Verificare la condivisione

# zfs get -r share.nfs pool/home
NAME             PROPERTY   VALUE  SOURCE
pool/home        share.nfs  on     local

Condividere tramite NFS la directory home dell'utente 1, 2...

# zfs create pool/home/utente1
# zfs create pool/home/utente2

Si possono specificare opzioni di montaggio per i permessi sul mount

# zfs set share.nfs.nosuid=on pool/home/utente1
# zfs set share.nfs=on pool/home/utente1

Condividere una directory con tutta la rete

# zfs share -o share.nfs=on -o share.nfs.public=on pool/public%pubshare

Condividere una directory con una parte della rete

# zfs set share.nfs='rw=@192.0.10.0/16,rw=@192.0.11.0/24' pool/public%pubshare

Disabilitare temporaneamente una condivisione

# zfs unshare pool/home/nomeshare

Rimuovere una condivisione

# zfs set share.nfs=off pool/share


Montare share

Montare il volume pool1 della macchina con IP 192.168.0.2 su /mnt/pool1

# mount -t nfs 192.168.0.2:/pool1 /mnt/pool1

Aggiungere la seguente riga al file /etc/fstab per automatizzare il montaggio

192.168.0.2:/pool1      /mnt/pool1      nfs       defaults          0          0


SWAP

Creare una partizione swap da 8 GiB

# zfs create -V 8G <pool>/swap

Formattazione della partizione

# mkswap -f /dev/zvol/<pool>/swap

Attivazione della swap

# swapon /dev/zvol/<pool>/swap

Aggiungere la swap al /etc/fstab

/dev/zvol/<pool>/swap none swap discard 0 0

Filesystem Cifrato

Esistono molti modi per cifrare volumi e file su Linux, come si può vedere da questa tabella

  • Generare una password di 32 caratteri alfanumerici con /dev/random.
cat /dev/random | tr -dc '[:alnum:]' | fold -w 32 | head -n 1

EncFS

Cifrare una directory può essere un'alternativa alla cifratura di un intera partizione come avviene invece con Cryptsetup. EncFS è un filesystem user-space montabile tramite FUSE che permette di effettuare questa operazione. Rispetto ad un filesystem loopback criptato ci sono però diversi pregi e difetti.

  • Pro
  1. Selezionare selettivamente i contenuti da cifrare, rispetto ad avere un device completamente cifrato, appesantisce meno il lavoro della CPU specialmente quando si utilizzano processori datati privi del set di istruzioni AES.
  2. Dimensioni modificabili: un file system vuoto EncFS è composto da qualche dozzina di byte e può crescere a qualsiasi dimensione senza bisogno di essere riformattato. Con un dispositivi di cifratura a blocchi, si alloca un filesystem in anticipo con le dimensioni desiderate.
  3. Possibilità di backup incrementali: Un filesystem EncFS può essere salvato con una politica per file. Un programma di backup è in grado di rilevare quali file sono cambiati, anche se non sarà in grado di decifrarli.
  4. Permette di aggiungere la crittografia a qualsiasi filesystem
  5. Lavora a livello utente, non richiede permessi di amministratore
  • Contro
  1. Non permette di cifrare l'intera installazione, ma solo i file selezionati
  2. Chi ha accesso ai file crittografati può conoscerne i meta-dati (numero di file, permessi, dimensione)
  3. EncFS sembra non sia più attivamente mantenuto. Un'alternativa molto simile potrebbe essere gocryptfs.

Montaggio automatico

Dato che non è possibile passare opzioni all'eseguibile encfs su fstab è necessario creare un wrapper, cioè uno script da rendere eseguibile (es. /home/user/encfs.sh) che vada a recuperare la password da un file (es. encfs_password), magari contenuto in una chiavetta USB anch'essa montata automaticamente all'avvio.

Wrapper

#!/bin/sh
encfs --public --extpass="cat /mnt/USB/encfs_password" $*


A questo punto è possibile aggiungere all'/etc/fstab le seguenti righe.

# Montaggio automatico della penna USB cafebabe-b00b5-deadbee all'avvio
UUID=cafebabe-b00b5-deadbeef /mnt/USB auto defaults,auto 0 0
# Richiamo del wrapper 
/home/user/encfs.sh#/home/user/.encrypted /home/user/decrypted fuse rw,user,auto 0 0


gocryptfs

Creare una directory cifrata crypt e montarla su dati

$ mkdir crypt dati
$ gocryptfs -init crypt
$ gocryptfs crypt dati

Creare una versione cifrata di una preesistente home

$ mkdir /home/user.crypt
$ gocryptfs -init -reverse /home/user
$ gocryptfs -reverse /home/user /home/user.crypt

È possibile aggiungere una linea simile alle seguente al file /etc/fstab per automatizzare il sistema di montaggio di una cartella cifrata durante il boot utilizzando un keyfile.

/home/user/cipher /home/user/plain fuse./usr/bin/gocryptfs nofail,allow_other,passfile=/tmp/password 0 0

ECryptfs

VeraCrypt

VeraCrypt (fork di TrueCrypt) è un tool opensource dotato di interfaccia grafica che permette di configurare la cifratura di volumi reali o file immagini montate in loop. Ha una funzione particolare, chiamata Hidden Volume che permette di creare un volume nascosto all'interno di un normale volume VeraCrypt al quale si può accedere con una diversa password così da evitare in caso di necessità (ricatto, fidanzata/moglie gelosa, imposizione da parte delle forze dell'ordine) di mostrare il contenuto del reale archivio cifrato.

Cryptsetup

Partizione cifrata

Volumi_criptati_LUKS

FScrypt

ZFS

RAID mdadm

Su Linux era possibile effettuare RAID via software anche prima dell'avvento di filesystem di nuova generazione come btrfs o zfs. Per fare ciò è possibile utilizzare il comando mdadm.

Vedere l'organizzazione della tabella delle partizioni dei dischi

$ lsblk
sda      8:16   0 447.1G  0 disk 
├─sda1   8:17   0   500M  0 part 
├─sda2   8:18   0    16G  0 part [SWAP]
└─sda3   8:19   0 430.6G  0 part /
                                
sdb      8:32   1   3.7G  0 disk 
├─sdb1   8:33   1   3.5G  0 part 
├─sdb2   8:34   1   239M  0 part [SWAP]
└─sdb3   8:19   0 430.6G  0 part /

Nell'esempio ci sono due dischi (sda, sdb) contenenti 3 partizioni: EFI, SWAP e Linux.

RAID 0

Creare un volume md3 che costituito dalla somma delle due partizioni sda3 e sdb3

# mdadm --create --verbose /dev/md3 --level=0 --raid-devices=2 /dev/sda3 /dev/sdb3

Verificare che il raid funzioni correttamente

# mdadm --detail /dev/md0

Utilizzare il nuovo volume md3, formattato col filesystem XFS, per una nuova installazione di Arch Linux (montandolo in /mnt)

# mkfs.xfs /dev/md3
# mount /dev/md3 /mnt/

Per memorizzare l'array nel file di configurazione

# mdadm –Es > /etc/mdadm.conf

RAID 1

Creare un volume md3 mirror delle due partizioni sda3 e sdb3

# mdadm --create /dev/md3 /dev/sda3 /dev/sdb3 --level=1 --raid-devices=2

RAID 5

Creare un volume md3 con un raid5, ovviamente stavolta occorreranno almeno 3 dischi es.: sda3, sdb3, sdc3.

Per creare tre partizioni tutte della stessa dimensione è possibile copiare su sdb e sdc la tabella delle partizioni di sda

#  sfdisk -d /dev/sda | sfdisk /dev/sdb
#  sfdisk -d /dev/sda | sfdisk /dev/sdc

Creare l'array in raid5

# mdadm --create /dev/md/md3 /dev/sda1 /dev/sdb1 /dev/sdc1 --level=5 --raid-devices=3 --bitmap=internal

Modificare l'array

È possibile passare da raid1 a raid5

# mdadm --grow /dev/md3 --level=5
# mdadm --grow /dev/md3 --add /dev/sdc3 --raid-devices=3

Accorgersi di un guasto

Nei raid 1 e 5 in caso di danneggiamento di un disco sarà possibile sostituirlo e ricostruire l'array senza perdere dati. Nell'ipotesi di avere un guasto su sdb in un raid1 comparirà qualcosa di simile a questo eseguendo cat /proc/mdstat

md3 : active raid1 sda3[1]
blocks [2/2] [U_] 

invece che

md3 : active raid1 sda3[1] sdb3[0]
     262016 blocks [2/2] [UU]

Rimuovere il disco danneggiato dal RAID

Si dovrà marcare sdb3 come danneggiata e andrà rimossa dall'array.

# mdadm --manage /dev/md3 --fail /dev/sdb3
# mdadm --manage /dev/md3 --remove /dev/sdb3

Se avessimo più array (es. md1, md2...) contenenti partizioni del disco sdb (sdb1, sdb2...), l'operazione andrebbe ripetuta per ciascuno di essi es.:

# mdadm --manage /dev/md1 --fail /dev/sdb1
# mdadm --manage /dev/md1 --remove /dev/sdb1
#  cat /proc/mdstat
Personalities : [linear] [multipath] [raid0] [raid1] [raid5] [raid4] [raid6] [raid10]
md0 : active raid1 sda3[0]
24418688 blocks [2/1] [U_]
unused devices: <none>

Sostituzione del disco danneggiato

Spegnere il computer, rimuovere il disco guasto e collegarne al suo posto uno funzionante.

NB: il nuovo disco dovrà essere di dimensioni uguali o maggiori del disco sostituito

Installato il nuovo disco, riaccendere il PC, loggarsi come root e ricreare sul nuovo sdb le stesse partizioni presenti su sda:

# sfdisk -d /dev/sda | sfdisk /dev/sdb
# fdisk -l (per controllare che le partizioni siano uguali)

Ripristino del RAID 1

Aggiungere /dev/sdb3 a /dev/md3

# mdadm --manage /dev/md3 --add /dev/sdb3

Se avessimo più array (es. md1, md2...) contenenti partizioni del disco sdb (sdb1, sdb2...), l'operazione andrebbe ripetuta per ciascuno di essi es.:

 # mdadm --manage /dev/md1 --add /dev/sdb1

Controllare che tutto sia andato a buon fine

# cat /proc/mdstat

LVM

Il Logical Volume Manager (LVM o gestore logico dei volumi) è un software per la gestione dei dischi che permette di superare le limitazioni legate al normale partizionamento di questi ultimi. Si tratta di una specie di strato che si va a frapporre tra il dispositivo fisico ed il filesystem. Permette di gestire dinamicamente aggiunta, rimozione o ridimensionamento dello spazio di archiviazione, il RAID, nonché lo snapshot dei volumi.

LVM è un prodotto oltremodo maturo, disponibile per Linux sin dal kernel 2.4, per questa ragione distribuzioni orientate al mercato aziendale come RedHat lo hanno scelto, accoppiandolo a XFS o ext4, come soluzione predefinita per implementare la maggior parte delle caratteristiche fornite dai moderni filesystem come BTRFS o ZFS

LVM si basa sui seguenti concetti

  • Physical Volumes (PV): rappresentano qualsiasi disco si voglia inizializzare ("formattare") come sottosistema LVM
# pvcreate /dev/sda1
# pvcreate /dev/sdb3
# pvcreate /dev/sdc
# pvdisplay
  • Volume Groups (VG): sono costituiti da physical volumes e rappresentano la capacità totale delle risorse di un LVM
# vgcreate vg0 /dev/sda1 /dev/sdb3 /dev/sdc
# vgdisplay vg0
  • Logical Volumes (LV): utilizzano le risorse messe a disposizione dai volume groups. Possono essere inizializzati anche con proprietà di RAID o cache.
# lvcreate -L 10G -n home vg0
# lvdisplay /dev/vg0/home

Oppure nel caso volessimo fare un raid5

# lvcreate -n lvr5 –type raid5 -L 10G -i 3 vg0

-n nome del volume
–type raid5 tipo di raid
-L dimensione massima della grandezza del raid
-i numero dei physical volumes che si vogliono utilizzare

Per formattare il volume logico appena creato

# mkfs -t ext4 /dev/vg0/lvr5

Per aggiungere un disco ad un Volume Groups

# vgextend vg0 /dev/sdb2


Snapshot

Creare uno snapshot della del volume logico /home che potrà contenere fino ad un massimo di 5 GiB di dati modificati rispetto all'originale

# lvcreate --size 5G --snapshot --name homesnap20230306 /dev/vg0/home

Ripristinare il volume logico ricaricando lo snapshot

# lvconvert --merge /dev/vg0/homesnap20230306

Nel caso il logical volume sia attivo il merging avverrà col prossimo riavvio e lo snapshot sparirà.

Cache

Utilizzare un moderno disco a stato solido può essere una soluzione economica per velocizzare un LV.

Convertire il disco a PV ed aggiungerlo al preesistente VG

# pvcreate /dev/discoSSD
# vgextend vg0 /dev/discoSSD

Aggiungere la cache al LV

# lvcreate --type cache --cachemode writethrough -l 100%FREE -n root_cachepool vg0/home /dev/discoSSD

Rimuovere la cache dal LV

# lvconvert --uncache vg0/home

GRUB (Boot loader)

È possibile scegliere tra più bootloader: GRUB, Lilo, Syslinux o addirittura il bootloader integrato del systemd (systemd-boot). Ma dato che GRUB è utilizzabile pressoché in ogni circostanza: schede madri BIOS, UEFI; Secure Boot, hard disk, floppy, CD-ROM... in questa guida mi limiterò alla sua configurazione, tralasciando le alternative.

Sistema con BIOS

# pacman -S grub
# grub-mkconfig -o /boot/grub/grub.cfg
# grub-install /dev/sda

Sistema UEFI

NB: per installare correttamente GRUB su un sistema UEFI occorre che il device di installazione abbia effettuato il boot in modalità UEFI e non Legacy (BIOS)

# pacman -S grub
# mkdir /boot/EFI
# mount /dev/sda1 /boot/EFI
# grub-install /dev/sda
# grub-mkconfig -o /boot/grub/grub.cfg

Gestione snapshot BTRFS

Manuale

Editare /etc/grub.d/40_custom (o crearlo) e aggiungere quanto segue per permettere l'avvio della snapshot rootsnap

menuentry 'Linux snapshot' {
       insmod gzio
       insmod part_gpt
       insmod btrfs
       set root='hd1,gpt3'
       linux   /rootsnap/boot/vmlinuz-linux root=/dev/partizione rw rootflags=subvol=rootsnap  quiet
       initrd  /rootsnap/boot/initramfs-linux.img
}

dopodichè aggiornare la configurazione di GRUB con

# grub-mkconfig -o /boot/grub/grub.cfg

Automatico

Per facilitare la gestione lei sottovolumi e delle snapshot del BTRFS Arch offre il pacchetto grub-btrfs, la sua installazione provvederà ad aggiungere tutti i sottovolumi contenenti un sistema Linux al menu di grub.

# pacman -S grub-btrfs

Ogni volta che si vorrà aggiornare grub con nuovi subvolumi basterà dare il seguente comando

# grub-mkconfig -o /boot/grub/grub.cfg

Ripristinare GRUB

Aggiornando la propria distribuzione Linux, il proprio boot loader o installando un altro sistema operativo (es. Windows) può capitare di sovrascrivere il MBR.

Avviare il computer con un liveCD/DVD o USB:

Ipotizziamo di avere una partizione / chiamata /dev/sda2 e nessuna /boot

Creiamo i seguenti mount point

# sudo su
# cd /mnt
# mkdir sda2
# mount /dev/sda2 /mnt/sda2

Se utilizziamo una scheda madre UEFI andrà montata anche la partizione efi (solitamente è la prima partizione del disco sda1)

# mount /dev/sda2 /mnt/sda2/boot/efi

Se necessario editiamo il file di configurazione di grub

 # nano /mnt/sda2/boot/grub/grub.cfg

arch-chroot

Se stiamo utilizzando un sistema basato su Arch Linux, utilizzando l'utility arch-chroot presente nel pacchetto arch-install-scripts potremo automatizzare il processo di chroot con un solo comando

# arch-chroot /mnt/sda2

Manuale

# mount --rbind /dev /mnt/sda2/dev
# mount -t proc /proc /mnt/sda2/proc
# mount -t sysfs /sys /mnt/sda2/sys/

Eseguiamo il vero e proprio chroot in /dev/sda2

# chroot /mnt/sda2

Reinstallazione

# grub-mkconfig -o /boot/grub/grub.cfg
# grub-install /dev/sda

Riavvio del sistema

Usciamo dal chroot, smontiamo la partizione e riavviamo il sistema

# exit
# umount /mnt/sda1/proc
# umount /mnt/sda1/dev
# umount /mnt/sda1
# systemctl reboot

Eliminare il boot loader

In caso di errori nell'installazione di GRUB è possibile cancellare il vecchio boot loader di un disco (devicename = sda,sdb,sdc...)

# dd if=/dev/zero of=/dev/devicename bs=446 count=1

ISOBoot

Con GRUB2 è possibile effettuare il boot di iso di LiveCD/USB Linux presenti sul disco aggiungendole su /etc/grub.d/40_custom

  • Ubuntu 23.04
menuentry "Ubuntu 23.04 desktop ISO" {
       insmod part_gpt
       insmod ext2
       insmod btrfs
       rmmod tpm
    # es.: terza partizione del primo disco
       set root=(hd0,gpt3)
       set isofile="/home/<username>/Downloads/ubuntu-23.04-desktop-amd64.iso"
       loopback loop $isofile
       linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile quiet splash
       initrd (loop)/casper/initrd
}

Networking

Manuale

net-tools

Storica serie di utility per gestire le interface di rete, presente da decenni nell'installazione base della maggior parte delle distribuzioni Linux, ma attualmente considerata obsoleta. Tra i suoi comandi principali: arp, hostname, ifconfig, iptunnel netstat e route.

Attivare l'interfaccia di rete eth0 ed assegnarle l'indirizzo ip 192.168.0.2

# ifconfig eth0 192.168.0.2 up

Disattivare l'interfaccia di rete eth0

# ifconfig eth0 down

Assegnare manualmente un gateway (es.: 192.168.0.1) alla rete

# route add default gw 192.168.0.1

Ovviamente occorrerà aggiungere un server DNS al file /etc/resolv.conf per la risoluzione degli indirizzi.

iproute2

Conversione comandi da net-tools a iproute2
net-tools iproute2 Note
ifconfig ip addr, ip link Address and link configuration
route ip route Routing tables
arp ip neigh Neighbors
iptunnel ip tunnel Tunnels
nameif, ifrename ip link set name Rename network interfaces
ipmaddr ip maddr Multicast
netstat ss, ip route Show various networking statistics
brctl bridge Handle bridge addresses and devices

Elencare gli indirizzi IP:

# ip addr

Mostra le informazioni di una specifica interfaccia di rete

# ip addr show eth0

Aggiungere un indirizzo all'interfaccia eth0:

# ip addr add 192.0.2.10/24 dev eth0

Cancellare un indirizzo associato all'interfaccia eth0:

# ip addr delete 192.0.2.10/24 dev eth0

Attivare l'interfaccia eth0:

# ip link set dev eth0 up

Disattivare l'interfaccia eth0:

# ip link set dev eth0 down

Svuotare la cache arp per tutte le interfacce:

# ip neigh flush all

Aggiungere una rotta che passa per gateway 192.0.2.1

# ip route add default via 192.0.2.1

Aggiungere una rotta che passa per gateway 192.168.2.1 per l'interfaccia 10.0.2.0

# ip route add 10.0.2.1/24 via 192.168.0.1 dev enp0s3

Aggiungere una rotta che passa per gateway 192.168.2.1 per l'interfaccia 10.0.2.0

# ip route del 10.0.2.0/24 via 192.168.0.1 dev enp0s3 

Mostrare la tabella di routing

# ip route show

Systemd-networkd

systemd-networkd è un demone, parte di systemd, che gestisce la configurazione della rete.

Esempi di configurazione

Per prima cosa sarà necessario abilitare il servizio

# systemctl enable --now systemd-networkd.service
# systemctl enable --now systemd-resolved.service
# ln -rsf /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf

DHCP

/etc/systemd/network/20-wired.network

[Match]
Name=enp1s0
[Network]
DHCP=yes

IP statico

/etc/systemd/network/20-wired.network

[Match]
Name=enp1s0
[Network]
Address=10.1.10.9/24
Gateway=10.1.10.1
DNS=10.1.10.1

Wireless adapter

Per potersi connettere a connessioni WIFI è necessario installare e configurare un'ulteriore applicazione dedicata come iwd o wpa_supplicant per l'autenticazione alla rete.

/etc/systemd/network/25-wireless.network

[Match]
Name=wlp2s0
[Network]
DHCP=yes
IgnoreCarrierLoss=3s


Rinominare l'interfaccia di rete

Invece che impostare una regola su udev è possibile usare un file di testo .link nel seguente modo

/etc/systemd/network/10-ethusb0.link

[Match]
MACAddress=12:34:56:78:90:ab
[Link]
Description=USB to Ethernet Adapter
Name=ethusb0

Wifi

Programmi WEXT nl80211 WEP WPA
wireless_tools No No
iw No No
wpa_supplicant No
iwd/iwgtk No No

NetworkManager

NetworkManager è una utility che si è imposta come standard per la configurazione della reti Linux (LAN e Wifi)

Si compone di un demone, un'interfaccia da riga di comando (nmcli) ed un'interfaccia di configurazione basata su un menu testuale (nmtui).

I principali desktop enviroment come GNOME e KDE Plasma possiedono una utility grafica che consente loro di configurare graficamente le reti basandosi su NetworkManager.

Installazione

# pacman -S networkmanager 
# systemctl enable NetworkManager
# systemctl start NetworkManager

Configurazione

  • Menu di configurazione: qualora si utilizzi un sistema privo di interfaccia grafica e si desideri configurare una rete wifi si consiglia caldamente l'utilizzo dell'applicazione nmtui
  • Per chi dovesse prediligere la configurazione manuale: nmcli
  • Per impedire a Network Manager di gestire una certa interfaccia di rete è sufficiente aggiungere il suo MAC Address al file di configurazione /etc/NetworkManager/NetworkManager.conf
[main]
plugins=keyfile
[keyfile]
unmanaged-devices=mac:00:25:21:73:90:72

Alternative

Condividere la connessione

Abilitazione del forwarding dei pacchetti

$ sudo echo 1 > /proc/sys/net/ipv4/ip_forward

Per rendere il forwarding definitivo editare il file /etc/sysctl.conf modificando come segue il parametro net.ipv4.ip_forward:

net.ipv4.ip_forward = 1


Mascheramento dei pacchetti

$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

eth0 non è un parametro fisso, identifica l'interfaccia con la quale il PC si connette ad Internet

Per applicare automaticamente tale regola ad ogni riavvio

# iptables-save > /etc/iptables.ipv4.nat
# iptables-restore < /etc/iptables.ipv4.nat

Moduli kernel

Assicurarsi che siano caricati i seguenti moduli:

# modprobe ip_tables
# modprobe ip_conntrack
# modprobe iptable_nat
# modprobe ipt_MASQUERADE

Condivisione tramite rete ethernet

Configurazione scheda di rete interna

Assegnare un IP statico alla scheda ethernet con la quale si vuol condividere la connessione.

# ifconfig eth1 192.168.5.1 netmask 255.255.255.0 up

Per rendere tale configurazione permanente sarà necessario editare il file /etc/network/interfaces ed aggiungere la seguente configurazione

auto eth1
iface eth1 inet static
address 192.168.5.1
netmask 255.255.255.0

Condivisione tramite rete WI-FI

Configurazione scheda wireless

Se non si desidera cifrare la rete e proteggerla con una password sarà sufficiente eseguire questi comandi.

# iwconfig wlan0 mode Master
# iwconfig wlan0 ESSID ReteGOLEM
# iwconfig wlan0 enc off
# ifconfig wlan0 192.168.5.1 netmask 255.255.255.0 up

Per rendere tale configurazione permanente sarà necessario editare il file /etc/network/interfaces ed aggiungere la seguente configurazione

iface wlan0 inet loopback
address 192.168.5.1
netmask 255.255.255.0
Proteggere la connessione WI-FI

Installare il programma hostapd

# pacman -S hostapd

Configurare hostapd modificando /etc/hostapd/hostapd.conf

# Interfaccia di rete
interface=wlan0
# Driver della scheda wifi usata (non tutte le schede sono supportate)
driver=nl80211
# Nome della rete (SSID)
ssid=ReteGOLEM
hw_mode=g
# Canale di trasmissione
channel=6
macaddr_acl=0
# Righe per la protezione
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
# Password del wifi
wpa_passphrase=password
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

Editare il file /etc/default/hostapd per impostare hostapd.conf come file di configurazione predefinito, modificando la riga DAEMON_CONF="":

DAEMON_CONF="/etc/hostapd/hostapd.conf"

Assegnazione automatica degli IP ai client

# pacman -S dhcp

Editare /etc/dhcpd.conf aggiungendo la configurazione per la rete interna (es.: eth1 o wlan0):

subnet 192.168.5.0 netmask 255.255.255.0 {
range 192.168.5.100  192.168.5.200;
option domain-name-servers 8.8.8.8;
}


VPN

OpenVPN

https://wiki.archlinux.org/title/OpenVPN

L2TP/IPsec VPN

https://wiki.archlinux.org/title/Openswan_L2TP/IPsec_VPN_client_setup

Container

Toolbox

Toolbox è un tool che permette di creare ed utilizzare container che si integrano col sistema host accedendo ad ogni sua risorsa: directory home dell'utente, X11/Wayland, networking, periferiche esterne. Tutto senza dover mettere mano a nessun file di configurazione. È il modo più semplice per di integrare più distribuzioni all'interno di una stessa macchina Linux.

Immagini

Comandi

Creare un container

$ toolbox create -i quay.io/toolbx-images/rhel-toolbox:9.1 -c redhat

Entrare in un container

$ toolbox enter redhat

Fermare un container

$ podman stop nome_macchina

Rimuovere un container

$ toolbox rm -f redhat

Rimuovere un container e la sua immagine

$ toolbox rmi redhat 

Esaminare la lista dei container e delle immagini disponibili

$ toolbox list 

Permettere agli utenti non root di utilizzare i container

$ sudo sh -c 'echo "username:100000:65536" >> /etc/subuid'
$ sudo sh -c 'echo "username:100000:65536" >> /etc/subgid'

Abilitare l'host al forwarding di X11 per le applicazioni che richiedono Xorg

# xhost +

Eseguire un comandi all'interno di un container

$ toolbox run -c redhat libreoffice

LXC

Linux Container (LXC) permette di virtualizzare uno o più container Linux su un singolo host LXC, gestendone virtualmente RAM, CPU, socket e rete.

È estremamente utile quando si ha bisogno di isolare dei servizi dal sistema host: es.: server web, imap, smtp...

Installazione

Installare LXC

# pacman -S lxc lxc-templates lxcfs lxd

Comandi

Lista dei container installati

lxc-ls -f 

Installare un container scegliendo l'immagine dalla lista di quelli disponibili

lxc-create -n playtime -t download

Se sapete già di quale container avete bisogno sarà possibile scaricarlo direttamente

lxc-create -n playtime -t download -- --dist archlinux --release current --arch amd64

Far partire il container chiamato debian

lxc-start debian 

Entrare dentro il container chiamato debian

lxc-attach debian

Fermare l'esecuzione del container chiamato debian

lxc-stop debian

Rimuovere il container chiamato debian

lxc-destroy debian 

Eseguire un comando dentro il container chiamato debian

lxc-attach --name debian nano

Rete Bridge

Nel caso si debbano usare servizi da tenere esposti su Internet potrebbe essere conveniente utilizzare una rete bridge piuttosto che NAT.

Configurazione rete bridge.


Docker

Abilitare ed avviare docker

# systemctl enable --now docker

Cercare il container desiderato

# docker search "xxx"

Scaricare l'immagine desiderata

# docker pull xxxx:latest

Visualizzare le immagini scaricate

# docker images

Visualizzare i docker creati

# docker ps -a

Avviare docker

# docker start nome_docker

Entrare nel docker

# docker attach nome_docker

Copiare un file dal sistema host al docker

# docker cp esempio.txt nome_docker: /esempio.txt

Copiare un file dal docker.

# docker cp container-id:/path/filename.txt ~/Desktop/filename.txt

Rimuovere un docker

# docker rm nome_docker

Rimuovere tutti i docker

# docker container stop $(docker container ls -aq)
# docker system prune -a --volumes

Avviare automaticamente un docker (da testare)

# docker run --restart=always --name nome_docker

Creare script di avvio docker-webserver.service

[Unit]
Description=Some service
Requires=docker.service
After=docker.service
[Service]
Restart=always
ExecStart=/usr/bin/docker start -a container_name
ExecStop=/usr/bin/docker stop -t 2 container_name
[Install]
WantedBy=multi-user.target

systemd-nspawn

Fonti software alternative

Nella rara eventualità che si necessiti di un programma non presente né nei repository ufficiali, né su AUR è possibile optare per una delle seguenti opzioni.

AppImage

Scaricate qualsiasi pacchetto disponibile su appimage.github.io e rendetelo eseguibile.

$ chmod a+x nomeprogramma.AppImage

Non resta che eseguirlo col seguente comando o con un doppio click

$ ./nomeprogramma.AppImage


Flatpak

Concepito per essere una sorta di Google Play Store per GNOME, è possibile installare programmi provenienti da flatpak utilizzando i normali gestori grafici di pacchetti basati su packagekit come Gnome Software o Discover di Plasma.

Installazione

# pacman -S flatpak

Abilitazione del repository ufficiale del progetto (software di terze parti potrebbe richiedere di aggiungere altri repository)

# flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Elenca i repository disponibili.

$ flatpak remotes

Installa un'applicazione (es.: libreoffice)

$ flatpak install flathub org.libreoffice.LibreOffice

Esegue un'applicazione (es.: libreoffice)

$ flatpak run org.libreoffice.LibreOffice

Disinstalla un'applicazione mantenendo i dati.

$ flatpak uninstall <nome app>

Disinstalla un'applicazione eliminando i dati (nella home utente .var/app/).

$ flatpak uninstall <nome app> --delete-data

Elimina i dati di tutte le applicazioni disinstallate (nella home utente .var/app/).

$ flatpak uninstall --delete-data

Disinstalla tutte le applicazioni flatpak installate sul sistema.

$ flatpak uninstall --all

Cerca ed esegue aggiornamenti per le applicazioni installate.

$ flatpak update

Aggiorna una singola applicazione.

$ flatpak update <nome app>

Elenca tutte le applicazioni flatpak installate sul sistema.

$ flatpak list --app

Elenca i runtime installati.

$ flatpak list --runtime

Visualizzare le informazioni sulle applicazioni in esecuzione.

$ flatpak ps

Termina un'applicazione bloccata o danneggiata (l'ID dell'istanza si può ottenere dal comando precedente).

$ flatpak kill <id istanza>

Tenta la riparare dei pacchetti danneggiati. Necessita dei privilegi di amministrazione.

$ flatpak repair

Nix

Nix package manager è il gestore di pacchetti utilizzato su NixOS. È possibile però utilizzarlo su qualsiasi distribuzione Linux affiancandone il gestore di pacchetti predefinito.

Nix analizza le istruzioni di compilazione (riproducibili) specificate in un file secondo il suo linguaggio di espressione, i risultati di questa compilazione sono archiviati secondo indirizzi univoci identificati da un hash e completi del loro intero albero delle dipendenze. Si crea così un archivio immutabile di pacchetti che consente aggiornamenti atomici, rollback e installazione simultanea di diverse versioni di un pacchetto.

Guida completa

Installazione

Guida ufficiale

Single-user installation

$ sudo install -d -m755 -o $(id -u) -g $(id -g) /nix
$ sh <(curl -L https://nixos.org/nix/install) --no-daemon

Aggiungere la riga seguente al .bashrc o al file di configurazione della vostra shell per poter utilizzare i comandi Nix

$ source $HOME/.nix-profile/etc/profile.d/nix.sh

Canali

Il software è distribuito attraverso in repository chiamati canali nei quali può essere disponibile in forma già precompilata binary cache o come sorgente da compilare. Questi canali determinano la versione dei pacchetti disponibili categorizzandoli nei rami stabile ed instabile.

Ecco di seguito i comandi principali per gestire questi canali

Lista dei canali configurati

$ nix-channel --list

Aggiungere il canale principale (nixos)

$ nix-channel --add https://nixos.org/channels/channel-name nixos

Aggiungere altri canali

$ nix-channel --add https://some.channel/url my-alias

Rimuovere un canale

$ nix-channel --remove channel-alias

Aggiornare un canale

$ nix-channel --update channel-alias

Aggiornare tutti i canali

$ nix-channel --update

Comandi

Cercare un pacchetto

$ nix search nixpkgs packagename

Installare un pacchetto

$ nix-env -iA packagename

Vedere i pacchetti installati

$ nix-env -q

Disinstallare un pacchetto

$ nix-env -e packagename

Aggiornare tutti i pacchetti

$ nix-env -u

Snap

È gestore di pacchetti ed un formato per la distribuzione di software ideato da Canonical Ltd. per Ubuntu, ma che adesso può essere utilizzato anche su altre distribuzioni. Consente di installare un'applicazione completa di tutte le sue librerie isolandola dal resto del sistema operativo. Si evitano così possibili conflitti tra applicazioni, permettendo la coesistenza di più versioni di uno stesso programma o libreria.

Su Arch è disponibile su AUR: snapd

Installazione

Installare ed abilitare Snap

$ yay -S snapd
$ sudo ln -s /var/lib/snapd/snap /snap
$ sudo systemctl start snapd.service
$ sudo systemctl enable snapd.service

Comandi

Cercare un programma

$ snap find nomeprogramma

Installare un programma

$ sudo snap install nomeprogramma

Rimuovere un programma

$ sudo snap remove nomeprogramma

Vedere i programmi installati

$ snap list

Rimuovere una determinata versione di un programma

$ sudo snap remove nomeprogramma --revision

Aggiornare manualmente i pacchetti snap

$ sudo snap refresh

GPG

GNU Privacy Guard (GnuPG o GPG) è un programma libero pensato per fornire un'alternativa opensource al Pretty Good Privacy (PGP). Nel PGP sono usate sia la crittografia asimmetrica (a chiave pubblica) che quella simmetrica. La chiave pubblica del destinatario serve al mittente unicamente per cifrare la chiave comune per un algoritmo di crittografia simmetrica che sarà usata per cifrare il testo in chiaro del messaggio. Un destinatario decifra un messaggio protetto da GPG usando la chiave di sessione con l'algoritmo simmetrico. Tale chiave di sessione è inclusa nel messaggio in maniera criptata ed è decifrata usando la chiave privata del destinatario. L'utilizzo di due cifrature oltre che a velocizzare l'esecuzione del programma (la cifratura a chiave simmetrica è molto più veloce di quella asimmetrica) permette di poter cifrare uno stesso messaggio per più destinatari.

Generare una chiave

$ gpg --gen-key

Controllare che la chiave sia stata correttamente creata

$ gpg --list-keys

Certificato di revoca

Il certificato di revoca serve per invalidare la chiave nel caso in cui questa venga compromessa. Chiunque sia in possesso del certificato di revoca può revocare la chiave corrispondente, per cui è bene tenerlo in un posto sicuro. Poiché, nel momento in cui si ha bisogno del certificato di revoca, potremmo non essere più in grado di generarlo, conviene generarlo subito dopo la creazione della chiave, e prima di iniziare a utilizzarla pubblicamente.

$ gpg --output certificato-di-revoca.asc --gen-revoke ID

dove ID è dato dalle ultime 8 cifre dell'impronta (fingerprint) della chiave.

Utilizzo pratico

Criptare un documento

$ gpg -o file1.ext.gpg -e -r UserID file1.ext

Esempio:

$ gpg -o tesi.odt.gpg -e -r spookyh@gmail.com tesi.odt

Decriptare un documento

$ gpg -o file1.ext -d file1.gpg

Firmare un documento

Il mittente può usare PGP per firmare un messaggio con l'algoritmo di firma RSA o Digital Signature Algorithm (DSA). Per fare ciò viene calcolato un hash (message digest) dal testo in chiaro e successivamente da questo hash è creata la firma digitale usando la chiave privata del mittente.

$ gpg -o file1.ext.sig -s file1.ext

Verificare un documento

$ gpg --verify file1.sig

Importare ed esportare chiavi (locali)

Importare una chiave (pubblica)

$ gpg --import chiave.asc (o .txt)

Esportare la propria chiave pubblica

$ gpg -a -o chiave_pubblica.asc --export

Esportare la propria chiave privata

Golem-template-note-attention.png La chiave privata può essere utilizzata per impersonare la vostra identità, NON inviarla mai a nessuno, ed esportala solo per effettuarne backup, naturalmente da custodire in un luogo sicuro.


$ gpg --armor --export-secret-keys <ID> > secret-key.gpg.asc

Condividere le chiavi pubbliche

Inviare la chiave ad un keyserver:

$ gpg --keyserver keyserver.linux.it --send-key <ID>

Importare una chiave da un keyserver:

$ gpg --keyserver keyserver.linux.it --recv-keys <ID>

Se ci fidiamo del proprietario e vogliamo mostrare pubblicamente la nostra fiducia, possiamo firmare la chiave appena importata e esportare la firma su un keyserver (vedere sezioni successive).

Keyserver

Quando si carica una chiave su un keyserver, poi questo la condivide con gli altri keyserver che fanno parte dello stesso circuito. Non esiste un'entità centralizzata o un circuito di riferimento (per scelta di design), e, a volte, questo può generare confusione nell'utilizzatore. Inoltre, alcuni keyserver potrebbero non essere sempre accessibili.

Tra i keyserver più noti:

  • keys.openpgp.org
  • keyserver.ubuntu.com
  • keys.gnupg.net
  • pgp.surfnet.nl
  • pgp.circl.lu
  • pgp.mit.edu

Editare una chiave

Per fare operazioni e modifiche dobbiamo "editare" le chiavi, aprendo l'editor interattivo:

$ gpg --edit-key <ID>

NB: Prima di uscire dall'editor, ricordarsi di salvare, altrimenti le modifiche vanno perdute

  • firmare
> sign
  • cambiare i valori di fiducia
> trust
  • vedere la fingerprint
> fpr
  • cambiare la data di scadenza
> expire
  • cambiare la password
> passwd
  • firmare localmente in modo non esportabile
> lsign
  • sempre ricordarsi di salvare
> save
  • oppure uscire
> quit

Digitare help per una lista esaustiva.

Tutte le modifiche da rendere pubbliche vanno inviate ad un keyserver.

Revocare una chiave

Avendo già il certificato di revoca:

$ gpg --import certificato-di-revoca.asc
$ gpg --keyserver pgp.surfnet.nl --send-key ID

Gestione delle chiavi

Controllare il database delle chiavi: questo comando mostra tutte le chiavi che abbiamo con molte informazioni.

$ gpg --list-keys --with-colons

Fornisce tutti i valori di fiducia assegnati alle varie chiavi. (Informazioni private)

$ gpg --list-ownertrust

Controllo firme

$ gpg --check-sigs
$ gpg --list-sigs

Esportare le chiavi altrui

Abbiamo importato e firmato la chiave di <ID>.

Rimandiamola al proprietario:

$ gpg --armor -export -o firma.sig <ID>

Questo comando crea un file di nome firma.sig nella directory corrente, che contiene la chiave firmata. Spedire al proprietario firma.sig.

Chi riceve la propria chiave firmata da altri può decidere inserirla nel proprio portachiavi, con

$ gpg --import firma.sig

Si aggiungono al portachiavi le nuove firme ma anche i nuovi ID che il mittente ha sulla sua chiave, col rispettivo valore di fiducia. Firmare le chiavi degli altri implica dar loro fiducia, e, spesso, anche aver verificato la loro identità in maniera sicura. Se non ci fidiamo, non firmiamo. Se si firmano a caso tutte le chiavi che capitano a tiro, si perde la reputazione che si ha presso gli altri partecipanti della rete. Se vogliamo fare un uso pubblico di questa fiducia reciproca possiamo mandare la nostra chiave, contenente la nuova firma, al keyserver:

$ gpg --keyserver pgp.circl.lu --send-key <ID mia chiave>

Periodicamente occorre aggiornare il proprio portachiavi digitale, così da venire a conoscenza delle modifiche sulle chiavi degli altri.

$ gpg --keyserver pgp.circl.lu --refresh-keys

Rete di fiducia

Una chiave importata può essere firmata con un certo grado di fiducia. Possiamo rispedirla al proprietario o caricare la firma su un keyserver, e se lui la importa nel suo portachiavi, avrà la propria chiave firmata da noi. Ognuno può quindi aggiungere le firme dei conoscenti alla propria chiave, che a loro volta hanno firme di altri.

GUI

Esistono vari programmi a interfaccia grafica:

  • Seahorse, per gestire le chiavi e i certificati, comprese quelle ssh, per un ambiente GTK
  • KGPG, per gestire le chiavi e i certificati, comprese quelle ssh, per un ambiente QT
  • Pinentry (anche da riga di comando) si ricorda la password della chiave per il tempo impostato (default 5 minuti)

Systemd

systemd-timesyncd — system time synchronization across the network;
systemd/Journal — system logging
systemd/Timers — alternative to cron

Link Utili

ArchWiki

Appunti Linux

LFS-BOOK