So verwenden Sie Inotify und RSYNC, um ein Live -Backup -System zu erstellen

Warum sollten Sie Bash -Skripte verwenden, um Ordnersynchronisationen und Backups durchzuführen?

Bash ist bei weitem der beliebteste und verwendete SH-kompatible Befehlssprache Interpreter. Heute finden Sie Bash fast überall, einschließlich Microsoft Windows mit dem neuen Windows -Subsystem für Linux. Praktisch die gesamte GNU/Linux -Verteilung wird mit Bash als Standardschale geliefert. Gleiches gilt für macOS und einige andere Unix-ähnliche Betriebssysteme.

Bash ist nicht nur eine Befehlssprache; Wie andere Unix -Muscheln, Bash ist sowohl eine Programmiersprache als auch ein Befehlsinterpreter. Technisch gesehen gibt die Programmierseite einer Shell die Benutzerfähigkeiten und -funktionen, um System- oder Shell -Dienstprogramme in einer Datei zu kombinieren. Der Benutzer kann Befehle erstellen, indem sie Befehle in einer Textdatei kombinieren. Diese speziellen Arten von Textdateien, die eine Sammlung von Befehlen enthalten.

Der Vorteil eines Bash-Skripts besteht darin, dass Sie Befehlszeilen-Tools direkt darin verwenden können, ohne dass importieren oder externe Bibliotheken für die Quelle erforderlich sind. Diese Befehlszeilenwerkzeuge und integrierten Dienstprogramme sind leistungsstark und können direkt mit dem Betriebssystem ohne Zusammenstellung oder zusätzlichen Dolmetscher interagieren. Normalerweise Kernversorger und Befehlszeilenschnittstellen wie awk, Xargs, finden, Und Grep, kann eine viel bessere Leistung haben als beispielsweise Python -Skripte und seine Bibliotheken zu verwenden. Es ist nicht schwierig, Personen zu finden, die erweiterte Datenanalysen mit nur Bash-Skript und GNU-integrierten Dienstprogrammen durchführen. Andere behaupten, dass diese Art von Ansatz 235 x schneller sein kann als ein Hadoop -Cluster - was nicht so schwer zu glauben ist.

In dieser Angelegenheit stellt sich immer eine Frage: Wenn Bash so leistungsfähig ist, verwenden Sie sie nicht, um alle langweiligen Dinge zu automatisieren? Die Bash -Syntax ist einfach und pragmatisch: Sie können Programme kombinieren, um gemeinsame Aufgaben zu automatisieren. Wenn das Skript jedoch mit mehreren Bedingungen umgehen oder zu viele Zwecke ansammeln, ist es an der Zeit, eine robustere Programmiersprache wie C oder andere Skriptsprachen zu berücksichtigen, in denen Python und Perl gute Beispiele sind.

Auf der anderen Seite eignen sich Bash -Skripte sehr gut für einzelne Aufgaben wie die Absicht dieses Artikels: Kombinieren Sie Versorgungsunternehmen mit Funktionen, um Änderungen in einem bestimmten Ordner zu überprüfen und dann die Dateien zu synchronisieren. Ein Bash -Skript kann perfekt zu dieser Aufgabe passen.

Was benötigen Sie, um Synkronisierung oder Autobackups durchzuführen??

Es gibt eine große Liste verschiedener Methoden, um Ordner und Dateien zu synchronisieren. Die Anzahl der Anwendungen, die verwendet werden können, um diese einfache Aufgabe zu erfüllen. Jedoch, Dieser Artikel zeigt Ihnen eine eleganter inotifywait Und rsync in einem Bash -Skript. Im Allgemeinen wird diese Lösung leicht, kostengünstig sein und, warum nicht, sicherer. Im Wesentlichen sind nur inotifizierte Tools, RSYNC und eine Weile Schleife erforderlich, um diese Mission abzuschließen.

So verwenden Sie Inotifywait für Autobacks und Synkretationen?

inotifywait Verwendet inotifizierende API, um auf Änderungen in Dateien zu warten. Dieser Befehl wurde speziell für die Verwendung in Shell -Skripten entwickelt. Ein mächtiges Merkmal von inotifywait ist kontinuierlich auf Änderungen zu überprüfen; Sobald neue Ereignisse auftreten, inotifywait druckt die Änderungen und Ausgänge aus.

inotifywait Bietet zwei Optionen, die für Ordnersynchronisation oder Echtzeit-Backups sehr interessant sind. Der erste ist der -R, -rekursiv Möglichkeit; Wie der Name schon sagt, beobachtet diese Flag inotifywait, ohne symbolische Links.

Der -e, -Fall Flag bietet eine weitere interessante Funktion. Diese Option erfordert eine Liste der vordefinierten Ereignisse. Inotify-Tool-Dokumentation listet mehr als 15 Ereignisse für auf inotifywait; Ein einfaches Sicherungs- und Synchronisationssystem erfordert jedoch nur das Löschen, Ändern und Erstellen von Ereignissen.
Der folgende Befehl ist ein gutes Beispiel für ein reales Szenario:

$ InotifyWait -r -e ändern, erstellen, löschen/home/userDir/Dokumente

In diesem Fall wartet der Befehl auf Änderungen - Änderungen, Datei- oder Ordnerkreationen oder Ausschlüsse jeglicher Art - im fiktiven /Home/UserDir/Dokumente Verzeichnis. Sobald der Benutzer Änderungen vornimmt, inotifywait Ausgibt die Modifikation und den Ausgang.

Angenommen, Sie erstellen eine neue Datei mit dem Namen neue Datei in der Unterlagen Ordner während der inotifywait überwacht es. Sobald der Befehl die Dateierstellung erkannt hat, gibt er aus

Dokumente/ Neufile erstellen

Mit anderen Worten, inotifywait Drucke, bei denen die Änderung erfolgt, welche Art von Änderungen sie vorgenommen haben, und der Name der Datei oder des Ordners, die geändert wurden.

Untersuchung des Exit -Status von inotifywait Wenn eine Änderung stattfindet, sehen Sie einen Status von 0-Exit, der eine erfolgreiche Ausführung bedeutet. Diese Situation ist perfekt für ein Shell -Skript, da ein Exit -Status als wahrer oder falscher Zustand verwendet werden kann.

Infolgedessen ist der erste Schritt des Skripts abgeschlossen: ein Dienstprogramm zu finden, das auf Änderungen der Verzeichnisse wartet. Die zweite besteht darin, nach einem Dienstprogramm zu suchen, das zwei Verzeichnisse synchronisieren kann, und rsync ist ein perfekter Kandidat.

So verwenden Sie RSYNC für Autobackups?

rsync ist eine leistungsstarke Anwendung. Sie können ein Buch schreiben, das alles beschreibt, was Sie mit diesem vielseitigen Dienstprogramm tun können. Technisch ausgedrückt, rsync ist nichts weiter als ein Datei-Coping-Tool, eine Art Art von CP Befehl mit Steroiden und speziellen Befugnissen wie sichern Übertragungsdateien. Die Verwendung von rsync In diesem Skript ist bescheidener, aber nicht weniger elegant.

Das Hauptziel ist es, einen Weg zu finden:

• In Verzeichnisse wiederholen;
• Symbolische Links als symbolische Links kopieren;
• Berechtigungen, Eigentümer, Gruppen, Änderungszeit, Geräte und Sonderdateien erhalten;
• Geben Sie zusätzliche Details an, die ausführliche Ausgabe - daher ist es möglich, bei Bedarf eine Protokolldatei zu erstellen
• Komprimieren Sie Dateien während der Übertragung zur Optimierung.

Der rsync Die Dokumentation ist gut geschrieben; Wenn Sie die Zusammenfassung der verfügbaren Optionen überprüfen, können Sie einfach die auswählen -avz Flaggen als bessere Wahl. Eine einfache Verwendung sieht wie folgt aus:

rsync -avz /

Es ist wichtig, einen Schrägstrich nach dem Origin -Ordner zu setzen. Andererseits, rsync Kopiert den gesamten Origin -Ordner (einschließlich sich selbst) in den Zielordner.

Wenn Sie beispielsweise zwei Ordner erstellen, namens einer aufgerufen OriginFolder und der andere Zielordner, zu machen rsync Senden Sie an die zweite, bei der jede Änderung beim ersten Vorgang den nachfolgenden Befehl verwenden:

$ rsync -avz OriginalsFolder/ DestinationFolder

Sobald Sie eine neue Datei namens erstellt haben neue Datei, rsync druckt so etwas wie:

Senden inkrementaler Dateiliste
./
neue Datei
gesendete 101 Bytes erhielten 38 Bytes 278.00 Bytes/Sek
Die Gesamtgröße beträgt 0 Beschleunigung 0.00

In der ersten Zeile druckt die Richtlinie den Prozesstyp, eine inkrementelle Kopie; Dies bedeutet, dass Die rsync Verwendet seine Kompressionsfunktionen, um die Datei nur zu erhöhen und das gesamte Archiv nicht zu ändern. Da der Befehl zum ersten Mal ausgeführt wird, kopiert die Anwendung die gesamte Datei. Sobald neue Änderungen aufgetreten sind, finden nur Inkrementierungen statt. Die nachfolgende Ausgabe ist der Speicherort, der Dateiname und die Leistungsdaten. Überprüfen Sie den Exit -Status der rsync Befehl, Sie erhalten einen 0-Exit für eine erfolgreiche Ausführung.

Es gibt also zwei wichtige Anwendungen, die in diesem Skript unterstützt werden können: Einer kann auf Änderungen warten, und der andere kann Kopien dieser Änderung in Echtzeit erstellen. Hier fehlt hier eine Möglichkeit, beide Versorgungsunternehmen auf eine Weise zu verbinden, die rsync ergriffen Maßnahmen, sobald inotifywait Nimmt jede Veränderung wahr.

Warum wir eine Weile Schleife brauchen?

Die einfachste Lösung für das obige Problem ist eine Weile Schleife. Mit anderen Worten, bei jeder Gelegenheit inotifywait Es existiert erfolgreich, das Bash -Skript muss anrufen rsync seine Inkrementierung durchführen; Unmittelbar nach dem Auftreten der Kopie muss die Shell zum Ausgangszustand zurückkehren und auf einen neuen Ausgang des inotifywait Befehl. Genau das macht eine Weile Schleife.

Sie benötigen keinen umfangreichen Hintergrund in der Programmierung, um ein Bash -Skript zu schreiben. Es ist sehr häufig, gute Systemadministratoren zu finden, die keine oder nur sehr begrenzte Erfahrung mit der Programmierung haben. Jedoch, Das Erstellen funktionaler Skripte ist immer eine wichtige Aufgabe der Systemverwaltung. Die gute Nachricht ist, dass das Konzept hinter einer Weile leicht zu verstehen ist.

Das folgende Diagramm entspricht einer Weile -Schleife:

Unendlich während des Schleifendiagramms.

A repräsentiert die inotifywait Befehl oben diskutiert und B, rsync. Jedes Mal A existiert mit einem 0-Exit-Status, die Shell interpretiert ihn als wahr; Somit erlaubt die while -Schleife die Ausführung von B; sobald B Auch erfolgreich beendet der Befehl zurück zu A wieder und wiederholt die Schleife.
In diesem Fall bewertet die while -Schleife immer wahr für die TRUE A. Technisch gesehen erzeugt es eine unendliche Schleife, was für das Vorschlag dieses Skripts gut ist inotifywait wird immer wieder ausgeführt, was bedeutet, dass es immer auf neue Modifikationen warten wird.

Formell ist die Syntax für eine Bash, während die Schleife:

während
Tun

Erledigt

bedeutet die Liste der Bedingungen (A) das muss wahr sein; Die while -Schleife kann also die ausführen , Stehen für den Block der Befehle (B). Wenn die Vor-Test-Schleife A ist falsch, dann ist die while -Schleife ohne Ausführung B.

Hier ist, wie rsync Und inotifywait Befehle passen in die while -Schleife,

während inotifywait -r -e inotify -ormenfolder ändern, erstellen, löschen
Tun
RSYNC -avz OriginalsFolder/ DestinationFolder
Erledigt

Alles kombinieren

Jetzt ist es Zeit, alles zu kombinieren, was oben besprochen wird, um ein Shell -Skript zu erstellen. Das erste ist, eine leere Datei zu erstellen und sie zu benennen. als Beispiel, LiveBackup.verprügeln ist eine gute Wahl. Es ist eine gute Praxis, Shell -Skripte in den Bin -Ordner unter dem Benutzer -Home -Verzeichnis zu platzieren, a.k.A. $ Home/Bin.

Danach können Sie die Datei im Texteditor Ihrer Wahl bearbeiten. Die erste Zeile eines Bash -Skripts ist sehr wichtig; Hier definiert das Skript die Interpreter -Anweisung beispielsweise:

#! [Optionen]

Der Shebang ist dieses seltsame Symbol mit einem Hash und einem Ausrufezeichen (#!). Wenn die Shell das Skript zum ersten Mal lädt, sucht sie nach diesem Zeichen, da angibt. Der Shebang ist kein Kommentar und muss ohne Leerzeichen oben im Drehbuch platziert werden.

Sie können die erste Zeile leer lassen und den Dolmetscher nicht definieren. Auf diese Weise verwendet die Shell den Standard -Interpreter, um das Skript zu laden und auszuführen. Sie wird jedoch nicht unterstützt. Die am besten geeignete und sichere Entscheidung ist, die Dolmetscheranweisung wie folgt anzuzeigen:

#!/usr/bin/bash

Mit der Expliziten der Interpreter -Richtlinie sucht die Shell nach dem Bash -Interpreter unter dem Verzeichnis /USR /Bin. Da die Aufgabe dieses Skripts einfach ist, müssen Sie nicht mehr Befehle oder Optionen angeben. Eine ausgefeiltere Möglichkeit besteht darin, den Interpreter mit dem Env -Befehl anzurufen.

#!/usr/bin/env bash

In diesem Zusammenhang sucht die Shell nach dem Befehl Standard -Bash unter der aktuellen Umgebung nach dem Befehl standardmäßig. Eine solche Anordnung ist nützlich, wenn die Benutzerumgebung wichtige Anpassungen hat. Dies kann jedoch zu Sicherheitsbestimmungen auf einer Unternehmensebene führen, sobald die Shell nicht erkennen kann, ob der Befehlsflocken unter einer individuellen Umgebung ein sicherer Dolmetscher ist oder kein sicherer Dolmetscher ist oder ist.

Wenn Sie an diesem Punkt alles zusammenstellen, sieht das Skript aus:

#!/usr/bin/bash
während inotifywait -r -e originFolder erstellen, erstellen, löschen
Tun
RSYNC -avz OriginalsFolder/ DestinationFolder
Erledigt

So verwenden Sie Argumente in einem Bash -Skript?

Was dieses Skript von einer Gesamtfunktionalität unterscheidet, ist, wie es den Ursprung und den Zielordner definiert. Zum Beispiel ist es notwendig, einen Weg zu finden, um zu zeigen, was diese Ordner sind. Der schnellere Modus zur Lösung dieser Frage besteht darin, Argumente und Variablen zu verwenden.

Hier ist ein Beispiel für die richtige Art, sich auf das Skript zu beziehen:

$ ./LiveBackup.Bash/Home/Benutzer/Origin/Home/Benutzer/Ziel

Die Shell lädt eines dieser nach dem Skriptnamen getippten Argumente und übergibt sie als Variablen an den Skriptlader. Zum Beispiel das Verzeichnis /Home/Benutzer/Ursprung ist das erste Argument, und Sie können im Skript mit der Skript darauf zugreifen $ 1. Daher, $ 2 hat einen Wert von /Home/Benutzer/Ziel. Alle diese Positionsvariablen können mit dem Dollar -Zeichen zugegriffen werden ($) gefolgt von einem n-nummer ($ n), wobei n die Position des Arguments ist, in dem das Skript aufgerufen wird.

Das Dollar Zeichen ($) hat eine ganz besondere Bedeutung und Auswirkungen in Shell -Skripten; In anderen Artikeln wird es ausführlich diskutiert. Im Moment ist das Rätsel fast gelöst.

#!/usr/bin/bash
während inotifywait -r -e $ 1 $ 1 erstellen, erstellen, $ 1 löschen
Tun
rsync -avz $ 1/ $ 2
Erledigt

Notiz: mit zu vielen Argumenten umzugehen, die nur Positionsparameter verwenden ($ n) kann schnell zu schlechten Designs und Verwirrung in Shell -Skripten führen. Eine elegantere Art, dieses Problem zu lösen, besteht darin, die zu verwenden Getopts Befehl. Dieser Befehl hilft Ihnen auch dabei, Warnmeldungen an Fehlverwältigungen zu erstellen, was nützlich sein kann, wenn andere Benutzer Zugriff auf das Skript haben. Eine schnelle Suche im Internet kann verschiedene Methoden zur Verwendung zeigen Getopts, Was kann das aktuelle Skript verbessern, wenn Sie anderen Benutzern mehr Nutzungsoptionen geben müssen?.

Es ausführbar machen

Jetzt muss nur noch eine Sache erledigt werden: um die Datei zu erstellen LiveBackup.verprügeln ausführbar. Es kann leicht mit dem durchgeführt werden Chmod Befehl.

Gehen Sie zum Ordner mit dem Skript und tippen Sie: Geben Sie:

$ chmod +x livebackups.verprügeln

Geben Sie dann das Dot-Slash-Zeichen ein (./)) Vor dem Skriptnamen. Der Punkt bedeutet in diesem Zusammenhang das aktuelle Verzeichnis und der Schrägstrich definiert einen relativen Pfad zur Datei im aktuellen Verzeichnis. In diesem Sinne müssen Sie auch den Origin -Ordner als erstes Argument eingeben, gefolgt vom Zielordner als zweites, z. B.:

$ ./LiveBackup.Bash/Home/Benutzer/Origin/Home/Benutzer/Ziel

Alternativ können Sie die Skripte mit dem Namen aufrufen, wobei der Ordnerort in den Umgebungsweg platziert oder sie eine Unterschale nennt, wie:

$ bash livebackup.Bash/Home/Benutzer/Origin/Home/Benutzer/Ziel

Die erste Option ist jedoch eine sichere Wahl.

Beispiel des wirklichen Lebens

In einem realen Szenario, Wenn Sie das System jedes Mal starten, können Sie manuell ein Backup -Skript ausführen, wenn Sie das System starten, kann mühsam sein. Eine gute Wahl ist, a zu verwenden Cron-Job oder Timer/Service Einheiten mit systemd. Wenn Sie viele verschiedene Ordner zur Sicherung haben, können Sie auch ein anderes Skript erstellen, das die Quelle des LiveBackup.verprügeln; Somit muss der Befehl nur einmal in a aufgerufen werden .Service Einheit. In einem anderen Artikel kann diese Funktion ausführlicher erörtert werden.

Wenn Sie das Windows -Subsystem für Linux verwenden, können Sie eine grundlegende Aufgabe erstellen, um Ihr Skript mit dem vom Systemstart ausgelösten "Task -Scheduler" auszuführen, das ausgelöst wird. Verwenden Sie eine Stapeldatei, um die aufzurufen verprügeln.exe Mit einer Liste von Befehlen ist eine gute Wahl. Sie können auch ein Visual Basic -Skript verwenden, um die Batch -Datei im Hintergrund zu starten.

Wie ein Pro -Bash -Skript aussieht

Hier ist ein Beispiel für ein Skript, das vom Autor entworfen wurde, das komplexere Befehlszeilenargumente lesen kann.

#!/usr/bin/env bash
#
####################################################################################################################### zu erhalten ######################################### ## ##################################################################### zu erhalten
####################################################################################################################### zu erhalten ######################################### ## ##################################################################### zu erhalten
#
# Skript: Synchronisierer.verprügeln
# Autor: Diego Aurino da Silva
# Datum: 16. Februar 2018
# Rev: 1.0
# Lizenz: MIT (https: // github.com/Diegoaurino/Bashscripts/Blob/Master/Lizenz)
#
# Plattform: WSL oder GNU/Linux
#
# Zweck: Kleines Skript zur Synchronisierung von Änderungen von links nach rechts von zwei Ordnern 
# unter WSL oder GNU/Linux (erfordert Inotify-Tools)
#
####################################################################################################################### zu erhalten ######################################### ## ##################################################################### zu erhalten
####################################################################################################################### zu erhalten ######################################### ## ##################################################################### zu erhalten
###########################ib
# ALLGEMEINE EINSTELLUNGEN
###########################ib
BOLD = $ (TPUT BOLD)
Normal = $ (TPUT SGR0)
Origenes = ""
destination = ""
###########################ib
# Optionen Abschnitt
###########################ib
Wenn [$# -Eq 0]
Dann
printf "\ n%s \ t \ t%s \ n \ n" "Verwenden Sie $ BOLD -H $ Normal für Hilfe."
Ausgang 1
anders
Während GetOpts ": H" Option
Tun
Fall $ Option in
H )
printf "\ n%s \ t \ t%s \ n \ n" "Verwendung: ./Ordner synchronisieren.Bash $ BOLD/Origene/Ordner $ Normal -o $ BOLD/Ziel/Ordner $ Normal "
beenden 0
;;
\? )
printf "\ n%s \ n \ n" "$ BOLD Ungültige Option für $ Normal $ (BasisName $ 0)" 1> & 2
Ausgang 1
;;
ESAC
Erledigt
verschieben $ ((optind -1))
Origenes = $ 1
Schicht
Während des Getopts ": O:" Option
Tun
Fall $ Option in
Ö )
destination = $ optarg
printf "\ n%s \ n \ n" "Die folgenden Ordner werden links rechts synchronisiert:"
printf "\ torigen: \ t \ t \ t%s \ n" "$ BOLD $ Origen $ normal"
printf "\ tdestination: \ t \ t%s \ n \ n" "$ BOLD $ Destination $ normal"
;;
\? )
printf "\ n%s \ n \ n" "$ BOLD Ungültige Option für $ normal $ (BasisName $ 0): -$ optarg."1> & 2
Ausgang 1
;;
:)
printf "\ n%s \ n \ n" "$ BOLD Die Option $ normal -$ optarg benötigt ein Verzeichnis als Argument."1> & 2
Ausgang 1
;;
*)
printf "\ n%s \ n \ n" "$ BOLD Unkowne Option für $ normal $ (BasisName $ 0): -$ optarg."1> & 2
Ausgang 1
;;
ESAC
Erledigt
verschieben $ ((optind -1))
fi
###########################ib
# Synchronisierungsabschnitt
###########################ib
während inotifywait -r -e $ alenen ändern, erstellen, löschen, löschen
Tun
rsync -avz $ aurzen/ $ destination - -delete -filter = 'p .Git '
Erledigt

Herausforderungen

Versuchen Sie als Herausforderung, zwei weitere Versionen des aktuellen Skripts zu entwerfen. Der erste muss eine Protokolldatei drucken, die jede von der gefundene Änderung speichert inotifywait Befehl und jede Inkrementierung von durchgeführt von rsync. Die zweite Herausforderung besteht darin, ein Zwei-Regisseur-Synchronisationssystem zu erstellen, das nur eine Weile als das vorherige Skript verwendet. Ein Ratschlag: Es ist einfacher als es erscheint.

Sie können Ihre Erkenntnisse oder Fragen auf Twitter @linuxHint teilen