Docker: Backup und Wie­der­her­stel­lung

Docker-Daten liegen über ver­schie­de­ne Docker-Objekte und -Dateien verteilt vor. Leider existiert kein ein­heit­li­cher Ansatz zum Erstellen von Backups der einzelnen Docker-Daten. Statt­des­sen kommt eine Reihe ver­schie­de­ner Befehle in Kom­bi­na­ti­on zum Einsatz. Wir zeigen, wie das Anlegen und Wie­der­her­stel­len von Docker-Backups funk­tio­niert.

Nachdem wir uns mit der Frage „Was ist ein Backup?“ be­schäf­tigt, ver­schie­de­ne Backup-Stra­te­gien vor­ge­stellt und Anlegen von Datenbank-Backups erklärt haben, befassen wir uns nun mit der Er­stel­lung von Docker-Backups.

Anders als beim Anlegen eines MySQL-Backup mit mysqldump oder eines Post­greS­QL-Backup mit pg_dump gibt es kein de­di­zier­tes Docker-Backup-Tool. Ein „docker backup volume“- oder „docker backup container“-Kommando sucht man ver­geb­lich. Statt­des­sen exis­tie­ren ver­schie­de­ne Ansätze, die einzelnen Docker-Kom­po­nen­ten in Backups auf­zu­neh­men. Schauen wir uns zunächst an, von welchen Docker-Kom­po­nen­ten man Backups erstellen sollte.

Grund­sätz­lich gilt bei Docker wie ganz generell: Von allen Daten, die bei Verlust nicht wie­der­her­ge­stellt werden können, sollten Backups erstellt werden. Im Falle von Docker gehören dazu min­des­tens drei Arten von Daten:

1. Docker-Objekte: Diese werden vom Docker-Deamon verwaltet. Die dabei an­fal­len­den Daten werden unterhalb eines spe­zi­el­len Ver­zeich­nis­ses abgelegt. Dabei besteht keine Eins-zu-eins-Kor­re­spon­denz der dort liegenden Dateien zu den im Docker-Container vor­han­de­nen Daten. Wir legen Backups der folgenden Docker-Objekte an:
   • Docker-Container
   • Docker-Volumes
   • Docker-Image
2. Docker-Build-Dateien: Diese werden vom Nutzer verwaltet und liegen in be­lie­bi­gen Ordnern auf dem Host-System. Die Build-Dateien lassen sich un­kom­pli­ziert kopieren und ar­chi­vie­ren. Wir legen Backups der folgenden Docker-Build-Dateien an:
   • Docker-Compose-Pro­jekt­ord­ner
   • Do­cker­files
3. Da­ten­ban­ken innerhalb eines Con­tai­ners: Diese werden aus dem Container als Dump-Dateien ex­por­tiert. Wir legen Backups von Da­ten­ban­ken der folgenden Systeme an:
   • MySQL-Da­ten­ban­ken
   • Post­greS­QL-Datenbank

Die generelle Idee beim Anlegen von Docker-Backups besteht darin, die Daten in Archiv-Dateien auf dem Host-System zu schreiben. Im Anschluss werden die Archiv-Dateien vom lokalen System auf ein Backup-System kopiert.

Sollen Backups vieler Docker-Daten erstellt werden, lohnt es sich, den Prozess zu au­to­ma­ti­sie­ren. Auf GitHub finden sich aus­ge­feil­te Skripte, die das Anlegen von Docker-Backups ver­ein­fa­chen. Der Ent­wick­ler Andreas Laub bei­spiels­wei­se stellt eine Reihe prak­ti­scher Docker-Backup-Tools unter Open-Source-Lizenz zur Verfügung.

Zum Anlegen eines Backups werden Daten kopiert. Dazu müssen wir zunächst wissen, wo die Daten liegen. Im Docker-Universum dienen Docker-Volumes als Ab­la­ge­or­te für den Austausch zwischen Docker-Con­tai­nern und Host-System bzw. zwischen mehreren Con­tai­nern.

Ein Docker-Container wird aus einem schreib­ge­schütz­ten Docker-Image erzeugt. Än­de­run­gen an einem laufenden Container sind flüchtig und gehen beim Entfernen des Con­tai­ners verloren. Um die Daten permanent zu sichern, müssen sie aus dem laufenden Container ex­por­tiert werden.

Neben Docker-Volumes lassen sich Container-Daten auch im laufenden Container speichern. Die Daten landen in der be­schreib­ba­ren Spei­cher­schicht des Container-Da­tei­sys­tems. In den meisten Fällen ist dies sub­op­ti­mal. Es ist daher wichtig, das System klug zu kon­fi­gu­rie­ren und bei­spiels­wei­se ein Docker-Volume zu nutzen.

Die Frage, wo genau Container-Daten abgelegt werden, erweist sich als recht komplex. Denn es gibt nicht nur eine Art von Docker-Volume. Je nach ver­wen­de­tem Volume-Typ bestehen subtile Un­ter­schie­de in Bezug auf Spei­cher­ort und Schicksal der Daten beim Entfernen des Con­tai­ners. Hier eine Übersicht der haupt­säch­li­chen Docker-Speicher-Kom­po­nen­ten:

In den meisten Fällen wird zum Erstellen eines Docker-Backups ein so­ge­nann­tes Tarball-Archiv erzeugt. Dabei kommt der Tar-Befehl zum Einsatz. Der generelle Be­fehls­auf­ruf zum Erzeugen einer Tar-Archiv-Datei ent­spricht dem folgenden Muster:

Dabei gibt es einen Haken: beim Aufruf wird der gesamte Pfad des ar­chi­vier­ten Ordners in das Archiv mit­auf­ge­nom­men. Beim Wie­der­her­stel­len kann dies pro­ble­ma­tisch sein. In der Praxis findet sich daher meist ein al­ter­na­ti­ver Ansatz:

Wir wechseln zunächst in den zu ar­chi­vie­ren­den Ordner und wenden das Tar-Kommando auf den der­zei­ti­gen Ordner an. Auf der Kom­man­do­zei­le wird auf den der­zei­ti­gen Ordner mit einem Punkt (.) verwiesen. Die Kom­bi­na­ti­on der beiden Schritte durch den &&-Operator stellt sicher, dass das Ar­chi­vie­ren nur aus­ge­führt wird, wenn das Wechseln in den Ziel­ord­ner er­folg­reich war.

Die beim Ar­chi­vie­ren der Docker-Daten erzeugte .tar-Dateien liegen zunächst auf dem Host-System. Um ein tat­säch­li­ches Backup zu erstellen, werden die Archiv-Dateien im Anschluss auf ein Backup-System über­tra­gen. Dabei handelt es sich entweder um ein externes Spei­cher­me­di­um oder einen Cloud-Speicher. Für die Über­tra­gung kommen spezielle Tools wie Rsync oder S3 zum Einsatz.

Nach­fol­gend eine Übersicht der beim Anlegen von Docker-Backups zum Einsatz kommenden Ansätze samt zu­ge­hö­ri­ger Be­fehls­mus­ter. In manchen Fällen gibt es mehr als einen Ansatz, ein Backup eines Docker-Objekts zu erzeugen.

Wir setzen für die nach­fol­gen­den Schritte voraus, dass Backup-Dateien beim Erzeugen im Ordner /backup/ im Heim­ver­zeich­nis abgelegt werden. Wir legen den Ordner als vor­be­rei­ten­den Schritt an:

In einem Docker-Container vor­han­de­ne Daten sind in schreib­ge­schütz­ten Schichten eines so­ge­nann­ten Union-Da­tei­sys­tems ge­spei­chert. Ein Docker-Container basiert auf einem schreib­ge­schütz­ten Image und enthält neben den Schichten des Images eine zu­sätz­li­che, be­schreib­ba­re Schicht.

Um die in der be­schreib­ba­ren Schicht vor­han­de­nen Daten permanent zu sichern, erzeugen wir ein neues Image aus dem laufenden Container. Dazu nutzen wir das „docker commit“-Kommando. Im Anschluss sichern wir den Inhalt des Images als Tarball-Archiv:

1. Docker-Da­tei­sys­tem in Image schreiben

2. Re­sul­tie­ren­des Image als Tarball-Archiv-Datei ex­por­tie­ren

Al­ter­na­tiv schieben wir das re­sul­tie­ren­de Image mit dem „docker image push“-Befehl auf ein Re­po­si­to­ry:

Zum Sichern eines auf dem lokalen Host ver­füg­ba­ren Docker-Images nutzen wir den bereits vom Erstellen eines Docker-Container-Backups bekannten Ansatz. Wir schreiben die Image-Daten in ein Tarball-Archiv:

Das Anlegen eines Docker-Volume-Backups erweist sich als komplexer Prozess. Denn wir müssen un­ter­schei­den zwischen „Bind Mounts“ und „benannten“ bzw. „anonymen“ Docker-Volumes. Der Zugriff auf ein Bind Mount ist vom Host-Da­tei­sys­tem pro­blem­los möglich. So ist es einfach, ein Tarball-Archiv des Ordners anzulegen:

Anders sieht es aus, wenn man aus Docker ein Backup eines benannten oder anonymen Volumes erzeugen möchte. Denn der Zugriff auf Volumes ist nur innerhalb eines laufenden Docker-Con­tai­ners möglich. Der Standard-Trick zum Ar­chi­vie­ren der in einem Docker-Volume ent­hal­te­nen Daten besteht darin, einen Container mit Zugriff auf das Volume zu starten. Im Anschluss werden die Daten des Volumes aus dem laufenden Container heraus ar­chi­viert. Be­trach­ten wir die einzelnen Schritte des Prozesses:

1. Container mit Zugriff auf das Volume stoppen

2. Tem­po­rä­ren Container starten und Volume-Daten ex­tra­hie­ren

Der temporäre Container erhält Zugriff auf die ge­wünsch­ten Volumes sowie auf den Backup-Ordner auf dem Host.

3. Container mit Zugriff auf das Volume neu starten

Das Kommando zum Ex­tra­hie­ren der Volume-Daten ist komplex. Schauen wir uns die einzelnen Kom­po­nen­ten im Detail an:

Um ein voll­stän­di­ges Backup des Docker-Compose-Pro­jekt­ord­ners zu erstellen, erzeugen wir ein Tarball-Archiv des Ordners:

Um ein voll­stän­di­ges Backup eines Do­cker­files anzulegen, wechseln wir in den Ordner, der das Do­cker­file enthält und legen ein Tarball-Archiv des Do­cker­files an:

Da­ten­ban­ken werden heut­zu­ta­ge gerne con­tai­ne­ri­siert. Um ein Backup einer im Docker-Container laufenden Datenbank zu erstellen, greift man auf da­ten­bank­spe­zi­fi­sche Backup-Tools zurück. Dazu zählen ins­be­son­de­re mysqldump und pg_dump.

Das jeweilige Backup-Tool wird innerhalb des Docker-Con­tai­ners aus­ge­führt. Wir nutzen dafür das „docker exec“-Kommando – hier dar­ge­stellt am Beispiel einer MySQL-Datenbank. Wir führen den „mysqldump“-Befehl innerhalb des Con­tai­ners aus. Der dabei ent­ste­hen­de Dump wird an die Stan­dard­aus­ga­be der Host-Shell aus­ge­ge­ben. Per Umleitung schreiben wir eine SQL-Dump-Datei im Backup-Ordner des lokalen Hosts:

Um aus einem laufenden Docker-Container ein Backup einer Post­greS­QL-Datenbank zu erzeugen, gehen wir analog vor. Dabei setzen wir voraus, dass Datenbank-Nut­zer­na­me und -Passwort in der .pgpass-Datei innerhalb des Con­tai­ners ge­spei­chert sind. Wir zeigen hier das Erstellen eines Backups im Custom-Dump-Format:

Al­ter­na­tiv lässt sich ein klas­si­scher Plain-Text-SQL-Dump erstellen. In diesem Fall fügen wir die Optionen „--clean“ und „--if-exists“ hinzu. Der Effekt ist, die Ziel­da­ten­bank vor dem Im­por­tie­ren zu be­rei­ni­gen. So lässt sich der Dump auf dem Quell­sys­tem ein­spie­len, ohne dass es zu Feh­ler­mel­dun­gen kommt:

Bisher haben wir gezeigt, wie Backups von Docker-Daten angelegt werden. Im weiteren Verlauf widmen wir uns der Wie­der­her­stel­lung der Daten aus den Docker-Backups. Wir nehmen wiederum an, dass alle Backups auf dem lokalen Host im Ordner ~/backup/ verfügbar sind. In der Praxis müssten die Backups ggf. zunächst vom Backup-Medium in der Backup-Ordner kopiert werden.

Zur Er­in­ne­rung: Um ein Backup eines Docker-Con­tai­ners anzulegen, erstellen wir ein neues Image aus dem laufenden Container und speichern dieses im Anschluss als Tarball-Archiv-Datei. Zur Wie­der­her­stel­lung eines Docker-Images aus einem Tarball-Archiv nutzen wir das „docker image load“-Kommando:

Im Anschluss starten wir einen neuen Container aus dem re­sul­tie­ren­den Image. Wir nutzen die „—detach“-Option, um den Container im Hin­ter­grund zu starten:

Die Wie­der­her­stel­lung eines Docker-Images aus einem Tarball-Archiv haben wir bereits be­schrie­ben. Wir nutzen dazu das „docker image load“-Kommando:

Beim Wie­der­her­stel­len der Daten eines Docker-Volumes aus einem Backup handelt es sich um einen komplexen Prozess. Das genaue Vorgehen hängt vom spe­zi­fi­schen Einsatz-Szenario ab. Wir zeigen hier das Über­schrei­ben der Volume-Daten aus einem Backup. Dabei nehmen wir an, dass wir uns auf demselben System befinden, auf dem das Backup erstellt wurde – d. h. die be­tei­lig­ten Container, Volumes und weitere Docker-Objekte sind allesamt vorhanden. Handelt es sich um ein frisch ein­ge­rich­te­tes System, gestaltet sich der Prozess dem­entspre­chend auf­wen­di­ger.

Das Wie­der­her­stel­len eines Docker-Volume-Backups erfordert wie beim Anlegen des Backups einen tem­po­rä­ren Container mit Zugriff auf das Volume. Wie das dabei zum Tragen kommende Docker-Kommando genau funk­tio­niert, ist im Abschnitt zum Anlegen eines Volume-Backups be­schrie­ben. Wir bilden die einzelnen Schritte des Prozesses sche­ma­tisch ab:

1. Container, die das Volume nutzen, stoppen

2. Tem­po­rä­ren Container mit Zugriff auf Volume starten und Docker-Daten aus Backup in Volume kopieren

3. Container, die das Volume nutzen, neu starten

Das Wie­der­her­stel­len eines Docker-Compose-Pro­jekt­ord­ners aus einem Backup geht un­kom­pli­ziert von der Hand. Wir wechseln in den Docker-Compose-Ordner und entpacken dort das Tarball-Archiv. Be­stehen­de Daten werden dabei über­schrie­ben.

Das Wie­der­her­stel­len eines Do­cker­files aus einem Tarball-Archiv ist eine simple Operation. Wir entpacken dazu lediglich das Tarball-Archiv innerhalb des Do­cker­file-Ordners. Das be­stehen­de Do­cker­file wird dabei über­schrie­ben.

Um eine im Docker-Container be­find­li­che Datenbank aus einem Backup wie­der­her­zu­stel­len, nutzen wir das „docker exec“-Kommando. Die Option „--in­ter­ac­ti­ve“ startet den Container im in­ter­ak­ti­ven Modus und hält die Stan­dard­ein­ga­be offen.

Auf dem lokalen Host geben wir den Inhalt des MySQL-Dumps mittels cat-Befehl aus und leiten die Ausgabe per Pipe an den Docker-Befehl weiter. Innerhalb des Con­tai­ners wird der mysql-Befehl aus­ge­führt, der die SQL-An­wei­sun­gen ver­ar­bei­tet und damit die Datenbank neu aufbaut.

Etwas komplexer ist der Vorgang zum Wie­der­her­stel­len einer Post­greS­QL-Datenbank. Je nach Format des Datenbank-Dumps kommt eines von zwei vor­han­de­nen Tools zum Einsatz. Zum Wie­der­her­stel­len eines Datenbank-Dumps im Post­greS­QL-„Custom“-Format führen wir das pg_restore-Tool innerhalb des Con­tai­ners aus. Wir nutzen eine Eingabe-Umleitung, um die Dump-Datei als Eingabe ein­zu­spei­sen:

Das Wie­der­her­stel­len eines Plain-Text-Post­greS­QL-Datenbank-Dumps funk­tio­niert analog zum Wie­der­her­stel­len eines MySQL-Dumps. Wir geben die Dump-Datei per cat-Befehl aus und pipen die Ausgabe an das „docker exec“-Kommando mit Option „--in­ter­ac­ti­ve“. Innerhalb des Con­tai­ners wird der psql-Befehl aus­ge­führt, der die SQL-An­wei­sun­gen ver­ar­bei­tet und die Datenbank neu aufbaut.