Dateibasierte RSync-Datensicherung auf externen Datenträger oder RSync kompatiblen Server: Unterschied zwischen den Versionen

Aus
Keine Bearbeitungszusammenfassung
Keine Bearbeitungszusammenfassung
Zeile 1: Zeile 1:
=Einleitung=
=Einleitung=
Mit dem Start der DSM 6 Beta und Hyper Backup wurde die dateibasierte Datensicherung bis auf weiteres auf Eis gelegt. Stattdessen werden die gesicherten Daten in einer Datenbank abgelegt, auf die man erstmal keinen direkten Zugriff hat. Zum wiederherstellen dieser Daten ist entweder ein NAS-System von Synology oder eine von Synology bereitgestellte Zusatzsoftware, dem "Hyper Backup Explorer" erforderlich, welchen es aktuell jedoch nur für Windows und Ubuntu gibt. Da in meinen Augen eine dateibasierte Datensicherung jedoch eine elementare Funktion darstellt, suchte ich nach einer Möglichkeit auch weiterhin nach diesem Prinzip meine persönlichen Daten zu sichern. Dabei lag mein Fokus auf eine einfache und handliche Funktionsweise sowie eine unkomplizierte Einrichtung über den DSM.  
 
'''Diese Anleitung zur dateibasierten RSync-Datensicherung bietet folgende Möglichkeiten...'''
 
* Quelle(n) und/oder Ziel können unverschlüsselt sein
* Quelle(n) und/oder Ziel können verschlüsselt sein
* Sicherung innerhalb eines /volume
* Sicherung zwischen internen /volumes
* Sicherung auf lokal angeschlossene USB-/SATA-Datenträger sowie eingebundene Remote-Shares (nur unverschlüsselt)
* Sicherung von einer entfernten DS oder RSync-kompatilben Server
* Sicherung auf eine entfernte DS oder RSync-kompatilben Server
* (weitere Konstellationen sind möglich, wurden jedoch nicht getestet)
 
'''Hinweis:''' Die Verschlüsselung beruht hierbei auf der von Synology verwendeten Ordnerverschlüsselung (eCryptfs). Um verschlüsselte gemeinsame Ordner einbinden zu können, wird das Key-File also der Exportschlüssel benötigt. Diesen erhält man über die DSM-Systemsteuerung/Gemeinsame Ordner.


=Anmerkung=
=Anmerkung=
Bevor ihr anfangt, nehmt bitte noch den Artikel "[[Wichtige Informationen zum Modden der Synology Stations]]" zur Kenntnis.   
Bevor ihr anfangt, nehmt bitte noch den Artikel "[[Wichtige Informationen zum Modden der Synology Stations]]" zur Kenntnis.   


'''Auch wenn dieses Script intensiv auf einwandfreie Funktion hin getestet wurde, so kann eine Fehlfunktion und demzufolge ein möglicher Datenverlust nicht ausgeschlossen werden. Daher verwendet ihr dieses Script auf eigene Gefahr. Aus diesem Grunde solltet ihr das System erstmal mit unwichtigen Testdaten auf Herz und Nieren prüfen, bevor ihr das ganze "produktiv" einsetzt. Auch ist es immer ratsam, bereits ein Backup seiner Daten in Reichweite zu haben.'''
Auch wenn dieses Script intensiv auf einwandfreie Funktion hin getestet wurde, so kann eine Fehlfunktion und demzufolge ein möglicher Datenverlust nicht ausgeschlossen werden. Aus diesem Grund solltet ihr das System erstmal mit unwichtigen Testdaten auf Herz und Nieren prüfen und sich mit der Arbeitsweise des Scripts und dessen Funktionen vertraut machen bevor ihr das ganze "produktiv" einsetzt. '''Ihr verwendet dieses Script auf eigene Gefahr.'''


=Voraussetzungen=
=Voraussetzungen=
Zeile 14: Zeile 26:
* Zum versenden einer E-Mail muss im DSM unter Hauptmenü/Systemsteuerung/Benachrichtigung eine E-Mail Adresse hinterlegt sein.
* Zum versenden einer E-Mail muss im DSM unter Hauptmenü/Systemsteuerung/Benachrichtigung eine E-Mail Adresse hinterlegt sein.
* Ein externer USB- oder SATA-Datenträger, eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk.
* Ein externer USB- oder SATA-Datenträger, eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk.
* Optional: autorun für externe Datenträger (Version 1.7)


=Erläuterungen zur Funktion und Arbeitsweise=
=Erläuterungen zur Funktion und Arbeitsweise=
Mit dem hier vorgestellten System ist sowohl eine Datensicherung von, als auch auf einen lokal angeschlossenen USB- oder SATA-Datenträger, sowie eine Netzwerksicherung auf eine weitere Synology Diskstation bzw. einem rsync-kompatiblen Server im Netzwerk möglich (SSH-Zugang vorausgesetzt). Die gewünschte Ausgangssituation bestimmt die Art und Weise der Scriptausführung, die im folgenden schematisch dargestellt wird:
Mit dem hier vorgestellten System ist sowohl eine Datensicherung auf einen lokal angeschlossenen USB- oder SATA-Datenträger als auch eine Netzwerksicherung von oder auf eine weitere Synology Diskstation bzw. einem RSync-kompatiblen Server im Netzwerk möglich (SSH-Zugang vorausgesetzt). Die gewünschte Ausgangssituation bestimmt die Art und Weise der Scriptausführung, die im folgenden schematisch dargestellt wird:


<pre>
<pre>
Diskstation
    |  |
    |  '--> Aufgabenplaner ------------------------------
    |            |                                      |
    |            '--> Such-Script -----> USB/SATA-Share ---> Ausführungs-
    |                                                    |      Script
    '----------------> USB/SATA-Share --> autorun --------    (Key-Files)
                                                                  |
                                      .---------------------------'
                                      |
                                      V
            .---------- Quelle <--- definiere ---> Ziel----------.
            |            |                          |            |
            V            '-- lokale/intern/extern --'            V
lokalisiere Quelle(n)                                    lokalisiere Ziel
  |                                                                    | 
  |                          Protokoll/E-Mail                          |
  |-->  Verschlüsselte              |              Verschlüsseltes  <--|
  |  Quelle(n) anhand der          |              Ziel anhand der    |
  |  Key-Files einhängen  <--- aushängen --->  Key-Files einhängen  |
  |          |                      |                  |              |
  |          V                      |                  V              |
  '--------------------->> !! DATENSICHERUNG !! >>---------------------'
                      |                          |
                      '--  lokale/intern/extern -'


  Aufgabenplaner (manuell/auto)
    |
    |                      .--> USB/SATA-Datenträger  --> start-rsync.sh
    |-> *search-rsync.sh ->|
    |                      '--> Diskstation SSH-Server --> start-rsync.sh
    |
    |                      .--> USB/SATA-Datenträger  --> *start-rsync.sh
    '--------------------->|
                            '--> Diskstation SSH-Server --> *start-rsync.sh
   
</pre>
</pre>


'''Der DSM-Aufgabenplaner'''


Der DSM-Aufgabenplaner ist die eigentliche Schaltzentrale dieses Systems, worüber sowohl das Such-Script (search-rsync.sh) als auch das Ausführungs-Script (start-rsync.sh) aufgerufen werden kann. Versierte Anwender können die Scripte bei Bedarf natürlich z.B. auch direkt über die Konsole aufrufen und ausführen.
'''Scriptausführung über den DSM-Aufgabenplaner'''


'''Das Such-Script (search-rsync.sh)'''
Die Scriptausführung kann über verschiedene Wege initiiert werden indem das Script entweder direkt oder indirekt über den Aufgabenplaner des DSM angesprochen bzw. über ein Such-Script lokalisiert und ausgeführt wird. Die Verwendung des Such-Scripts ist hierbei nicht zwingend erforderlich und kommt nur bei einer lokalen Datensicherung (auf USB- oder SATA-Datenträger) zum Einsatz, da sich die Suche nur auf diese beschränkt. Aber auch wenn es nicht unbedingt benötigt wird, so hat das Such-Script den entscheidenden Vorteil, dass das eigentliche Ausführungs-Script entweder anhand des vollständigen Script-Dateinamens, oder aber anhand einer bestimmten Zeichenkette innerhalb des Script-Dateinamens lokalisiert, ausgeführt oder bei Bedarf von der Ausführung ausgeschlossen werden kann. Des weiteren kann sich das Ausführungs-Script auch innerhalb eines gemeinsamen Ordners der DS befinden worin z.B. eine Datensicherung abgelegt werden soll. Der Standort des Scripts sowie der Key-Files bestimmt sogesehen das Ziel der Datensicherung, jedoch können Quelle(n) und Ziel auch an anderen Orten liegen. Einzig das Logfile wird immer am Speicherort des Scriptes abgelegt. Auch ist der Name des Ausführungs-Scripts erstmal nicht relevant, es macht jedoch Sinn einen aussagekräftigen Namen zu vergeben, da unter Umständen mehrere Scripte hintereinander ausgeführt werden können. Einzig muss darauf geachtet werden, dass das Script die Dateiendung .sh trägt und ggfl. ausführbar ist, sollte es nicht über das Such-Script ausgeführt werden.
 
 
'''Scriptausführung mittels "autorun"'''
 
Das Script kann aber auch in Verbindung mit "autorun" gestartet werden. Grade bei der Verwendung verschlüsselter Ordner, wo das entsprechende Key-File (der Exportschlüssel) am Speicherort des Scriptes liegen muß, gewinnt man in Verbindung mit "autorun" eine erhöhte Sicherheit, da die Key-Files nur für den Zeitraum der Datensicherung verfügbar sind. Mit entfernen des USB-Sticks und den darauf befindlichen Key-Files sind die verschlüsselten Daten auf der DS erstmal sicher, bewahrt man den USB-Stick denn an einem sicheren Ort auf.
autorun wird zwar offiell nicht mehr für DSM 6 weiterentwickelt, jedoch stellt uns Merthos (der Erfinder von autorun) mit der Version 1.7 eine Möglichkeit zur Verfügung auch weiterhin Scripte automatisch ausführen zu lassen. Dieses Verhalten machen wir uns zu nutze, indem wir den Dateinamen des hier vorgestellten Scripts einfach umbennenen in "autorun" und diese Datei dann zusammen mit evtl. benötigten Key-Files in das Wurzel- oder auch Hauptverzeichnis eines extern angeschlossenen USB-/SATA-Datenträgers kopieren. Auf diese Weise kann jede oben beschriebene Möglichkeit der Datensicherung ausführt werden, egal ob lokal, intern oder extern gesichert werden soll. Allein die Einstellung der benötigten Optionen innerhalb des Scriptes, beschreibt die Art und Weise der Datensicherung. 


Die Verwendung des Such-Scripts ist nicht zwingend erforderlich und kommt auch nur bei einer lokalen Datensicherung (auf internes Volume, USB- oder SATA-Datenträger) zum Einsatz, da sich die Suche nur auf lokale Datenträger beschränkt. Aber auch wenn es nicht unbedingt benötigt wird, so hat das Such-Script den entscheidenen Vorteil, dass das Ausführungs-Script entweder anhand des vollständigen Script-Dateinamens, oder aber anhand einer bestimmten Zeichenkette innerhalb des Script-Dateinamens lokalisiert, ausgeführt oder bei Bedarf von der Ausführung ausgeschlossen werden kann. Der Name sowie der Speicherort des Such-Scripts ist auch erstmal nicht relevant. Es macht jedoch Sinn dem Script einen aussagekräftigen Namen zu geben und es an einem Ort auf der Synology Diskstation abzulegen, wo man es bei Bedarf z.B. mit dem DSM eigenen Text-Editor bearbeiten kann. Einzig muss darauf geachtet werden, dass das Script die Dateiendung .sh trägt und ausführbar ist. Über das Such-Script lassen sich demnach mehrere Ausführungs-Scripte suchen und ausführen.


'''Das Ausführungs-Script (start-rsync.sh)'''
'''Das Ausführungs-Script (start-rsync.sh)'''
Das Ausführungs-Script befindet sich entweder im Wurzel- oder auch Hauptverzeichnis eines an der DS angeschlossenen, externen USB- oder SATA-Datenträgers, oder aber innerhalb eines "gemeinsamen Ordners" auf der Synology Diskstation, dort wo die gesicherten Daten später abgelegt werden sollen. Der Standort des Scripts bestimmt also das Ziel der Datensicherung, welcher jedoch auch über die Variable $DESTINATION im Script genauer definiert werden kann.
Auch hier ist der Name des Ausführungs-Scripts erstmal nicht relevant, es macht jedoch auch hier Sinn einen aussagekräftigen Namen zu vergeben, da unter umständen mehrere Scripte hintereinander ausgeführt werden. Einzig muss darauf geachtet werden, dass das Script die Dateiendung .sh trägt und ausführbar ist, sollte es nicht über das Such-Script ausgeführt werden.


Das Ausführungs-Script selber synchronisiert sämtliche konfigurierte Quellen mit dem Backupziel. Dabei werden die Ordnerpfade relativ, nach dem jeweiligen Volume (1,2,3,4….) angelegt. Gelöschte Dateien in der Quelle werden im Ziel in den Ordner /@Recycle verschoben um einen möglichen Datenverlust vorzubeugen. Systemorder wie z.B. /@eaDIR, /#recycle, /#snapshot und /.DS_Store werden von der Synchronisation ausgeschlossen. Protokolle und zum Löschen vorgemerkte Dateien, sowie die Sicherung der DSM-Systemkonfiguration im Ordner /@DSMConfig, können nach Ablauf einer einstellbaren Zeitvorgabe (in Tagen) automatisch über das System gelöscht werden. Über das interne Benachrichtingssystem werden alle durchgeführten Schritte in einem Protokoll zusammengefasst welche im Ordner @/Logfiles abgelegt werden und man sich diese bei Bedarf auch als E-Mail zustellen lassen kann. Ebenso werden auftretende Fehler oder Störungen protokolliert und an verschiedenen Stellen mit weitergehenden Informationen, wie z.B. den Exit-Codes der rsync Ausführung näher beschrieben. Außerdem erhält die DSM-Administratorengruppe über das Benachrichtigungssystems des DSM eine Meldung über Erfolg oder Misserfolg des Vorganges inkl. Fehler-Code. Optional kein eine optische und akustische Signalausgabe ausgewählt werden.  
Das Ausführungs-Script selber synchronisiert sämtliche konfigurierte Quellen mit dem Backupziel. Dabei werden die Ordnerpfade relativ, nach dem jeweiligen Volume (1,2,3,4….) angelegt. Gelöschte Dateien in der Quelle werden im Ziel in den Ordner /@Recycle verschoben um einen möglichen Datenverlust vorzubeugen. Systemorder wie z.B. /@eaDIR, /#recycle, /#snapshot und /.DS_Store werden von der Synchronisation ausgeschlossen. Protokolle und zum Löschen vorgemerkte Dateien, sowie die Sicherung der DSM-Systemkonfiguration im Ordner /@DSMConfig, können nach Ablauf einer einstellbaren Zeitvorgabe (in Tagen) automatisch über das System gelöscht werden. Über das interne Benachrichtingssystem werden alle durchgeführten Schritte in einem Protokoll zusammengefasst welche im Ordner @/Logfiles abgelegt werden und man sich diese bei Bedarf auch als E-Mail zustellen lassen kann. Ebenso werden auftretende Fehler oder Störungen protokolliert und an verschiedenen Stellen mit weitergehenden Informationen, wie z.B. den Exit-Codes der rsync Ausführung näher beschrieben. Außerdem erhält die DSM-Administratorengruppe über das Benachrichtigungssystems des DSM eine Meldung über Erfolg oder Misserfolg des Vorganges inkl. Fehler-Code. Optional kein eine optische und akustische Signalausgabe ausgewählt werden.  


'''Datensicherungsvarianten'''
Dieses System ist mittlerweile so flexibel Aufgebaut, das Quelle und Ziel einer Datensicherung individuell definiert werden kann. So kann bei einer lokalen Datensicherung zwischen Synology Diskstation und einem angeschlossenen, externen USB- oder SATA-Datenträger sowohl der Datenträger als auch die Synology Diskstation die Quelle als auch das Ziel sein. Auch eine Datensicherung innerhalb einer Synology Diskstation ist möglich z.B. um regelmäßig Daten von /volume1 nach /volume2 zu sichern. Gleiches gilt für die Datensicherung auf eine weitere Synology Diskstation oder einem rsync-kompatiblen Server über eine SSH-Verbindung. Das Ziel der Datensicherung bestimmt immer der Speicherort des Ausführungs-Script, wobei selbst hier noch das Ziel individuell angepasst werden kann.


=Hinweise zum Erstellen und ausführen der Scripte=
=Hinweise zum Erstellen und ausführen der Scripte=
Zeile 91: Zeile 117:
=Script 2: Das ausführungs-Script "start-rsync.sh"=
=Script 2: Das ausführungs-Script "start-rsync.sh"=
Das nächste Script mit dem beispielhaften Script-Dateinamen "start-rsync.sh", wird entweder auf den entsprechenden externen USB- oder SATA-Datenträger in dessen Wurzelverzeichnis oder aber in einen "gemeinsamen Ordner" auf der Diskstation abgelegt, auf dem die Datensicherung abgelegt werden soll.  
Das nächste Script mit dem beispielhaften Script-Dateinamen "start-rsync.sh", wird entweder auf den entsprechenden externen USB- oder SATA-Datenträger in dessen Wurzelverzeichnis oder aber in einen "gemeinsamen Ordner" auf der Diskstation abgelegt, auf dem die Datensicherung abgelegt werden soll.  
Vor der ersten Ausführung des Scriptes müssen im Vorfeld noch die Backup-Quellen (SOURCES), der Backup-Zielordner (DESTINATION) sowie ggfls. eine E-Mailadresse (EMAIL) und bei Bedarf die SSH-Verbindungsdaten eingegeben werden. Ebenso kann eine Zeitvorgabe für das Löschen alter Logdateien und zum Löschen vorgemerkter Dateien bestimmt werden, sowie eine Signalsteuerung miteinbezogen werden.
Vor der ersten Ausführung des Scriptes müssen im Vorfeld noch die Backup-Quellen (SOURCES), der Backup-Zielordner (TARGET) sowie ggfls. eine E-Mailadresse (EMAIL) und bei Bedarf die SSH-Verbindungsdaten eingegeben werden. Ebenso kann eine Zeitvorgabe für das Löschen alter Logdateien und zum Löschen vorgemerkter Dateien bestimmt werden, sowie eine Signalsteuerung miteinbezogen werden.


Es ist hierbei durchaus möglich, unterschiedliche Scripte mit unterschiedlichen Backup-Aufgaben auszuführen, die dabei auch auf unterschiedlichen Datenträgern  oder auf der DS (bei SSH-Verbindungen) abgelegt wurden. Es ist nicht zwingend erforderlich, das alle Scripte permanent Verfügbar sind. Alle gefundenen Scripte werden ausgeführt, nicht auffindbare Scripte werden übersprungen. Hierzu bitte auch die weiteren Hinweise in den Scripten beachten. Nachdem alle Parameter bestimmt wurden, kann man den Vorgang über den Aufgabenplaner ausführen lassen.  
Es ist hierbei durchaus möglich, unterschiedliche Scripte mit unterschiedlichen Backup-Aufgaben auszuführen, die dabei auch auf unterschiedlichen Datenträgern  oder auf der DS (bei SSH-Verbindungen) abgelegt wurden. Es ist nicht zwingend erforderlich, das alle Scripte permanent Verfügbar sind. Alle gefundenen Scripte werden ausgeführt, nicht auffindbare Scripte werden übersprungen. Hierzu bitte auch die weiteren Hinweise in den Scripten beachten. Nachdem alle Parameter bestimmt wurden, kann man den Vorgang über den Aufgabenplaner ausführen lassen.  
Zeile 99: Zeile 125:
#!/bin/sh
#!/bin/sh


# E-Mail Adresse, SSH-Benutzer sowie Netzwerkquelle
# E-Mail Adresse
# ------------------------------------------------------------------------  
# -------------------------------------------------------------------------
# Bei Angabe einer E-Mail-Adresse, die identisch mit der bereits im DSM |
# Es wird ein Sicherungsprotokoll unter /@Logfiles angelegt.              |
# unter Hauptmenue/Systemsteuerung/Benachrichtigung hinterlegten         |
# Bei Angabe einer E-Mail-Adresse, die identisch mit der bereits im DSM   |
# E-Mail-Adresse sein muß, wird einem das Sicherungsprotokoll zugestellt |
# unter Hauptmenue/Systemsteuerung/Benachrichtigung hinterlegten         |
# Möchte man dies nicht, kann das Feld mit # auskommentiert werden. Es   |
# E-Mail-Adresse sein muß, wird einem das Sicherungsprotokoll zugestellt. |
# wird dann nur ein Sicherungsprotokoll unter @Logfiles im Ziel abgelegt.|
# -------------------------------------------------------------------------
# Weiterhin wird hier der SSH-Benutzer, sowie die Netzwerkquelle in Form |
EMAIL=""
# der IP eingegeben. Soll keine Datensicherung über SSH stattdinden sind |
 
# die Felder SSHUSER und FROMSSH mit # auszukommentieren                |
# SSH - Verbindungsdaten
# -------------------------------------------------------------------------
# Bei einer Netzwerksicherung nachfolgend die Verbindungsdaten angeben.  |
# Werden keine Verbindungsdaten angegeben, wird eine lokale Datensicherung|
# durchgeführt.                                                           |
# -------------------------------------------------------------------------
SSH_USER=""        # Benutzername
SSH_FROM=""        # IP-Adresse - VON entfernter Quelle AUF lokales Ziel -
SSH_TO=""          # IP-Adresse - VON lokaler Quelle AUF entferntes Ziel -
 
# Umgang mit verschlüsselten Ordnern
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
EMAIL="you@mail.de"
# Angeben, ob eingehangene verschlüsselte Ordner nach der Datensicherung |
#SSHUSER="root"
# wieder ausgehangen werden sollen.                                     |
#FROMSSH="192.168.178.10"
# Backup - Quellen 
# ------------------------------------------------------------------------                                               
# Hier können beliebige sowie unterschiedliche Backupquellen von der DS  |
# eingetragen werden. Zu beachten ist, das immer der vollständige Pfad  |
# ohne Angabe des entsprechenden Volume anzugeben ist. Weiterhin ist auf |
# die Schreibweise im Beispiel zu achten, pro Zeile je eine Backupquelle.|                                                        |
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
SOURCES="/Musik/Alben
UNMOUNT="1"         # "" = Nein "1" = Ja
        /Fotos
/Videos/Serien
/homes/admin"


# Backup - Quellen
# Backup - Ziel  
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------  
# Hier können beliebige, unverschlüsselte sowie verschlüsselte          |
# Als Backupziel bedarf es nur der Angabe des Ordners, worin das Backup  |
# Backup-Quellen einer lokalen oder entfernten DS eingetragen werden.   |
# abgelegt werden soll. Das Script erkennt automatisch an welchen USB-  |
# Zu beachten ist, das immer der vollständige Pfad ohne Angabe des      |
# oder SATA-Port sich der externe Datenträger befindet (volumeUSB1,      |
# entsprechenden Volume anzugeben ist. Weiterhin ist auf  die           |
# volumeUSB2, volumeUSB3 oder volumeSATA) und fügt die Ordnerstruktur    |
# Schreibweise im Beispiel zu achten, pro Zeile je eine Backupquelle.   |
# dementsprechnend dem Backupziel hinzu.                                 |
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
DESTINATION="/Backup_DS"
SOURCES="/homes/admin
        /music
/photo/2016
        /secret-folder"


# Backup - Ziel
# ------------------------------------------------------------------------
# -> Befindet sich das Sicherungsziel am Speicherort des Scripts, dann  |
#    entspricht TARGET einem Unterverzeichnis. Hierbei wird NOTTOSCRIPT  |
#    kein Wert mitgegeben, also NOTTOSCRIPT=""                          |
#    Beispiel: /Backup_DS (volumeUSB[x]/usbshare/[TARGET])              |
#                                                                        |
# -> Befindet sich das Sicherungsziel jenseits des Scripts, dann        |
#    entspricht TARGET einem gemeinsamen Ordner auf der DS. Hierbei wird |
#    NOTTOSCRIPT ein Wert mitgegeben, also NOTTOSCRIPT="1"              |
#    Beispiel: /NetBackup (volume[X]/[TARGET=gemeinsamer Ordner])        |
#                                                                        |
#  -Wird hierbei kein weiteres Unterverzeichnis angegeben, so wird      |
#    direkt in den gemeinsamen Ordner gesichert.                        |
#    Beipiel: /NetBackup                                                |
#            (volume[X]/[TARGET=gemeinsamer Ordner])                    |
#                                                                        |
#  -Wird HOSTNAME="1" gesetzt, dann entspricht das Unterverzeichnis dem |
#    Netzwerknamen der DS.                                              |
#    Beispiel: /NetBackup/Diskstation                                    |
#              (volume[X]/[TARGET=gemeinsamer Ordner/Unterverzeichnis])  |
#                                                                        |
#  -Gibt man TARGET jedoch noch ein eigenes Unterverzeichnis mit, wird  |
#    dieses angelegt und verwendet.                                      |
#    Beispiel: /NetBackup/Mein_Backup_Verzeichnis                        |
#              (volume[X]/[TARGET=gemeinsamer Ordner/Unterverzeichnis])  |
#-------------------------------------------------------------------------
TARGET="/Backup_DS"
HOSTNAME=""        #      = Sicherungsziel entspricht TARGET
                    #  1  = Sicherungsziel entspricht TARGET/HOSTNAME
NOTTOSCRIPT=""      #      = Sicherungsziel liegt beim Script
                    #  1  = Sicherungsziel liegt im geinsamen Ordner
AUTORUN=""          #      = autorun wirft USB-Stick nicht aus
                    #  1  = autorun wirft USB-Stick aus


# Optische- sowie akustische Signalausgabe
# Optische- sowie akustische Signalausgabe
Zeile 150: Zeile 210:
#                  und es erklinkt ein 3-Facher Fehler-Signalton        |
#                  und es erklinkt ein 3-Facher Fehler-Signalton        |
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
SIGNAL="1"
SIGNAL="0"
 


# Exportieren der DSM-Systemkonfiguration (.dss)
# Exportieren der DSM-Systemkonfiguration (.dss)
Zeile 157: Zeile 216:
# Durch Eingabe einer "1" wird die DSM-Systemkonfigurartion (.dss) in den|
# Durch Eingabe einer "1" wird die DSM-Systemkonfigurartion (.dss) in den|
# Systemordner /@DSMConfig exportiert. Ist der Export nicht gewünscht,  |
# Systemordner /@DSMConfig exportiert. Ist der Export nicht gewünscht,  |
# ist hier eine "0" einzutragen.                                         |
# ist hier nichts einzutragen.                                           |
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
DSSEXPORT="1"
DSM_EXPORT=""


# Rotationszyklus für das Löschen von @Recycle und @Logfiles  
# Rotationszyklus für das Löschen von @Recycle und @Logfiles
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
# Zeitangabe, wann Ordner bzw. Dateien in den System-Ordnern            |
# Zeitangabe, wann Ordner bzw. Dateien in den System-Ordnern            |
Zeile 170: Zeile 229:
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
RECYCLE_ROTATE="90"
RECYCLE_ROTATE="90"
LOGFILES_ROTATE="90"
LOGFILES_ROTATE="30"
DSMCONFIG_ROTATE="90"
DSMCONFIG_ROTATE="30"


# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
Zeile 182: Zeile 241:
SCRIPTFILE="${0##*/}"
SCRIPTFILE="${0##*/}"
SCRIPTNAME="${SCRIPTFILE%.*}"
SCRIPTNAME="${SCRIPTFILE%.*}"
DATEOPT=`date +%Y-%m-%d_%Hh%M`
TARGET_EMPTY="/Backup_DS"
TIMESTAMPOPT=`date +%d.%m.%Y%t%H:%M:%S`
DEST="${TARGET#*/}"
TARGET_PATH="${TARGET##*/}"
TARGET_DECRYPT="${DEST%%/*}"
SOURCE="${SHARE#*/}"
SOURCE_DECRYPT="${SOURCE%%/*}"
DATE=`date +%Y-%m-%d_%Hh%M`
TIMESTAMP=`date +%d.%m.%Y%t%H:%M:%S`
LOKALHOST="$(hostname)"
if [[ ${TARGET:0:1} != \/ ]] ; then
  TARGET="/$TARGET"
fi
HR="------------------------------------------------------------------------------------------------"


# RSync Optionen konfigurieren
# RSync Optionen konfigurieren
Zeile 190: Zeile 260:
LOGSTAT="--stats"
LOGSTAT="--stats"
EXCLUDE="--exclude=/@eaDir/*** --exclude=/#recycle/*** --exclude=/#snapshot/*** --exclude=/.DS_Store/***"
EXCLUDE="--exclude=/@eaDir/*** --exclude=/#recycle/*** --exclude=/#snapshot/*** --exclude=/.DS_Store/***"
RECYCLE="--delete --backup --backup-dir=@Recycle/"$DATEOPT"_$SCRIPTNAME"
RECYCLE="--delete --backup --backup-dir=@Recycle/"$DATE"_$SCRIPTNAME"


# Variablen je nach Verbindung festlegen
#-------------------------------------------------------------------------
if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  FROMSSH="ssh $SSH_USER@$SSH_FROM"
  REMOTEHOST=$($FROMSSH "echo \`hostname\`")
  SYNOSHARE_SOURCE="$FROMSSH"
  SYNOSHARE_TARGET=""
  SYNO_TARGET=""
  FIND="$FROMSSH find"
  SOURCE_TEST="$FROMSSH test"
  TARGET_TEST="test"
  if [ -n "$HOSTNAME" ]; then
    NAME="$REMOTEHOST"
  fi
elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  TOSSH="ssh $SSH_USER@$SSH_TO"
  REMOTEHOST=$($TOSSH "echo \`hostname\`")
  SYNOSHARE_SOURCE=""
  SYNOSHARE_TARGET="$TOSSH"
  FIND="$TOSSH find"
  SOURCE_TEST="test"
  TARGET_TEST="$TOSSH test"
  if [ -n "$HOSTNAME" ]; then
    NAME="$LOKALHOST"
  fi
elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  SYNOSHARE=""
  SYNO_TARGET=""
  FIND="find"
  SOURCE_TEST="test"
  TARGET_TEST="test"
  if [ -n "$HOSTNAME" ]; then
    NAME="$LOKALHOST"
  fi
fi


# DSM-Benachrichtigung: Script wird ausgeführt...
#-------------------------------------------------------------------------
synodsmnotify @administrators "Script: $SCRIPTNAME" "Wird ausgeführt.."
synodsmnotify @administrators "Script: $SCRIPTNAME" "Wird ausgeführt.."


# Speicherort des Logfiles festlegen
#-------------------------------------------------------------------------
if [ -z "$NOTTOSCRIPT" ] && [ -z "$SSH_TO" ] && [ -z "$TARGET" ]; then
  mkdir -p `dirname $0`$TARGET_EMPTY
  mkdir -p `dirname $0`$TARGET_EMPTY/@Logfiles
  LOG="`dirname $0`$TARGET_EMPTY/@Logfiles/"$DATE"_$SCRIPTNAME.log"
elif [ -z "$NOTTOSCRIPT" ] && [ -z "$SSH_TO" ] && [ -z "$SSH_FROM" ]; then
  mkdir -p `dirname $0`$TARGET
  mkdir -p `dirname $0`$TARGET/@Logfiles
  LOG="`dirname $0`$TARGET/@Logfiles/"$DATE"_$SCRIPTNAME.log"
elif [ -n "$NOTTOSCRIPT" ] || [ -n "$SSH_TO" ] || [ -n "$SSH_FROM" ]; then
  mkdir -p `dirname $0`/@Logfiles
  LOG="`dirname $0`/@Logfiles/"$DATE"_$SCRIPTNAME.log"
fi
if [ -z "$TARGET" ] && [ -n "$NOTTOSCRIPT" ]; then
  STOP="Bitte TARGET setzen oder NOTTOSCRIPT nicht setzen..." >> $LOG
fi


# Volume lokalisieren und Sicherungsziel definieren
if [ $SIGNAL -eq 1 ]; then
#-------------------------------------------------------------------------
  echo 3 >/dev/ttyS1; echo : >/dev/ttyS1
if find $0; then
  sleep 2
  mkdir -p "`dirname $0`$DESTINATION"
fi
  TARGET="`dirname $0`$DESTINATION"
  # Signalausgabe - Beginn der Datensicherung
  if [ $SIGNAL -eq 1 ]; then
  echo 3 >/dev/ttyS1; echo : >/dev/ttyS1
    sleep 2
  fi 
fi  


# Ordner/Datei für das Protokoll anlegen und Kopfdaten generieren
# Ordner/Datei für das Protokoll anlegen und Kopfdaten generieren
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
mkdir -p $TARGET/@Logfiles
LOG="$TARGET/@Logfiles/"$DATEOPT"_$SCRIPTNAME.log"
# E-Mail-Kopf aufbauen...
# E-Mail-Kopf aufbauen...
if [ "$EMAIL" ]; then
if [ -n "$EMAIL" ]; then
   echo "To: $EMAIL" > $LOG
   echo "To: $EMAIL" > $LOG
   echo "From: $EMAIL" >> $LOG
   echo "From: $EMAIL" >> $LOG
   echo "Subject: Sicherungsprotokoll vom $TIMESTAMPOPT Uhr" >> $LOG
   echo "Subject: Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
   echo "" >> $LOG
   echo "" >> $LOG
   echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
   echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
   echo ""
   echo "" >> $LOG; echo "$HR" >> $LOG
# Protokoll-Kopf aufbauen...
# Protokoll-Kopf aufbauen...
else
else
   echo "Sicherungsprotokoll vom $TIMESTAMPOPT Uhr" > $LOG
   echo "Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
   echo "" >> $LOG
   echo "" >> $LOG
   echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
   echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
  echo "" >> $LOG; echo "$HR" >> $LOG
fi
fi


# Verbindungstest (SSH_FROM)
#-------------------------------------------------------------------------
if [ -n "$SSH_FROM" ]; then
  if ! $FROMSSH; then
    echo "FEHLER: Es konnte keine SSH-Verbindung zu $SSH_FROM aufgebaut werden." >> $LOG
  elif $FROMSSH; then
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
  fi
fi
# Verbindungstest (SSH_TO)
#-------------------------------------------------------------------------
if [ -n "$SSH_TO" ]; then
  if ! $TOSSH; then
    echo "FEHLER: Es konnte keine SSH-Verbindung zu $SSH_TO aufgebaut werden." >> $LOG
  elif $TOSSH; then
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
  fi
fi


# RSync-Datensicherung über SSH an Diskstation oder Rsync-komp. Server
# Zielordner checken
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
if [ "$SSHUSER" ] || [ "$FROMSSH" ] && ! ssh $SSHUSER@$FROMSSH; then
if [ -z "$STOP" ]; then
  EXITCODE="1"
  if [ -n "$NOTTOSCRIPT" ] || [ -n "$SSH_TO" ]; then
   SSHEXIT="1"
    if $TARGET_TEST ! -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
      echo "Zielordner $TARGET_DECRYPT wurde lokalisiert..." >> $LOG
    elif $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT bereits eingehangen..." >> $LOG
    elif $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST ! -d /volume*/$TARGET_DECRYPT; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT nicht eingehangen..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Zielordner einbinden
      if test -f `dirname $0`/$TARGET_DECRYPT.key; then
        echo "$TARGET_DECRYPT.key gefunden" >> $LOG
        echo "Verschluesselter Zielordner $TARGET_DECRYPT wird eingehangen..."  >> $LOG
        KEYFILEDEST=$(ecryptfs-unwrap-passphrase `dirname $0`/$TARGET_DECRYPT.key "\$1\$5YN01o9y")
        $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_mount "$TARGET_DECRYPT" "$KEYFILEDEST" >> $LOG
        sleep 20
        if $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST ! -d /volume*/$TARGET_DECRYPT; then
          echo "Verschluesselter Zielordner $TARGET_DECRYPT konnte nicht eingehangen werden..."  >> $LOG
        fi
      else
        echo "Kein Keyfile fuer $TARGET_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden!"
      fi
    fi
    if $TARGET_TEST ! -d /volume*/$TARGET_DECRYPT; then
      STOP="Zielordner $TARGET_DECRYPT nicht gefunden!"
    fi
   fi
fi
 
# Quellordner checken
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
   echo "" >> $LOG
   echo "" >> $LOG
   echo "FEHLER: Es konnte keine SSH-Verbindung aufgebaut werden." >> $LOG
   for SHARE in $SOURCES; do
  DSMNOTIFY="FEHLER: Es konnte keine SSH-Verbindung aufgebaut werden."
    SOURCE="${SHARE#*/}"
else
    SHARE_DECRYPT="${SOURCE%%/*}"
# SSH-Verbindung erfolgreich...
    if $SOURCE_TEST ! -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
  if [ "$SSHUSER" ] && [ "$FROMSSH" ] && ssh $SSHUSER@$FROMSSH; then 
      echo "Quellordner $SHARE_DECRYPT wurde lokalisiert..." >> $LOG
    for SHARE in $SOURCES; do  
    elif $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
  echo "" >> $LOG 
      echo "Verschluesselter Quellordner $SHARE_DECRYPT bereits eingehangen..." >> $LOG
# Quellordner ist erreichbar. RSync ausführen...
    elif $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST ! -d /volume*/$SHARE_DECRYPT; then
      if ssh $SSHUSER@$FROMSSH test -d /volume*$SHARE; then
      echo "Verschluesselter Quellordner $SHARE_DECRYPT nicht eingehangen..." >> $LOG
        echo "SSH-Verbindung aufgebaut. Quellordner $SHARE wurde lokalisiert..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Quellordner einbinden
        echo "Starte Datensicherung: $SHARE nach $TARGET" >> $LOG
      if test -f `dirname $0`/$SHARE_DECRYPT.key; then
        rsync $SYNCOPT -e ssh $SSHUSER@$FROMSSH:/volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$TARGET" >> $LOG 2>&1
        echo "$SHARE_DECRYPT.key gefunden" >> $LOG
        RSYNC_CODE=$?
        echo "Verschluesselter Quellordner $SHARE_DECRYPT wird eingehangen..." >> $LOG
# RSync Exit-Code Auswertung einleiten...
        KEYFILESHARE=$(ecryptfs-unwrap-passphrase `dirname $0`/$SHARE_DECRYPT.key "\$1\$5YN01o9y")
          if [ $RSYNC_CODE -ne 0 ]; then
        $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_mount "$SHARE_DECRYPT" "$KEYFILESHARE" >> $LOG
            echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
        sleep 20
          fi
        if $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST ! -d /volume*/$SHARE_DECRYPT; then
# RSync Exit-Code Auswertung: Entfernter Server ausgeschaltet?
          echo "Verschluesselter Quellordner $SHARE_DECRYPT konnte nicht eingehangen werden..." >> $LOG
          if [ $RSYNC_CODE -eq 43 ]; then
        fi
            echo "Entfernte DS oder RSync komp. Server ausgeschaltet?" >> $LOG
      else
            echo "Starte Datensicherung erneut: $SHARE nach $TARGET" >> $LOG
        STOP="Kein Keyfile fuer $SHARE_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden! Datensicherung ABGEBROCHEN..."
            pkill rsync
       fi
            sleep 300
     fi
            rsync $SYNCOPT -e ssh $SSHUSER@$FROMSSH:/volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$TARGET" >> $LOG 2>&1
   done
            RSYNC_CODE=$?
     
            if [ $RSYNC_CODE -ne 0 ]; then
          echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
          echo "Erneute Sicherung wieder fehlerhaft: $SHARE nach $TARGET" >> $LOG
        echo "Bitte Power-Status checken" >> $LOG
            fi
          fi
# RSync Exit-Code Auswertung: DSL-Verbindung getrennt?
          if [ $RSYNC_CODE -eq 255 ]; then
            echo "DSL Verbindung getrennt?" >> $LOG
            echo "Starte Datensicherung erneut: $SHARE nach $TARGET" >> $LOG
            pkill rsync
            sleep 300
            rsync $SYNCOPT -e ssh $SSHUSER@$FROMSSH:/volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$TARGET" >> $LOG 2>&1
            RSYNC_CODE=$?
     
            if [ $RSYNC_CODE -ne 0 ]; then
          echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
          echo "Erneute Sicherung wieder fehlerhaft: $SHARE nach $TARGET" >> $LOG
        echo "Bitte Verbindung checken" >> $LOG
            fi
          fi
# SSH-Quellordner nicht erreichbar.
  else  
    EXITCODE="1"
        echo "FEHLER: Quellordner $SHARE nicht erreichbar! (SSH-Verbindung i.O.)" >> $LOG
        echo "Datensicherung ABGEBROCHEN..." >> $LOG
       fi
        echo "" >> $LOG
        echo "------------------------------------------------------------------------------------------------" >> $LOG
     done 
   fi 
fi
fi
echo "" >> $LOG


# RSync- Lokale Datensicherung auf Volume, USB- oder SATA-Datenträger
# Ziel definieren
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
if [ ! "$SSHUSER" ] && [ ! "$FROMSSH" ]; then
if [ -z "$STOP" ]; then
   for SHARE in $SOURCES; do
  if [ -n "$SSH_TO" ] && [ -n "$TARGET" ]; then
     echo "" >> $LOG
    VOLDEST=$($TOSSH "echo /volume*/$TARGET_DECRYPT")
# Quellordner ist erreichbar. RSync ausführen...   
    VOLTARGET="${VOLDEST%/*}"
     if [ -d /volume*"$SHARE" ]; then
    DESTINATION="$VOLTARGET$TARGET"
      echo "Lokaler Quellordner $SHARE wurde lokalisiert..." >> $LOG
    if [ -n "$HOSTNAME" ]; then
      echo "Starte Datensicherung: $SHARE nach $TARGET" >> $LOG
DESTINATION="$VOLTARGET$TARGET/$NAME"
      rsync $SYNCOPT /volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$TARGET" >> $LOG 2>&1
  else
      RSYNC_CODE=$?
  DESTINATION="$VOLTARGET$TARGET"
# RSync Exit-Code Auswertung
    fi
       if [ $RSYNC_CODE -ne 0 ]; then
   elif [ -n "$SSH_TO" ] && [ -z "$TARGET" ]; then
        echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
     STOP="Bei SSH_TO muss TARGET angeben werden !" >> $LOG
  elif [ -z "$SSH_TO" ] && [ -z "$NOTTOSCRIPT" ] && [ -z "$TARGET" ]; then
     if [ -n "$HOSTNAME" ]; then
    DESTINATION="`dirname $0`$TARGET_EMPTY/$NAME"
  else
    DESTINATION="`dirname $0`$TARGET_EMPTY"
    fi
  elif [ -z "$SSH_TO" ] && [ -n "$NOTTOSCRIPT" ] && [ -n "$TARGET" ]; then
    VOLDEST=$(echo /volume*/$TARGET_DECRYPT)
    VOLTARGET="${VOLDEST%/*}"
    if [ -n "$HOSTNAME" ]; then
DESTINATION="$VOLTARGET$TARGET/$NAME"
  else
    DESTINATION="$VOLTARGET$TARGET"
    fi
    mkdir -p "$DESTINATION"
  elif [ -z "$SSH_TO" ] && [ -z "$NOTTOSCRIPT" ]; then
       if [ -n "$HOSTNAME" ]; then
      DESTINATION="`dirname $0`$TARGET/$NAME"
    else
    DESTINATION="`dirname $0`$TARGET"
       fi
       fi
# Quellordner nicht erreichbar 
     mkdir -p "$DESTINATION"
     else
  fi
      EXITCODE="1"
  if [ -n "$SSH_TO" ] && [ -n "$NOTTOSCRIPT" ]; then
      echo "------------------------------------------------------------------------------------------------" >> $LOG
    if $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
      echo "FEHLER: Lokaler Quellordner $SHARE nicht erreichbar!" >> $LOG
    $TOSSH mkdir -p "$DESTINATION"
      echo "Datensicherung ABGEBROCHEN..." >> $LOG
      echo "" >> $LOG
      echo "------------------------------------------------------------------------------------------------" >> $LOG
     fi
     fi
   done  
   fi
fi
fi
   


# RSync Exit-Code = keine Fehlermeldung
for SHARE in $SOURCES; do
  SOURCE="${SHARE#*/}"
  SHARE_DECRYPT="${SOURCE%%/*}"
 
if $SOURCE_TEST ! -d /volume*/$SHARE_DECRYPT; then
ERROR="1"
echo "" >> $LOG
echo "ACHTUNG: Quellordner $SHARE_DECRYPT nicht erreichbar..." >> $LOG
    echo "" >> $LOG; echo "" >> $LOG
elif $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
# SSH-SSH_FROM RSync-Datensicherung VON einer entfernten DS oder komp. Server
#--------------------------------------------------------------------------
if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ] && [ -z "$STOP" ] && [ -n "$DESTINATION" ]; then
echo "$HR" >> $LOG
    echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
echo "$HR" >> $LOG
    rsync $SYNCOPT -e ssh $SSH_USER@$SSH_FROM:/volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
    RSYNC_CODE="$?"
  fi
# SSH-SSH_TO RSync-Datensicherung AUF eine entfernte DS oder komp. Server
#--------------------------------------------------------------------------
  if [ -n "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -z "$STOP" ] && [ -n "$DESTINATION" ]; then
echo "$HR" >> $LOG
    echo "Starte Datensicherung: $LOKALHOST$SHARE nach $DESTINATION" >> $LOG
echo "$HR" >> $LOG
    rsync $SYNCOPT /volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE $SSH_USER@$SSH_TO:"$DESTINATION" >> $LOG
    RSYNC_CODE="$?"
  fi
# RSync- Lokale Datensicherung auf Volume, USB- oder SATA-Datenträger
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
  if [ $? -eq 0 ] && [ ! "$EXITCODE" ]; then
  if [ -z "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -z "$STOP" ] && [ -n "$DESTINATION" ]; then
    echo  "" >> $LOG
echo "$HR" >> $LOG
    echo "RSync-Datensicherung erfolgreich. Sicherungsziel: $TARGET" >> $LOG
    echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
    DSMNOTIFY="RSync-Datensicherung erfolgreich. Sicherungsziel: $TARGET"
echo "$HR" >> $LOG
    rsync $SYNCOPT /volume*"$SHARE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
    RSYNC_CODE="$?"
  fi
# RSync Exit-Code = Fehlermeldung
#-------------------------------------------------------------------------  
# Exit-Code: Entfernter Server ausgeschaltet?
  if [ $RSYNC_CODE -eq 43 ]; then
    echo "Entfernte DS oder RSync komp. Server nicht Online?" >> $LOG
# Exit-Code: DSL-Verbindung getrennt?
  elif [ $RSYNC_CODE -eq 255 ]; then
    echo "Bitte Internetverbindung kontrollieren!" >> $LOG
#Exit-Code ausgeben...
  elif [ $RSYNC_CODE -ne 0 ]; then
    echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
  fi
  echo "" >> $LOG; echo "$HR" >> $LOG
fi
done
 
# RSync Exit-Code = Erfolgreich bzw. Unvollständig
#-------------------------------------------------------------------------
if [ $RSYNC_CODE -eq 0 ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
  echo "RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION" >> $LOG
  DSMNOTIFY="RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION"
# Signalausgabe - Datensicherung erfolgreich
# Signalausgabe - Datensicherung erfolgreich
    if [ $SIGNAL -eq 1 ]; then
  if [ $SIGNAL -eq 1 ]; then
      echo 3 >/dev/ttyS1; echo 8 >/dev/ttyS1
    echo 3 >/dev/ttyS1; echo 8 >/dev/ttyS1
      sleep 2    
    sleep 2
    fi  
  fi
# RSync Exit-Code = Fehlermeldung
# RSync Exit-Code = Fehlermeldung
  elif [ $? -ne 0 ] || [ "$EXITCODE" ] && [ ! "$SSHEXIT" ]; then
elif [ $RSYNC_CODE -ne 0 ] || [ -n "$STOP" ] || [ -n "$ERROR" ]; then
    echo  "" >> $LOG
  echo "RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Sicherungsziel: $DESTINATION" >> $LOG
    echo "RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Sicherungsziel: $TARGET" >> $LOG
  DSMNOTIFY="RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Bitte Protokoll prüfen!"
    DSMNOTIFY="RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Weitere Informationen im Protokoll"
fi
# Signalausgabe - Datensicherung fehlgeschlagen
  echo "$HR" >> $LOG; echo "" >> $LOG
    if [ $SIGNAL -eq 1 ]; then
if [ -n "$STOP" ]; then
      echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 8 >/dev/ttyS1
  echo "$STOP" >> $LOG
    fi 
fi
  fi    


# DSM-Systemkonfiguration exportieren
# DSM-Systemkonfiguration exportieren
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
if [ $DSSEXPORT -eq 1 ]; then
if [ -n "$DSM_EXPORT" ] && [ -z "$STOP" ] && [ $RSYNC_CODE -eq 0 ]; then
  mkdir -p $TARGET/@DSMConfig
   if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
   if [ "$SSHUSER" ] && [ "$FROMSSH" ] && ssh $SSHUSER@$FROMSSH; then
     $FROMSSH /usr/syno/bin/synoconfbkp export --filepath DSMConfig_TEMP.dss
     ssh $SSHUSER@$FROMSSH /usr/syno/bin/synoconfbkp export --filepath DSMConfig_TEMP.dss
      mkdir -p $DESTINATION/@DSMConfig
    scp $SSHUSER@$FROMSSH:DSMConfig_TEMP.dss /$TARGET/@DSMConfig/DSMConfig_$DATEOPT.dss
      scp -r $SSH_USER@$SSH_FROM:DSMConfig_TEMP.dss $DESTINATION/@DSMConfig/DSMConfig_"$DATE"_$REMOTEHOST.dss
     ssh $SSHUSER@$FROMSSH rm DSMConfig_TEMP.dss
     $FROMSSH rm -rf DSMConfig_TEMP.dss
     echo  "Sicherung der DSM-Systemkonfiguration einer entfernten SSH-Quelle erfolgreich." >> $LOG
     echo  "Sicherung der DSM-Systemkonfiguration von $REMOTEHOST erfolgreich zu $LOKALHOST kopiert.." >> $LOG
  fi
    echo "" >> $LOG
   if [ ! "$SSHUSER" ] && [ ! "$FROMSSH" ]; then
  elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
     synoconfbkp export --filepath $TARGET/@DSMConfig/DSMConfig_$DATEOPT.dss
    synoconfbkp export --filepath `dirname $0`/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
    $TOSSH mkdir  -p $DESTINATION/@DSMConfig
    scp -r `dirname $0`/@DSMConfig/*.dss $SSH_USER@$SSH_TO:$DESTINATION/@DSMConfig/
    rm -rf `dirname $0`/@DSMConfig
    echo  "Sicherung der DSM-Systemkonfiguration von $LOKALHOST erfolgreich zu $REMOTEHOST kopiert.." >> $LOG
    echo "" >> $LOG
   elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
    mkdir -p $VOLTARGET/@DSMConfig
     synoconfbkp export --filepath $DESTINATION/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
     echo  "Lokale Sicherung der DSM-Systemkonfiguration erfolgreich." >> $LOG
     echo  "Lokale Sicherung der DSM-Systemkonfiguration erfolgreich." >> $LOG
   fi  
    echo "" >> $LOG
   fi
fi
fi
   
 
# Rotationszyklus für das Löschen von @Recycle, @Logfiles und @DSMConfig
  # Rotationszyklus für das Löschen von @Recycle, @Logfiles und @DSMConfig
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
# Dateien im Ordner @Recycle die älter als x Tage sind, löschen.
# Dateien im Ordner @Recycle die älter als x Tage sind, löschen.
if [ -d $TARGET/@Recycle/ ]; then  
if $TARGET_TEST -d $DESTINATION/$NAME/@Recycle/; then
   if [ $RECYCLE_ROTATE -ne 0 ]; then
   if [ -n "$RECYCLE_ROTATE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
     find $TARGET/@Recycle/* -type d -mtime +$RECYCLE_ROTATE -exec rm -rf {} \;
     $FIND $DESTINATION/@Recycle/* -type d -mtime +$RECYCLE_ROTATE -exec rm -rf {} \;
     echo  "HINWEIS: Daten aus dem Ordner /@Recycle, die mehr als $RECYCLE_ROTATE Tage alt waren, wurden geloescht." >> $LOG
     echo  "HINWEIS: Daten aus dem Ordner /@Recycle, die mehr als $RECYCLE_ROTATE Tage alt waren, wurden geloescht." >> $LOG
    echo "" >> $LOG
   fi
   fi
fi
fi
# Dateien im Ordner @RLogfiles die älter als x Tage sind, löschen.
# Dateien im Ordner @RLogfiles die älter als x Tage sind, löschen.
if [ -d $TARGET/@Logfiles/ ]; then
if $TARGET_TEST -d $DESTINATION/@Logfiles/; then
   if [ $LOGFILES_ROTATE -ne 0 ]; then
   if [ -n "$LOGFILES_ROTATE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
     find $TARGET/@Logfiles -name "*.log" -type f -mtime +$LOGFILES_ROTATE -exec rm {} \;
     $FIND $DESTINATION/@Logfiles -name "*.log" -type f -mtime +$LOGFILES_ROTATE -exec rm {} \;
     echo  "HINWEIS: Daten aus dem Ordner /@Logfiles, die mehr als $LOGFILES_ROTATE Tage alt waren, wurden geloescht." >> $LOG
     echo  "HINWEIS: Daten aus dem Ordner /@Logfiles, die mehr als $LOGFILES_ROTATE Tage alt waren, wurden geloescht." >> $LOG
   fi
    echo "" >> $LOG
   fi
fi
fi
# Dateien im Ordner @DSMConfig die älter als x Tage sind, löschen.
# Dateien im Ordner @DSMConfig die älter als x Tage sind, löschen.
if [ -d $TARGET/@DSMConfig/ ]; then
if $TARGET_TEST -d $DESTINATION/@DSMConfig/; then
   if [ $DSMCONFIG_ROTATE -ne 0 ]; then
   if [ -n "$DSMCONFIG_ROTATE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
     find $TARGET/@DSMConfig -name "*.dss" -type f -mtime +$DSMCONFIG_ROTATE -exec rm {} \;
     $FIND $DESTINATION/@DSMConfig -name "*.dss" -type f -mtime +$DSMCONFIG_ROTATE -exec rm {} \;
     echo  "HINWEIS: Daten aus dem Ordner /@DSMConfig, die mehr als $DSMCONFIG_ROTATE Tage alt waren, wurden geloescht." >> $LOG
     echo  "HINWEIS: Daten aus dem Ordner /@DSMConfig, die mehr als $DSMCONFIG_ROTATE Tage alt waren, wurden geloescht." >> $LOG
    echo "" >> $LOG
   fi
   fi
fi
# Verschlüsselte Shares wieder aushängen..
#-------------------------------------------------------------------------
if [ -n "$UNMOUNT" ]; then
  if $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
    echo "Ziel: $TARGET_DECRYPT wurde ausgehangen" >> $LOG
    $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_unmount $TARGET_DECRYPT >> $LOG
    sleep 10
  fi
fi
if [ -n "$UNMOUNT" ]; then
  for SHARE in $SOURCES; do
    SHARE_DECRYPT="${SHARE#*/}"
    if $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
      echo "Quelle: $SHARE_DECRYPT wurde ausgehangen" >> $LOG
      $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_unmount $SHARE_DECRYPT >> $LOG
      sleep 10
    fi
    unset KEYFILEPW
  done
fi
fi


Zeile 388: Zeile 619:
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
synodsmnotify @administrators "Script: $SCRIPTNAME" "$DSMNOTIFY"
synodsmnotify @administrators "Script: $SCRIPTNAME" "$DSMNOTIFY"
#ssh $SSHUSER@$FROMSSH /usr/syno/bin/synodsmnotify @administrators "$SCRIPTNAME" "$DSMNOTIFY"
 
 
   if [ -n "$EMAIL" ]; then
   if [ "$EMAIL" ]; then
     ssmtp $EMAIL < $LOG
     ssmtp $EMAIL < $LOG
   fi
   fi
exit $?
 
if [ $RSYNC_CODE -eq 0 ] && [ -z "$STOP" ] && [ -z "$ERROR" ] && [ -n "$AUTORUN" ]; then
  exit 100
else
  exit $?
fi
</pre>
</pre>


=Erstellen eines RSA-Keys für den Aufbau einer SSH-Verbindung=
=Erstellen eines RSA-Keys für den Aufbau einer SSH-Verbindung=
Es soll eine dateibasierte Datensicherung mittels rsync von Diskstation "A" (Produktivsystem) auf Diskstation "B" (Backupsystem) angelegt werden. Dabei übernimmt das Backupsystem die Aufgabe des Servers, worüber der Verbindungsaufbau und der eigentliche Sicherungsvorgang initiiert wird. Das Produktivsystem übernimmt somit die Aufgabe des Client und muß dem ganzen Vorgang nur zustimmen. Um dies zu ermöglichen muß im Vorfeld ein RSA-Schlüssel auf dem Backupsystem erzeugt und dem Produktivsystem der öffentliche Schlüssel mitgeteilt werden, um so den automatischen Verbindungsaufbau per SSH zu ermöglichen. Nachdem die SSH-Verbindung erfolgreich aufgebaut wurde, wird der eigentliche rsync-Befehl abgesetzt und somit die Datensicherung ausgelöst.
Es soll eine dateibasierte Datensicherung mittels RSync von Diskstation "A" (Produktivsystem) auf Diskstation "B" (Backupsystem) angelegt werden. Dabei übernimmt das Backupsystem die Aufgabe des Servers, worüber der Verbindungsaufbau und der eigentliche Sicherungsvorgang initiiert wird. Das Produktivsystem übernimmt somit die Aufgabe des Client und muß dem ganzen Vorgang nur zustimmen. Um dies zu ermöglichen muß im Vorfeld ein RSA-Schlüssel auf dem Backupsystem erzeugt und dem Produktivsystem der öffentliche Schlüssel mitgeteilt werden, um so den automatischen Verbindungsaufbau per SSH zu ermöglichen. Nachdem die SSH-Verbindung erfolgreich aufgebaut wurde, wird der eigentliche rsync-Befehl abgesetzt und somit die Datensicherung ausgelöst. Um auch in die Gegenrichtung sichern zu können, muss die RSA-Key Einrichtung dementsprechend gedreht werden, so das am Ende sowohl Diskstation "A" als auch Diskstation "B" Quelle als auch Ziel der Datensicherung darstellen können.


Im folgenden werden alle Einstellungen für den Benutzer '''root''' getroffen, da nur unter diesem Benutzer die Signalausgabe als auch das Sichern der DSM-Konfiguration funktioniert. Wer hier lieber als "admin" oder vielleicht sogar als eingeschränkter Benutzer "rsync" arbeiten möchte, muss nachfolgend an den entsprechenden Stellen den gewünschten Benutzernamen einsetzen. Das hier verwendete Homeverzeichnis des Benutzer "root" wird im folgenden nur in dessen Kurzform mit ~/ angesprochen, wobei hier immer auf /root verwiesen wird. Alle anderen Benutzerkonten befinden sich im Homeverzeichnis /home/[BENUTZERNAME] bzw. richtigerweise unter /var/services/homes/[BENUTZERNAME].
Im folgenden werden alle Einstellungen für den Benutzer '''root''' getroffen, da nur unter diesem Benutzer die Signalausgabe als auch das Sichern der DSM-Konfiguration funktioniert. Wer hier lieber als "admin" oder vielleicht sogar als eingeschränkter Benutzer "rsync" arbeiten möchte, muss nachfolgend an den entsprechenden Stellen den gewünschten Benutzernamen einsetzen. Das hier verwendete Homeverzeichnis des Benutzer "root" wird im folgenden nur in dessen Kurzform mit ~/ angesprochen, wobei hier immer auf /root verwiesen wird. Alle anderen Benutzerkonten befinden sich im Homeverzeichnis /home/[BENUTZERNAME] bzw. richtigerweise unter /var/services/homes/[BENUTZERNAME].
Zeile 492: Zeile 727:


<pre>$ exit</pre>
<pre>$ exit</pre>
=Realese-Notes vom 03.04.2016=
*Daten im Ordner @Recycle wurden trotz eingestellter Zeitvorgabe nicht gelöscht. Fehler im Löschvorgang behoben.
*Daten im Ordner @DSMConfig wurden trotz eingestellter Zeitvorgabe nicht gelöscht. Fehler im Löschvorgang behoben.
*Fehler bei der Sicherung der DSM-Systemkonfiguration behoben. Es wurde selbst bei einer SSH-Verbindung immer nur eine lokale, also Serverseitige Sicherung der DSM-Systemkonfiguration angelegt nicht aber, wie es richtig wäre, eine Clientseitige. Da bei einer SSH-Verbindung die Quelldaten jedoch vom Client geholt werden, sollte auch die DSM-Systemkonfiguration von dort stammen. Dieser Fehler wurde behoben und man findet die entsprechende Info auch im Protokoll wieder.
*Diverse Fehlerkorrekturen im Script eigenen Benachrichtigungssystem wurden behoben. Außerdem wird jetzt jede Aktion sowie Reaktion vom System erfasst und ins Protokoll übergeben. So ist gewährleistet, das der Benutzer immer ein Feedback erhält um mögliche Fehler besser lokalisieren zu können.
*Bei einer Datensicherung über eine SSH-Verbindung werden im Vorfeld diverse Bedingungen vom System abgefragt um zu prüfen ob eine Verbindung überhaupt hergestellt werden konnte und ob der gewünschte Ordner überhaupt erreichbar bzw. vorhanden ist, bevor mit der eigentlichen Datensicherung begonnen wird. Sollte die Verbindung zwischenzeitlich getrennt werden, versucht das System erstmal von alleine die Verbindung wiederherzustellen, bevor eine Fehlermeldung generiert wird.
C'''omming soon...'''
Wir arbeiten mit Hochdruck an einer Lösung um verschlüsselte Ordner sichern zu können, die vom System in der Quelle und im Ziel automatisch eingehangen- und nach der Sicherung wieder automatisch ausgehangen werden. Auch weitere Möglichkeiten der Sicherung eines veschlüsselten Ordners werden zur Zeit geprüft und getestet. Es bleibt also spannend...
'''Realese-Notes (Stand: 31.03.2016)'''
*Das System ist mittlerweile so flexibel Aufgestellt, das Quelle und Ziel einer Datensicherung individuell definiert werden kann. Aus diesem Grunde mussten abermals Änderungen am Wiki-Eintrag vorgenommen werden und das alles beschreiben zu können.
*Es wurden weitere Funktionen und Abfragen hinzugefügt die prüfen, ob eine SSH-Verbindung erfolgreich hergestellt und ob der gewünschte Quellordner lokalisiert werden konnte um eine Datensicherung durchzuführen. Treten hier Unstimmigkeiten auf, wird eine Fehlermeldung ins Protokoll geleitet. Eine Unstimmigkeit könnte z.B. ein nicht eingehangener verschlüsselter Ordner, ein nicht berechtigter SSH-Benutzer, eine falsche oder fehlende IP-Adresse oder ein einfacher Tippfehler sein.
*Gleiches gilt für die "lokale" Datensicherung. Auch hier wird erstmal über eine Abfrage versucht, den gewünschten Quellordner zu lokalisieren, bevor die Datensicherung durchgeführt wird. Bei Unstimmigkeiten werden auch hier Fehlermeldungen ins Protokoll geleitet.
*Weiterhin wurde die Scriptschreibweise ein wenig angepasst und verbessert um es kompakter aussehen zu lassen.
'''Realese-Notes (Stand: 28.03.2016)'''
*Mit diesem Update wurde die Möglichkeit geschaffen, auf eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk per SSH-Verbindung  zu sichern.
*Dafür wurde dieses Wiki vollständig Überarbeitet, umgeschrieben und ergänzt um die neuen Funktionen zu beschreiben.
*Eine Anleitung zur Erstellung eines RSA-Keys um den Zugriff per SSH zu ermöglichen wurde hinzugefügt.
'''Realese-Notes (Stand: 19.03.2016)'''
*Ab sofort kann man die DSM-Systemkonfiguration exportieren. Diese wird auf Wunsch in den Systemordner @DSMConfig nach dem Muster DSMConfig_2016-03-19_22h00.dss abgelegt. Weiterhin kann auch hier über eine Zeitvorgabe (in Tagen) eingestellt werden, wie lange die exportieren Systemkonfigurationen erhalten bleiben sollen.
*Eine weitere Variante des Such-Scriptes wurde veröffentlicht um die Suchbedingungen individueller anpassen zu können.
'''Release-Notes (Stand: 18.03.2016)'''
*Die chronologische Speicherung innerhalb der Systemordner @Recycle und @Logfiles kann jetzt unabhängig von einander über eine individuell einstellbare Zeitvorgabe in Tagen begrenzt werden. Daten, die älter sind als die eingestellten Zeitvorgaben, werden "unwiderruflich" gelöscht.
*Die eigentliche Befehlszeile des rsync-Aufrufes im Script wurde neu strukturiert, indem die Ausführungsoptionen in Variablen ausgelagert, gruppiert und optimiert wurden. Das erleichtert eine Anpassung des rsync-Aufruf an die gewünschten Bedürfnisse.
*Verbesserung der Anzeige und Ausgabe von Datum und Uhrzeit sowie des Script-Dateinamens
*@Logfile Protokolle werden jetzt nach dem Muster 2016-03-18_21h37_[SCRIPT-NAME].log abgelegt
*@Recycle Ordner werden jetzt nach dem Muster 2016-03-18_21h37_[SCRIPT-NAME] abgelegt
*In den Benachrichtigungen und Protokollen wird stets der ausgeführte Script-Dateiname angegeben. 
*Viele kleinere Script-Verbesserungen- und Anpassungen
'''Release-Notes (Stand: 11.03.2016)'''
* Anstatt wie bisher nur eine Backup-Aufgabe ausführen zu können, kann jetzt eine beliebige Anzahl von Backup-Aufgaben auf unterschiedlichen Datenträgern ausgeführt werden.
* Die Script-Dateinamen („search-rsync.sh“ sowie „rsync.sh“) können ab sofort individuell vergeben werden, einzig die Endung .sh muss erhalten bleiben.
* Beim Definieren der Backup-Quellen (SOURCES), müssen keine Volume-Bezeichnungen mehr mitgeführt werden. Es reicht demnach der Pfad eines gemeinsamen Ordners, also z.B. /music/Alben/International
* Über das Benachrichtigungssystems des DSM wird jetzt auch der ausgeführte Script-Dateiname angezeigt.
* Es wurde eine optische- sowie akustische Signalausgabe eingebaut, die optional ausgewählt werden kann.
* Kleinere Script-Verbesserungen und Beseitigung von Schönheitsfehlern.


=Externe Links=
=Externe Links=

Version vom 23. April 2016, 20:23 Uhr

Einleitung

Diese Anleitung zur dateibasierten RSync-Datensicherung bietet folgende Möglichkeiten...

  • Quelle(n) und/oder Ziel können unverschlüsselt sein
  • Quelle(n) und/oder Ziel können verschlüsselt sein
  • Sicherung innerhalb eines /volume
  • Sicherung zwischen internen /volumes
  • Sicherung auf lokal angeschlossene USB-/SATA-Datenträger sowie eingebundene Remote-Shares (nur unverschlüsselt)
  • Sicherung von einer entfernten DS oder RSync-kompatilben Server
  • Sicherung auf eine entfernte DS oder RSync-kompatilben Server
  • (weitere Konstellationen sind möglich, wurden jedoch nicht getestet)

Hinweis: Die Verschlüsselung beruht hierbei auf der von Synology verwendeten Ordnerverschlüsselung (eCryptfs). Um verschlüsselte gemeinsame Ordner einbinden zu können, wird das Key-File also der Exportschlüssel benötigt. Diesen erhält man über die DSM-Systemsteuerung/Gemeinsame Ordner.

Anmerkung

Bevor ihr anfangt, nehmt bitte noch den Artikel "Wichtige Informationen zum Modden der Synology Stations" zur Kenntnis.

Auch wenn dieses Script intensiv auf einwandfreie Funktion hin getestet wurde, so kann eine Fehlfunktion und demzufolge ein möglicher Datenverlust nicht ausgeschlossen werden. Aus diesem Grund solltet ihr das System erstmal mit unwichtigen Testdaten auf Herz und Nieren prüfen und sich mit der Arbeitsweise des Scripts und dessen Funktionen vertraut machen bevor ihr das ganze "produktiv" einsetzt. Ihr verwendet dieses Script auf eigene Gefahr.

Voraussetzungen

  • Umgang mit dem DSM Aufgabenplaner
  • Umgang mit einem Editor seiner Wahl (z.B. Notepad++ oder dem DSM Text-Editor)
  • Grundkenntnisse im Umgang mit Shell-Scripten
  • Umgang mit der Konsole (bei Verwendung des SSH-Zuganges)
  • Zum versenden einer E-Mail muss im DSM unter Hauptmenü/Systemsteuerung/Benachrichtigung eine E-Mail Adresse hinterlegt sein.
  • Ein externer USB- oder SATA-Datenträger, eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk.
  • Optional: autorun für externe Datenträger (Version 1.7)

Erläuterungen zur Funktion und Arbeitsweise

Mit dem hier vorgestellten System ist sowohl eine Datensicherung auf einen lokal angeschlossenen USB- oder SATA-Datenträger als auch eine Netzwerksicherung von oder auf eine weitere Synology Diskstation bzw. einem RSync-kompatiblen Server im Netzwerk möglich (SSH-Zugang vorausgesetzt). Die gewünschte Ausgangssituation bestimmt die Art und Weise der Scriptausführung, die im folgenden schematisch dargestellt wird:

 Diskstation
    |   |
    |   '--> Aufgabenplaner ------------------------------
    |             |                                      |
    |             '--> Such-Script -----> USB/SATA-Share ---> Ausführungs-
    |                                                    |       Script
    '----------------> USB/SATA-Share --> autorun --------    (Key-Files)
                                                                   |
                                       .---------------------------'
                                       |
                                       V
            .---------- Quelle <--- definiere ---> Ziel----------.
            |            |                          |            |
            V            '-- lokale/intern/extern --'            V
lokalisiere Quelle(n)                                     lokalisiere Ziel
  |                                                                    |  
  |                          Protokoll/E-Mail                          |
  |-->  Verschlüsselte              |              Verschlüsseltes  <--|
  |  Quelle(n) anhand der           |              Ziel anhand der     |
  |  Key-Files einhängen   <--- aushängen --->   Key-Files einhängen   |
  |          |                      |                   |              |
  |          V                      |                   V              |
  '--------------------->> !! DATENSICHERUNG !! >>---------------------'
                       |                          |
                       '--  lokale/intern/extern -'


Scriptausführung über den DSM-Aufgabenplaner

Die Scriptausführung kann über verschiedene Wege initiiert werden indem das Script entweder direkt oder indirekt über den Aufgabenplaner des DSM angesprochen bzw. über ein Such-Script lokalisiert und ausgeführt wird. Die Verwendung des Such-Scripts ist hierbei nicht zwingend erforderlich und kommt nur bei einer lokalen Datensicherung (auf USB- oder SATA-Datenträger) zum Einsatz, da sich die Suche nur auf diese beschränkt. Aber auch wenn es nicht unbedingt benötigt wird, so hat das Such-Script den entscheidenden Vorteil, dass das eigentliche Ausführungs-Script entweder anhand des vollständigen Script-Dateinamens, oder aber anhand einer bestimmten Zeichenkette innerhalb des Script-Dateinamens lokalisiert, ausgeführt oder bei Bedarf von der Ausführung ausgeschlossen werden kann. Des weiteren kann sich das Ausführungs-Script auch innerhalb eines gemeinsamen Ordners der DS befinden worin z.B. eine Datensicherung abgelegt werden soll. Der Standort des Scripts sowie der Key-Files bestimmt sogesehen das Ziel der Datensicherung, jedoch können Quelle(n) und Ziel auch an anderen Orten liegen. Einzig das Logfile wird immer am Speicherort des Scriptes abgelegt. Auch ist der Name des Ausführungs-Scripts erstmal nicht relevant, es macht jedoch Sinn einen aussagekräftigen Namen zu vergeben, da unter Umständen mehrere Scripte hintereinander ausgeführt werden können. Einzig muss darauf geachtet werden, dass das Script die Dateiendung .sh trägt und ggfl. ausführbar ist, sollte es nicht über das Such-Script ausgeführt werden.


Scriptausführung mittels "autorun"

Das Script kann aber auch in Verbindung mit "autorun" gestartet werden. Grade bei der Verwendung verschlüsselter Ordner, wo das entsprechende Key-File (der Exportschlüssel) am Speicherort des Scriptes liegen muß, gewinnt man in Verbindung mit "autorun" eine erhöhte Sicherheit, da die Key-Files nur für den Zeitraum der Datensicherung verfügbar sind. Mit entfernen des USB-Sticks und den darauf befindlichen Key-Files sind die verschlüsselten Daten auf der DS erstmal sicher, bewahrt man den USB-Stick denn an einem sicheren Ort auf. autorun wird zwar offiell nicht mehr für DSM 6 weiterentwickelt, jedoch stellt uns Merthos (der Erfinder von autorun) mit der Version 1.7 eine Möglichkeit zur Verfügung auch weiterhin Scripte automatisch ausführen zu lassen. Dieses Verhalten machen wir uns zu nutze, indem wir den Dateinamen des hier vorgestellten Scripts einfach umbennenen in "autorun" und diese Datei dann zusammen mit evtl. benötigten Key-Files in das Wurzel- oder auch Hauptverzeichnis eines extern angeschlossenen USB-/SATA-Datenträgers kopieren. Auf diese Weise kann jede oben beschriebene Möglichkeit der Datensicherung ausführt werden, egal ob lokal, intern oder extern gesichert werden soll. Allein die Einstellung der benötigten Optionen innerhalb des Scriptes, beschreibt die Art und Weise der Datensicherung.


Das Ausführungs-Script (start-rsync.sh)

Das Ausführungs-Script selber synchronisiert sämtliche konfigurierte Quellen mit dem Backupziel. Dabei werden die Ordnerpfade relativ, nach dem jeweiligen Volume (1,2,3,4….) angelegt. Gelöschte Dateien in der Quelle werden im Ziel in den Ordner /@Recycle verschoben um einen möglichen Datenverlust vorzubeugen. Systemorder wie z.B. /@eaDIR, /#recycle, /#snapshot und /.DS_Store werden von der Synchronisation ausgeschlossen. Protokolle und zum Löschen vorgemerkte Dateien, sowie die Sicherung der DSM-Systemkonfiguration im Ordner /@DSMConfig, können nach Ablauf einer einstellbaren Zeitvorgabe (in Tagen) automatisch über das System gelöscht werden. Über das interne Benachrichtingssystem werden alle durchgeführten Schritte in einem Protokoll zusammengefasst welche im Ordner @/Logfiles abgelegt werden und man sich diese bei Bedarf auch als E-Mail zustellen lassen kann. Ebenso werden auftretende Fehler oder Störungen protokolliert und an verschiedenen Stellen mit weitergehenden Informationen, wie z.B. den Exit-Codes der rsync Ausführung näher beschrieben. Außerdem erhält die DSM-Administratorengruppe über das Benachrichtigungssystems des DSM eine Meldung über Erfolg oder Misserfolg des Vorganges inkl. Fehler-Code. Optional kein eine optische und akustische Signalausgabe ausgewählt werden.


Hinweise zum Erstellen und ausführen der Scripte

Die hier verwendeten Script-Dateinamen dienen nur der Veranschaulichung und können, unter Beachtung einiger Rahmenbedingungen nach Belieben verändert werden. Für die Erstellung der Scripte wurde im DSM unter dem Benutzer "admin" der DSM eigene Text-Editor, der evtl. noch über das Paketzentrum installiert werden muss, verwendet. Wichtig ist das im Editor unter "Voreinstellungen" im Reiter "Bearbeiten" als Standardcodierung "Unicode (UTF-8)" ausgewählt wird.

Nachdem das jeweilige Script aus dem Wiki in die Zwischenablage kopiert und im Text-Editor eingefügt wurde, kann die entsprechende Datei über "Speichern unter..." am gewünschten Ort abgespeichert werden. Scripte die später über den Aufgabenplaner ausgeführt werden, müssen noch die entsprechenden Berechtigungen erhalten um das jeweilige Script "ausführbar" zu machen (In der schematischen Darstellung mit einem * gekennzeichnet). Dazu muss man in der FileStation mit einem rechtsklick auf die betreffenden Datei gehen und im Kontextmenü den Menüpunkt "Eigenschaften" auswählen. Dort angekommen wechselt man zum Reiter "Genehmigung" und weiter auf die Schaltfläche "Erweiterte Optionen" um darauffolgend den Punkt "Übernommene Genehmigungen einschließen" auszuwählen. Zum Schluss bestätigt man das Ganze mit der Schaltfläche "OK" (Die Datei sollte jetzt die Berechtigung rwxrw-rw, bzw. 766 haben)

Nachdem die Privilegien richtig gesetzt wurden, kann das Script unter Hauptmenü/Systemsteuerung in den Aufgabenplaner aufgenommen werden, ohne die Aufgabe jedoch vorerst auszuführen. Dazu wählt man unter DSM 6 "Erstellen" --> "Geplante Aufgabe" --> "Benutzerdefiniertes Script". Im Reiter "Allgemein" kann man unter "Vorgang" einen individuellen Namen für die Aufgabe vergeben und als Benutzer sollte "root" ausgewählt werden. Bei einer Netzwerksicherung über eine SSH-Verbindung muss hier der Benutzer angegeben werden, auf dem der RSA-Key ausgestellt wurde, in unserem Fall (siehe Anleitung unten) ist das der Benutzer "root". (Nur unter dem Benutzer "root" funktioniert die Signaausgabe sowie die Sicherung der DSM-Konfiguration) Die Checkbox "Aktiviert" wird nur benötigt, sollte das Script automatisiert, also Zeitgesteuert gestartet werden. Dazu wäre dann im nächsten Schritt unter dem Reiter der "Zeitplan" zu definieren. Im Reiter "Aufgabeneinstellungen" muss jetzt noch unter dem Punkt "Befehl ausführen" der Pfad zum "Benutzerdefinierten Script" angegeben werden, also z.B. /volume1/ScriptStuff/search-rsync.sh. Nach dem Bestätigen mit "OK" wird die Aufgabe dem Aufgabenplaner hinzugefügt und kann später, falls gewünscht, nach dem Markieren der Aufgabe, über die Schaltfläche "Ausführen" manuell ausgeführt werden.

Script 1: Das Such-Script "search-rsync.sh"

Da es mehrere Ansätze für die Suche gibt, kann man sich hier Weitere Suchscriptvarianten anschauen und sich die für sich passenden Möglichkeit auswählen.

search-rsync.sh

#!/bin/sh

# Zeichenkette für Script-Dateinamen definieren
# ------------------------------------------------------------------------
# Es ist nicht erforderlich, den kompletten Script-Dateinamen anzugeben. |
# Es reicht die Eingabe einer Zeichenkette, die in jedem auszuführenden  |
# Script-Dateinamen enthalten sein muss.                                 |
# Beispiele für die Zeichenkette: "local" = local_Backup_Filme.sh        |
# local_Filme.sh oder auch Filme_local_sichern.sh                        |
#-------------------------------------------------------------------------
SCRIPT_STRING="start"

# ------------------------------------------------------------------------
# Ab hier bitte nichts mehr ändern                                       |
# ------------------------------------------------------------------------

for SCRIPT in /volume*/*share/*$SCRIPT_STRING*.sh
  do
    if [ -f $SCRIPT ]; then
    sh $SCRIPT
    fi
  done

Script 2: Das ausführungs-Script "start-rsync.sh"

Das nächste Script mit dem beispielhaften Script-Dateinamen "start-rsync.sh", wird entweder auf den entsprechenden externen USB- oder SATA-Datenträger in dessen Wurzelverzeichnis oder aber in einen "gemeinsamen Ordner" auf der Diskstation abgelegt, auf dem die Datensicherung abgelegt werden soll. Vor der ersten Ausführung des Scriptes müssen im Vorfeld noch die Backup-Quellen (SOURCES), der Backup-Zielordner (TARGET) sowie ggfls. eine E-Mailadresse (EMAIL) und bei Bedarf die SSH-Verbindungsdaten eingegeben werden. Ebenso kann eine Zeitvorgabe für das Löschen alter Logdateien und zum Löschen vorgemerkter Dateien bestimmt werden, sowie eine Signalsteuerung miteinbezogen werden.

Es ist hierbei durchaus möglich, unterschiedliche Scripte mit unterschiedlichen Backup-Aufgaben auszuführen, die dabei auch auf unterschiedlichen Datenträgern oder auf der DS (bei SSH-Verbindungen) abgelegt wurden. Es ist nicht zwingend erforderlich, das alle Scripte permanent Verfügbar sind. Alle gefundenen Scripte werden ausgeführt, nicht auffindbare Scripte werden übersprungen. Hierzu bitte auch die weiteren Hinweise in den Scripten beachten. Nachdem alle Parameter bestimmt wurden, kann man den Vorgang über den Aufgabenplaner ausführen lassen.

start-rsync.sh

#!/bin/sh

# E-Mail Adresse
# -------------------------------------------------------------------------
# Es wird ein Sicherungsprotokoll unter /@Logfiles angelegt.              |
# Bei Angabe einer E-Mail-Adresse, die identisch mit der bereits im DSM   |
# unter Hauptmenue/Systemsteuerung/Benachrichtigung hinterlegten          |
# E-Mail-Adresse sein muß, wird einem das Sicherungsprotokoll zugestellt. |
# -------------------------------------------------------------------------
EMAIL=""

# SSH - Verbindungsdaten
# -------------------------------------------------------------------------
# Bei einer Netzwerksicherung nachfolgend die Verbindungsdaten angeben.   |
# Werden keine Verbindungsdaten angegeben, wird eine lokale Datensicherung|
# durchgeführt.                                                           |
# -------------------------------------------------------------------------
SSH_USER=""         # Benutzername 
SSH_FROM=""         # IP-Adresse - VON entfernter Quelle AUF lokales Ziel -
SSH_TO=""           # IP-Adresse - VON lokaler Quelle AUF entferntes Ziel -

# Umgang mit verschlüsselten Ordnern
# ------------------------------------------------------------------------
# Angeben, ob eingehangene verschlüsselte Ordner nach der Datensicherung |
# wieder ausgehangen werden sollen.                                      |
# ------------------------------------------------------------------------
UNMOUNT="1"         # "" = Nein "1" = Ja 

# Backup - Quellen
# ------------------------------------------------------------------------
# Hier können beliebige, unverschlüsselte sowie verschlüsselte           |
# Backup-Quellen einer lokalen oder entfernten DS eingetragen werden.    |
# Zu beachten ist, das immer der vollständige Pfad ohne Angabe des       |
# entsprechenden Volume anzugeben ist. Weiterhin ist auf  die            |
# Schreibweise im Beispiel zu achten, pro Zeile je eine Backupquelle.    |
# ------------------------------------------------------------------------
SOURCES="/homes/admin
         /music
		 /photo/2016
         /secret-folder"

# Backup - Ziel
# ------------------------------------------------------------------------
# -> Befindet sich das Sicherungsziel am Speicherort des Scripts, dann   |
#    entspricht TARGET einem Unterverzeichnis. Hierbei wird NOTTOSCRIPT  |
#    kein Wert mitgegeben, also NOTTOSCRIPT=""                           |
#    Beispiel: /Backup_DS (volumeUSB[x]/usbshare/[TARGET])               |
#                                                                        |
# -> Befindet sich das Sicherungsziel jenseits des Scripts, dann         |
#    entspricht TARGET einem gemeinsamen Ordner auf der DS. Hierbei wird |
#    NOTTOSCRIPT ein Wert mitgegeben, also NOTTOSCRIPT="1"               |
#    Beispiel: /NetBackup (volume[X]/[TARGET=gemeinsamer Ordner])        | 
#                                                                        |
#   -Wird hierbei kein weiteres Unterverzeichnis angegeben, so wird      |
#    direkt in den gemeinsamen Ordner gesichert.                         |
#    Beipiel: /NetBackup                                                 |
#             (volume[X]/[TARGET=gemeinsamer Ordner])                    |
#                                                                        |
#   -Wird HOSTNAME="1" gesetzt, dann entspricht das Unterverzeichnis dem |
#    Netzwerknamen der DS.                                               |
#    Beispiel: /NetBackup/Diskstation                                    |
#              (volume[X]/[TARGET=gemeinsamer Ordner/Unterverzeichnis])  |
#                                                                        |
#   -Gibt man TARGET jedoch noch ein eigenes Unterverzeichnis mit, wird  |
#    dieses angelegt und verwendet.                                      |
#    Beispiel: /NetBackup/Mein_Backup_Verzeichnis                        |
#              (volume[X]/[TARGET=gemeinsamer Ordner/Unterverzeichnis])  |
#-------------------------------------------------------------------------
TARGET="/Backup_DS"
HOSTNAME=""         #      = Sicherungsziel entspricht TARGET
                    #   1  = Sicherungsziel entspricht TARGET/HOSTNAME
NOTTOSCRIPT=""      #      = Sicherungsziel liegt beim Script
                    #   1  = Sicherungsziel liegt im geinsamen Ordner
AUTORUN=""          #      = autorun wirft USB-Stick nicht aus
                    #   1  = autorun wirft USB-Stick aus

# Optische- sowie akustische Signalausgabe
#-------------------------------------------------------------------------
# 0 = Optische- sowie akustische Signalausgabe aus                       |
# 1 = Optische- sowie akustische Signalausgabe an                        |
#     Start      :  Status-LED wechselt von grün nach orange             |
#                   und es erklinkt ein Signalton                        |
#     Erfolgreich:  Status-LED wechselt von orange nach grün             |
#                   und es erklinkt ein weiterer Signalton               |
#     Fehler     :  Status-LED wechselt von orange nach grün             |
#                   und es erklinkt ein 3-Facher Fehler-Signalton        |
#-------------------------------------------------------------------------
SIGNAL="0"

# Exportieren der DSM-Systemkonfiguration (.dss)
#-------------------------------------------------------------------------
# Durch Eingabe einer "1" wird die DSM-Systemkonfigurartion (.dss) in den|
# Systemordner /@DSMConfig exportiert. Ist der Export nicht gewünscht,   |
# ist hier nichts einzutragen.                                           |
#-------------------------------------------------------------------------
DSM_EXPORT=""

# Rotationszyklus für das Löschen von @Recycle und @Logfiles
#-------------------------------------------------------------------------
# Zeitangabe, wann Ordner bzw. Dateien in den System-Ordnern             |
# @Recycle (RECYCLE_ROTATE), @Logfiles (LOGFILES_ROTATE) sowie           |
# @DSMConfig (DSMCONFIG_ROTATE) endgültig gelöscht werden sollen, die    |
# älter als x Tage sind. Bei der Angabe "0" werden keinen Ordner/Dateien |
# in dem jeweiligen Ordner @Recycle, @Logfiles oder @DSMConfig gelöscht. |
# ------------------------------------------------------------------------
RECYCLE_ROTATE="90"
LOGFILES_ROTATE="30"
DSMCONFIG_ROTATE="30"

# ------------------------------------------------------------------------
# Ab hier bitte nichts mehr ändern, wenn man nicht weiß was man tut !!!  |
# ------------------------------------------------------------------------

# Umgebungsvariablen definieren
#-------------------------------------------------------------------------
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/syno/bin:/usr/syno/sbin
SCRIPTFILE="${0##*/}"
SCRIPTNAME="${SCRIPTFILE%.*}"
TARGET_EMPTY="/Backup_DS"
DEST="${TARGET#*/}"
TARGET_PATH="${TARGET##*/}"
TARGET_DECRYPT="${DEST%%/*}"
SOURCE="${SHARE#*/}"
SOURCE_DECRYPT="${SOURCE%%/*}"
DATE=`date +%Y-%m-%d_%Hh%M`
TIMESTAMP=`date +%d.%m.%Y%t%H:%M:%S`
LOKALHOST="$(hostname)"
if [[ ${TARGET:0:1} != \/ ]] ; then
  TARGET="/$TARGET"
fi
HR="------------------------------------------------------------------------------------------------"

# RSync Optionen konfigurieren
#-------------------------------------------------------------------------
SYNCOPT="-ahR"
LOGSTAT="--stats"
EXCLUDE="--exclude=/@eaDir/*** --exclude=/#recycle/*** --exclude=/#snapshot/*** --exclude=/.DS_Store/***"
RECYCLE="--delete --backup --backup-dir=@Recycle/"$DATE"_$SCRIPTNAME"

# Variablen je nach Verbindung festlegen
#-------------------------------------------------------------------------
if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  FROMSSH="ssh $SSH_USER@$SSH_FROM"
  REMOTEHOST=$($FROMSSH "echo \`hostname\`")
  SYNOSHARE_SOURCE="$FROMSSH"
  SYNOSHARE_TARGET=""
  SYNO_TARGET=""
  FIND="$FROMSSH find"
  SOURCE_TEST="$FROMSSH test"
  TARGET_TEST="test"
  if [ -n "$HOSTNAME" ]; then
    NAME="$REMOTEHOST"
  fi
elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  TOSSH="ssh $SSH_USER@$SSH_TO"
  REMOTEHOST=$($TOSSH "echo \`hostname\`")
  SYNOSHARE_SOURCE=""
  SYNOSHARE_TARGET="$TOSSH"
  FIND="$TOSSH find"
  SOURCE_TEST="test"
  TARGET_TEST="$TOSSH test"
  if [ -n "$HOSTNAME" ]; then
    NAME="$LOKALHOST"
  fi
elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  SYNOSHARE=""
  SYNO_TARGET=""
  FIND="find"
  SOURCE_TEST="test"
  TARGET_TEST="test"
  if [ -n "$HOSTNAME" ]; then
    NAME="$LOKALHOST"
  fi
fi

# DSM-Benachrichtigung: Script wird ausgeführt...
#-------------------------------------------------------------------------
synodsmnotify @administrators "Script: $SCRIPTNAME" "Wird ausgeführt.."

# Speicherort des Logfiles festlegen
#-------------------------------------------------------------------------
if [ -z "$NOTTOSCRIPT" ] && [ -z "$SSH_TO" ] && [ -z "$TARGET" ]; then
  mkdir -p `dirname $0`$TARGET_EMPTY
  mkdir -p `dirname $0`$TARGET_EMPTY/@Logfiles
  LOG="`dirname $0`$TARGET_EMPTY/@Logfiles/"$DATE"_$SCRIPTNAME.log"
elif [ -z "$NOTTOSCRIPT" ] && [ -z "$SSH_TO" ] && [ -z "$SSH_FROM" ]; then
  mkdir -p `dirname $0`$TARGET
  mkdir -p `dirname $0`$TARGET/@Logfiles
  LOG="`dirname $0`$TARGET/@Logfiles/"$DATE"_$SCRIPTNAME.log" 
elif [ -n "$NOTTOSCRIPT" ] || [ -n "$SSH_TO" ] || [ -n "$SSH_FROM" ]; then
  mkdir -p `dirname $0`/@Logfiles
  LOG="`dirname $0`/@Logfiles/"$DATE"_$SCRIPTNAME.log"
fi
if [ -z "$TARGET" ] && [ -n "$NOTTOSCRIPT" ]; then
  STOP="Bitte TARGET setzen oder NOTTOSCRIPT nicht setzen..." >> $LOG
fi

if [ $SIGNAL -eq 1 ]; then
  echo 3 >/dev/ttyS1; echo : >/dev/ttyS1
  sleep 2
fi

# Ordner/Datei für das Protokoll anlegen und Kopfdaten generieren
#-------------------------------------------------------------------------
# E-Mail-Kopf aufbauen...
if [ -n "$EMAIL" ]; then
  echo "To: $EMAIL" > $LOG
  echo "From: $EMAIL" >> $LOG
  echo "Subject: Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
  echo "" >> $LOG
  echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
  echo "" >> $LOG; echo "$HR" >> $LOG
# Protokoll-Kopf aufbauen...
else
  echo "Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
  echo "" >> $LOG
  echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
  echo "" >> $LOG; echo "$HR" >> $LOG
fi

# Verbindungstest (SSH_FROM)
#-------------------------------------------------------------------------
if [ -n "$SSH_FROM" ]; then
  if ! $FROMSSH; then
    echo "FEHLER: Es konnte keine SSH-Verbindung zu $SSH_FROM aufgebaut werden." >> $LOG
  elif $FROMSSH; then
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
  fi
fi

# Verbindungstest (SSH_TO)
#-------------------------------------------------------------------------
if [ -n "$SSH_TO" ]; then
  if ! $TOSSH; then
    echo "FEHLER: Es konnte keine SSH-Verbindung zu $SSH_TO aufgebaut werden." >> $LOG
  elif $TOSSH; then
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
  fi
fi

# Zielordner checken
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
  if [ -n "$NOTTOSCRIPT" ] || [ -n "$SSH_TO" ]; then
    if $TARGET_TEST ! -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
      echo "Zielordner $TARGET_DECRYPT wurde lokalisiert..." >> $LOG
    elif $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT bereits eingehangen..." >> $LOG
    elif $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST ! -d /volume*/$TARGET_DECRYPT; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT nicht eingehangen..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Zielordner einbinden
      if test -f `dirname $0`/$TARGET_DECRYPT.key; then
        echo "$TARGET_DECRYPT.key gefunden" >> $LOG
        echo "Verschluesselter Zielordner $TARGET_DECRYPT wird eingehangen..."  >> $LOG
        KEYFILEDEST=$(ecryptfs-unwrap-passphrase `dirname $0`/$TARGET_DECRYPT.key "\$1\$5YN01o9y")
        $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_mount "$TARGET_DECRYPT" "$KEYFILEDEST" >> $LOG
        sleep 20
        if $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST ! -d /volume*/$TARGET_DECRYPT; then
          echo "Verschluesselter Zielordner $TARGET_DECRYPT konnte nicht eingehangen werden..."  >> $LOG
        fi
      else
        echo "Kein Keyfile fuer $TARGET_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden!"
      fi 
    fi
    if $TARGET_TEST ! -d /volume*/$TARGET_DECRYPT; then
      STOP="Zielordner $TARGET_DECRYPT nicht gefunden!"
    fi
  fi
fi

# Quellordner checken
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
  echo "" >> $LOG
  for SHARE in $SOURCES; do
    SOURCE="${SHARE#*/}"
    SHARE_DECRYPT="${SOURCE%%/*}"
    if $SOURCE_TEST ! -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
      echo "Quellordner $SHARE_DECRYPT wurde lokalisiert..." >> $LOG
    elif $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
      echo "Verschluesselter Quellordner $SHARE_DECRYPT bereits eingehangen..." >> $LOG
    elif $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST ! -d /volume*/$SHARE_DECRYPT; then
      echo "Verschluesselter Quellordner $SHARE_DECRYPT nicht eingehangen..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Quellordner einbinden
      if test -f `dirname $0`/$SHARE_DECRYPT.key; then
        echo "$SHARE_DECRYPT.key gefunden" >> $LOG
        echo "Verschluesselter Quellordner $SHARE_DECRYPT wird eingehangen..."  >> $LOG
        KEYFILESHARE=$(ecryptfs-unwrap-passphrase `dirname $0`/$SHARE_DECRYPT.key "\$1\$5YN01o9y")
        $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_mount "$SHARE_DECRYPT" "$KEYFILESHARE" >> $LOG
        sleep 20
        if $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST ! -d /volume*/$SHARE_DECRYPT; then
          echo "Verschluesselter Quellordner $SHARE_DECRYPT konnte nicht eingehangen werden..."  >> $LOG
        fi
      else
        STOP="Kein Keyfile fuer $SHARE_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden! Datensicherung ABGEBROCHEN..."
      fi
    fi
  done
fi
echo "" >> $LOG

# Ziel definieren
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
  if [ -n "$SSH_TO" ] && [ -n "$TARGET" ]; then
    VOLDEST=$($TOSSH "echo /volume*/$TARGET_DECRYPT")
    VOLTARGET="${VOLDEST%/*}"
    DESTINATION="$VOLTARGET$TARGET"
    if [ -n "$HOSTNAME" ]; then
		DESTINATION="$VOLTARGET$TARGET/$NAME"
  	else
	  	DESTINATION="$VOLTARGET$TARGET"
    fi
  elif [ -n "$SSH_TO" ] && [ -z "$TARGET" ]; then
    STOP="Bei SSH_TO muss TARGET angeben werden !" >> $LOG
  elif [ -z "$SSH_TO" ] && [ -z "$NOTTOSCRIPT" ] && [ -z "$TARGET" ]; then
    if [ -n "$HOSTNAME" ]; then
	    DESTINATION="`dirname $0`$TARGET_EMPTY/$NAME"
  	else
	    DESTINATION="`dirname $0`$TARGET_EMPTY"
    fi
  elif [ -z "$SSH_TO" ] && [ -n "$NOTTOSCRIPT" ] && [ -n "$TARGET" ]; then
    VOLDEST=$(echo /volume*/$TARGET_DECRYPT)
    VOLTARGET="${VOLDEST%/*}"
    if [ -n "$HOSTNAME" ]; then
		DESTINATION="$VOLTARGET$TARGET/$NAME"
  	else
	    DESTINATION="$VOLTARGET$TARGET"
    fi
    mkdir -p "$DESTINATION"
	
  elif [ -z "$SSH_TO" ] && [ -z "$NOTTOSCRIPT" ]; then
      if [ -n "$HOSTNAME" ]; then
	      DESTINATION="`dirname $0`$TARGET/$NAME"
    	else
		    DESTINATION="`dirname $0`$TARGET"
      fi
    mkdir -p "$DESTINATION"
  fi
  if [ -n "$SSH_TO" ] && [ -n "$NOTTOSCRIPT" ]; then
    if $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
    	$TOSSH mkdir -p "$DESTINATION"
    fi
  fi
fi

for SHARE in $SOURCES; do
  SOURCE="${SHARE#*/}"
  SHARE_DECRYPT="${SOURCE%%/*}"
  
	if $SOURCE_TEST ! -d /volume*/$SHARE_DECRYPT; then
	ERROR="1"
	echo "" >> $LOG
	echo "ACHTUNG: Quellordner $SHARE_DECRYPT nicht erreichbar..." >> $LOG
    echo "" >> $LOG; echo "" >> $LOG	
	elif $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
# SSH-SSH_FROM RSync-Datensicherung VON einer entfernten DS oder komp. Server
#--------------------------------------------------------------------------
		if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ] && [ -z "$STOP" ] && [ -n "$DESTINATION" ]; then
		echo "$HR" >> $LOG
    	echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
		echo "$HR" >> $LOG
    	rsync $SYNCOPT -e ssh $SSH_USER@$SSH_FROM:/volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
    	RSYNC_CODE="$?"
  		fi
# SSH-SSH_TO RSync-Datensicherung AUF eine entfernte DS oder komp. Server
#--------------------------------------------------------------------------
  		if [ -n "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -z "$STOP" ] && [ -n "$DESTINATION" ]; then
		echo "$HR" >> $LOG
    	echo "Starte Datensicherung: $LOKALHOST$SHARE nach $DESTINATION" >> $LOG
		echo "$HR" >> $LOG
    	rsync $SYNCOPT /volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE $SSH_USER@$SSH_TO:"$DESTINATION" >> $LOG
    	RSYNC_CODE="$?"
  		fi
# RSync- Lokale Datensicherung auf Volume, USB- oder SATA-Datenträger
#-------------------------------------------------------------------------
  		if [ -z "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -z "$STOP" ] && [ -n "$DESTINATION" ]; then
		echo "$HR" >> $LOG
    	echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
		echo "$HR" >> $LOG
    	rsync $SYNCOPT /volume*"$SHARE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
    	RSYNC_CODE="$?"
  		fi
# RSync Exit-Code = Fehlermeldung 
#-------------------------------------------------------------------------  
# Exit-Code: Entfernter Server ausgeschaltet?
  		if [ $RSYNC_CODE -eq 43 ]; then
    		echo "Entfernte DS oder RSync komp. Server nicht Online?" >> $LOG
# Exit-Code: DSL-Verbindung getrennt?
  		elif [ $RSYNC_CODE -eq 255 ]; then
    		echo "Bitte Internetverbindung kontrollieren!" >> $LOG
#Exit-Code ausgeben...
  		elif [ $RSYNC_CODE -ne 0 ]; then
    		echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
  		fi
  		echo "" >> $LOG; echo "$HR" >> $LOG
	fi
done

# RSync Exit-Code = Erfolgreich bzw. Unvollständig
#-------------------------------------------------------------------------
if [ $RSYNC_CODE -eq 0 ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
  echo "RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION" >> $LOG
  DSMNOTIFY="RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION"
# Signalausgabe - Datensicherung erfolgreich
  if [ $SIGNAL -eq 1 ]; then
    echo 3 >/dev/ttyS1; echo 8 >/dev/ttyS1
    sleep 2
  fi
# RSync Exit-Code = Fehlermeldung
elif [ $RSYNC_CODE -ne 0 ] || [ -n "$STOP" ] || [ -n "$ERROR" ]; then
  echo "RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Sicherungsziel: $DESTINATION" >> $LOG
  DSMNOTIFY="RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Bitte Protokoll prüfen!"
fi
  echo "$HR" >> $LOG; echo "" >> $LOG
if [ -n "$STOP" ]; then
  echo "$STOP" >> $LOG
fi

# DSM-Systemkonfiguration exportieren
#-------------------------------------------------------------------------
if [ -n "$DSM_EXPORT" ] && [ -z "$STOP" ] && [ $RSYNC_CODE -eq 0 ]; then
  if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
    $FROMSSH /usr/syno/bin/synoconfbkp export --filepath DSMConfig_TEMP.dss
      mkdir -p $DESTINATION/@DSMConfig
      scp -r $SSH_USER@$SSH_FROM:DSMConfig_TEMP.dss $DESTINATION/@DSMConfig/DSMConfig_"$DATE"_$REMOTEHOST.dss
    $FROMSSH rm -rf DSMConfig_TEMP.dss
    echo  "Sicherung der DSM-Systemkonfiguration von $REMOTEHOST erfolgreich zu $LOKALHOST kopiert.." >> $LOG
    echo "" >> $LOG
  elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
    synoconfbkp export --filepath `dirname $0`/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
    $TOSSH mkdir  -p $DESTINATION/@DSMConfig
    scp -r `dirname $0`/@DSMConfig/*.dss $SSH_USER@$SSH_TO:$DESTINATION/@DSMConfig/
    rm -rf `dirname $0`/@DSMConfig
    echo  "Sicherung der DSM-Systemkonfiguration von $LOKALHOST erfolgreich zu $REMOTEHOST kopiert.." >> $LOG
    echo "" >> $LOG
  elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
    mkdir -p $VOLTARGET/@DSMConfig
    synoconfbkp export --filepath $DESTINATION/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
    echo  "Lokale Sicherung der DSM-Systemkonfiguration erfolgreich." >> $LOG
    echo "" >> $LOG
  fi
fi

 # Rotationszyklus für das Löschen von @Recycle, @Logfiles und @DSMConfig
#-------------------------------------------------------------------------
# Dateien im Ordner @Recycle die älter als x Tage sind, löschen.
if $TARGET_TEST -d $DESTINATION/$NAME/@Recycle/; then
  if [ -n "$RECYCLE_ROTATE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
    $FIND $DESTINATION/@Recycle/* -type d -mtime +$RECYCLE_ROTATE -exec rm -rf {} \;
    echo  "HINWEIS: Daten aus dem Ordner /@Recycle, die mehr als $RECYCLE_ROTATE Tage alt waren, wurden geloescht." >> $LOG
    echo "" >> $LOG
  fi
fi
# Dateien im Ordner @RLogfiles die älter als x Tage sind, löschen.
if $TARGET_TEST -d $DESTINATION/@Logfiles/; then
  if [ -n "$LOGFILES_ROTATE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
    $FIND $DESTINATION/@Logfiles -name "*.log" -type f -mtime +$LOGFILES_ROTATE -exec rm {} \;
    echo  "HINWEIS: Daten aus dem Ordner /@Logfiles, die mehr als $LOGFILES_ROTATE Tage alt waren, wurden geloescht." >> $LOG
    echo "" >> $LOG
  fi
fi
# Dateien im Ordner @DSMConfig die älter als x Tage sind, löschen.
if  $TARGET_TEST -d $DESTINATION/@DSMConfig/; then
  if [ -n "$DSMCONFIG_ROTATE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
    $FIND $DESTINATION/@DSMConfig -name "*.dss" -type f -mtime +$DSMCONFIG_ROTATE -exec rm {} \;
    echo  "HINWEIS: Daten aus dem Ordner /@DSMConfig, die mehr als $DSMCONFIG_ROTATE Tage alt waren, wurden geloescht." >> $LOG
    echo "" >> $LOG
  fi
fi

# Verschlüsselte Shares wieder aushängen..
#-------------------------------------------------------------------------
if [ -n "$UNMOUNT" ]; then
  if $TARGET_TEST -d /volume*/@$TARGET_DECRYPT@ && $TARGET_TEST -d /volume*/$TARGET_DECRYPT; then
    echo "Ziel: $TARGET_DECRYPT wurde ausgehangen" >> $LOG
    $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_unmount $TARGET_DECRYPT >> $LOG
    sleep 10
  fi
fi

if [ -n "$UNMOUNT" ]; then
  for SHARE in $SOURCES; do
    SHARE_DECRYPT="${SHARE#*/}"
    if $SOURCE_TEST -d /volume*/@$SHARE_DECRYPT@ && $SOURCE_TEST -d /volume*/$SHARE_DECRYPT; then
      echo "Quelle: $SHARE_DECRYPT wurde ausgehangen" >> $LOG
      $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_unmount $SHARE_DECRYPT >> $LOG
      sleep 10
    fi
    unset KEYFILEPW
  done
fi

# Benachrichtigung an die DSM-Administratorengruppe sowie E-Mail senden
#-------------------------------------------------------------------------
synodsmnotify @administrators "Script: $SCRIPTNAME" "$DSMNOTIFY"

  if [ -n "$EMAIL" ]; then
    ssmtp $EMAIL < $LOG
  fi

if [ $RSYNC_CODE -eq 0 ] && [ -z "$STOP" ] && [ -z "$ERROR" ] && [ -n "$AUTORUN" ]; then
  exit 100
else
  exit $?
fi

Erstellen eines RSA-Keys für den Aufbau einer SSH-Verbindung

Es soll eine dateibasierte Datensicherung mittels RSync von Diskstation "A" (Produktivsystem) auf Diskstation "B" (Backupsystem) angelegt werden. Dabei übernimmt das Backupsystem die Aufgabe des Servers, worüber der Verbindungsaufbau und der eigentliche Sicherungsvorgang initiiert wird. Das Produktivsystem übernimmt somit die Aufgabe des Client und muß dem ganzen Vorgang nur zustimmen. Um dies zu ermöglichen muß im Vorfeld ein RSA-Schlüssel auf dem Backupsystem erzeugt und dem Produktivsystem der öffentliche Schlüssel mitgeteilt werden, um so den automatischen Verbindungsaufbau per SSH zu ermöglichen. Nachdem die SSH-Verbindung erfolgreich aufgebaut wurde, wird der eigentliche rsync-Befehl abgesetzt und somit die Datensicherung ausgelöst. Um auch in die Gegenrichtung sichern zu können, muss die RSA-Key Einrichtung dementsprechend gedreht werden, so das am Ende sowohl Diskstation "A" als auch Diskstation "B" Quelle als auch Ziel der Datensicherung darstellen können.

Im folgenden werden alle Einstellungen für den Benutzer root getroffen, da nur unter diesem Benutzer die Signalausgabe als auch das Sichern der DSM-Konfiguration funktioniert. Wer hier lieber als "admin" oder vielleicht sogar als eingeschränkter Benutzer "rsync" arbeiten möchte, muss nachfolgend an den entsprechenden Stellen den gewünschten Benutzernamen einsetzen. Das hier verwendete Homeverzeichnis des Benutzer "root" wird im folgenden nur in dessen Kurzform mit ~/ angesprochen, wobei hier immer auf /root verwiesen wird. Alle anderen Benutzerkonten befinden sich im Homeverzeichnis /home/[BENUTZERNAME] bzw. richtigerweise unter /var/services/homes/[BENUTZERNAME].

(Nachfolgend symbolisiert das Zeichen "$" nur den Zeilenanfang und wird nicht mit geschrieben)


Hinweis zum Loginvorgang bis DSM 5.2 für den Benutzer "root"

Login als Benutzer "root" mit dem Passwort des DSM-Benutzer "admin"

Hinweis zum Loginvorgang ab DSM 6 für den Benutzer "root"

Login als Benutzer "admin" mit dem Passwort des DSM-Benutzer "admin"
 
"root"-Zugriff erhält man dann über die Eingabe von...

  $ sudo -i
 
  ...und gibt abermals das Password des DSM-Benutzer "admin" ein.


Beginnen wir auf dem Server der "Diskstation B" oder besser gesagt, dem Backupsystem

Auf der Konsole der DS als Benutzer "root" einloggen. Erstellen des RSA-Schlüssels mit...

$ ssh-keygen -t rsa

Bei der Erstellung wird man nach Speicherort und Passphrase gefragt...

Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no oassphrase):
Enter same passphrase again:

... hier bitte nichts eintragen, sondern einfach nur mit der "Return-Taste" bestätigen. Nach der Ausführung werden im Homeverzeichnis des Benutzer "root" folgende Ordner und Dateien erstellt:

~/.ssh
~/.ssh/id_rsa
~/.ssh/id_rsa.pub

An dieser Stelle sollte man gleich noch die Ordner- und Dateirechte anpassen.

$ chmod 0700 ~/.ssh
$ chmod 0600 ~/.ssh/id_rsa*

Den Inhalt der Datei ~/.ssh/id_rsa.pub z.B. mit vi, nano oder dem AdminTool editieren und den Inhalt in die Zwischenablage kopieren.

$ nano ~/.ssh/id_rsa.pub

Wichtig, wie hier im Beispiel gezeigt (RSA-Schlüssel wurde hier gekürzt) ist, das alles in einer Zeile steht...

ssh-rsa AAAAB3NzaC1yc2..*gekürzt*...EAAAADAQABA3e root@Backupstation

Weiter gehts auf dem Client der "Diskstation A", also dem Produktivsystem.

Auf der Konsole der DS als Benutzer "root" einloggen. Erstellen eines neuen Ornders

$ mkdir ~/.ssh

Daraufhin wird unter ~/.ssh/ eine neue Datei namens "authorized_keys" erstellt...

$ nano ~/.ssh/authorized_keys

...und der Inhalt aus der Zwischenablage, also der Inhalt aus der ~/.ssh/id_rsa.pub, die auf dem Backupsystem erstellt wurde, in die geöffnete Datei eingefügt. Nach dem Speichern und verlassen des Editors müssen auch hier noch die Ordner- und Dateirechte richtig gesetzt werden.

$ chmod 0700 ~/.ssh
$ chmod 0600 ~/.ssh/authorized_keys

Zurück auf der Konsole der Backupstation.

Als Benutzer "root" auf der DS einloggen und als Erstes die SSH-Verbindung prüfen mit...

$ ssh root@IP-DER-DISKSTATION_A -p 22

Der Verbindungsaufbau möchte vom System nochmal mit "yes" bestätigt werden um anschließend auf der Konsole des Produktivsystemes zu landen. Diese Verbindung kann man durch die Eingabe eines...

$ exit

... wieder beenden. Durch den Verbindungsaufbau wurde nun in der Datei ~/.ssh/known_hosts ein neuer Eintrag hinzugefügt, der die Zugangsdaten zur Diskstation beinhaltet. Kontrollieren kann man das mit...

$ nano ~/.ssh/known_hosts

Nachdem alles gut verlaufen ist, wird die Konsole wieder geschlossen mit...

$ exit

Externe Links