-=Kernel-Error=-

IT-Blog von Sebastian van de Meer

Schlagwort: Snapshot

FreeBSD Jail Upgrade: Wenn freebsd-update die Version nicht erkennt

26. Juli 2018 / / Keine Kommentare

FreeBSD-Jails lassen sich mit freebsd-update genauso upgraden wie das Host-System. Der Parameter -b gibt den Pfad zur Jail an:

# Normales Jail-Upgrade
freebsd-update -r 14.2-RELEASE upgrade -b /zroot/jails/myjail
freebsd-update install -b /zroot/jails/myjail
service jail restart myjail
freebsd-update install -b /zroot/jails/myjail
# Pakete aktualisieren
jexec myjail pkg upgrade
freebsd-update install -b /zroot/jails/myjail

Das Problem: Falsche Versionserkennung

Manchmal ist freebsd-update davon überzeugt, dass die Jail bereits auf der Zielversion läuft, obwohl sie es nicht ist. Prüft man manuell, steht da noch die alte Version:

jexec myjail freebsd-version
13.2-RELEASE-p9

Das passiert typischerweise wenn die Jail schon Patches bekommen hat oder wenn der Host auf einer anderen Version läuft als die Jail. freebsd-update liest die Version aus Dateien im Jail-Dateisystem und kommt durcheinander.

Die Lösung: –currently-running

Mit --currently-running gibt man freebsd-update die aktuelle Version explizit vor:

freebsd-update -b /zroot/jails/myjail --currently-running 13.2-RELEASE-p9 -r 14.2-RELEASE upgrade

Danach läuft das Upgrade normal durch. Die Version, die man bei --currently-running angibt, muss exakt der Ausgabe von freebsd-version in der Jail entsprechen, inklusive Patchlevel.

Tipp: Vor dem Upgrade einen ZFS-Snapshot der Jail anlegen. Falls etwas schiefgeht, ist ein Rollback in Sekunden erledigt.

Fragen? Einfach melden.

bhyve und vm-bhyve: Windows-VM auf FreeBSD einrichten

20. Juni 2018 / / Keine Kommentare

FreeBSD bringt seit Version 10.0 einen eigenen Typ-2-Hypervisor mit: bhyve. Für den täglichen Umgang empfiehlt sich vm-bhyve als Verwaltungstool — damit lässt sich eine Windows-VM in wenigen Minuten einrichten, ohne sich mit den bhyve-Basistools herumschlagen zu müssen.

vm-bhyve installieren und einrichten

# Installation
pkg install vm-bhyve grub2-bhyve uefi-edk2-bhyve

# ZFS-Dataset für VMs anlegen
zfs create pool/vm

# Autostart aktivieren
sysrc vm_enable="YES"
sysrc vm_dir="zfs:pool/vm"

# Initialisieren und Templates kopieren
vm init
cp /usr/local/share/examples/vm-bhyve/* /pool/vm/.templates/

# Netzwerk-Switch erstellen und physisches Interface anhängen
vm switch create public
vm switch add public em0

Windows-VM erstellen

ISO-Dateien importieren — die Windows-ISO und die virtio-Treiber für die Netzwerkkarte:

# Windows-ISO importieren
vm iso /home/kernel/Download/win10.iso

# virtio-net Treiber (für die Netzwerkkarte in der VM)
fetch https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso
vm iso /home/kernel/Download/virtio-win.iso

VM aus dem mitgelieferten Windows-Template erstellen:

vm create -t windows -s 200G win10

VM-Konfiguration anpassen

Das Windows-Template kommt mit 2 CPUs und 2 GB RAM. Für eine brauchbare Windows-VM besser anpassen:

vm configure win10
uefi="yes"
cpu=4
memory=8G
graphics="yes"
graphics_port="5999"
graphics_listen="127.0.0.1"
graphics_res="1280x1024"
graphics_wait="auto"
xhci_mouse="yes"
network0_type="virtio-net"
network0_switch="public"
disk0_type="ahci-hd"
disk0_name="disk0.img"

Die wichtigsten Optionen: graphics="yes" aktiviert einen VNC-Server für die Grafikausgabe, xhci_mouse="yes" sorgt für eine brauchbare Maus in der VM, network0_type="virtio-net" nutzt den schnelleren paravirtualisierten Netzwerktreiber statt einer emulierten Karte.

Installation und Zugriff

# VM starten und ISO einlegen
vm install win10 win10.iso

Dann mit einem VNC-Viewer auf 127.0.0.1:5999 verbinden und Windows installieren. Nach der Installation die virtio-Treiber-ISO einlegen (vm install win10 virtio-win.iso) und Windows die Netzwerktreiber dort suchen lassen.

Für den täglichen Zugriff RDP in der VM aktivieren — dann braucht man den VNC-Viewer nur noch für die Ersteinrichtung.

VM verwalten

# Laufende VMs anzeigen
vm list
NAME   DATASTORE  LOADER  CPU  MEMORY  VNC  AUTOSTART  STATE
win10  default    uefi    4    8G      -    No         Running (10638)

# VM stoppen / starten
vm stop win10
vm start win10

# Snapshot erstellen (ZFS-Snapshot der VM-Disk)
vm snapshot win10

Details und weitere Optionen im vm-bhyve Wiki. Fragen? Einfach melden.

FreeBSD: Automatische ZFS-Snapshots mit zfs-auto-snapshot

19. Mai 2016 / / Keine Kommentare

Automatische Snapshots einrichten

Auf FreeBSD gibt es mehrere Wege, ZFS-Snapshots zu automatisieren. Ein bewährtes Tool ist zfs-auto-snapshot aus den Ports (sysutils/zfstools). Es orientiert sich an der Snapshot-Automatisierung von Solaris/OpenSolaris und kann auch konsistente Snapshots einer MySQL- oder PostgreSQL-Datenbank erstellen.

Hinweis: Seit FreeBSD 13 gibt es mit periodic(8) und dem ZFS-Periodic-Script eine eingebaute Alternative, die ohne zusätzliche Pakete auskommt. Für ältere Systeme oder mehr Kontrolle über die Retention bleibt zfstools eine gute Wahl.

Installation:

pkg install zfstools

Danach die Cronjobs in /etc/crontab eintragen:

# ZFS snapshots
15,30,45 * * * * root /usr/local/sbin/zfs-auto-snapshot frequent  4
0        * * * * root /usr/local/sbin/zfs-auto-snapshot hourly   24
7        0 * * * root /usr/local/sbin/zfs-auto-snapshot daily     7
14       0 * * 7 root /usr/local/sbin/zfs-auto-snapshot weekly    4
28       0 1 * * root /usr/local/sbin/zfs-auto-snapshot monthly  12

Falls zfs im Cronjob nicht gefunden wird, die PATH-Variable in der Crontab erweitern:

PATH=/etc:/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin

Jetzt noch die Snapshots für das gewünschte Dataset aktivieren:

zfs set com.sun:auto-snapshot=true zroot/usr/home

Retention-Schema

Mit der Crontab oben werden folgende Snapshots vorgehalten:

  • Alle 15 Minuten — 4 Snapshots vorgehalten
  • Stündlich — 24 Snapshots vorgehalten
  • Täglich — 7 Snapshots vorgehalten
  • Wöchentlich — 4 Snapshots vorgehalten
  • Monatlich — 12 Snapshots vorgehalten

Snapshots prüfen

zfs list -r -H -t snapshot zroot/usr/home
zroot/usr/home@zfs-auto-snap_hourly-2016-05-19-11h00     21,5M  -  82,5G  -
zroot/usr/home@zfs-auto-snap_frequent-2016-05-19-11h30   14,6M  -  82,6G  -
zroot/usr/home@zfs-auto-snap_frequent-2016-05-19-11h45   13,3M  -  82,6G  -
zroot/usr/home@zfs-auto-snap_hourly-2016-05-19-12h00     14,0M  -  82,7G  -

Datenbank-Snapshots

Für konsistente Datenbank-Snapshots muss das Property auf dem Datenbank-Dataset speziell gesetzt werden — zfs-auto-snapshot friert die Datenbank dann vor dem Snapshot kurz ein:

# PostgreSQL
zfs set com.sun:auto-snapshot=postgresql zroot/data/postgres

# MySQL/MariaDB
zfs set com.sun:auto-snapshot=mysql zroot/data/mysql

Wichtig: Snapshots auf demselben System sind kein Backup-Ersatz. Geht die Platte kaputt, sind die Snapshots mit weg. Für eine echte Sicherung die Snapshots per zfs send/recv auf ein zweites System replizieren.

Mehr zu ZFS: ZFS Compression und Deduplication. Details zu allen Snapshot-Optionen in der OpenZFS-Dokumentation. Fragen? Einfach melden.

FreeBSD: ZFS-Datensicherung mit Snapshots und zfs send/recv

5. November 2014 / / Keine Kommentare

ZFS bringt alles mit, was man für eine solide Datensicherung braucht: Snapshots sind atomar und sofort erstellt, und mit zfs send lassen sie sich über SSH auf ein anderes System replizieren. Nach einem initialen Vollabgleich werden nur noch die Differenzen übertragen.

Der Ablauf:

  • Snapshot auf dem Quellsystem anlegen
  • Ziel-Dataset auf dem Backup-Server erstellen
  • Snapshot per SSH ins Ziel schieben (Vollabgleich)
  • Weitere Snapshots anlegen und nur die Differenz übertragen

Snapshot erstellen

Auf dem Quellsystem — hier ein FreeBSD-Notebook — einen rekursiven Snapshot anlegen:

zfs snapshot -r tank/usr/home/kernel@2014-10-12

Prüfen:

zfs list -t snapshot tank/usr/home/kernel
NAME                                    USED  AVAIL  REFER  MOUNTPOINT
tank/usr/home/kernel@2014-10-12        20,0M      -  96,9G  -

Initialer Vollabgleich

Auf dem Backup-Server ein Ziel-Dataset anlegen:

zfs create DatenPool01/Datensicherung/errorlap

Den Snapshot per SSH ins Ziel schieben — -R sendet rekursiv alle Datasets und Properties mit:

zfs send -R tank/usr/home/kernel@2014-10-12 \
  | ssh root@backup-server zfs recv -Fduv DatenPool01/Datensicherung/errorlap

receiving full stream of tank/usr/home/kernel@2014-10-12 into
DatenPool01/Datensicherung/errorlap/usr/home/kernel@2014-10-12
received 98.4GB stream in 5298 seconds (19.0MB/sec)

Inkrementelle Sicherung

Neuen Snapshot anlegen und nur die Differenz zum vorherigen übertragen:

zfs snapshot -r tank/usr/home/kernel@2014-10-12-02

zfs send -R -i tank/usr/home/kernel@2014-10-12 tank/usr/home/kernel@2014-10-12-02 \
  | ssh root@backup-server zfs recv -Fduv DatenPool01/Datensicherung/errorlap

receiving incremental stream of tank/usr/home/kernel@2014-10-12-02 into
DatenPool01/Datensicherung/errorlap/usr/home/kernel@2014-10-12-02
received 991MB stream in 59 seconds (16.8MB/sec)

991 MB statt 98 GB — das ist der Vorteil inkrementeller Snapshots.

Automatisierung

Dieser Ablauf lässt sich per Skript und Cronjob vollständig automatisieren. Mit automatischen ZFS-Snapshots und SSH-Key-Authentifizierung kann man alle 15 Minuten inkrementell sichern — bei passender Internetanbindung auch standortübergreifend. Falls beim inkrementellen Transfer ein cannot receive incremental stream auftaucht, hilft der Beitrag zur Fehlerbehebung mit zfs recv -F.

Wer das Backup auf eine verschlüsselte USB-Platte statt auf einen Server schieben will, findet dort die geli-Anleitung dazu.

Fragen? Einfach melden.

ZFS Snapshots: Erstellen, Zugreifen und per SSH replizieren

22. März 2012 / / Keine Kommentare

Was sind ZFS-Snapshots?

ZFS arbeitet mit Copy-on-Write — jede Änderung wird an eine neue Stelle geschrieben, die alten Blöcke bleiben erhalten. Ein Snapshot friert diesen Stand ein: Die Blöcke werden einfach nicht mehr zum Überschreiben freigegeben. Deshalb ist ein Snapshot schneller erstellt als eine Datei gespeichert — er kostet nur so viel Platz, wie sich danach ändert.

Was man damit machen kann:

  • Einzelne Dateien aus dem Snapshot herauskopieren
  • Das gesamte Dataset auf den Snapshot-Stand zurückrollen
  • Einen beschreibbaren Clone aus dem Snapshot erstellen
  • Den Snapshot (oder nur die Differenz zum nächsten) per SSH auf ein anderes System replizieren

Snapshot erstellen und nutzen

Dataset mit Testdaten vorbereiten:

zfs create rpool/testdaten
dd if=/dev/zero of=/rpool/testdaten/image01.img bs=10240 count=10240   # 100 MB

zfs list rpool/testdaten
NAME              USED  AVAIL  REFER  MOUNTPOINT
rpool/testdaten   100M  9,02G   100M  /rpool/testdaten

Snapshot erstellen — der Name nach dem @ ist frei wählbar:

zfs snapshot rpool/testdaten@vor-aenderung

Auf den Snapshot zugreifen — das versteckte Verzeichnis .zfs taucht nicht in ls auf, ist aber direkt erreichbar:

ls /rpool/testdaten/.zfs/snapshot/
vor-aenderung

ls /rpool/testdaten/.zfs/snapshot/vor-aenderung/
image01.img

Von hier aus lassen sich versehentlich gelöschte Dateien einfach zurückkopieren. Um das gesamte Dataset auf den Snapshot-Stand zurückzurollen:

zfs rollback rpool/testdaten@vor-aenderung

Snapshot per SSH replizieren

Mit zfs send und zfs recv lässt sich ein Snapshot auf ein anderes System schieben — ein Einzeiler:

zfs send rpool/testdaten@vor-aenderung \
  | ssh root@backup-server zfs recv backup/testdaten@vor-aenderung

Danach muss nur noch die Differenz zwischen zwei Snapshots übertragen werden — bei 1 GB Änderungen auf einem 100 GB Dataset werden auch nur 1 GB übertragen. Alle ZFS-Properties (NFS-Shares, SMB-Shares, Quotas) wandern mit. Mehr dazu im Beitrag zur ZFS-Datensicherung und zur Fehlerbehebung bei zfs send/recv.

Time Slider und Boot Environments

Unter OpenIndiana/Solaris gibt es den Time Slider — ein Nautilus-Plugin, das automatisch Snapshots erstellt und eine grafische Zeitleiste bietet. Alte Snapshots werden automatisch aufgeräumt wenn die Platte voll wird.

Noch mächtiger sind Boot Environments (beadm). Vor einem Systemupdate wird automatisch ein Snapshot des Root-Pools erstellt und davon ein Clone gebootet. Geht beim Update etwas schief, bootet man einfach das alte Environment — kein Stress, kein Ausfall:

beadm list
BE                  Active Mountpoint Space  Policy Created
openindiana         NR     /          11,6G  static 2011-09-28 19:06
openindiana-1       -      -          37,3M  static 2011-10-27 20:04

# Neues Boot Environment anlegen
beadm create vor-experiment

Für automatisierte Snapshots unter FreeBSD siehe automatische ZFS-Snapshots mit zfs-auto-snapshot. Fragen? Einfach melden.

ZFS Boot Environments: Sichere Updates unter Solaris/OpenIndiana

15. Februar 2012 / / Keine Kommentare

Boot Environments (BEs) sind eine der besten Funktionen von Solaris/OpenIndiana: Vor einem Update erstellt man einen Snapshot des laufenden Systems. Geht etwas schief, bootet man einfach die alte Umgebung — kein Rollback-Stress, kein Datenverlust. Das Ganze basiert auf ZFS-Snapshots und ist mit dem Befehl beadm in Sekunden erledigt.

Boot Environments anzeigen

beadm list
BE                                     Active Mountpoint Space  Policy Created
oi_151a2-Sebastians-geht-steil-Version NR     /          14,7G  static 2012-02-14 16:18
openindiana                            -      -          26,5M  static 2011-09-28 19:06
openindiana-1                          -      -          22,6M  static 2011-10-27 20:04

N bedeutet: aktuell gebootet. R bedeutet: wird beim nächsten Reboot gestartet. NR heißt beides. Die BEs erscheinen auch im GRUB-Bootmenü.

Neue Boot Environment erstellen und aktivieren

Vor einem Update — hier ein VirtualBox-Upgrade als Beispiel:

# Neue BE anlegen (Snapshot des aktuellen Systems)
beadm create Nach-Virtualbox-Update
Created successfully

# Beim nächsten Reboot diese BE starten
beadm activate Nach-Virtualbox-Update
Activated successfully

Updates in der neuen BE installieren

Das Besondere: Man kann die neue BE mounten und dort Pakete installieren oder deinstallieren — ohne das laufende System zu berühren. Der Ausfall beschränkt sich auf den Reboot.

# Neue BE mounten
beadm mount Nach-Virtualbox-Update /mnt
Mounted successfully on: '/mnt'

# Alte Version in der neuen BE deinstallieren
pkgrm -R /mnt SUNWvbox
Removal of  was successful.

# Neue Version in der neuen BE installieren
pkgadd -R /mnt -d VirtualBox-4.1.8-SunOS-r75467.pkg
Installation of  was successful.

# BE wieder aushängen
beadm unmount Nach-Virtualbox-Update
Unmounted successfully

Nach dem Reboot startet das System in der neuen BE mit der aktualisierten Software. Funktioniert alles? Fertig. Funktioniert etwas nicht? Im GRUB die alte BE auswählen und man ist sofort zurück auf dem vorherigen Stand.

GRUB-Bootmenü mit mehreren ZFS Boot Environments unter OpenIndiana.

Aufräumen

# Alte BE löschen (wenn nicht mehr gebraucht)
beadm destroy openindiana-1
Are you sure you want to destroy openindiana-1? [y|n] y
Destroyed successfully

Alte BEs belegen nur so viel Platz wie sich seitdem geändert hat — genau wie bei ZFS-Snapshots. Trotzdem lohnt es sich, nicht mehr benötigte BEs zu löschen.

Eine Warnung

Boot Environments machen nachlässig. Man gewöhnt sich daran, dass man alles zurückrollen kann — und hört irgendwann auf, sich den vorherigen Stand zu merken oder Konfigurationsdateien vorher zu sichern. Bis man dann an einem System ohne BEs sitzt und sich fragt, warum man keine Kopie gemacht hat.

Mehr zu ZFS: ZFS Snapshots und ZFS Pool erstellen. Unter FreeBSD gibt es mit bectl ein äquivalentes Tool. Fragen? Einfach melden.

ZFS: Warum dieses Dateisystem anders ist

13. Oktober 2011 / / Keine Kommentare

ZFS ist kein normales Dateisystem — es vereint Dateisystem, Volumemanager und RAID in einem. Keine separate Partitionierung, kein mdadm, kein LVM. Ein Befehl erstellt einen Pool, ein zweiter ein Dataset. Snapshots, Compression, Verschlüsselung und Replikation sind eingebaut. Ursprünglich von Sun Microsystems für Solaris entwickelt, läuft ZFS heute als OpenZFS auf FreeBSD, Linux und macOS.

Was ZFS anders macht

Copy-on-Write: Daten werden nie überschrieben — jede Änderung wird an eine neue Stelle geschrieben. Erst wenn der neue Block vollständig ist, wird der Zeiger umgehängt. Dadurch gibt es kein Write Hole wie bei klassischem RAID und Snapshots sind praktisch kostenlos.

Checksummen und Selbstheilung: Jeder Block hat eine Checksumme, gespeichert im übergeordneten Block (Merkle Tree). Beim Lesen wird die Checksumme geprüft — bei einem Fehler repariert ZFS den Block automatisch aus der Redundanz. Silent Data Corruption wird erkannt, bevor sie Schaden anrichtet.

Integrierter Volumemanager: ZFS weiß, welche Blöcke belegt sind und welche nicht. Beim Resilvering (Neusynchronisation nach Plattenausfall) werden nur belegte Blöcke kopiert — ein 80-GB-Mirror mit 4 GB Daten ist in Minuten fertig statt Stunden.

Technische Eckdaten

Adressierung128 Bit
Max. Dateisystemgröße16 EiB (16 × 2⁶⁰ Byte)
Max. Poolgröße256 ZiB (256 × 2⁷⁰ Byte)
Max. Dateien pro Verzeichnis2⁴⁸
Max. Geräte pro Pool2⁶⁴
RAID-LevelMirror, RAID-Z (1–3 Paritäten), Striping, Spare
VolumemanagerIntegriert

ZFS im Detail — die Artikelserie

Jedes Feature ist in einem eigenen Beitrag erklärt:

Fragen? Einfach melden.

© 2026 -=Kernel-Error=- — RSS

Theme von Anders Norén — Hoch ↑