# Manuelles Backup und Restore

### <span class="mw-headline" id="bkmrk-docker-volume-0">Docker Volume</span>

Zuerst sollte man wissen wie das zu sichernde Docker Volume heißt. Eine Übersicht ergibt der folgende Befehl:

```bash
docker volume ls
```

Ich möchte das Volume mit dem Namen `test-data` sichern, mein Backup Verzeichnis soll `/backup/volumes/` sein, welches vorher angelegt werden muss:

```bash
mkdir -p /backup/volumes/
docker run --rm \
        -v /backup/volumes:/backup \
        -v test-data:/data:ro \
        debian:stretch-slim bash -c "cd /data && /bin/tar -czvf /backup/test-data.tar.gz ."
```

Zum Restore das Ganze einfach umdrehen.

```bash
docker run --rm \
        -v /backup/volumes:/backup \
        -v test-data:/data \
        debian:stretch-slim bash -c "cd /data && /bin/tar -xzvf /backup/test-data.tar.gz"
```

Nun sollten wieder alle Dateien an Ort und Stelle sein. Falls Dateien am Ort vorhanden sind, werden diese mit den Dateien aus dem Backup überschrieben.

### <span class="mw-headline" id="bkmrk-mysql-0">MySQL</span>

So kann man ganz einfach eine MySQL oder eine ältere MariaDB mittels `mysqldump` und `mysql` Sichern und Wiederherstellen:

```bash
# Sichern
docker exec CONTAINERNAME /usr/bin/mysqldump -u root --password=ROOTPASSWORD DATABASE > backup.sql

# Wiederherstellen
cat backup.sql | docker exec -i CONTAINERNAME /usr/bin/mysql -u root --password=ROOTPASSWORD DATABASENAME
```

und das Ganze nun noch komprimiert mit `gzip`:

```bash
# Sichern
docker exec CONTAINERNAME /usr/bin/mysqldump -u root --password=ROOTPASSWORD DATABASE | gzip > backup.sql.gz

# Wiederherstellen
zcat backup.sql.gz | docker exec -i CONTAINERNAME /usr/bin/mysql -u root --password=ROOTPASSWORD DATABASENAME

```

### <span class="mw-headline" id="bkmrk-mariadb-0">MariaDB</span>

So kann man ganz einfach eine MariaDB mittels `mariadb-dump` sichern und mit dem `mysql` command wiederherstellen:

```bash
# Sichern
docker exec CONTAINERNAME /usr/bin/mariadb-dump -u root --password=ROOTPASSWORD DATABASE > backup.sql

# Wiederherstellen
cat backup.sql | docker exec -i CONTAINERNAME /usr/bin/mysql -u root --password=ROOTPASSWORD DATABASENAME
```

und das Ganze nun noch komprimiert mit `gzip`:

```bash
# Sichern
docker exec CONTAINERNAME /usr/bin/mariadb-dump -u root --password=ROOTPASSWORD DATABASE | gzip > backup.sql.gz

# Wiederherstellen
zcat backup.sql.gz | docker exec -i CONTAINERNAME /usr/bin/mysql -u root --password=ROOTPASSWORD DATABASENAME

```

### <span class="mw-headline" id="bkmrk-postgresql-0">PostgreSQL</span>

Um PostgreSQL zu sichern, verwenden wir einfach `pg_dump` oder für alle Datenbanken `pg_dumpall`. Die Befehle schicken wir direkt in den Datenbank Container:

```bash
# Backup Aller Datenbanken unkomprimiert
docker exec CONTAINERNAME pg_dumpall -c -U POSTGRESUSER > backup.sql

# Backup Aller Datenbanken komprimiert
docker exec CONTAINERNAME pg_dumpall -c -U POSTGRESUSER | gzip > backup.sql.gz

# Backup einer Bestimmten Datenbank unkomprimiert
docker exec CONTAINERNAME pg_dumpall -c -U POSTGRESUSER -d DATABASENAME > backup.sql

# Backup einer Bestimmten Datenbank komprimiert
docker exec CONTAINERNAME pg_dumpall -c -U POSTGRESUSER -d DATABASENAME | gzip > backup.sql.gz

```

Der Restore erfolgt dann so:

```bash
# Restore Aller Datenbanken unkomprimiert
cat backup.sql | docker -i exec CONTAINERNAME psql -U POSTGRESUSER

# Restore Aller Datenbanken komprimiert
zcat backup.sql.gz |docker -i exec CONTAINERNAME psql -U POSTGRESUSER

# Restore einer Bestimmten Datenbank unkomprimiert
cat backup.sql | docker -i exec CONTAINERNAME psql -U POSTGRESUSER -d DATABASENAME

# Restore einer Bestimmten Datenbank komprimiert
zcat backup.sql.gz | docker -i exec CONTAINERNAME psql -U POSTGRESUSER -d DATABASENAME

```

### <span class="mw-headline" id="bkmrk-influxdb-v2.x-0">InfluxDB v2.x</span>

Die InfluxDB in Version 2.x bringt mit der CLI influx einen Parameter backup / restore mit. Mit diesem kann man ganz einfach die InfluxDB Datenbank sichern. Voraussetzung hierfür ist, das ihr ein Backup Folder in euren Container vorab nach /backup mountet.

```bash
    volumes:
      - "/backup/influxdb:/backup/"
```

dann kann man ein komplettes komprimiertes Backup der Datenbank ganz einfach mit dem folgenden Befehl ausführen:

```bash
docker exec CONTAINERNAME influx backup --compression gzip /backup/backup1
```

Das Backup file sollte dann im Ordner unter /backup/backup1 abgelegt werden. Den Backup Status sieht man im STDOUT. Der Restore kann dann durch den restore Parameter ausgeführt werden:

```bash
# Restore aller Timeseries
docker exec CONTAINERNAME influx restore /backup/backup1

# Restore und alles ersetzen
docker exec CONTAINERNAME influx restore /backup/backup1
```

### <span class="mw-headline" id="bkmrk-docker-compose-proje-0">Docker Compose Projekt Ordners</span>

Um ein Compose Projekt zu sichern ist es am besten einfach ein `tar.gz` des gesamten Ordners zu erstellen:

```bash
mkdir /opt/backup-compose-projects/
cd /opt/composeproject1
tar -czvf /opt/backup-compose-projects/composeproject1.tar.gz .
```

Der Restore erfolgt dann durch Entpacken des `tar.gz`

```bash
mkdir /opt/composeproject1
cd /opt/composeproject1
tar -xzvf /opt/backup-compose-projects/composeproject1.tar.gz
```

schon ist alles wieder an Ort und Stelle.

### <span class="mw-headline" id="bkmrk-docker-container-bzw-0">Docker Container bzw. Image</span>

Auch Docker Container oder Images selbst kann man sichern und wiederherstellen, oder besser gesagt, man kann so den Status eines Containers in ein Image abspeichern (wie einen Snapshot). Das erstellte Image bzw. der Snapshot kann dann gesichert werden. Dies kann Sinn machen, wenn man zu Debugging Zwecken einen Container mit dem aktuellen Stand in eine Testumgebung kopieren möchte, um dort dann ausgiebig zu troubleshooten.  
Wir wollen nun wissen wie unser Container heißt, mit diesem Befehl bekommt man eine Übersicht aller laufender Container:

```bash
docker ps
```

nun sucht man sich den zu sichernden Container heraus und nutzt entweder dessen `CONTAINER ID` oder den Namen:

```bash
docker commit -p CONTAINER-ID BACKUP-NAME
```

verifizieren kann man das nun mit folgendem Befehl, in der Liste sollte nun irgendwo der `BACKUP-NAME` auftauchen

```bash
docker image ls
```

Um das Image nun auf der Festplatte abzuspeichern:

```bash
docker save -o backup-name.tar BACKUP-NAME
```

komprimieren kann man die Datei zum Schluss ebenfalls noch

```bash
gzip backup-name.tar
```

Nun hat man eine komprimierte Version des Docker Containers.

Der Restore des Images erfolgt dann mit `docker load`:

```bash
docker load -i backup-name.tar
```

Um den Container wieder herzustellen, kann dann einfach das Image mit `docker run` gestartet werden:

```bash
docker run -d --name NEWCONTAINERNAME BACKUP-NAME
```