linux:zfs

Dies ist eine alte Version des Dokuments!


ZFS auf Linux ("ZFS on Linux")

ZFS ist ein von Sun Microsystems entwickeltes transaktionales Dateisystem, das zahlreiche Erweiterungen für die Verwendung im Server- und Rechenzentrumsbereich enthält. Hierzu zählen die vergleichsweise große maximale Dateisystemgröße, eine einfache Verwaltung selbst komplexer Konfigurationen, die integrierten RAID-Funktionalitäten, das Volume-Management sowie der prüfsummenbasierte Schutz vor Datenübertragungsfehlern. Der Name ZFS stand ursprünglich für Zettabyte File System.

Eine direkte Unterstützung innerhalb des Linux-Kernels ist aus Lizenzgründen problematisch (Inkompatibilität von GPLv2 und CDDL), daher gibt es momentan keine Implementierung die direkt im Kernel integriert ist. Zudem ist es (aus Sicht von ZFS) problematisch das zunehmend Kernel-Funktionen exklusiv für GPL-Software reserviert werden, die Problematik beschreibt der Artikel Linux 5.0: Lizenzkennzeichnung trifft Nvidia und ZFS on Linux.

Allerdings gibt es:

  • das Projekt ZFS on FUSE, das ZFS auch unter Linux nutzbar macht. Die Implementierung im Userspace hat verschiedene Nachteile, unter anderem einen verminderten Datendurchsatz.
  • aktuell ist der bevorzugte Lösungsansatz „ZFS on Linux“ (ZoL), nach Aussagen der Entwickler ist es seit der im April 2013 veröffentlichen Version 0.6.1 reif für den produktiven Einsatz. Hier werden die nötigen Kernel-Module außerhalb des Kernel-Quellbaums gepflegt und sind daher bei vielen Installationsprogrammen nicht enthalten.

Quelle: Wikipedia.

Enthaltene Versionen von ZFS on Linux in den Distributionen

Leider ist die Anleitung etwas dünn, die Installation von zfs-utils scheitert wenn das Kernel-modul vorher nicht geladen worden ist.

# vi /etc/apt/sources.list.d/buster-backports.list
deb http://deb.debian.org/debian buster-backports main contrib
deb-src http://deb.debian.org/debian buster-backports main contrib
# vi /etc/apt/preferences.d/90_zfs
Package: libnvpair1linux libuutil1linux libzfs2linux libzpool2linux spl-dkms zfs-dkms zfs-test zfsutils-linux zfsutils-linux-dev zfs-zed
Pin: release n=buster-backports
Pin-Priority: 990
sudo apt install linux-headers-amd64 dkms 
sudo apt install zfs-dkms --no-install-recommends
sudo modprobe zfs
sudo apt install zfsutils-linux

# debian10
echo "zfs" >> /etc/modules-load.d/modules.conf
# auf anderen Systemen:
# echo "zfs" >> /etc/modules

ab 15.10:

apt install zfsutils-linux

Ältere Versionen siehe hier.

Install zfs-release package:

yum localinstall --nogpgcheck http://archive.zfsonlinux.org/epel/zfs-release.el7.noarch.rpm
yum-config-manager --enable "zfs"
yum install zfs
modprobe zfs

ZFS Virtual Devices (ZFS VDEVs) sind meta-Devices die aus den u.g. Geräten bestehen kann. VDEVs werden dynamisch erzeugt, devices/Geräte können hinzugefügt, aber nicht entfernt werden.

Bezeichnung Bedeutung
File Dateien auf anderen Dateisystemen die als Quelle dienen
Physical Drive physikalisches Gerät (HDD, SDD, PCIe NVME, usw.)
Mirror a standard RAID1 mirror
ZFS software raidz1, raidz2, raidz3 'distributed' parity based RAID
Hot Spare hot spare for ZFS software raid.
Cache a device for level 2 adaptive read cache (ZFS L2ARC)
Log ZFS Intent Log (ZFS ZIL)

ZFS Pools: bestehen aus einem oder mehreren VDEVS, auf einem Pool können ZFS-Dateisysteme erzeugt werden.

ZFS Dataset Types - es gibt drei Typen:

  • filesystem: Dateisystem und Clones
  • snapshot: Snapshots 1)
  • volume: ein blockdevice was unter /dev/zvol/$Poolname/$Volumename auftaucht. Das Volume hat ein fixe Größe, je nach Implementierung kann es auch direkt von zfs oder indirekt als iSCSI target exportiert werden. Weitere Informationen finden sich in der Doku zu ZFS Volumes

Der folgende Befehl listet die vorhandenen Typen auf:

zfs list -o name,type,mountpoint
NAME       TYPE        MOUNTPOINT
pool1      filesystem  /pool1
pool1/fs1  volume      -
pool1/fs2  filesystem  /pool1/fs2
  1. import Fehler nach reboots (insbesondere bei mehreren pools): Es sollten immer /dev/disk/by-id/* Aliases benutzt werden
  2. zfs als root-Dateisystem erfordert einige Anpassungen: https://github.com/zfsonlinux/zfs/wiki/Ubuntu-18.04-Root-on-ZFS
  3. race conditions mit anderen daemons beim mounten aufgrund fehlender systemd.mount integration: https://github.com/zfsonlinux/zfs/issues/4898 https://github.com/zfsonlinux/zfs/pull/7329
  4. Geräte (top-level VDEV) können erst mit Solaris 11.4 entfernt werden https://docs.oracle.com/cd/E37838_01/html/E61017/remove-devices.html
  5. Swap-devices auf zfs-Volumes können Problem bereiten

ZFS benutzt standardmäßig bis zu 50% des RAMs, die aktuelle Belegung anzeigen:

echo $(( `cat /proc/spl/kmem/slab | tail -n +3 | awk '{ print $3 }' | tr "\n" "+" | sed "s/$/0/"` ))

Beispiel: auf 8G RAM beschränken /etc/modprobe.d/zfs.conf

options zfs zfs_arc_max=8589934592

OpenZFS 2.1.x führt distributed RAID (dRAID) als neuen vdev Typ ein. Dies reduziert bei großen Datenträgerverbünden die Wiederherstellungszeiten.

siehe auch: man zpool

pool anlegen

pool aus VDEVs anlegen:

sudo zpool create single-DISK /dev/disk/by-id/DISK1

Redundanz (vergleichbar mit RAID-Level)

  • Striped VDEVS („Raid 0“)
    sudo zpool create samsung-stripe /dev/disk/by-id/DISK1 /dev/DISK2
  • Mirrored VDEVs („Raid 1“)
    sudo zpool create samsung-mirror mirror /dev/DISK1 /dev/DISK2
  • Striped Mirrored VDEVs („RAID10“, einen stripe über zwei mirrored pools):
    sudo zpool create meinStripedMirroredPool mirror /dev/DISK1 /dev/disk/DISK2 mirror /dev/DISK3 /dev/DISK4

    oder

    sudo zpool create meinStripedMirroredPool mirror /dev/DISK1 /dev/DISK2
    sudo zpool add meinStripedMirroredPool mirror /dev/DISK3 /dev/DISK4
  • RAIDZ („Raid 5“, verkraftet den Ausfall eines VDEVs):
    sudo zpool create meinRAIDZ raidz /dev/disk/by-id/DISK1 /dev/disk/by-id/DISK2 /dev/disk/by-id/DISK3
  • RAIDZ2 („RAID6“, verkraftet den Ausfall zweier VDEVs):
    sudo zpool create meinRAIDZ2 raidz2 /dev/disk/by-id/DISK1 /dev/disk/by-id/DISK2 /dev/disk/by-id/DISK3 /dev/disk/by-id/DISK4
  • RAIDZ3 (verkraftet den Ausfall dreier VDEVs):
    sudo zpool create meinRAIDZ3 raidz3 /dev/disk/by-id/DISK1 /dev/disk/by-id/DISK2 /dev/disk/by-id/DISK3 /dev/disk/by-id/DISK4 /dev/disk/by-id/DISK5
  • verschachteltes „Nested“ RAIDZ („RAID50“, „RAID60“)
    sudo zpool create meinNestedRAIDZ raidz /dev/disk/by-id/DISK1 /dev/disk/by-id/DISK2 /dev/disk/by-id/DISK3 /dev/disk/by-id/DISK4
    sudo zpool add example raidz /dev/DISK5 /dev/DISK6 /dev/DISK7 /dev/DISK8

pools auflisten

zpool list

pool zerstören

sudo zpool destroy $Poolname

pool Informationen anzeigen

sudo zpool status

Pools erweitern

Datenträger komplett zuweisen machen:

  • Alte Partitionen und Dateisystemsignaturen löschen:
    wipefs /dev/DISK2
  • neue GPT-Signatur erzeugen:
    parted /dev/DISK2 mklabel gpt

neue disk hinzufügen:

  • sudo zpool add $Poolname /dev/DISK2 -f

das drunterliegende device (hier 1) erweitern:

  • parted /dev/xvdf resizepart 1 100%
  • pool erweitern auf volle Größe des drunterliegenden devices:
    zpool online -e $Poolname $disk

ZFS Pool Scrubbing

Scrubbing starten (Fortschritt beobachten mit -v):

zpool scrub $Poolname

Diskaustausch

Wenn der scrub Fehler gezeigt hat (zpool status)

zpool detach mypool /dev/BADDISK
zpool attach mypool /dev/GOODDISK /dev/BADDISK  -f

pool umbenennen

…das geht über export/import:

zpool export AlterNAME
zpool import AlterNAME NeuerName

pools importieren

Scan nach pools: zpool import

import eines pools (-f ist nötig wenn der pool vorher an einem anderen Systemen angemeldet war): zpool import $NAME -f

ZFS Intent Logs

ZFS Intent Logs

sudo zpool add meinPool log /dev/DISK1 -f

ZFS Cache Drives

ZFS Cache Drives bieten eine extra caching-Schicht zwischen Arbeitsspeicher und Speichergerät, vor allem für zufällige Lesezugriffe vorrangig statischer Daten.

sudo zpool add meinPool cache /dev/DISK1 -f

ZFS trim

  • Automatisches Trim für $pool aktivieren (ZoL 0.8.x nötig):
    sudo zpool set autotrim=on $pool
  • manuelles trim:
    zpool trim$pool

Jeder Pool kann 2^64 ZFS-Dateisysteme enthalten.

erzeugen

Hinweis: Die Größe wird über Quota festgelegt, ohne Angabe wird die Kapazität des pool ausgeschöpft.

Dateisystem anlegen:

zfs create -o acltype=posixacl -o compression=on -o dnodesize=auto -o normalization=formD -o relatime=on -o mountpoint=/media/FS1 meinPool/FS1

Erklärungen:

  • ashift=12: Berücksichtigung der physikalisch benutzten 4k Blöcke
  • acltype=posixacl POSIX ACLs global aktivieren (wichtig wenn damit / oder ein Ort genutzt wird der von systemd beschrieben wird)
  • xattr=sa verbessert performance erweiterter Attribute (Linux-only)
  • normalization=formD UTF-8 Dateinamens-Normalisierung (impliziert utf8only=on was gültige UTF-8 Dateinamen erzwingt)

Verschlüsselung

Dateisystem (verschlüsselt) anlegen (ZoL Version 0.8.x erforderlich) - zusätzliche Parameter:

zfs create -o compression=on -o encryption=aes-256-ccm -o keyformat=passphrase -o mountpoint=/media/FS1 meinPool/FS1
  • encryption is standardmäßig „aes-128-ccm“, möglich sind die CCM-Modi aes-128-ccm, aes-192-ccm, aes-256-ccm und die GCM-modi „aes-128-gcm, aes-192-gcm, aes-256-gcm“. :!: Der GCM-Modus ist normalerweise schneller als ccm, aber bei neueren Kerneln (4.14.120, 4.19.38, and 5.0) ist wegen den fehlenden SIMD-Instruktionen der GCM-Modus deutlich langsamer (50%?)
  • keylocation=prompt ist standard

datastore öffnen:

zfs load-key meinPool/FS1

datastore schließen:

zfs unload-key meinPool/FS1

Informationen anzeigen:

zfs get -p encryption,keystatus,keyformat,keylocation,encryptionroot

Key ändern (Zugang zum Masterschlüssel der die Daten verschlüsselt):

zfs change-key meinPool/FS1

Falls manueller import erzwungen werden soll: (canmount=off erzwingt manuellen import)

keyfiles
  • Anforderungen an die Schlüsseldatei: „Raw keys and hex keys must be 32 bytes long (regardless of the chosen encryption suite) and must be randomly generated“:
  • Datei anlegen:
    dd if=/dev/urandom of=/root/zfs_key bs=32 count=1
  • keylocation angeben
    -o keyformat=raw -o keylocation=file:///root/zfs_key $poolname
  • keylocation via GET-request von einem Server holen:
    -o keysource=raw,https://keys.example.com/mykey $poolname

Weitere Informationen:

mounten

  • Bei der Erstellung werden ZFS-Dateisysteme automatisch eingehangen.
  • Die Eigenschaften übergeordneter Dateisystem werden vererbt.
  • Standardmäßig wird nur in leere Verzeichnisse gemounted, der Parameter -O ändert das

Automatische Einhängepunkte:

  • zfs list die aktuellen mountpoint auf
  • abfragen geht auch:
    zfs get mountpoint meinPool/FS1
  • Einhängepunkte setzen:
    zfs set mountpoint=/media/meinPool_FS1 meinPool/FS1
  • Property mounted:
    zfs get mounted meinPool/FS1

Auf Anforderung:

  • wenn die Eigenschaft canmount auf off steht, ist die Eigeschaft mountpoint leer (und zfs mount bzw. zfs mount -a funktionieren nicht).
  • bei canmount auf noauto können diese nur explizit eingehangen werden

Legacy-Einhängepunkte

zfs set mountpoint=legacy meinPool/FS1
  • ZFS-Dateisysteme können nur mit Legacy-Dienstprogrammen verwaltet werden (indem Sie die Eigenschaft „mountpoint“ auf „legacy“ setzen)
  • dann sind die Befehle mount und umount sowie die Datei /etc/vfstab relevant.
  • ZFS hängt Legacy-Dateisysteme beim Systemstart nicht automatisch ein, die ZFS-Befehle zfs mount und zfs umount funktionieren nicht!
ZFS-Property mount Option
atime atime/noatime
devices devices/nodevices
exec exec/noexec
nbmand nbmand/nonbmand
readonly ro/rw
setuid setuid/nosetuid
xattr xattr/noaxttr

Die mount Option nosuid ist ein Alias für nodevices,nosetuid.

löschen

sudo zfs destroy meinPool/FS1

Eigenschaften festlegen

  • Reservierung (minimal reserviert):
    zfs set reservation=800G meinPool/FS1
  • Quota (Maximalverbrauch):
    sudo zfs set quota=10G meinPool/FS1
  • Kompression2):
    compression=on
    compression=lz4

Deduplication

:!: Deduplication kostet Arbeitsspeicher und hat Auzswirkungen auf die Leistung, siehe ZFS auf Linux/ Deduplizierung und ZFS: To Dedupe or not to Dedupe....

  • abfragen der property „dedup“: zfs get dedup $Pool
  • setzen: zfs set dedup=on $Pool

ZFS Snapshots

  • Snapshot erstellen ( meinPool/FS1 Name des snapshots „snapshot1“):
    zfs snapshot -r meinPool/FS1@snapshot1
  • Snapshots auflisten:
    • …alle:
      zfs list -t snapshot
    • Standardmäßig mit auflisten:
      zpool set listsnapshots=on rpool
    • …geordnet nach Name und Erstellungszeit:
      zfs list -t snapshot -o name,creation -s creation
    • …nur für FS1 (ebenfalls geordnet nach Name und Erstellungszeit):
      zfs list -t snapshot -o name,creation -s creation | grep FS1
  • rollback des Dateisystems „meinPool/FS1“ auf den Snapshot „snapshot1“ (-r ist nötig wenn neuere snapshots/bookmarks existieren):
    zfs rollback -r meinPool/FS1@snapshot1
  • Snapshot löschen:
    zfs destroy meinPool/FS1@snapshot1
  • Snapshots mounten (read-only):
    • im normalen mountverzeichnis gibt es den unsichtbaren Ordner .zfs. Auch wenn dieser Ordner auch mit ls -la nicht sichtbar ist, so kann dennoch hinein gewechselt werden. Dieses Verhalten ist praktisch damit tools wie rsync nicht versehentlich snapshots mitkopieren. Falls es notwendig sein sollte den .zfs-Ordner immer mit anzuzeigen, kann dies über die folgende property aktiviert werden:
      zfs set snapdir=visible meinPool/FS1
    • legacy mount:
      mount -t zfs meinPool/FS1@snapshot1 /media/snapshot
  • Snapshot diff: Unterschiede zwischen den Snapshots anzeigen: zfs diff meinPool/FS1@snapshot1 meinPool/FS1@snapshot2
  • inkrementelle Snapshots (nur Änderungen zwischen Snapshots werden übertragen), Beispiel (Quellhost mit meinPool und Snapshots snap1,2,… sollen übertragen werden zum entfernten Rechner mit SSH-Login root$Zielhost mit Pool meinBACKUPPool):
    • initial übertragen:
      zfs send meinPool/FS1@snap1 | ssh root@$Zielhost zfs recv meinBACKUPPool/FS1
    • Datei mit 1G erstellen:
      dd if=/dev/zero bs=1024000 count=1024 >> /meinPool/FS1/test2
    • Snapshot anlegen:
      zfs snapshot -r meinPool/FS1@snap2
    • Snapshot inkrementell senden (lt. ifconfig werden 1G übertragen):
      zfs send -i meinPool/FS1@snap1 meinPool/FS1@snap2 | ssh root$Zielhost zfs recv meinBACKUPPool/FS1

      siehe auch: Sending and Receiving ZFS Data How to do incremental snapshot backups with ZFS

Vorteile inkrementeller Snapshot gegenüber rsync

  • kein CPU (I/O) overhead weil beide Datenbestände nicht verglichen werden müssen
  • unabhängig vom Dateisystem weil auf Blockebene
  • Daten sind konsistent, wenn rsync ohne snapshot läuft, können Dateien während der Übertragung verändert oder gelöscht worden sein.
Snapshot Belegungsberechnung
NAME                  AVAIL USED   USEDSNAP  USEDDS  USEDREFRESERV  USEDCHILD                                                                                                                                                                                                     
meinPool              550G  27,2G        0B     24K             0B      27,2G                                                                                                                                                                                                     
meinPool/FS1          253G  27,1G     3,46G   23,7G             0B         0B                                                                                                                                                                                                     
meinPool/FS1@snap1       -   153K         -       -              -          -                                                                                                                                                                                                     
meinPool/FS1@snap2       -   150K         -       -              -          -
Spalte Bedeutung
NAME Name des Elements
AVAIL freier Speicherplatz
USED Speicherplatz belegt
USEDSNAP Speicherplatz belegt vom Snapshot
USEDDS Speicherplatz belegt vom dataset selbst
USEDREFRESERV belegt von einer ref-reservation
USEDCHILD belegt von einem „children“ des data sets

Links:

ZFS Clones

Ein ZFS clone ist eine schreibbare Kopie eines Snapshots. Der Snapshot kann so lange nicht gelöscht werden wie der Clone besteht.

zfs snapshot -r meinPool/FS1@snapshot1
zfs clone meinPool/FS1@snapshot1 meinPool/FS2

ZFS Send and Receive

  • Senden:
    zfs send meinPool/FS1 > /backup-snap.zfs
  • Empfangen:
    zfs receive -F meinPool/FS1-Kopie < /backup-snap.zfs

Um über Netzwerk zu senden muss die Ausgabe per pipe an ein entferntes System senden:

  • Senden:
    sudo zfs send meinPool/FS1@snap1 | ssh $remoteServer zfs recv remotePool/remoteFS1

verschlüsselt Senden: hier muss lt. techgoat wohl -w, –raw angegeben werden damit die Daten exakt so wie in der Quelle verschickt werden (Schlüssel muss nicht geladen werden, testen: funktioniert das entschlüsseln obwohl ?)

ZFS Ditto Blocks

zfs set copies=3 meinPool/FS1

Statt Dateisystemen kann ZFS auch volumes anlegen, das sind Blockgeräte die z.B. in virtualisierten Gästen verwendet werden können.

Aufruf ist wie beim Dateisystem anlegen, nur zusätzlich mit dem Parameter „-V $Größe“:

zfs create -V 2G tank/volumes/v2

Das Volume steht dann unter /dev/tank/volumes/v2 zur Verfügung und kann normal wie blockdevice verwendet werden.

ZED - ZFS Event Daemon

  • Config: /etc/zfs/zed.d/zed.rc
  • zpool events

Beispielskript: inkrementelle Snapshots über Netzwerk

#!/bin/sh
 
# Transfers zfs snapshots to a remote system
# add -v to zfs send if you want transfer-information
 
# set -x
 
# put SSH-user in ssh-config
snapshot_name="backup-latest"
source_reference_snapshot="backup-baseline"
source_server="server1"
source_fs="tank/pool1"
dest_server="backupserver"
dest_fs="tank_backup/pool1_backup"
 
# if you want to run preparations (only once needed!) -> set to "yes" (no backup is made)
first_run=no
 
# usually nothing needs to be changed after this point
source_reference_dataset="$source_fs@$source_reference_snapshot"
source_dataset="$source_fs@$snapshot_name"
dest_dataset="$dest_fs@$snapshot_name"
 
 
# === preparations START ===
if [ first_run == "yes" ]
then
  # create pool (need to edit level and disks here):
  # ssh $dest_server "zpool create $pool_name mirror|raidz|whatever /dev/DISK1 /dev/DISK2"
 
  # and a fs as target:
  ssh $dest_server "zfs create -o acltype=posixacl -o compression=on -o dnodesize=auto -o normalization=formD -o relatime=on $source_fs"
 
  #  the reference-snapshot needs to be created:
  ssh $source_server "zfs snapshot -r $source_reference_dataset"
  # and on the target system, there needs to be a pool...
  exit
fi
# === preparations END ===
 
 
# destroy old snapshots
ssh $source_server "zfs destroy $source_dataset"
ssh $dest_server "zfs destroy $dest_dataset"
 
# make new snapshot
ssh $source_server "zfs snapshot -r $source_dataset"
 
# SSH (encrypted)
# using the agent here (-A), since i need to login on remote host. not needed if source-Host has a access to backup-system via pubkey.
ssh -A $source_server "zfs send -i $source_reference_dataset $source_dataset | ssh $dest_server zfs recv -F $dest_dataset"
 
# netcat (unencrypted, might be faster on slow machines)
#ssh dest_server "nc -w 300 -l -p 2020 | zfs recv -F $dest_dataset" &
#ssh root@source_server  "zfs send -i $source_reference_dataset $source_dataset | nc -w 20 $dest_server 2020"

1)
Momentaufnahmen von Dateisystem
2)
die effektive Kompressionsrate gibt der folgende Befehl aus:
zfs get compressratio [$Pool/$FS]
je höher der Wert über 1.00x liegt desto besser die Kompression