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

Aus
Zeile 118: Zeile 118:
</pre>
</pre>


=Script 2: Das ausführungs-Script "start-rsync.sh"=
=Script 2: Das Ausführungs-Script "start-rsync.sh"=
Das 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 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.  



Version vom 24. April 2016, 12:48 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

 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

Das manuelle oder automatisierte Aufrufen von Such- oder Ausführungs-Script wird komfortabel über den DSM - Aufgabenplaner gesteuert. Das Such-Script hat dabei die Aufgabe, das Ausführungs-Script zu lokalisieren und starten. Es wird jedoch nur bei der Verwendung einer lokalen Datensicherung auf einem angeschlossenen USB-/SATA-Datenträger eingesetzt, da sich hier die Datenträgerbezeichnungen durchaus mal ändern können. Für alle andern Aufgaben wird das Such-Script nicht benötigt weshalb man das Ausführungs-Script auch direkt über den DSM-Aufgabenplaner ansprechen kann, um es manuell oder automatisiert auszuführen. Dabei befindet sich das Ausführungs-Script innerhalb eines "gemeinsamen Ordners" auf der DS, also z.B. dort, wo die interne oder externe Datensicherung später gespeichert werden soll.


Scriptausführung mittels "autorun"

Eine weitere Möglichkeit der Scriptausführung bietet die Verwendung von "autorun", welches angeschlossene USB-/SATA-Datenträger automatisch erkennt und ein darauf liegendes Script Namens "autorun" ausführt, sollte es im Wurzel- bzw. Hauptverzeichnis des externen Datenträgers lokalisiert werden. Dieses Verhalten machen wir uns zunutze, indem wir entweder den Inhalt unseres Ausführungs-Scriptes per Copy & Paste mit dem des "autorun" Scripts überschreiben, oder wir legen uns eine neue Datei namens "autorun" an bzw. benennen unser Script einfach nach "autorun" um und legen es auf dem externen Datenträger ab. Somit erhält man die Möglichkeit durch einfaches anstecken des USB-Sticks eine lokale, interne oder externe Datensicherung auszuführen. Ein weiterer Vorteil von "autorun" ist der Tatsache geschuldet, das sich evtl. benötigte Key-Files (also der Exportschlüssel) für das Einhängen verschlüsselter gemeinsamer Ordner am Speicherort des Ausführungs-Scripts befinden müssen. Wird der USB-Stick demnach nur für die Zeit der Datensicherung verwendet und ansonsten an einem sicheren Ort aufbewahrt, sind auch die Key-Files für diesen Zeitraum erstmal sicher.


Arbeitsweise des Ausführungs-Script (start-rsync.sh)

Das Ausführungs-Script führt neben einigen anderen Dingen die eigentliche Datensicherung aus, wobei mittels RSync sämtliche konfigurierte Quellen mit dem Ziel synchronisiert werden. Befindet sich unter den Quellen oder dem Ziel ein oder mehrere verschlüsselte gemeinsame Ordner, so können diese über das sogenanntes Key-File (der Exportschlüssel) automatisch ein- und nach dem Beenden der Datensicherung wieder automatisch ausgehangen werden. Dazu ist es jedoch erforderlich, das sich das Key-File am Speicherort des Ausführungs-Scripts befindet. Das Key-File selber wird einem beim erstellen eines verschlüsselten gemeinsamen Ordners im DSM unter Systemsteuerung/ Gemeinsame Ordner zum Download angeboten, man kann sich dieses aber auch nachträglich erstellen lassen. Weiterhin muss der Benutzer im Vorfeld noch einige Parameter innerhalb des Ausführungs-Scripts definieren, dessen Funktionen durch zusätzliche Kommentare näher beschrieben werden.

Neben dem eigentlichen Ausführungs-Script sowie den evtl. benötigten Key-Files wird auch das Systemprotokoll immer am Speicherort des Scripts in einem Ordner Namens /@Logfiles abgelegt. Erfolgt hierbei die eigentliche Datensicherung auch innerhalb dieses Speicherortes, so liegt /@Logfiles im Unterverzeichnis der Datensicherung, ansonsten befindet es sich im Hauptverzeichnis des Ausführungs-Scripts. Weiterhin werden gelöschte Daten einer Quelle, im Ziel bei Bedarf in den Ordner /@Recycle verschoben, welcher sich auch im Speicherort der Datensicherung befindet. Ebenso wird hier bei Bedarf ein weiterer Ordner mit dem Namen @/DSMConfig angelegt, worin die Sicherungen der DSM-Systemkonfiguration des Systems aufbewahrt werden, von dem auch die Quellen stammen. Die Inhalte der Ordner /@Logfiles, /@Recycle sowie /@DSMConfig können nach der Angabe einer Individuellen Zeitvorgabe (in Tagen) vom System automatisch gelöscht werden um einen Speicherüberlauf zu verhindern und um die Übersicht zu bewahren.

Bei der eigentlichen Datensicherung über RSync werden die Ordnerpfade relativ, nach dem jeweiligen Volume (1,2,3,4….) in das entsprechende Unterverzeichnis gespeichert. Systemorder wie z.B. /@eaDIR, /#recycle, /#snapshot und /.DS_Store werden von der Synchronisation ausgeschlossen. Alle ausgeführten Schritte sowie Fehlermeldungen als auch Abbrüche werden protokolliert und teilweise über sogenannte Exit-Codes als Zahlenwert ausgegeben. Diese Exit-Codes geben weitere Auskunft über mögliche Fehlerquellen. Im Anhang unten findet man ein entsprechender Link zur Auswertung. Das Protokoll wird im oben beschriebenen Ordner /@Logfiles abgelegt und kann bei Bedarf auch als E-Mail zugestellt werden.

Weitere Einstellmöglichkeiten werden innerhalb des Scripts beschrieben und hier nicht weiter ausgeführt.

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 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.

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