Abraxas

TrueNAS bietet zwar von sich aus eine Backup-Lösung an, allerdings geht die Initiierung des Backups immer vom Server mit den Daten aus, der dann zum Backup-Server repliziert. Aus Sicherheitsaspekten ist dies nicht optimal, denn wenn der Datenserver kompromittiert ist, besteht auch die Gefahr, dass der Backup-Server oder die Backups verändert werden. Aus diesem Grund habe ich mich dazu entschlossen, selbst eine Backup-Lösung mit zrep zu implementieren. Diese sieht folgendermaßen aus:

1. Der Backup-Server greift über ssh auf den Datenserver zu. Dabei wird ein Benutzer verwendet, der nur eingeschränkte Rechte auf dem Daten- und Backupserver hat
2. Der Backup-Server legt mit zrep einen Snapshot auf den zu sichernden ZFS Pools des Datenservers an und kopiert diese dann auf den ZFS Pool auf dem Backup-Server
3. Der Backup-Server löscht in regelmäßigen Abständen nicht mehr benötigte Snapshots auf dem Backup-Server
4. Der Daten-Server löscht in regelmäßigen Abständen nicht mehr benötigte Snapshots auf dem Daten-Server

In TrueNAS wird im GUI unter Storage/Pools zunächst ein Dataset für den Benutzer zsbackup (s für send) angelegt (hier: /mnt/data0/zsbackup) und dann der Benutzer:

Über die Shell geben wir dem Benutzer nun die erforderlichen Rechte, laden das zrep Skript herunter und machen es ausführbar

zfs allow -u zsbackup send,hold,snapshot,userprop data0
cd /mnt/data0/zsbackup
wget https://github.com/bolthole/zrep/raw/master/zrep
chmod +x zrep

Auf dem Backup-Server machen wir das analog:

und führen auch hier die folgenden Befehle aus:

zfs allow -u zrbackup create,mount,receive,userprop remote_backup
cd /mnt/remote_backup/zrbackup
wget https://github.com/bolthole/zrep/raw/master/zrep
chmod +x zrep

SSH-Keys erzeugen

Im nächsten Schritt müssen wir dafür sorgen, dass zrbackup sich auf dem Datenserver als zsbackup mittels ssh einloggen kann. Dazu erzeugen wir auf dem Backup-Server den ssh-key:

su zrbackup
ssh-keygen -t rsa -b 4096

Wichtig hier ist, dass alles mit Enter bestätigt wird und kein Passwort vergeben wird. Dann legen wir auf dem Datenserver das .ssh-Verzeichnis an und ergänzen den öffentlichen Key in der Datei authorized_keys hinterlegen

su zsbackup
mkdir /mnt/data0/zsbackup/.ssh
vi /mnt/data0/zsbackup/.ssh/authorized_keys

Statt mit dem Editor zu arbeiten kann man vom Backup-Server mittels root-login auch den Schlüssel wie folgt hinterlegen:

<.ssh/id_rsa.pub ssh root@dataserver 'cat >> /mnt/data0/zsbackup/.ssh/authorized_keys'

Dann sollte man vom Backup-Server den Login testen mittels

ssh zsbackup@dataserver

Erstes Backup manuell erzeugen

Wenn man noch keinen Backup-Pool hat, sondern komplett neu anfängt, kann man sich an die zrep-Anleitung halten und von Grund auf einen Backup-Pool erzeugen. Da ich jedoch bereits einen Pool mit Backup-Snapshots habe, bin ich wie folgt vorgegangen, um diesen Pool auch mit zrep zu nutzen.

Im ersten Schritt wird ein Snapshot in der zrep-Nomenklatur erzeugt und dann die entsprechende zrep-Konfiguration hinterlegt.

zsbackup@dataserver$ zfs snap data0/pool1@zrep_000001
zsbackup@dataserver$ ./zrep changeconfig -f data0/pool1 backupserver remote_backup/pool1

Anschließend kann man mit folgenden Befehlen manuell über zfs send/receive diesen Snapshot auf den backupserver übertragen und zwar vom Backupserver aus (last_synced_snapshot durch den Snapshot ersetzen, der auf beiden Systemen vorhanden ist).

zrbackup@backupserver$ ssh -p 22 -l zsbackup dataserver zfs send -I data0/pool1@last_synced_snapshot data0/pool1@zrep_000001 | zfs recv -F remote_backup/pool1

Nun kann man auch auf dem Backup-Server auch die zrep-Konfiguration ergänzen

zrbackup@backupserver$ ./zrep changeconfig -f -d remote_backup/pool1 dataserver data0/pool1

Jetzt noch auf dem Datenserver das „master“ flag setzen und zrep mitteilen, dass der letzte Sync schon erfolgt ist mittels

zsbackup@dataserver$ ./zrep sentsync -L data0/pool1@zrep_000001

Überprüfen lassen sich die im zfs pool als properties hinterlegten Konfigurationen mittels

zsbackup@dataserver$ ./zrep list -v data0/pool1
zrbackup@backupserver$ ./zrep list -v remote_backup/pool1

Backup mit zrep testen

Folgender Befehl auf dem Backup-Server sollte nun erfolgreich ausgeführt werden können

zrbackup@backupserver$ env SSH="ssh -p 22 -l zsbackup" ZREP_SKIP_EXPIRE=1 ZREP_PATH="/mnt/data0/zsbackup/zrep" /mnt/remote_backup/zsbackup/zrep refresh remote_backup/pool1

Übrigens habe ich in allen Befehlen explizit den Port 22 angegeben. Das wäre nicht notwendig, aber wenn man SSH nicht auf dem Standardport laufen lässt, kann man 22 einfach ändern in den passenden Port.

Cronjobs anlegen

Nun können wir einen Cronjob anlegen – entweder direkt mit dem Befehl zum Testen oder aber über ein eigenes Skript, das den obigen Befehl enthält und z.B. so aussehen kann

#!/bin/bash
# Skript to pull backups of different datasets from dataserver
env SSH="ssh -p 22 -l zsbackup" ZREP_PATH="/mnt/data0/zsbackup/zrep" ZREP_SKIP_EXPIRE=1 /mnt/remote_backup/zrbackup/zrep refresh remote_backup/pool1
env SSH="ssh -p 22 -l zsbackup" ZREP_PATH="/mnt/data0/zsbackup/zrep" ZREP_SKIP_EXPIRE=1 /mnt/remote_backup/zrbackup/zrep refresh remote_backup/pool2
env SSH="ssh -p 22 -l zsbackup" ZREP_PATH="/mnt/data0/zsbackup/zrep" ZREP_SKIP_EXPIRE=1 /mnt/remote_backup/zrbackup/zrep refresh remote_backup/pool3

Im TrueNAS GUI auf dem Backup-Server legen wir dann den Cronjob an:

Cronjobs, um alte Snapshots zu löschen

Die Berechtigung zum Löschen von Snapshots haben sowohl der zrbackup als auch der zsbackup user nicht auf den Servern, denn leider könnten diese mit der entsprechenden Berechtigung destroy sogar das komplette dataset löschen. Aus diesem Grund werden alte zrep Snapshots über einen separaten Cronjob gelöscht, der root-Rechte besitzt und dessen Befehl auf dem Backup-Server wie folgt aussieht:

/mnt/remote_backup/zrbackup/zrep expire -L remote_backup/pool1

Auch auf dem Datenserver legen wir auch einen entsprechenden Cronjob an

/mnt/remote_backup/zsbackup/zrep expire -L data0/pool1

Ein interessantes und noch flexibleres Tool für diese Aufgabe ist zrep-expire. Inspiriert zu diesem Vorgehen hat mich auch der Blog-Post Improving Replication Security With OpenZFS Delegation

Podcasts sind eine tolle Sache und ich höre sie wahnsinnig gerne beim Autofahren. Um die Zeit noch effektiver zu nutzen, möchte ich manche Audiodateien bei erhöhter Geschwindigkeit hören. Das unterstüzten mittlerweile viele Podcast-Spieler auf dem Handy von Hause aus – nur leider nicht das Entertainment-System von meinem Auto. Und genau deshalb habe ich einen Weg gesucht, um die Podcast-Dateien schnell und komfortabel unter Linux im Batchmodus umzuwandeln, so dass sie mit einer höheren Geschwindigkeit vom USB-Stick abgespielt werden.

Dazu benötigt man unter Ubuntu nur ein Paket: ffmpeg. Wenn man eine etwas bessere Qualität haben möchte, kann man alternativ eine Kombination aus verschiedenen Programmen einsetzen. Dazu benötigt man dann die Pakete: sox, libsox-fmt-mp3, python-mutagen sowie das Programm mid3cp. Letzteres bekommt man unter ubuntu, wenn man diese Datei in github in /usr/bin schiebt und ausführbar macht.

Wenn man diese Voraussetzungen geschaffen hat, kann man mit folgendem Skript sehr komfortabel alle Audio-Dateien in einem Verzeichnis komplett umwandeln.

#!/usr/bin/env bash
# 
# Simple shell script to speed up audio files to 1.5 playing speed
# with ffmpeg
#
#==========================================================
#
#contains username separated by newline
INPUTDIR="/mnt/markus/Downloads/Sorted/Mp3Z/Podcasts/export/dk"
#Directory to link training files to
OUTPUTDIR=/mnt/output/dk
USE_FFMPEG=true
# ffmpeg binary 
FFMPEG_COMMAND=/usr/bin/ffmpeg
SOX_COMMAND=/usr/bin/sox
MID3CP_COMMAND=/usr/bin/mid3cp

echo `date` Begin Audio Conversion
find "${INPUTDIR}" -type f -regextype posix-egrep -regex '.*\.(mp3|m4a|ogg)$' -print0 | sort -z | while read -d $'\0' AUDIO
do
	echo `date` Converting File $AUDIO
	filename=$(basename -- "$AUDIO")
	extension="${filename##*.}"
	filename="${filename%.*}_speed"
	if [ ! -d "$OUTPUTDIR/$dir/" ]; then
		mkdir -p "$OUTPUTDIR/$dir/"
	fi
	if [ -f "$OUTPUTDIR/$dir$filename.$extension" ]; then
		echo `date` Skipping.. "$OUTPUTDIR/$dir$filename.$extension" exists already
	else
		if [[ "${extension,,}" != "mp3" ]] || [ "$USE_FFMPEG" == "true" ] ; then
			echo `date` Generating "$OUTPUTDIR/$dir$filename.$extension" with ffmpeg
			</dev/null $FFMPEG_COMMAND -i "$AUDIO" -v quiet -loglevel panic -filter:a "atempo=1.5" -vn "$OUTPUTDIR/$dir$filename.$extension"
		else
			echo `date` Generating "$OUTPUTDIR/$dir$filename.$extension" with sox
			# variant with sox to change speed and pitch
			#$SOX_COMMAND "$AUDIO" "$OUTPUTDIR/$dir$filename.$extension" speed 1.5 pitch -700
			# variant with sox to change tempo
			$SOX_COMMAND "$AUDIO" "$OUTPUTDIR/$dir$filename.$extension" tempo 1.5
			echo Copying ID3 Tag from original file
			$MID3CP_COMMAND "$AUDIO" "$OUTPUTDIR/$dir$filename.$extension"
		fi
	fi
done