TOC

So konfigurieren Sie MySQL-Backups mit Percona XtraBackup unter Ubuntu 16.04

Einführung

Datenbanken speichern häufig einige der wertvollsten Informationen in Ihrer Infrastruktur. Aus diesem Grund ist es wichtig, zuverlässige Backups zu haben, um Datenverlusten bei Unfällen oder Hardwareausfällen vorzubeugen.

Die Percona XtraBackup-Sicherungstools bieten eine Methode zur Durchführung von "Hot" -Sicherungen von MySQL-Daten, während das System ausgeführt wird. Dazu kopieren sie die Datendateien auf Dateisystemebene und führen anschließend eine Absturzwiederherstellung durch, um die Konsistenz innerhalb des Datasets zu gewährleisten.

In diesem Handbuch erstellen wir ein System zur Automatisierung von Backups von MySQL-Daten auf einem Ubuntu 16.04-Server. Wir werden cron und die Percona-Tools in einer Gruppe von Skripten verwenden, um regelmäßige, sichere Backups zu erstellen, die wir bei Problemen zur Wiederherstellung verwenden können.

Voraussetzungen

Um dieses Handbuch zu vervollständigen, benötigen Sie einen Ubuntu 16.04-Server mit einem Nicht-Root-Benutzer + sudo +, der für administrative Aufgaben konfiguriert ist. Sie können unserer "Initial Server Setup with Ubuntu 16.04" Anleitung folgen, um einen Benutzer mit diesen Berechtigungen einzurichten auf Ihrem Server.

Sobald Sie einen "+ sudo +" - Benutzer zur Verfügung haben, müssen Sie MySQL installieren. Beide Anleitungen können verwendet werden, je nachdem, welches Paket Sie verwenden möchten. Das erste Handbuch ist geeignet, wenn Sie sich an die offiziellen Ubuntu-Repositorys halten möchten, während das zweite Handbuch besser geeignet ist, wenn Sie aktuellere Funktionen benötigen:

Melden Sie sich nach der Installation von MySQL auf Ihrem Server als "+ sudo +" - Benutzer an, um fortzufahren.

Installieren der Percona Xtrabackup-Tools

Als erstes müssen wir die eigentlichen Percona-Backup-Utilities installieren. Das Projekt unterhält eigene Repositorys, die wir unserem MySQL-Server hinzufügen können, um Zugriff auf die Pakete zu erhalten.

Rufen Sie zunächst die Percona-Versionsseite für Ubuntu auf, um die neuesten + .deb + - Pakete für die Installation des Repositorys zu finden. Da wir uns auf Ubuntu 16.04 befinden, das den Codenamen "Xenial Xerus" trägt, sollten wir das Paket "xenial" wählen. Klicken Sie mit der rechten Maustaste auf den entsprechenden Link und kopieren Sie die Adresse.

Nachdem Sie den Link kopiert haben, wechseln Sie in das Verzeichnis "+ / tmp " und laden Sie das Repository-Konfigurationspaket mit " curl +" herunter:

cd /tmp
curl -LO https://repo.percona.com/apt/.deb

Als nächstes installieren Sie das heruntergeladene Paket mit + dpkg +, wodurch das Percona-Repository + apt + auf dem System konfiguriert wird:

sudo dpkg -i percona*

Wenn das neue Repository konfiguriert ist, aktualisieren wir den lokalen Paketindex, um Informationen zu den neu verfügbaren Paketen abzurufen. Anschließend installieren wir die XtraBackup-Tools und das Komprimierungsprogramm "+ qpress +" aus dem Repository:

sudo apt-get update
sudo apt-get install percona-xtrabackup-24 qpress

Unter anderen gebündelten Dienstprogrammen sind jetzt die Befehle "+ xtrabackup ", " xbstream " und " qpress +" verfügbar. Unsere Skripte verwenden jedes dieser Elemente, um Sicherungen durchzuführen und Daten wiederherzustellen.

Konfigurieren eines MySQL Backup-Benutzers und Hinzufügen von Testdaten

Starten Sie zunächst eine interaktive MySQL-Sitzung mit dem MySQL-Root-Benutzer:

mysql -u root -p

Sie werden aufgefordert, das Administratorkennwort einzugeben, das Sie während der MySQL-Installation ausgewählt haben. Sobald Sie das Passwort eingegeben haben, werden Sie in eine MySQL-Sitzung versetzt.

Erstellen Sie einen MySQL-Benutzer mit entsprechenden Berechtigungen

Als Erstes müssen wir einen neuen MySQL-Benutzer erstellen, der für Sicherungsaufgaben konfiguriert ist. Wir werden diesem Benutzer nur die Rechte geben, die er benötigt, um die Daten sicher zu kopieren, während das System läuft.

Um den Zweck des Kontos zu erläutern, rufen wir den neuen Benutzer "+ backup +" auf. Wir speichern die Anmeldeinformationen des Benutzers in einer sicheren Datei. Sie können also ein komplexes Kennwort auswählen:

CREATE USER 'backup'@'localhost' IDENTIFIED BY '';

Als nächstes müssen wir dem neuen Benutzer "+ backup +" die Berechtigungen erteilen, die er benötigt, um alle Sicherungsaktionen auf dem Datenbanksystem durchzuführen. Gewähren Sie die erforderlichen Berechtigungen und wenden Sie sie auf die aktuelle Sitzung an, indem Sie Folgendes eingeben:

GRANT RELOAD, LOCK TABLES, REPLICATION CLIENT, CREATE TABLESPACE, PROCESS, SUPER, CREATE, INSERT, SELECT ON *.* TO 'backup'@'localhost';
FLUSH PRIVILEGES;

Unser MySQL-Sicherungsbenutzer ist konfiguriert und verfügt über den erforderlichen Zugriff.

Erstellen Sie Testdaten für die Sicherungen

Als nächstes werden wir einige Testdaten erstellen. Führen Sie die folgenden Befehle aus, um eine "+ playground " - Datenbank mit einer " equipment +" - Tabelle zu erstellen. Wir beginnen mit dem Einfügen eines einzelnen Datensatzes, der eine blaue Folie darstellt:

CREATE DATABASE playground;
CREATE TABLE playground.equipment ( id INT NOT NULL AUTO_INCREMENT, type VARCHAR(50), quant INT, color VARCHAR(25), PRIMARY KEY(id));
INSERT INTO playground.equipment (type, quant, color) VALUES ("slide", 2, "blue");

Später in diesem Handbuch werden wir diese Daten verwenden und ändern, um zu testen, ob wir vollständige und inkrementelle Sicherungen erstellen können.

Bevor wir unsere MySQL-Sitzung beenden, überprüfen wir den Wert der Variablen + datadir +. Wir müssen diesen Wert kennen, um sicherzustellen, dass unser Benutzer auf Systemebene "+ backup +" Zugriff auf die MySQL-Datendateien hat.

Zeigen Sie den Wert der Variablen + datadir + an, indem Sie Folgendes eingeben:

SELECT @@datadir;
Output+-----------------+
| @@datadir       |
+-----------------+
| /var/lib/mysql/ |
+-----------------+
1 row in set (0.01 sec)

Notieren Sie sich den Standort, den Sie finden.

Das ist alles, was wir im Moment in MySQL tun müssen. Beenden Sie die Shell, indem Sie Folgendes eingeben:

exit

Als Nächstes können wir uns einige Konfigurationen auf Systemebene ansehen.

Konfigurieren eines Systems Backup-Benutzers und Zuweisen von Berechtigungen

Da wir nun einen MySQL-Benutzer haben, der Backups durchführen kann, werden wir sicherstellen, dass ein entsprechender Linux-Benutzer mit ähnlichen eingeschränkten Rechten existiert.

Unter Ubuntu 16.04 ist bereits ein Benutzer "+ backup " und die entsprechende Gruppe " backup " verfügbar. Bestätigen Sie dies, indem Sie die Dateien " / etc / passwd" und "+ / etc / group" mit dem folgenden Befehl überprüfen:

grep backup /etc/passwd /etc/group
Output/etc/passwd:backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
/etc/group:backup:x:34:

Die erste Zeile aus der Datei "+ / etc / passwd " beschreibt den Benutzer " backup ", während die zweite Zeile aus der Datei " / etc / group " die Gruppe " backup +" definiert.

Das Verzeichnis "+ / var / lib / mysql", in dem die MySQL-Daten gespeichert sind, gehört dem Benutzer und der Gruppe "+ mysql". Wir können den Benutzer "+ backup" zur Gruppe "+ mysql" hinzufügen, um den sicheren Zugriff auf die Datenbankdateien und -verzeichnisse zu ermöglichen. Wir sollten der Gruppe "+ backup" auch einen Benutzer "+ sudo" hinzufügen, damit wir auf die zu sichernden Dateien zugreifen können.

Geben Sie die folgenden Befehle ein, um den Benutzer "+ backup " zur Gruppe " mysql" und Ihren Benutzer "+ sudo" zur Gruppe "+ backup +" hinzuzufügen:

sudo usermod -aG mysql backup
sudo usermod -aG backup ${USER}

Wenn wir die Dateien "+ / etc / group " erneut überprüfen, werden Sie feststellen, dass Ihr aktueller Benutzer der Gruppe " backup " und der Benutzer " backup " der Gruppe " mysql +" hinzugefügt wird:

grep backup /etc/group
Outputbackup:x:34:
mysql:x:116:backup

Die neue Gruppe ist in unserer aktuellen Sitzung nicht automatisch verfügbar. Um die Gruppen zu überprüfen, die unserem Benutzer "+ sudo +" zur Verfügung stehen, melden Sie sich entweder ab und wieder an oder geben Sie Folgendes ein:

exec su - ${USER}

Sie werden aufgefordert, das Kennwort Ihres "+ sudo " - Benutzers einzugeben, um fortzufahren. Bestätigen Sie, dass Ihre aktuelle Sitzung jetzt Zugriff auf die Gruppe " backup +" hat, indem Sie die Gruppen unserer Benutzer erneut überprüfen:

id -nG
Output sudo backup

Unser Benutzer "+ sudo " kann nun seine Mitgliedschaft in der Gruppe " backup +" nutzen.

Als nächstes müssen wir das Verzeichnis "+ / var / lib / mysql" und seine Unterverzeichnisse für die Gruppe "+ mysql" zugänglich machen, indem wir Gruppenausführungsberechtigungen hinzufügen. Andernfalls kann der Benutzer "+ backup " diese Verzeichnisse nicht eingeben, obwohl er Mitglied der Gruppe " mysql +" ist.

Geben Sie Folgendes ein, um der Gruppe "+ mysql +" Zugriff auf die MySQL-Datenverzeichnisse zu gewähren:

sudo find /var/lib/mysql -type d -exec chmod 750 {} \;

Unser Benutzer + backup + hat jetzt den erforderlichen Zugriff auf das MySQL-Verzeichnis.

Sicherungs-Assets erstellen

Jetzt, da Benutzer von MySQL und Systemsicherungen verfügbar sind, können wir beginnen, Konfigurationsdateien, Verschlüsselungsschlüssel und andere Ressourcen einzurichten, die wir zum erfolgreichen Erstellen und Sichern unserer Sicherungen benötigen.

Erstellen Sie eine MySQL-Konfigurationsdatei mit den Sicherungsparametern

Beginnen Sie mit der Erstellung einer minimalen MySQL-Konfigurationsdatei, die das Backup-Skript verwenden wird. Dieser enthält die MySQL-Anmeldeinformationen für den MySQL-Benutzer.

Öffnen Sie eine Datei unter + / etc / mysql / backup.cnf + in Ihrem Texteditor:

sudo nano /etc/mysql/backup.cnf

Starten Sie einen Abschnitt "+ [client] +" und legen Sie den MySQL-Sicherungsbenutzer und den Kennwortbenutzer fest, die Sie in MySQL definiert haben:

/etc/mysql/backup.cnf

[client]
user=backup
password=

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Geben Sie dem Benutzer "+ backup +" den Besitz der Datei und schränken Sie dann die Berechtigungen ein, damit keine anderen Benutzer auf die Datei zugreifen können:

sudo chown backup /etc/mysql/backup.cnf
sudo chmod 600 /etc/mysql/backup.cnf

Der Sicherungsbenutzer kann auf diese Datei zugreifen, um die richtigen Anmeldeinformationen abzurufen, andere Benutzer sind jedoch eingeschränkt.

Erstellen Sie ein Backup-Stammverzeichnis

Erstellen Sie als Nächstes ein Verzeichnis für den Sicherungsinhalt. Wir werden "+ / backups / mysql" als Basisverzeichnis für unsere Backups verwenden:

sudo mkdir -p /backups/mysql

Als nächstes weisen Sie dem Benutzer "+ backup " und der Gruppe " mysql" den Besitz des Verzeichnisses "+ / backups / mysql" zu:

sudo chown backup:mysql /backups/mysql

Der Benutzer "+ backup +" sollte nun in der Lage sein, Sicherungsdaten an diesen Speicherort zu schreiben.

Erstellen Sie einen Verschlüsselungsschlüssel, um die Sicherungsdateien zu sichern

Da Sicherungen alle Daten aus dem Datenbanksystem selbst enthalten, ist es wichtig, sie ordnungsgemäß zu sichern. Das Hilfsprogramm "+ xtrabackup +" kann jede gesicherte und archivierte Datei verschlüsseln. Wir müssen es nur mit einem Verschlüsselungsschlüssel versehen.

Mit dem Befehl + openssl + können wir einen Verschlüsselungsschlüssel im Backup-Stammverzeichnis erstellen:

printf '%s' "$(openssl rand -base64 24)" | sudo tee /backups/mysql/encryption_key && echo

Es ist sehr wichtig, den Zugriff auf diese Datei ebenfalls einzuschränken. Weisen Sie dem Benutzer "+ backup +" erneut den Besitz zu und verweigern Sie allen anderen Benutzern den Zugriff:

sudo chown backup:backup /backups/mysql/encryption_key
sudo chmod 600 /backups/mysql/encryption_key

Dieser Schlüssel wird während des Sicherungsvorgangs und zu jedem Zeitpunkt verwendet, zu dem Sie von einer Sicherung wiederherstellen müssen.

Erstellen der Sicherungs- und Wiederherstellungsskripte

Wir haben jetzt alles, was wir brauchen, um sichere Backups der laufenden MySQL-Instanz durchzuführen.

Um unsere Sicherungs- und Wiederherstellungsschritte wiederholbar zu machen, erstellen wir ein Skript für den gesamten Prozess. Wir werden die folgenden Skripte erstellen:

  • + backup-mysql.sh +: Dieses Skript sichert die MySQL-Datenbanken und verschlüsselt und komprimiert dabei die Dateien. Es erstellt vollständige und inkrementelle Sicherungen und organisiert Inhalte automatisch nach Tag. Standardmäßig verwaltet das Skript Backups für 3 Tage.

  • + extract-mysql.sh +: Dieses Skript dekomprimiert und entschlüsselt die Sicherungsdateien, um Verzeichnisse mit dem gesicherten Inhalt zu erstellen.

  • + prepare-mysql.sh +: Dieses Skript "bereitet" die Sicherungsverzeichnisse durch Verarbeiten der Dateien und Anwenden von Protokollen vor. Alle inkrementellen Sicherungen werden auf die vollständige Sicherung angewendet. Sobald das Vorbereitungsskript abgeschlossen ist, können die Dateien wieder in das Datenverzeichnis verschoben werden.

Sie können die Skripte jederzeit im repository für dieses Tutorial auf GitHub anzeigen. Wenn Sie die folgenden Inhalte nicht kopieren und einfügen möchten, können Sie sie direkt von GitHub herunterladen, indem Sie Folgendes eingeben:

cd /tmp
curl -LO https://raw.githubusercontent.com/do-community/ubuntu-1604-mysql-backup/master/backup-mysql.sh
curl -LO https://raw.githubusercontent.com/do-community/ubuntu-1604-mysql-backup/master/extract-mysql.sh
curl -LO https://raw.githubusercontent.com/do-community/ubuntu-1604-mysql-backup/master/prepare-mysql.sh

Überprüfen Sie die Skripts nach dem Herunterladen, um sicherzustellen, dass sie erfolgreich abgerufen wurden und dass Sie die von ihnen ausgeführten Aktionen genehmigen. Wenn Sie zufrieden sind, markieren Sie die Skripte als ausführbar und verschieben Sie sie in das Verzeichnis "+ / usr / local / bin +", indem Sie Folgendes eingeben:

chmod +x /tmp/{backup,extract,prepare}-mysql.sh
sudo mv /tmp/{backup,extract,prepare}-mysql.sh /usr/local/bin

Als nächstes werden wir jedes dieser Skripte einrichten und sie detaillierter besprechen.

Erstellen Sie das Skript backup-mysql.sh

Wenn Sie das Skript "+ backup-mysql.sh " nicht von GitHub heruntergeladen haben, erstellen Sie eine neue Datei im Verzeichnis " / usr / local / bin " mit dem Namen " backup-mysql.sh +":

sudo nano /usr/local/bin/backup-mysql.sh

Kopieren Sie den Skriptinhalt und fügen Sie ihn in die Datei ein:

/usr/local/bin/backup-mysql.sh

#!/bin/bash

export LC_ALL=C

days_of_backups=3  # Must be less than 7
backup_owner="backup"
parent_dir="/backups/mysql"
defaults_file="/etc/mysql/backup.cnf"
todays_dir="${parent_dir}/$(date +%a)"
log_file="${todays_dir}/backup-progress.log"
encryption_key_file="${parent_dir}/encryption_key"
now="$(date +%m-%d-%Y_%H-%M-%S)"
processors="$(nproc --all)"

# Use this to echo to standard error
error () {
   printf "%s: %s\n" "$(basename "${BASH_SOURCE}")" "${1}" >&2
   exit 1
}

trap 'error "An unexpected error occurred."' ERR

sanity_check () {
   # Check user running the script
   if [ "$(id --user --name)" != "$backup_owner" ]; then
       error "Script can only be run as the \"$backup_owner\" user"
   fi

   # Check whether the encryption key file is available
   if [ ! -r "${encryption_key_file}" ]; then
       error "Cannot read encryption key at ${encryption_key_file}"
   fi
}

set_options () {
   # List the xtrabackup arguments
   xtrabackup_args=(
       "--defaults-file=${defaults_file}"
       "--backup"
       "--extra-lsndir=${todays_dir}"
       "--compress"
       "--stream=xbstream"
       "--encrypt=AES256"
       "--encrypt-key-file=${encryption_key_file}"
       "--parallel=${processors}"
       "--compress-threads=${processors}"
       "--encrypt-threads=${processors}"
       "--slave-info"
   )

   backup_type="full"

   # Add option to read LSN (log sequence number) if a full backup has been
   # taken today.
   if grep -q -s "to_lsn" "${todays_dir}/xtrabackup_checkpoints"; then
       backup_type="incremental"
       lsn=$(awk '/to_lsn/ {print $3;}' "${todays_dir}/xtrabackup_checkpoints")
       xtrabackup_args+=( "--incremental-lsn=${lsn}" )
   fi
}

rotate_old () {
   # Remove the oldest backup in rotation
   day_dir_to_remove="${parent_dir}/$(date --date="${days_of_backups} days ago" +%a)"

   if [ -d "${day_dir_to_remove}" ]; then
       rm -rf "${day_dir_to_remove}"
   fi
}

take_backup () {
   # Make sure today's backup directory is available and take the actual backup
   mkdir -p "${todays_dir}"
   find "${todays_dir}" -type f -name "*.incomplete" -delete
   xtrabackup "${xtrabackup_args[@]}" --target-dir="${todays_dir}" > "${todays_dir}/${backup_type}-${now}.xbstream.incomplete" 2> "${log_file}"

   mv "${todays_dir}/${backup_type}-${now}.xbstream.incomplete" "${todays_dir}/${backup_type}-${now}.xbstream"
}

sanity_check && set_options && rotate_old && take_backup

# Check success and print message
if tail -1 "${log_file}" | grep -q "completed OK"; then
   printf "Backup successful!\n"
   printf "Backup created at %s/%s-%s.xbstream\n" "${todays_dir}" "${backup_type}" "${now}"
else
   error "Backup failure! Check ${log_file} for more information"
fi

Das Skript hat folgende Funktionen:

  • Erstellt eine verschlüsselte, komprimierte vollständige Sicherung, wenn diese jeden Tag zum ersten Mal ausgeführt wird.

  • Erzeugt verschlüsselte, komprimierte Teilsicherungen auf der Grundlage der täglichen vollständigen Sicherung, wenn sie am selben Tag erneut aufgerufen werden.

  • Verwaltet Backups nach Tag. Standardmäßig werden Backups für drei Tage aufbewahrt. Dies kann durch Anpassen des Parameters + days_of_backups + innerhalb des Skripts geändert werden.

Beim Ausführen des Skripts wird ein tägliches Verzeichnis erstellt, in das mit Zeitstempeln versehene Dateien für einzelne Sicherungen geschrieben werden. Die Datei mit dem ersten Zeitstempel ist eine vollständige Sicherung mit dem Präfix "+ full- ". Nachfolgende Sicherungen für diesen Tag sind inkrementelle Sicherungen, die durch das Präfix " inkrementell- +" gekennzeichnet sind und die Änderungen seit der letzten vollständigen oder inkrementellen Sicherung darstellen.

Backups erzeugen eine Datei mit dem Namen "+ backup-progress.log " im täglichen Verzeichnis mit der Ausgabe der letzten Backup-Operation. Dort wird auch eine Datei mit dem Namen " xtrabackup_checkpoints " erstellt, die die neuesten Sicherungsmetadaten enthält. Diese Datei wird für zukünftige inkrementelle Sicherungen benötigt, daher ist es wichtig, sie nicht zu entfernen. Eine Datei mit dem Namen " xtrabackup_info +", die zusätzliche Metadaten enthält, wird ebenfalls erstellt, das Skript verweist jedoch nicht auf diese Datei.

Wenn Sie fertig sind, speichern und schließen Sie die Datei.

Wenn Sie dies noch nicht getan haben, können Sie das Skript ausführbar machen, indem Sie Folgendes eingeben:

sudo chmod +x /usr/local/bin/backup-mysql.sh

Wir haben jetzt einen einzigen Befehl zur Verfügung, der MySQL-Backups initiiert.

Erstellen Sie das Skript extract-mysql.sh

Als nächstes erstellen wir das Skript + extract-mysql.sh +. Dies wird verwendet, um die MySQL-Datenverzeichnisstruktur aus einzelnen Sicherungsdateien zu extrahieren.

Wenn Sie das Skript nicht aus dem Repository heruntergeladen haben, erstellen und öffnen Sie eine Datei mit dem Namen "+ extract-mysql.sh " im Verzeichnis " / usr / local / bin +":

sudo nano /usr/local/bin/extract-mysql.sh

Fügen Sie das folgende Skript ein:

/usr/local/bin/extract-mysql.sh

#!/bin/bash

export LC_ALL=C

backup_owner="backup"
encryption_key_file="/backups/mysql/encryption_key"
log_file="extract-progress.log"
number_of_args="${#}"
processors="$(nproc --all)"

# Use this to echo to standard error
error () {
   printf "%s: %s\n" "$(basename "${BASH_SOURCE}")" "${1}" >&2
   exit 1
}

trap 'error "An unexpected error occurred.  Try checking the \"${log_file}\" file for more information."' ERR

sanity_check () {
   # Check user running the script
   if [ "${USER}" != "${backup_owner}" ]; then
       error "Script can only be run as the \"${backup_owner}\" user"
   fi

   # Check whether the qpress binary is installed
   if ! command -v qpress >/dev/null 2>&1; then
       error "Could not find the \"qpress\" command.  Please install it and try again."
   fi

   # Check whether any arguments were passed
   if [ "${number_of_args}" -lt 1 ]; then
       error "Script requires at least one \".xbstream\" file as an argument."
   fi

   # Check whether the encryption key file is available
   if [ ! -r "${encryption_key_file}" ]; then
       error "Cannot read encryption key at ${encryption_key_file}"
   fi
}

do_extraction () {
   for file in "${@}"; do
       base_filename="$(basename "${file%.xbstream}")"
       restore_dir="./restore/${base_filename}"

       printf "\n\nExtracting file %s\n\n" "${file}"

       # Extract the directory structure from the backup file
       mkdir --verbose -p "${restore_dir}"
       xbstream -x -C "${restore_dir}" < "${file}"

       xtrabackup_args=(
           "--parallel=${processors}"
           "--decrypt=AES256"
           "--encrypt-key-file=${encryption_key_file}"
           "--decompress"
       )

       xtrabackup "${xtrabackup_args[@]}" --target-dir="${restore_dir}"
       find "${restore_dir}" -name "*.xbcrypt" -exec rm {} \;
       find "${restore_dir}" -name "*.qp" -exec rm {} \;

       printf "\n\nFinished work on %s\n\n" "${file}"

   done > "${log_file}" 2>&1
}

sanity_check && do_extraction "$@"

ok_count="$(grep -c 'completed OK' "${log_file}")"

# Check the number of reported completions.  For each file, there is an
# informational "completed OK".  If the processing was successful, an
# additional "completed OK" is printed. Together, this means there should be 2
# notices per backup file if the process was successful.
if (( $ok_count !=  $# )); then
   error "It looks like something went wrong. Please check the \"${log_file}\" file for additional information"
else
   printf "Extraction complete! Backup directories have been extracted to the \"restore\" directory.\n"
fi

Im Gegensatz zum Skript "+ backup-mysql.sh ", das für die Automatisierung ausgelegt ist, soll dieses Skript absichtlich verwendet werden, wenn Sie eine Wiederherstellung aus einer Sicherung planen. Aus diesem Grund erwartet das Skript, dass Sie die zu extrahierenden ` .xbstream +` - Dateien übergeben.

Das Skript erstellt ein "+ restore " - Verzeichnis im aktuellen Verzeichnis und erstellt dann einzelne Verzeichnisse für jedes der als Argumente übergebenen Backups. Die bereitgestellten " .xbstream +" - Dateien werden verarbeitet, indem die Verzeichnisstruktur aus dem Archiv extrahiert, die einzelnen Dateien darin entschlüsselt und die entschlüsselten Dateien anschließend dekomprimiert werden.

Nach Abschluss dieses Vorgangs sollte das Verzeichnis "+ restore +" Verzeichnisse für jede der bereitgestellten Sicherungen enthalten. Auf diese Weise können Sie die Verzeichnisse überprüfen, den Inhalt der Sicherungen überprüfen und entscheiden, welche Sicherungen Sie vorbereiten und wiederherstellen möchten.

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Stellen Sie anschließend sicher, dass das Skript ausführbar ist, indem Sie Folgendes eingeben:

sudo chmod +x /usr/local/bin/extract-mysql.sh

Mit diesem Skript können wir einzelne Sicherungsdateien in die Verzeichnisstruktur erweitern, die für die Wiederherstellung erforderlich ist.

Erstellen Sie das Skript prepare-mysql.sh

Laden Sie abschließend das Skript "+ prepare-mysql.sh " im Verzeichnis " / usr / local / bin +" herunter oder erstellen Sie es. Dieses Skript wendet die Protokolle auf jede Sicherung an, um einen konsistenten Datenbank-Snapshot zu erstellen. Alle inkrementellen Sicherungen werden auf die vollständige Sicherung angewendet, um die späteren Änderungen zu berücksichtigen.

Erstellen Sie die Skriptdatei in Ihrem Texteditor, wenn Sie sie nicht zuvor heruntergeladen haben:

sudo nano /usr/local/bin/prepare-mysql.sh

Fügen Sie den folgenden Inhalt ein:

/usr/local/bin/prepare-mysql.sh

#!/bin/bash

export LC_ALL=C

shopt -s nullglob
incremental_dirs=( ./incremental-*/ )
full_dirs=( ./full-*/ )
shopt -u nullglob

backup_owner="backup"
log_file="prepare-progress.log"
full_backup_dir="${full_dirs[0]}"

# Use this to echo to standard error
error() {
   printf "%s: %s\n" "$(basename "${BASH_SOURCE}")" "${1}" >&2
   exit 1
}

trap 'error "An unexpected error occurred.  Try checking the \"${log_file}\" file for more information."' ERR

sanity_check () {
   # Check user running the script
   if [ "${USER}" != "${backup_owner}" ]; then
       error "Script can only be run as the \"${backup_owner}\" user."
   fi

   # Check whether a single full backup directory are available
   if (( ${#full_dirs[@]} != 1 )); then
       error "Exactly one full backup directory is required."
   fi
}

do_backup () {
   # Apply the logs to each of the backups
   printf "Initial prep of full backup %s\n" "${full_backup_dir}"
   xtrabackup --prepare --apply-log-only --target-dir="${full_backup_dir}"

   for increment in "${incremental_dirs[@]}"; do
       printf "Applying incremental backup %s to %s\n" "${increment}" "${full_backup_dir}"
       xtrabackup --prepare --apply-log-only --incremental-dir="${increment}" --target-dir="${full_backup_dir}"
   done

   printf "Applying final logs to full backup %s\n" "${full_backup_dir}"
   xtrabackup --prepare --target-dir="${full_backup_dir}"
}

sanity_check && do_backup > "${log_file}" 2>&1

# Check the number of reported completions.  Each time a backup is processed,
# an informational "completed OK" and a real version is printed.  At the end of
# the process, a final full apply is performed, generating another 2 messages.
ok_count="$(grep -c 'completed OK' "${log_file}")"

if (( ${ok_count} == ${#full_dirs[@]} + ${#incremental_dirs[@]} + 1 )); then
   cat << EOF
Backup looks to be fully prepared.  Please check the "prepare-progress.log" file
to verify before continuing.

If everything looks correct, you can apply the restored files.

First, stop MySQL and move or remove the contents of the MySQL data directory:

       sudo systemctl stop mysql
       sudo mv /var/lib/mysql/ /tmp/

Then, recreate the data directory and  copy the backup files:

       sudo mkdir /var/lib/mysql
       sudo xtrabackup --copy-back --target-dir=${PWD}/$(basename "${full_backup_dir}")

Afterward the files are copied, adjust the permissions and restart the service:

       sudo chown -R mysql:mysql /var/lib/mysql
       sudo find /var/lib/mysql -type d -exec chmod 750 {} \\;
       sudo systemctl start mysql
EOF
else
   error "It looks like something went wrong.  Check the \"${log_file}\" file for more information."
fi

Das Skript sucht im aktuellen Verzeichnis nach Verzeichnissen, die mit "+ full- " oder " incremental- +" beginnen. Es verwendet die MySQL-Protokolle, um die festgeschriebenen Transaktionen auf die vollständige Sicherung anzuwenden. Anschließend werden alle inkrementellen Sicherungen auf die vollständige Sicherung angewendet, um die Daten mit den aktuelleren Informationen zu aktualisieren, wobei erneut die festgeschriebenen Transaktionen angewendet werden.

Nachdem alle Sicherungen kombiniert wurden, werden die nicht festgeschriebenen Transaktionen zurückgesetzt. Zu diesem Zeitpunkt stellt das "+ full- +" - Backup einen konsistenten Datensatz dar, der in das Datenverzeichnis von MySQL verschoben werden kann.

Um das Risiko eines Datenverlusts so gering wie möglich zu halten, werden die Dateien nicht mehr in das Datenverzeichnis kopiert. Auf diese Weise kann der Benutzer den Sicherungsinhalt und die Protokolldatei, die während dieses Vorgangs erstellt wurden, manuell überprüfen und entscheiden, was mit dem aktuellen Inhalt des MySQL-Datenverzeichnisses geschehen soll. Die Befehle, die zum vollständigen Wiederherstellen der Dateien erforderlich sind, werden beim Beenden des Befehls angezeigt.

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Wenn Sie dies noch nicht getan haben, markieren Sie die Datei als ausführbar, indem Sie Folgendes eingeben:

sudo chmod +x /usr/local/bin/prepare-mysql.sh

Dieses Skript ist das letzte Skript, das wir ausführen, bevor wir die Sicherungsdateien in das Datenverzeichnis von MySQL verschieben.

Testen der MySQL-Sicherungs- und Wiederherstellungsskripte

Jetzt, da sich die Sicherungs- und Wiederherstellungsskripte auf dem Server befinden, sollten wir sie testen.

Führen Sie eine vollständige Sicherung durch

Rufen Sie zunächst das Skript "+ backup-mysql.sh " mit dem Benutzer " backup +" auf:

sudo -u backup backup-mysql.sh
OutputBackup successful!
Backup created at /backups/mysql/Thu/full-04-20-2017_14-55-17.xbstream

Wenn alles wie geplant gelaufen ist, wird das Skript korrekt ausgeführt, der Erfolg angezeigt und der Speicherort der neuen Sicherungsdatei ausgegeben. Wie aus der obigen Ausgabe hervorgeht, wurde ein tägliches Verzeichnis (in diesem Fall "Do") erstellt, in dem die täglichen Backups gespeichert werden. Die Sicherungsdatei selbst beginnt mit "+ full- +", um auszudrücken, dass es sich um eine vollständige Sicherung handelt.

Wechseln Sie in das tägliche Sicherungsverzeichnis und zeigen Sie den Inhalt an:

cd /backups/mysql/"$(date +%a)"
ls
Outputbackup-progress.log  full-04-20-2017_14-55-17.xbstream  xtrabackup_checkpoints  xtrabackup_info

Hier sehen wir die eigentliche Sicherungsdatei (in diesem Fall + full-04-20-2017_14-55-17.xbstream +), das Protokoll des Sicherungsereignisses (+ backup-progress.log +), das + xtrabackup_checkpoints + `- Datei, die Metadaten zum gesicherten Inhalt enthält, und + xtrabackup_info + `- Datei, die zusätzliche Metadaten enthält.

Wenn wir "+ backup-progress.log +" beenden, können wir bestätigen, dass die Sicherung erfolgreich abgeschlossen wurde.

tail backup-progress.log
Output170420 14:55:19 All tables unlocked
170420 14:55:19 [00] Compressing, encrypting and streaming ib_buffer_pool to <STDOUT>
170420 14:55:19 [00]        ...done
170420 14:55:19 Backup created in directory '/backups/mysql/Thu/'
170420 14:55:19 [00] Compressing, encrypting and streaming backup-my.cnf
170420 14:55:19 [00]        ...done
170420 14:55:19 [00] Compressing, encrypting and streaming xtrabackup_info
170420 14:55:19 [00]        ...done
xtrabackup: Transaction log of lsn (2549956) to (2549965) was copied.
170420 14:55:19

Wenn wir uns die Datei + xtrabackup_checkpoints ansehen, können wir Informationen über die Sicherung anzeigen. Diese Datei enthält einige Informationen, die für Administratoren nützlich sind. Sie wird jedoch hauptsächlich von nachfolgenden Sicherungsjobs verwendet, damit diese wissen, welche Daten bereits verarbeitet wurden.

Dies ist eine Kopie einer Datei, die in jedem Archiv enthalten ist. Obwohl diese Kopie mit jeder Sicherung überschrieben wird, um die neuesten Informationen darzustellen, ist jedes Original weiterhin im Sicherungsarchiv verfügbar.

cat xtrabackup_checkpoints
Outputbackup_type = full-backuped
from_lsn = 0
to_lsn = 2549956
last_lsn = 2549965
compact = 0
recover_binlog_info = 0

Aus dem obigen Beispiel geht hervor, dass eine vollständige Sicherung erstellt wurde und dass die Sicherung die Protokollfolgenummer (LSN) 0 bis 2549956 umfasst. Die Zahl "+ last_lsn +" gibt an, dass während des Sicherungsvorgangs einige Vorgänge ausgeführt wurden.

Führen Sie eine Teilsicherung durch

Jetzt, da wir eine vollständige Sicherung haben, können wir zusätzliche inkrementelle Sicherungen durchführen. Inkrementelle Sicherungen zeichnen die Änderungen auf, die seit der letzten Sicherung vorgenommen wurden. Die erste Teilsicherung basiert auf einer vollständigen Sicherung und nachfolgende Teilsicherungen basieren auf der vorherigen Teilsicherung.

Wir sollten unserer Datenbank einige Daten hinzufügen, bevor wir eine weitere Sicherung durchführen, damit wir feststellen können, welche Sicherungen angewendet wurden.

Fügen Sie einen weiteren Datensatz in die Tabelle "+ Ausrüstung " unserer Datenbank " Spielplatz +" ein, der 10 gelbe Schaukeln darstellt. Während dieses Vorgangs werden Sie zur Eingabe des MySQL-Administratorkennworts aufgefordert:

mysql -u root -p -e 'INSERT INTO playground.equipment (type, quant, color) VALUES ("swing", 10, "yellow");'

Da jetzt mehr aktuelle Daten als bei unserer letzten Sicherung vorhanden sind, können wir eine inkrementelle Sicherung durchführen, um die Änderungen zu erfassen. Das Skript + backup-mysql.sh + erstellt eine Teilsicherung, wenn eine vollständige Sicherung für denselben Tag vorhanden ist:

sudo -u backup backup-mysql.sh
OutputBackup successful!
Backup created at /backups/mysql/Thu/incremental-04-20-2017_17-15-03.xbstream

Überprüfen Sie das tägliche Sicherungsverzeichnis erneut, um das inkrementelle Sicherungsarchiv zu finden:

cd /backups/mysql/"$(date +%a)"
ls
Outputbackup-progress.log                incremental-04-20-2017_17-15-03.xbstream  xtrabackup_info
full-04-20-2017_14-55-17.xbstream  xtrabackup_checkpoints

Der Inhalt der Datei + xtrabackup_checkpoints + bezieht sich jetzt auf die letzte Teilsicherung:

cat xtrabackup_checkpoints
Outputbackup_type = incremental
from_lsn = 2549956
to_lsn = 2550159
last_lsn = 2550168
compact = 0
recover_binlog_info = 0

Der Sicherungstyp wird als "inkrementell" aufgeführt und beginnt nicht wie bei unserer vollständigen Sicherung bei LSN 0, sondern bei der LSN, bei der unsere letzte Sicherung beendet wurde.

Extrahieren Sie die Backups

Als Nächstes extrahieren wir die Sicherungsdateien, um Sicherungsverzeichnisse zu erstellen. Aus Platz- und Sicherheitsgründen sollte dies normalerweise nur erfolgen, wenn Sie bereit sind, die Daten wiederherzustellen.

Wir können die Backups extrahieren, indem wir die Backup-Dateien + .xbstream + an das Skript + extract-mysql.sh + übergeben. Auch dies muss vom Benutzer "+ backup +" ausgeführt werden:

sudo -u backup extract-mysql.sh *.xbstream
OutputExtraction complete! Backup directories have been extracted to the "restore" directory.

Die obige Ausgabe zeigt an, dass der Prozess erfolgreich abgeschlossen wurde. Wenn wir den Inhalt des täglichen Sicherungsverzeichnisses erneut überprüfen, wurden eine Datei "+ extract-progress.log " und ein Verzeichnis " restore +" erstellt.

Wenn wir das Extraktionsprotokoll abschließen, können wir bestätigen, dass die letzte Sicherung erfolgreich extrahiert wurde. Die anderen Sicherungserfolgsmeldungen werden früher in der Datei angezeigt.

tail extract-progress.log
Output170420 17:23:32 [01] decrypting and decompressing ./performance_schema/socket_instances.frm.qp.xbcrypt
170420 17:23:32 [01] decrypting and decompressing ./performance_schema/events_waits_summary_by_user_by_event_name.frm.qp.xbcrypt
170420 17:23:32 [01] decrypting and decompressing ./performance_schema/status_by_user.frm.qp.xbcrypt
170420 17:23:32 [01] decrypting and decompressing ./performance_schema/replication_group_members.frm.qp.xbcrypt
170420 17:23:32 [01] decrypting and decompressing ./xtrabackup_logfile.qp.xbcrypt
170420 17:23:33 completed OK!


Finished work on incremental-04-20-2017_17-15-03.xbstream

Wenn wir in das Verzeichnis "+ restore +" wechseln, stehen jetzt die Verzeichnisse zur Verfügung, die den extrahierten Sicherungsdateien entsprechen:

cd restore
ls -F
Outputfull-04-20-2017_14-55-17/  incremental-04-20-2017_17-15-03/

Das Sicherungsverzeichnis enthält die unformatierten Sicherungsdateien, sie befinden sich jedoch noch nicht in einem Zustand, den MySQL verwenden kann. Um das zu beheben, müssen wir die Dateien vorbereiten.

Bereiten Sie die letzte Sicherung vor

Als nächstes bereiten wir die Sicherungsdateien vor. Dazu müssen Sie sich im Verzeichnis "+ restore " befinden, das die " full- " und alle " incremental- +" Sicherungen enthält. Das Skript wendet die Änderungen von allen inkrementellen Verzeichnissen auf das vollständige Sicherungsverzeichnis an. Anschließend werden die Protokolle angewendet, um ein konsistentes Dataset zu erstellen, das MySQL verwenden kann.

Wenn Sie aus irgendeinem Grund einige der Änderungen nicht wiederherstellen möchten, besteht jetzt die letzte Möglichkeit, diese inkrementellen Sicherungsverzeichnisse aus dem Verzeichnis "+ restore +" zu entfernen (die inkrementellen Sicherungsdateien sind weiterhin im übergeordneten Verzeichnis verfügbar). Alle verbleibenden inkrementellen Verzeichnisse innerhalb des aktuellen Verzeichnisses werden auf das vollständige Sicherungsverzeichnis angewendet.

Wenn Sie fertig sind, rufen Sie das Skript + prepare-mysql.sh + auf. Stellen Sie erneut sicher, dass Sie sich im Verzeichnis "+ restore +" befinden, in dem sich Ihre einzelnen Sicherungsverzeichnisse befinden:

sudo -u backup prepare-mysql.sh
OutputBackup looks to be fully prepared.  Please check the "prepare-progress.log" file
to verify before continuing.

If everything looks correct, you can apply the restored files.

First, stop MySQL and move or remove the contents of the MySQL data directory:

       sudo systemctl stop mysql
       sudo mv /var/lib/mysql/ /tmp/

Then, recreate the data directory and  copy the backup files:

       sudo mkdir /var/lib/mysql
       sudo xtrabackup --copy-back --target-dir=/backups/mysql/Thu/restore/full-04-20-2017_14-55-17

Afterward the files are copied, adjust the permissions and restart the service:

       sudo chown -R mysql:mysql /var/lib/mysql
       sudo find /var/lib/mysql -type d -exec chmod 750 {} \;
       sudo systemctl start mysql

Die obige Ausgabe zeigt an, dass das Skript der Ansicht ist, dass die Sicherung vollständig vorbereitet ist und dass die "+ full- " - Sicherung jetzt eine vollständig konsistente Datenmenge darstellt. Wie in der Ausgabe angegeben, sollten Sie die Datei " prepare-progress.log +" überprüfen, um sicherzustellen, dass während des Vorgangs keine Fehler gemeldet wurden.

Das Skript kopiert die Dateien nicht mehr in das Datenverzeichnis von MySQL, sodass Sie überprüfen können, ob alles korrekt aussieht.

Stellen Sie die Sicherungsdaten im MySQL-Datenverzeichnis wieder her

Wenn Sie sich nach Durchsicht der Protokolle davon überzeugt haben, dass alles in Ordnung ist, befolgen Sie die Anweisungen in der Ausgabe von "+ prepare-mysql.sh +".

Stoppen Sie zuerst den laufenden MySQL-Prozess:

sudo systemctl stop mysql

Da die Sicherungsdaten möglicherweise mit dem aktuellen Inhalt des MySQL-Datenverzeichnisses in Konflikt stehen, sollten wir das Verzeichnis + / var / lib / mysql + entfernen oder verschieben. Wenn Sie Speicherplatz auf Ihrem Dateisystem haben, ist die beste Option, den aktuellen Inhalt in das Verzeichnis "+ / tmp +" oder an eine andere Stelle zu verschieben, falls etwas schief geht:

sudo mv /var/lib/mysql/ /tmp

Erstellen Sie ein leeres "+ / var / lib / mysql" -Verzeichnis. Wir müssen die Berechtigungen in Kürze korrigieren, damit wir uns noch keine Sorgen machen müssen:

sudo mkdir /var/lib/mysql

Jetzt können wir die vollständige Sicherung mit dem Dienstprogramm + xtrabackup + in das MySQL-Datenverzeichnis kopieren. Ersetzen Sie den Pfad zu Ihrer vorbereiteten vollständigen Sicherung im folgenden Befehl:

sudo xtrabackup --copy-back --target-dir=/backups/mysql//restore/full-

Während des gesamten Vorgangs wird ein laufendes Protokoll der zu kopierenden Dateien angezeigt. Sobald die Dateien vorhanden sind, müssen wir den Besitz und die Berechtigungen erneut korrigieren, damit der MySQL-Benutzer und die Gruppe Eigentümer sind und auf die wiederhergestellte Struktur zugreifen können:

sudo chown -R mysql:mysql /var/lib/mysql
sudo find /var/lib/mysql -type d -exec chmod 750 {} \;

Unsere wiederhergestellten Dateien befinden sich jetzt im MySQL-Datenverzeichnis.

Starten Sie MySQL erneut, um den Vorgang abzuschließen:

sudo systemctl start mysql

Überprüfen Sie, ob die Daten wiederhergestellt wurden, indem Sie den Inhalt der Tabelle "+ playground.equipment" anzeigen. Erneut werden Sie aufgefordert, das MySQL-Passwort + root einzugeben, um fortzufahren:

mysql -u root -p -e 'SELECT * FROM playground.equipment;'
Output+----+-------+-------+--------+
| id | type  | quant | color  |
+----+-------+-------+--------+
|  1 | slide |     2 | blue   |
|  2 | swing |    10 | yellow |
+----+-------+-------+--------+
2 rows in set (0.02 sec)

Unsere Daten wurden erfolgreich wiederhergestellt.

Nach dem Wiederherstellen Ihrer Daten ist es wichtig, das Verzeichnis "+ restore +" zu löschen. Zukünftige inkrementelle Sicherungen können nach der Vorbereitung nicht mehr auf die vollständige Sicherung angewendet werden. Daher sollten wir sie entfernen. Darüber hinaus sollten die Sicherungsverzeichnisse aus Sicherheitsgründen nicht unverschlüsselt auf der Festplatte belassen werden:

cd ~
sudo rm -rf /backups/mysql/"$(date +%a)"/restore

Wenn wir das nächste Mal eine saubere Kopie der Sicherungsverzeichnisse benötigen, können wir sie erneut aus den Sicherungsdateien extrahieren.

Erstellen eines Cron-Jobs zum stündlichen Ausführen von Sicherungen

Nachdem wir überprüft haben, dass der Sicherungs- und Wiederherstellungsprozess reibungslos funktioniert, sollten wir einen "+ cron +" - Job einrichten, um automatisch regelmäßige Sicherungen durchzuführen.

Wir erstellen ein kleines Skript im Verzeichnis "+ / etc / cron.hourly ", um unser Backup-Skript automatisch auszuführen und die Ergebnisse zu protokollieren. Der ` cron +` Prozess wird automatisch jede Stunde ausgeführt:

sudo nano /etc/cron.hourly/backup-mysql

Im Inneren rufen wir das Backup-Skript mit dem Dienstprogramm + systemd-cat + auf, damit die Ausgabe im Journal verfügbar ist. Wir werden sie mit einem "+ backup-mysql" -Kennzeichen kennzeichnen, damit wir die Protokolle leicht filtern können:

/etc/cron.hourly/backup-mysql

#!/bin/bash
sudo -u backup systemd-cat --identifier=backup-mysql /usr/local/bin/backup-mysql.sh

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Machen Sie das Skript ausführbar, indem Sie Folgendes eingeben:

sudo chmod +x /etc/cron.hourly/backup-mysql

Das Backup-Skript wird nun stündlich ausgeführt. Das Skript selbst übernimmt die Bereinigung von Backups, die älter als drei Tage sind.

Wir können das + cron + Skript testen, indem wir es manuell ausführen:

sudo /etc/cron.hourly/backup-mysql

Überprüfen Sie nach Abschluss des Vorgangs das Journal auf die Protokollnachrichten, indem Sie Folgendes eingeben:

sudo journalctl -t backup-mysql
Output-- Logs begin at Wed 2017-04-19 18:59:23 UTC, end at Thu 2017-04-20 18:54:49 UTC. --
Apr 20 18:35:07 myserver backup-mysql[2302]: Backup successful!
Apr 20 18:35:07 myserver backup-mysql[2302]: Backup created at /backups/mysql/Thu/incremental-04-20-2017_18-35-05.xbstream

Versuchen Sie es in ein paar Stunden erneut, um sicherzustellen, dass zusätzliche Sicherungen erstellt werden.

Fazit

In diesem Handbuch haben wir die Percona Xtrabackup-Tools installiert, um regelmäßig Live-Snapshots unserer MySQL-Daten zu erstellen. Wir haben einen MySQL- und einen Systemsicherungsbenutzer konfiguriert, einen Verschlüsselungsschlüssel zum Sichern unserer Sicherungsdateien eingerichtet und dann Skripts eingerichtet, um Teile der Sicherungs- und Wiederherstellungsvorgänge zu automatisieren.

Das Sicherungsskript erstellt zu Beginn eines jeden Tages eine vollständige Sicherung und anschließend jede Stunde inkrementelle Sicherungen, wobei drei Sicherungstage zu jeder Zeit aufbewahrt werden. Die verschlüsselten Dateien und der Verschlüsselungsschlüssel können in Verbindung mit anderen Sicherungstechnologien verwendet werden, um die Daten zur sicheren Aufbewahrung außerhalb des Standorts zu übertragen. Mit den Extraktions- und Vorbereitungsskripten können wir die Backups des Tages zu einem konsistenten Satz von Daten zusammenfassen, die zur Wiederherstellung des Systems verwendet werden können.

Related