TOC

So automatisieren Sie Backups mit DigitalOcean Spaces

Einführung

Das Sichern wichtiger Daten ist ein wesentlicher Bestandteil der Verwaltung jeder Computerinfrastruktur. Obwohl die Anforderungen aller Benutzer bei der Durchführung von Sicherungen unterschiedlich sind, empfiehlt es sich, die Sicherungsdaten an einem externen Standort zu speichern.

Das Versenden von Kopien von Daten an einen externen Standort war bisher eine große logistische Herausforderung. Aber mit dem Aufkommen von Cloud-basierten Speicherdiensten wie Crashplan und Dropbox sowie der Entwicklung von Objektspeicherlösungen wie DigitalOcean Räume, ist es jetzt eine viel einfachere Aufgabe geworden. Nichtsdestotrotz kann das Sichern von Dateien und das zeitaufwendige Hochladen ein Hindernis für einige sein.

Aus diesem Grund verwenden die Benutzer verschiedene Tools, um routinemäßig automatische Sicherungen ihrer wichtigen Daten durchzuführen. In diesem Tutorial erstellen wir ein Skript rund um das Befehlszeilentool "+ s3cmd ", mit dem Sie Daten schnell in DigitalOcean Spaces hochladen können. Wir werden dann " crontab +" verwenden, um regelmäßig das Backup-Skript aufzurufen und Dateien in unseren Space hochzuladen.

Voraussetzungen

Für dieses Tutorial benötigen Sie:

Eine gewisse Vertrautheit mit Shell-Skripten und dem Job-Scheduler von + cron + könnte ebenfalls hilfreich sein. Lesen Sie für einige Anleitungen und zusätzlichen Kontext "https://www.digitalocean.com/community/tutorial_series/an-introduction-to-shell-scripting[An Introduction to Shell Scripting]" und "https: //www.digitalocean" .com / community / tutorials / routineaufgaben mit cron und anacron auf vps planen [Planen von Routineaufgaben mit Cron und Anacron auf einem VPS]. “

Wenn unsere Voraussetzungen erfüllt sind, können wir mit dem Automatisierungsprozess für Sicherungen beginnen.

Erstellen unseres Backup-Skripts

Es gibt eine Reihe von Tools, mit denen Sicherungsdateien automatisch und in regelmäßigen Abständen auf einen Objektspeicherdienst hochgeladen werden können. Diese können jedoch schwierig zu konfigurieren sein und bieten möglicherweise nicht viel Flexibilität. Die Verwendung eines einfachen Shell-Skripts kann eine viel elegantere und einfachere Methode zur Automatisierung von Objektspeichersicherungen sein.

In diesem Tutorial schreiben wir ein einfaches Bash-Skript, mit dem eine Sicherungskopie einer Datei oder eines Verzeichnisses mit + tar + erstellt wird. Das Skript lädt diese Sicherung dann mit dem Befehlszeilenprogramm + s3cmd + in Spaces hoch.

Melden Sie sich zunächst in Ihrem Droplet an und navigieren Sie zu Ihrem Basisordner:

cd ~

Sobald wir uns im Home-Ordner befinden, erstellen wir mit "+ nano +" eine leere Datei, in die wir in unserem Skript schreiben können:

nano

Jetzt können Sie mit dem Schreiben unseres Sicherungsskripts im Texteditor beginnen. Während wir das Skript erstellen, werden wir jeden Teil in der angegebenen Reihenfolge abschnittsweise erläutern.

Initiieren unseres Skripts

Zu diesem Zeitpunkt ist ++ nur eine leere Textdatei. Damit unser Computer unsere ausführbare Datei als Befehle aufrufen kann, müssen wir unser Skript mit einem Hash-Bang beginnen. Ein * hashbang * ist eine Interpreter-Direktive, mit der Skripte oder Datendateien als Befehle ausgeführt werden können.

In unserem Fall sieht der Hashbang folgendermaßen aus:

bkupscript.sh

#!/bin/bash

Indem wir dies oben im Skript einfügen, weisen wir die Shell an, die Befehle der Datei in bash auszuführen.

Variablen deklarieren

Als Nächstes teilen wir unserem Skript die Variablen mit, die es wissen muss, um richtig zu funktionieren. Wir können diese direkt unterhalb des Hashbangs am oberen Rand der Textdatei hinzufügen:

bkupscript.sh

...
DATETIME=`date +%y%m%d-%H_%M_%S`
SRC=$1
DST=$2
GIVENNAME=$3

Lass uns durchgehen, was wir jeder dieser Variablen zuweisen:

  • + DATETIME +: Diese Variable enthält einen Zeitstempel, der an den resultierenden Dateinamen angehängt wird, sodass jede in unserem Space gesicherte Datei einen eindeutigen Namen hat. Dieser Zeitstempel wird erstellt, indem der Befehl "+ Datum " aufgerufen und die Ausgabe formatiert wird, um die letzten beiden Ziffern des Jahres ("% y "), die beiden Ziffern des Monats ("% m "), anzuzeigen des Tages ("% d "), der Stunde ("% H "), der Minuten ("% M ") und der Sekunden ("% S +").

  • + SRC +: Dies ist der * Quell * -Pfad für die zu sichernde Datei oder den Ordner. Das + $ 1 + zeigt an, dass wir diesen Wert aus dem ersten an das Skript übergebenen Parameter übernehmen.

  • + DST +: Diese Variable repräsentiert das * Ziel * der Datei. In unserem Fall ist dies der Name des Space, in den wir das Backup hochladen. Dieser Name stammt aus dem zweiten Parameter, der an das Skript übergeben wird, wie durch "+ $ 2 +" angegeben.

  • + GIVENNAME +: Diese Variable enthält den vom Benutzer gewählten Namen für die Zieldatei. Der resultierende Dateiname beginnt mit "+ GIVENNAME " und ist mit " DATETIME " verknüpft. Dieser Name stammt aus dem dritten Parameter, der an das Skript übergeben wird (` $ 3 +`).

Hilfe leisten

Wenn Sie ein Skript schreiben, ist es hilfreich, einige Tipps oder allgemeine Ratschläge hinzuzufügen, die Benutzern bei der Fehlerbehebung helfen können, wenn ihre Versuche, es zu verwenden, fehlschlagen.

Für unser Backup-Skript fügen wir eine Funktion mit dem Namen "+ showhelp () +" unter unseren Variablen hinzu. Dadurch wird eine Reihe von Meldungen gedruckt, die Benutzern bei der Problembehandlung helfen, falls das Skript fehlschlägt. Wenn Sie eine Funktion in bash hinzufügen, sieht unsere Syntax folgendermaßen aus:

bkupscript.sh

...
showhelp(){

}

Diese Funktion gibt Hilfemeldungen aus, indem eine Reihe von Verwendungsanweisungen auf dem Bildschirm angezeigt werden. Jede Anweisung sollte in Anführungszeichen gesetzt werden. In unserem folgenden Beispiel werden Sie feststellen, dass einige der Zeichenfolgen am Anfang oder Ende mit + \ t + oder + \ n + geschrieben sind. Hierbei handelt es sich um escape-Zeichen, die spezifische Anweisungen dafür enthalten, wie die Zeichenfolge in der Ausgabe des Skripts angezeigt werden soll:

  • + \ t + zeigt einen Tabulatorraum an

  • + \ n + zeigt einen Zeilenumbruch an

Fühlen Sie sich frei, zwischen den geschweiften Klammern alle Verwendungsdetails hinzuzufügen, die für Sie hilfreich wären (denken Sie daran, vor einer Zeichenfolge das Zeichen "+ echo +" einzufügen). Zu Demonstrationszwecken werden wir Folgendes hinzufügen:

bkupscript.sh

echo "\n\n############################################"
echo "# bkupscript.sh                            #"
echo "############################################"
echo "\nThis script will backup files/folders into a single compressed file and will store it in the current folder."
echo "In order to work, this script needs the following three parameters in the listed order: "
echo "\t- The full path for the folder or file you want to backup."
echo "\t- The name of the Space where you want to store the backup at."
echo "\t- The name for the backup file (timestamp will be added to the beginning of the filename)\n"
echo "Example: sh bckupscript.sh ./testdir testSpace backupdata\n"<^>

Die letzte "+ showhelp +" - Funktion sollte ungefähr so ​​aussehen:

bkupscript.sh

...
showhelp(
       echo "\n\n############################################"
       echo "# bkupscript.sh                            #"
       echo "############################################"
       echo "\nThis script will backup files/folders into a single compressed file and will store it in the current folder."
       echo "In order to work, this script needs the following three parameters in the listed order: "
       echo "\t- The full path for the folder or file you want to backup."
       echo "\t- The name of the Space where you want to store the backup at."
       echo "\t- The name for the backup file (timestamp will be added to the beginning of the filename)\n"
       echo "Example: sh bckupscript.sh ./testdir testSpace backupdata\n"
}

Mit unserem Hilfetext können wir die Dateien, die wir sichern möchten, in unserem Space sammeln.

Dateien sammeln

Bevor unser Skript irgendetwas in unseren Space übertragen kann, muss es zuerst die richtigen Dateien sammeln und sie in einem einzigen Paket zusammenfassen, damit wir sie hochladen können. Wir können dies erreichen, indem wir das Dienstprogramm "+ tar " und eine bedingte Anweisung verwenden. Da wir " tar " verwenden, um eine Archivdatei (manchmal auch als "zip" -Datei bezeichnet) zu erstellen, rufen wir diese Funktion " tarandzip () +" auf.

Beginnen wir mit der Deklaration der Funktion und dem Hinzufügen eines weiteren "+ echo +" - Befehls, um den Benutzern mitzuteilen, dass das Skript mit dem Sammeln von Dateien begonnen hat:

bkupscript.sh

...
tarandzip(){
   echo "\n##### Gathering files #####\n"
}

Unter dem Befehl "+ echo " können wir einen Befehl " tar +" hinzufügen, der das Sammeln und Komprimieren der Dateien in eine einzige Ausgabedatei übernimmt.

bkupscript.sh

tarandzip(){
   echo "\n##### Gathering files #####\n"

}

Sie werden feststellen, dass dieser Befehl "+ tar +" mit verschiedenen Optionen und Variablen aufgerufen wird:

  • + c ++: Dieses Flag weist + tar an, die Ausgabedatei zu komprimieren.

  • + z +: Dies weist + tar + an, die Datei mit + gzip + zu komprimieren.

  • + v +: Dies kennzeichnet die Option + verbose +, mit der + tar + angewiesen wird, weitere Informationen in der Ausgabe anzuzeigen.

  • + f +: Dieses Flag weist + tar + an, die Datei unter dem als nächstes angegebenen Dateinamen zu speichern.

  • + $ GIVENNAME- $ DATETIME.tar.gz +: Das Skript ruft diese Variablen auf, die wir zu Beginn deklariert haben, um den neuen Dateinamen zu erstellen. Dazu werden die Variablen "+ $ GIVENNAME " und " $ DATETIME " kombiniert und am Ende die Erweiterung " .tar.gz +" hinzugefügt, um den neuen Dateinamen zu bilden.

  • + $ SRC +: Diese Variable repräsentiert die Source-Dateien oder -Ordner, die mit + tar + gesichert werden sollen.

Diese Funktion sollte nun in der Lage sein, das zu tun, was wir wollen, aber wir können ein paar weitere "+ echo +" - Aufrufe hinzufügen, um dem Benutzer einige zusätzliche Informationen über die Funktionsweise des Skripts zu geben. Dies kann durch Hinzufügen einiger bedingter Anweisungen wie folgt erreicht werden:

bkupscript.sh

    tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC;

Wenn die "+ if " - Klausel aufgerufen wird, führt sie den Befehl " tar " aus und wartet auf das Ergebnis. Wenn das Ergebnis für den Befehl positiv ist (was bedeutet, dass er erfolgreich ausgeführt wurde), werden die Zeilen zwischen ` then ` und ` else +` ausgeführt. Diese sind:

  • Echo einer Nachricht, dass das Skript den Prozess "+ tar +" erfolgreich abgeschlossen hat

  • Rückgabe eines Fehlercodes von "+ 0 +", damit der Teil des Codes, der diese Funktion aufruft, weiß, dass alles gut funktioniert hat.

Der Teil "+ else " dieser Funktion wird nur ausgeführt, wenn der Befehl " tar " während der Ausführung einen Fehler findet. In diesem Fall wird der Zweig " else +" der Klausel:

  • Echo eine Nachricht, die angibt, dass der Befehl "+ tar +" fehlgeschlagen ist

  • Geben Sie den Fehlercode "+ 1 +" zurück, um anzuzeigen, dass ein Fehler aufgetreten ist

Schließlich beenden wir die + if / then / else + -Klausel mit einem + fi +, was in der Bash-Sprache bedeutet, dass die + if + -Klausel beendet wurde.

Die fertige Funktion + tarandzip () + sieht folgendermaßen aus:

bkupscript.sh

tarandzip(){
   echo "\n##### Gathering files #####\n"
   if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
       echo "\n##### Done gathering files #####\n"
       return 0
   else
       echo "\n##### Failed to gather files #####\n"
       return 1
   fi
}

Mit unserer Funktion + tarandzip () + können wir das Skript für das Verschieben unserer Backups einrichten.

Übertragen von Dateien in den Objektspeicher

Zu diesem Zeitpunkt können wir Ihr Sicherungsskript dazu bringen, eine Datei mit dem Befehl "+ s3cmd" in unseren Space zu übertragen. Wie bei "+ tarandzip " können wir auch einige Zeichenfolgen " echo " und eine " if / then / else +" - Anweisung verwenden, um die Benutzer auf dem Laufenden zu halten.

Zuerst werden wir unsere Funktion deklarieren. Lassen Sie uns das noch einmal einfach halten und es "+ movetoSpace () +" nennen:

bkupscript.sh

...
movetoSpace(){

}

Jetzt können wir + s3cmd + und die zuvor deklarierten Variablen verwenden, um den Befehl zu erstellen, mit dem unsere Sicherungsdateien in unseren Space verschoben werden:

bkupscript.sh

movetoSpace(){

}

Die einzelnen Teile dieses Befehls haben folgende Bedeutung:

  • + ~ / s3cmd-2.0.1 / s3cmd +: Dies ruft + s3cmd + auf, eine command Linientool zum Verwalten von Objektspeicherbereichen.

  • + put +: Dies ist ein Befehl, der von + s3cmd + zum Hochladen von Daten in einen Bucket verwendet wird.

  • + $ GIVENNAME- $ DATETIME.tar.gz +: Dies ist der Name des Backups, das in unseren Space hochgeladen wird. Es besteht aus der vierten und ersten Variablen, die wir deklariert haben, gefolgt von + .tar.gz + und wird von der Funktion + tarandzip () + aus früheren Versionen erstellt.

  • + s3: // $ DST; +: Dies ist der Ort, an den wir die Datei hochladen möchten. + s3: // + ist ein URI-ähnliches Schema, das speziell zum Beschreiben von Objektspeicherorten im Internet verwendet wird, während + $ DST; + die dritte Variable ist, die wir zuvor deklariert haben.

Wir haben jetzt eine Funktion, mit der Sie Ihre archivierten Dateien in unseren Space hochladen können. Es benachrichtigt den Benutzer jedoch nicht über seinen Status. Ändern Sie dies, indem Sie eine Zeichenfolge vor dem Befehl wiederholen, um den Benutzer darüber zu informieren, dass sie gestartet wurde, und um uns nach Abschluss der Funktion mitzuteilen, ob sie erfolgreich war.

Beginnen wir damit, dem Benutzer mitzuteilen, dass der Prozess begonnen hat:

bkupscript.sh

movetoSpace(){

   ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST
}

Da der Befehl entweder erfolgreich oder nicht erfolgreich ist (dh, die Dateien werden entweder in unseren Space hochgeladen oder nicht), können wir den Benutzern mitteilen, ob er funktioniert hat, indem wir eine der beiden Zeichenfolgen wiederholen, die in einem `+ if / then enthalten sind / else + `Anweisung, wie folgt:

bkupscript.sh

...
~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST

Diese bedingte Anweisung teilt bash mit: „Wenn unser Befehl` + s3cmd + `korrekt funktioniert, teilen Sie dem Benutzer mit, dass das Skript das Verschieben von Dateien in unseren Space abgeschlossen hat. Ansonsten teilen Sie dem Benutzer mit, dass der Vorgang fehlgeschlagen ist. “

Wenn der Vorgang "+ s3cmd " erfolgreich abgeschlossen wurde, gibt die Funktion eine Meldung auf dem Bildschirm aus (die erste Zeichenfolge " echo " in der Anweisung " then ") und gibt den informierenden Wert " 0 " zurück die aufrufende Funktion, mit der die Operation abgeschlossen wurde. Wenn der Prozess fehlschlägt, gibt die ` then` -Klausel einfach die Fehlermeldung (die zweite` + echo` -String) aus und gibt ein + 1 + zurück, sodass der Rest des Skripts weiß, dass ein Fehler aufgetreten ist.

Insgesamt sollte die Funktion + movetoSpace () + so aussehen:

bkupscript.sh

movetoSpace(){
   echo "\n##### MOVING TO SPACE #####\n"
   if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
       echo "\n##### Done moving files to s3://"$DST" #####\n"
       return 0
   else
       echo "\n##### Failed to move files to the Space #####\n"
       return 1
   fi
}

Mit der geschriebenen Funktion + movetoSpace () + können wir sicherstellen, dass das Skript so eingerichtet ist, dass Funktionen in der erwarteten Reihenfolge aufgerufen werden, indem bedingte Anweisungen für die Flusssteuerung verwendet werden.

Flow Control einrichten

Obwohl wir unser Skript mit Funktionen eingerichtet haben, haben wir keine Anweisung angegeben, dass das Skript diese Funktionen ausführen soll. An dieser Stelle können wir eine aufrufende Funktion einführen, die dem Rest des Skripts genau mitteilt, wie und wann die anderen von uns geschriebenen Funktionen ausgeführt werden sollen.

Unter der Annahme, dass alles korrekt konfiguriert wurde, sollte beim Ausführen des Skripts der Eingabebefehl gelesen, die Werte jeder Variablen zugewiesen, die Funktion + tarandzip () + ausgeführt und anschließend die Funktion + movetoSpace () + verwendet werden `Funktion. Sollte das Skript zwischen diesen Punkten fehlschlagen, sollte es die Ausgabe unserer Funktion `+ showhelp () + ausgeben, um den Benutzern bei der Fehlerbehebung zu helfen. Wir können dies bestellen und Fehler abfangen, indem wir eine Reihe von "+ if / then / else" -Anweisungen am Ende der Datei hinzufügen:

bkupscript.sh

...
if [ ! -z "$GIVENNAME" ]; then
   if tarandzip; then
       movetoSpace
   else
       showhelp
   fi
else
   showhelp
fi

Die erste "+ if +" - Anweisung im obigen Abschnitt prüft, ob die dritte übergebene Variable nicht leer ist. Dies geschieht auf folgende Weise:

  • + [] +: Die eckigen Klammern zeigen an, dass sich zwischen ihnen ein test befindet. In diesem Fall wird geprüft, ob eine bestimmte Variable nicht leer ist.

  • +! +: In diesem Fall bedeutet dieses Symbol + nicht +.

  • + -z +: Diese Option zeigt eine leere Zeichenkette an. In Kombination mit dem ! _ Fordern wir daher _keine leere Zeichenfolge an.

  • + $ GIVENNAME +: Hier geben wir an, dass die Zeichenfolge, die nicht leer sein soll, der Wert ist, der der Variablen + $ GIVENNAME + zugewiesen wurde. Wir haben diesen Ansatz gewählt, weil dieser Variablen der Wert zugewiesen wird, den der dritte Parameter beim Aufruf des Skripts über die Befehlszeile übergibt. Wenn wir weniger als 3 Parameter an das Skript übergeben, enthält der Code keinen dritten Parameter, um den Wert _ $ GIVENNAME_ zuzuweisen. Daher wird eine leere Zeichenfolge zugewiesen, und dieser Test schlägt fehl.

Angenommen, dieser erste Test ist erfolgreich, dann wird mit der nächsten "+ if +" - Anweisung fortgefahren und so weiter. Wenn eine der + if + -Anweisungen einen Fehler zurückgibt, ruft die then -Klausel die showhelp -Funktion auf und der Hilfetext wird in der Ausgabe angezeigt. Dies führt im Wesentlichen alle zuvor beschriebenen Funktionen zusammen und gibt bash die erforderlichen Informationen, um sie in der richtigen Reihenfolge auszuführen.

Unser Skript ist jetzt fertig! Sie können überprüfen, ob Ihr Skript dem vollständigen Skript entspricht, das wir im folgenden Abschnitt erstellt haben.

Das vollständige Skript

Das fertige Backup-Skript, das wir erstellt haben, sollte folgendermaßen aussehen:

bkupscript.sh

#!/bin/bash
DATETIME=`date +%y%m%d-%H_%M_%S`
SRC=$1
DST=$2
GIVENNAME=$3
showhelp(){
       echo "\n\n############################################"
       echo "# bkupscript.sh                            #"
       echo "############################################"
       echo "\nThis script will backup files/folders into a single compressed file and will store it in the current folder."
       echo "In order to work, this script needs the following three parameters in the listed order: "
       echo "\t- The full path for the folder or file you want to backup."
       echo "\t- The name of the Space where you want to store the backup at (not the url, just the name)."
       echo "\t- The name for the backup file (timestamp will be added to the beginning of the filename)\n"
       echo "Example: sh bkupscript.sh ./testdir testSpace backupdata\n"
}
tarandzip(){
   echo "\n##### Gathering files #####\n"
   if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
       echo "\n##### Done gathering files #####\n"
       return 0
   else
       echo "\n##### Failed to gather files #####\n"
       return 1
   fi
}
movetoSpace(){
   echo "\n##### MOVING TO SPACE #####\n"
   if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
       echo "\n##### Done moving files to s3://"$DST" #####\n"
       return 0
   else
       echo "\n##### Failed to move files to the Space #####\n"
       return 1
   fi
}
if [ ! -z "$GIVENNAME" ]; then
   if tarandzip; then
       movetoSpace
   else
       showhelp
   fi
else
   showhelp
fi

Nachdem Sie Ihr Skript überprüft haben, müssen Sie die Datei speichern und schließen (+ CTRL-x +, + y +, dann + ENTER +), bevor Sie nano beenden.

Testen des Skripts

Nachdem wir mit dem Erstellen des Skripts fertig sind, können wir es testen. Dies sagt uns nicht nur, ob wir das Skript richtig geschrieben haben, sondern gibt uns auch die Möglichkeit, die Verwendung des Skripts zu üben und es in Aktion zu sehen.

Wenn Sie ein solches Skript testen, ist es normalerweise eine gute Idee, Dummy-Dateien zu verwenden. Obwohl wir wissen, dass es nicht in der Lage ist, Daten zu zerstören oder zu entfernen, ist es klug, auf Nummer sicher zu gehen, indem Sie es mit einigen unwichtigen Dateien testen. Wir erstellen zuerst ein Verzeichnis mit dem Befehl "+ mkdir +":

mkdir

Als nächstes erstellen wir zwei leere Dateien in diesem Verzeichnis mit "+ touch +":

sudo touch
sudo touch

Wir können das Skript jetzt testen, indem wir das Verzeichnis "++" und seinen Inhalt in unseren Space hochladen. Dies ist das Format, das wir verwenden müssen, um das Skript aufzurufen:

sh bkupscript.sh

Der obige Befehl setzt das Skript in Bewegung und die Ausgabe sollte folgendermaßen aussehen:

Output
##### Gathering files #####

./backupthis/
./backupthis/file1.txt
./backupthis/file2.txt

##### Done gathering files #####


##### MOVING TO SPACE #####

upload: '.tar.gz' -> 's3:// /.tar.gz'  [1 of 1]
162 of 162   100% in    8s    19.81 B/s  done

##### Done moving files to s3:// #####

Wenn Sie auf Fehler stoßen, überprüfen Sie Ihr Skript, um sicherzustellen, dass es unserem Beispiel entspricht. Stellen Sie außerdem sicher, dass Ihre Installation von "+ s3cmd +" ordnungsgemäß konfiguriert wurde und dass sowohl der Zugriffsschlüssel als auch der von Ihnen verwendete geheime Schlüssel korrekt sind.

Automatisieren von Backups mit Crontab

Nachdem wir das Backup-Skript erfolgreich getestet haben, können wir einen + cron + - Job einrichten, der das Skript verwendet, um regelmäßige Backups in unserem Space durchzuführen. In diesem Lernprogramm wird festgelegt, dass das Sicherungsskript jede Minute ausgeführt wird.

Zuerst müssen wir das Skript ausführbar machen:

chmod +x bkupscript.sh

Da das Skript nun als Befehl ausgeführt werden kann, können wir die Datei "+ crontab +" bearbeiten, um das Skript jede Minute auszuführen:

crontab -e

Wenn Sie + crontab -e + zum ersten Mal ausführen, werden Sie aufgefordert, einen Editor aus einer Liste auszuwählen:

no crontab for root - using an empty one
Select an editor.  To change later, run 'select-editor'.
 1. /bin/ed
 2. /bin/nano        <---- easiest
 3. /usr/bin/vim.basic
 4. /usr/bin/vim.tiny
Choose 1-4 [2]:

Sie können den Standard-Nano oder einen anderen Texteditor Ihrer Wahl auswählen.

Sobald wir in + crontab + sind, werden wir die folgende Zeile am Ende der bereits vorhandenen Werte einfügen:

/tmp/crontab.example/crontab

* * * * * ~/bkupscript.sh

Um die Änderungen zu speichern, drücken Sie + CTRL-x +, dann + y + und dann + ENTER +.

Nach ungefähr einer Minute sehen Sie eine neue Datei im Dashboard Ihres Space!

Wenn Sie den Job + cron + laufen lassen, ohne Änderungen vorzunehmen, wird jede Minute eine neue Datei in Ihren Space kopiert. Nachdem Sie bestätigt haben, dass "+ cron " erfolgreich ausgeführt wird, können Sie " crontab +" so konfigurieren, dass Ihre Dateien in dem gewünschten Intervall gesichert werden.

Sie haben jetzt ein Skript, das Ihre Backups regelmäßig komprimiert und an einen DigitalOcean Space sendet!

Fazit

In diesem Tutorial wurde erläutert, wie Sie regelmäßig geplante Offsite-Sicherungen Ihrer wichtigen Dateien mit einem Bash-Skript, "+ crontab +" und DigitalOcean Spaces erstellen. Obwohl das in diesem Tutorial vorgestellte Skript nur zu Demonstrationszwecken gedacht ist, kann es als Grundlage für die Erstellung einer produktionsbereiten Version verwendet werden, die später in eine CI / CD-Lösung wie Jenkins integriert werden kann , Drone oder Travis CI.

Wenn Sie mehr über CI / CD-Tools erfahren möchten, lesen Sie die folgenden Tutorials:

Related