Borg – Linux Backup Tool mit Deduplizierung, Komprimierung und Verschlüsselung

Borg-Backup (alias: Borg) ist ein deduplizierendes Backup-Programm, das Komprimierung und authentifizierte Verschlüsselung unterstützt. Das Hauptziel von Borg ist es, eine effiziente und sichere Möglichkeit zur Datensicherung bereitzustellen. Die beim Borg-Backup verwendete Datendeduplizierungstechnik macht es für tägliche Backups geeignet, da nur Änderungen gespeichert werden, und die authentifizierte Verschlüsselungstechnik macht es für Backups auf nicht vollständig vertrauenswürdige Ziele geeignet.

Dieser Artikel behandelt die Installation und Verwendung von Borg Backup in Ubuntu 16 und anderen Linux-Varianten.

Hauptfunktionen von Borg Backup

Platzsparende Aufbewahrung

→Deduplizierung basiert auf inhaltsdefiniertem Chunking, das verwendet wird, um die Anzahl der gespeicherten Bytes zu reduzieren. Jede Datei wird in eine Reihe von Blöcken mit variabler Länge aufgeteilt, und nur Blöcke, die noch nie zuvor gesehen wurden, werden dem Repository hinzugefügt.

→Zur Deduplizierung werden alle Chunks im selben Repository berücksichtigt, egal ob sie von verschiedenen Maschinen, aus früheren Backups, aus demselben Backup oder sogar aus derselben einzelnen Datei stammen.

→Im Vergleich zu anderen Deduplizierungsansätzen ist die in Borg verwendete Methode NICHT abhängig von

• Gleichbleibende Datei-/Verzeichnisnamen: So können Sie Dateien und Verzeichnisse verschieben, ohne die Deduplizierung zu beenden, sogar zwischen Computern, die sich ein Repository teilen.
• Vollständige Dateien oder Zeitstempel bleiben gleich: Wenn sich eine große Datei ein wenig ändert, müssen nur wenige neue Chunks gespeichert werden – dies ist ideal für VMs oder Raw Disks.
• Die absolute Position eines Datenblocks innerhalb einer Datei: Sachen können verschoben werden und werden trotzdem vom Deduplizierungsalgorithmus gefunden.

Geschwindigkeit

• Leistungskritischer Code (Chunking, Komprimierung, Verschlüsselung) ist in C/Cython . implementiert
• Lokales Caching von Dateien/Chunks-Indexdaten
• Schnelle Erkennung von unveränderten Dateien

Datenverschlüsselung

→Alle Daten können mit 256-Bit-AES-Verschlüsselung geschützt werden, Datenintegrität und Authentizität werden mit HMAC-SHA256 verifiziert. Die Daten werden clientseitig verschlüsselt.

Kompression

→Alle Daten können mit lz4 (super schnell, niedrige Komprimierung), zlib (mittlere Geschwindigkeit und Komprimierung) oder lzma (niedrige Geschwindigkeit, hohe Komprimierung) komprimiert werden.

Off-Site-Backups

→Borg kann Daten auf jedem Remote-Host speichern, auf den über SSH zugegriffen werden kann. Wenn Borg auf dem entfernten Host installiert ist, können große Leistungssteigerungen im Vergleich zur Verwendung eines Netzwerkdateisystems (sshfs, nfs, …) erzielt werden.

Backups als Dateisysteme mountbar

→Backup-Archive können als Userspace-Dateisysteme gemountet werden, um eine einfache interaktive Überprüfung und Wiederherstellung von Backups zu ermöglichen (zB mit einem regulären Dateimanager).

Einfache Installation auf mehreren Plattformen

→Wir bieten Einzeldatei-Binärdateien an, die keine Installation erfordern – Sie können sie einfach auf diesen Plattformen ausführen:

• Linux
Mac OS X
• FreeBSD
• OpenBSD und NetBSD (noch keine Unterstützung für xattrs/ACLs oder Binärdateien)
• Cygwin (nicht unterstützt, noch keine Binärdateien)
• Linux-Subsystem von Windows 10 (nicht unterstützt)

Kostenlose und Open-Source-Software

• Sicherheit und Funktionalität können unabhängig auditiert werden
• Lizenziert unter der BSD (3-Klausel) Lizenz, siehe Lizenz für die vollständige Lizenz

Borg . installieren

Um Borg Backup in Ubuntu 16 zu installieren, führen Sie den folgenden Befehl im Terminal aus.

# sudo apt-get install borgbackup borgbackup-doc

Sie können die Borg-Binärdatei auch herunterladen von github und verschieben Sie es an eine Position, auf die die Umgebungsvariable PATH zeigt.

# wget https://github.com/borgbackup/borg/releases/download/1.0.10/borg-linux64
# mv borg-linux64 /usr/local/bin/borg
# chmod u+x /usr/local/bin/borg
# chown root:root /usr/local/bin/borg

Verwendungen von Borg

Borg besteht aus einer Reihe von Befehlen. Jeder Befehl akzeptiert eine Reihe von Argumenten und Optionen. In den folgenden Abschnitten werden die einzelnen Befehle detailliert beschrieben.

borg init

Initialisieren Sie ein neues Backup-Repository und erstellen Sie ein Backup-Archiv.

# Local repository (default is to use encryption in repokey mode)
$ borg init /path/to/repo

# Local repository (no encryption)
$ borg init --encryption=none /path/to/repo

# Remote repository (accesses a remote borg via ssh)
$ borg init user@hostname:backup

# Remote repository (store the key your home dir)
$ borg init --encryption=keyfile user@hostname:backup

Verwenden Sie die Verschlüsselung, da diese Sie schützt, falls ein nicht autorisierter Benutzer Zugriff auf das Backup-Repository hat.

Borg erstellen

Dieser Befehl erstellt ein Borg-Sicherungsarchiv, das alle gefundenen Dateien enthält, während alle angegebenen Pfade rekursiv durchlaufen werden. Wenn ‘-‘ als Pfad angegeben wird, liest borg Daten aus der Standardeingabe und erstellt aus diesen Daten eine Datei ‘stdin’ im erstellten Archiv. Das Archiv verbraucht fast keinen Speicherplatz für Dateien oder Teile von Dateien, die bereits in anderen Archiven gespeichert wurden.

# Backup ~/Documents into an archive named "my-documents"
$ borg create /path/to/repo::my-documents ~/Documents

# same, but verbosely list all files as we process them
$ borg create -v --list /path/to/repo::my-documents ~/Documents

# Backup ~/Documents and ~/src but exclude pyc files
$ borg create /path/to/repo::my-files 
~/Documents                       
~/src                             
--exclude '*.pyc'

# Backup home directories excluding image thumbnails (i.e. only
# /home/*/.thumbnails is excluded, not /home/*/*/.thumbnails)
$ borg create /path/to/repo::my-files /home 
--exclude 're:^/home/[^/]+/.thumbnails/'

# Do the same using a shell-style pattern
$ borg create /path/to/repo::my-files /home 
--exclude 'sh:/home/*/.thumbnails'

# Backup the root filesystem into an archive named "root-YYYY-MM-DD"
# use zlib compression (good, but slow) - default is no compression
$ borg create -C zlib,6 /path/to/repo::root-{now:%Y-%m-%d} / --one-file-system

# Make a big effort in fine granular deduplication (big chunk management
# overhead, needs a lot of RAM and disk space, see formula in internals
# docs - same parameters as borg < 1.0 or attic):
$ borg create --chunker-params 10,23,16,4095 /path/to/repo::small /smallstuff

# Backup a raw device (must not be active/in use/mounted at that time)
$ dd if=/dev/sdx bs=10M | borg create /path/to/repo::my-sdx -

# No compression (default)
$ borg create /path/to/repo::arch ~

# Super fast, low compression
$ borg create --compression lz4 /path/to/repo::arch ~

# Less fast, higher compression (N = 0..9)
$ borg create --compression zlib,N /path/to/repo::arch ~

# Even slower, even higher compression (N = 0..9)
$ borg create --compression lzma,N /path/to/repo::arch ~

# Use short hostname, user name and current time in archive name
$ borg create /path/to/repo::{hostname}-{user}-{now} ~
# Similar, use the same datetime format as borg 1.1 will have as default
$ borg create /path/to/repo::{hostname}-{user}-{now:%Y-%m-%dT%H:%M:%S} ~
# As above, but add nanoseconds
$ borg create /path/to/repo::{hostname}-{user}-{now:%Y-%m-%dT%H:%M:%S.%f} ~

Borg-Extrakt

Dieser Befehl extrahiert den Inhalt aus einem Archiv und schreibt in das aktuelle Verzeichnis.

# Extract entire archive
$ borg extract /path/to/repo::my-files

# Extract entire archive and list files while processing
$ borg extract -v --list /path/to/repo::my-files

# Extract the "src" directory
$ borg extract /path/to/repo::my-files home/USERNAME/src

# Extract the "src" directory but exclude object files
$ borg extract /path/to/repo::my-files home/USERNAME/src --exclude '*.o'

# Restore a raw device (must not be active/in use/mounted at that time)
$ borg extract --stdout /path/to/repo::my-sdx | dd of=/dev/sdx bs=10M

borg check

Das check-Kommando überprüft die Konsistenz eines Repositorys und der entsprechenden Archive.

# check for corrupt chunks / segments:
borg check -v --repository-only REPO
# repair the repo:
borg check -v --repository-only --repair REPO
# make sure everything is fixed:
borg check -v --repository-only REPO

borg umbenennen

Dieser Befehl benennt ein Archiv im Repository um.

$ borg create /path/to/repo::archivename ~
$ borg list /path/to/repo
archivename                          Mon, 2017-03-06 19:50:19

$ borg rename /path/to/repo::archivename newname
$ borg list /path/to/repo
newname                              Mon, 2017-03-06 19:52:19

borg liste

Dieser Befehl listet den Inhalt eines Repositorys oder Archivs auf.

$ borg list /path/to/repository
$ borg list /path/to/repo::root-2017-03-06
$ borg list /path/to/repo::archiveA --list-format="{mode} {user:6} {group:6} {size:8d} {isomtime} {path}{extra}{NEWLINE}"
# see what is changed between archives, based on file modification time, size and file path
$ borg list /path/to/repo::archiveA --list-format="{mtime:%s}{TAB}{size}{TAB}{path}{LF}" |sort -n > /tmp/list.archiveA
$ borg list /path/to/repo::archiveB --list-format="{mtime:%s}{TAB}{size}{TAB}{path}{LF}" |sort -n > /tmp/list.archiveB
$ diff -y /tmp/list.archiveA /tmp/list.archiveB

borg löschen

Dieser Befehl löscht ein Archiv aus dem Repository oder das gesamte Repository. Entsprechend wird Speicherplatz freigegeben. Wenn Sie das komplette Repository löschen, wird auch der lokale Cache dafür (sofern vorhanden) gelöscht.

# delete a single backup archive:
$ borg delete /path/to/repo::Monday

# delete the whole repository and the related local cache:
$ borg delete /path/to/repo
You requested to completely DELETE the repository *including* all archives it contains:
repo                                 Mon, 2017-03-06 19:26:54
root-2017-03-06                      Mon, 2017-03-06 19:50:29
newname                              Mon, 2017-03-06 19:52:19
Type 'YES' if you understand this and want to continue: YES

borg pflaume

Der Befehl prune bereinigt ein Repository, indem er alle Archive löscht, die keiner der angegebenen Aufbewahrungsoptionen entsprechen. Dieser Befehl wird normalerweise von automatisierten Backup-Skripten verwendet, die eine bestimmte Anzahl von historischen Borg-Backups behalten möchten.

# Keep 7 end of day and 4 additional end of week archives.
# Do a dry-run without actually deleting anything.
$ borg prune -v --list --dry-run --keep-daily=7 --keep-weekly=4 /path/to/repo

# Same as above but only apply to archive names starting with the hostname
# of the machine followed by a "-" character:
$ borg prune -v --list --keep-daily=7 --keep-weekly=4 --prefix='{hostname}-' /path/to/repo

# Keep 7 end of day, 4 additional end of week archives,
# and an end of month archive for every month:
$ borg prune -v --list --keep-daily=7 --keep-weekly=4 --keep-monthly=-1 /path/to/repo

# Keep all backups in the last 10 days, 4 additional end of week archives,
# and an end of month archive for every month:
$ borg prune -v --list --keep-within=10d --keep-weekly=4 --keep-monthly=-1 /path/to/repo

borg info

Dieser Befehl zeigt einige detaillierte Informationen über das angegebene Archiv an.

$ borg info /path/to/repo::root-2017-03-06

borg reiten

Dieser Befehl mountet ein Archiv als FUSE-Dateisystem. Dies kann nützlich sein, um ein Archiv zu durchsuchen oder einzelne Dateien wiederherzustellen.

$ borg mount /path/to/repo::root-2017-03-06 /tmp/mymountpoint
$ ls /tmp/mymountpoint

borg ummount

Dieser Befehl hebt ein FUSE-Dateisystem aus, das mit borg mount gemountet wurde.

$ borg umount /tmp/mymountpoint

Borg-Schlüsselexport

Wenn die Repository-Verschlüsselung verwendet wird, ist das Repository ohne den Schlüssel nicht zugänglich. Mit diesem Befehl können Sie diesen wichtigen Schlüssel sichern.

$ borg key export /path/to/repo /path/to/export

borg schlüssel importieren

Dieser Befehl ermöglicht die Wiederherstellung eines Schlüssels, der zuvor mit dem Exportbefehl gesichert wurde.

$ borg key import /path/to/repo /path/to/import

borg passphrase ändern

Die für die Repository-Verschlüsselung verwendeten Schlüsseldateien sind optional durch eine Passphrase geschützt. Mit diesem Befehl kann diese Passphrase geändert werden.

# Create a key file protected repository
$ borg init --encryption=keyfile -v /path/to/repo
Initializing repository at "/path/to/repo"
Enter new passphrase:
Enter same passphrase again:
Remember your passphrase. Your data will be inaccessible without it.
Key in "/root/.config/borg/keys/mnt_backup" created.
Keep this key safe. Your data will be inaccessible without it.
Synchronizing chunks cache...
Archives: 0, w/ cached Idx: 0, w/ outdated Idx: 0, w/o cached Idx: 0.
Done.

# Change key file passphrase
$ borg change-passphrase -v /path/to/repo
Enter passphrase for key /root/.config/borg/keys/mnt_backup:
Enter new passphrase:
Enter same passphrase again:
Remember your passphrase. Your data will be inaccessible without it.
Key updated

borg dienen

Dieser Befehl startet einen Repository-Serverprozess. Dieser Befehl wird normalerweise nicht manuell verwendet.

# Allow an SSH keypair to only run borg, and only have access to /path/to/repo.
# Use key options to disable unneeded and potentially dangerous SSH functionality.
# This will help to secure an automated remote backup system.
$ cat ~/.ssh/authorized_keys
command="borg serve --restrict-to-path /path/to/repo",no-pty,no-agent-forwarding,no-port-forwarding,no-X11-forwarding,no-user-rc ssh-rsa AAAAB3[...]

Borg-Upgrade

Aktualisieren Sie ein vorhandenes Borg-Backup-Repository.

$ borg upgrade --tam REPO

borg brechen schloss

Dieser Befehl hebt die Repository- und Cache-Sperren auf. Bitte verwenden Sie es vorsichtig und nur solange kein Borg-Prozess (auf keinem Computer) versucht, auf den Cache oder das Repository zuzugreifen.

$ borg break-lock /path/to/repo

Fazit

Borg ist in Python geschrieben und hat viele Vorteile gegenüber anderen klassischen Backup-Lösungen. Die Datendeduplizierung und Verschlüsselung sind die beiden Funktionen. Die meisten Linux-Distributionen haben es bereits in ihrem offiziellen Repository. Die Konfiguration auf dem Backup-Server ist einfach, da sich die Clients per SSH mit dem Server verbinden. Vielleicht möchten Sie also nur einen einzelnen Borg-Benutzer einrichten und die Clients ein wenig einschränken.