Zum Glück wird die HDD selbst noch vom System erkannt. Das mounting klappt aber nicht und wird mit folgender Meldung abgebrochen:

error mounting /dev/ssd at /media/ad/pidisk2: can't read superblock on /dev/ssd

Nach etwas Recherche habe ich herausgefunden das möglicherweise noch Hoffnung besteht. Möglichkeit das ich die Hoffnung nicht Aufgeben sollte und nur die "Superblöcke" (Metadaten zum System) einen Treffer haben aber nicht unbedingt die Daten selbst. Ich soll mal mein Glück mit dem Tool "fsck" versuchen, welches das Backup von Superblöcken wiederherstellen kann.

Dafür muss zuerst der Name der betroffenen HDD ermittelt werden. Mit folgendem Befehl erhält man eine Übersicht über alle Laufwerke:

sudo fdisk -l

Bei mir lautet der Name der Platte lautet so: /dev/sdc

Achtung: An dieser Stellte könnte es ratsam sein ein Backup der Platte anzustossen, z.B. mit dem Befehl dd.

Folgend der Befehl zum reparieren der Superblöcke:

sudo fsck /dev/sdc

Ich konnte es nicht fassen. Das Tool hat ruck-zuck seine Aufgabe erledigt und die Platte geht wieder wie geschmiert. Unglaublich!

Tipps & Tricks

Lokale Änderungen verwerfen

Folgende Befehle verwerfen alle Änderungen und stellen quasi den Server-Zustand her:

git reset --hard
git clean -df

Squash - (Lokale) Commits zusammenführen

Manchmal ist es praktisch Zwischenstände in kurzen Abständen zu committen, besonders um etwas auszuprobieren. Blöd nur wenn jedes "Mini"-Commit zum Server geschickt wird. In so einem Fall wünscht man sich eine Merge-Funktion der lokalen Commits um einen großen zu erhalten.

Achtung: Dieser Befehl darf nur für lokale Commits angewendet werden welche noch nicht zum Server gepusht wurden!

Folgt noch...

Das Backup beim Pi kann sich in ein oder zwei Schritte aufteilen. Zum einen muss immer die SD-Karte gesichert werden (Betriebssystem). Solltet Ihr auch ein USB-Speichergerät verwenden muss dieses ebenfalls gesichert werden.
Da ich es so handhabe das die SD-Karte ausschließlich Systemdateien enthält empfehle ich dieses als Image zu sichern. Für die USB-Platte reicht mir einfaches komprimieren.

Dieser Artikel ist Bestandteil der Artikelserie "Home Server mit dem Raspberry Pi". Zum Inhaltsverzeichnis gelangt ihr hier.

Backup von der SD-Karte erstellen

Steckt die SD-Karte vom Raspberry ab und in euren PC ein. Dort startet Ihr das Programm Win32DiskImager (sourceforge.net/projects/win32diskimager).

Wählt mit dem blauen Ordnericon den Pfad wo das Image gespeichert werden soll. Bei Device bitte den Laufwerksbuchstaben der SD-Karte selektieren. Mit Read wird das Backup erstellt.

Anschließen solltet ihr die .img Datei komprimieren z.b. mit 7zip. Es empfiehlt sich beim Dateinamen die Größe der SD-Karte festzuhalten solltet Ihr das Image mal auf einem Medium mit anderer Größe wiederherstellen müssen (ungefähr so: 2016-12-30_piSD_8GB).

Backup der SD-Karte wiederherstellen

Mit dem Programm SD Card Formatter muss die SD-Karte formatiert werden (www.sdcard.org/downloads/formatter_4/index.html).

1. Formatieren

Wählt den korrekten Laufwerksbuchstaben der SD-Karte (in dem Bild unten ist es F:) und öffnet die Optionen. Aktiviert nun Format Size Adjustment. Mit dem Button Format beginnt das Programm.

2. Image einspielen

Zuerst entpackt ihr das Image falls es komprimiert ist.
Danach startet ihr das Programm Win32DiskImager. Wählt dort mit dem blauen Ordnericon das Image aus. Rechts daneben bei Device bitte den Laufwerksbuchstaben der SD-Karte wählen. Anschließend wird mit Write das Backup wiederhergestellt.

Backup von der USB-Disk erstellen

Die externe Festplatte könnt Ihr auf diverse Arten sichern. Bei Bedarf kann man mit der obigen Anleitung auch ein Image erstellen. Ich habe mich allerdings dafür entschieden alle Daten der Disk lediglich zu komprimieren (gzip). Nun möchte ich zwei Lösungen dafür Vorschlagen.

Archivieren vom Pi aus

Stoppt alle Dienste welche während des Backups auf die Festplatte zugreifen könnten, wechselt zum User root und navigiert anschließend in das Verzeichnis von dem ein Backup erstellt werden soll:

# stop all programs which access the usb drive.
sudo su -
cd /media/pidisk1

Nun könnt ihr das Komprimieren der Festplatte anstoßen:

tar -zcvf pidisk1.tar.gz *

Sichert die Datei pidisk1.tar.gz und startet danach wieder alle Dienste.
Wenn benötigt könnt Ihr unter Windows das Archiv mit 7zip öffnen.

Optional: Archivieren von Windows aus

Achtung! Die obige Variante ist besser und sollte bevorzugt verwendet werden. Wenn Ihr derzeit keine Möglichkeit habt mit Linux zu arbeiten kann alternativ auch von Windows aus das Backup gestartet werden. Eventuell gehen (je nach verwendetem Tool) Meta-Daten verloren.

Steckt die Festplatte an euren Windows PC. Sollte diese als NTFS formatiert sein ist das Backup mehr als einfach da Ihr nun die Dateien/Ordner wählen könnt welche Ihr sichern möchtet. Kopiert die Dateien und komprimiert Sie mit z.B. 7zip.

Ist die Platte als ext4 formatiert wird es etwas aufwändiger. Windows kann, ohne Hilfe von Drittanbietern, kein Linux-Format lesen.

Mit dem Programm Ext2Read könnt Ihr Lesezugriff auf die Festplatte erhalten (sourceforge.net/projects/ext2read).
Mit diesem Programm könnt Ihr allerdings das Backup nicht wiederherstellen. Zum sichern reicht es allerdings aus.

Besser ist die Lösung Ext2File (sourceforge.net/projects/ext2fsd/) oder von Paragon (www.paragon-software.com/de/home/extfs-windows-pro/download.html).
Diese binden das Laufwerk ganz normal in den Windows Explorer ein. Der Zugriff erfolgt dann wie gewohnt (ich habe allerdings den Eindruck das zeit der Installation der Startvorgang vom WinExplorer träger wurde).

Backup der USB-Disk wiederherstellen

Achtet darauf das die Festplatte das gewünschte Format hat (ext4 oder NTFS). Die Festplatte muss außerdem gemountet sein. Lest hier wie das geht: blog.rollnut.com/mount-disk-festplatte-in-linux-einbinden/.

Nun benötigt Ihr das Backup (die Datei mit der Endung .tar.gz). Diese sollte sich in dem Ordner befinden welcher das Ziel der wiederherstellung ist. Dann stoßt man einfach das entpacken an:

sudo tar -zxvf pidisk1.tar.gz

Zu meiner Überraschung habe ich festgestellt das sogar Owner, Gruppe und Rechte von Dateien wiederhergestellt wurden. Aber Achtung: Einstellungen die mit ACL vorgenommen wurden (also mit dem Befehl setfacl) konnten nicht erstellt werden. Diese sollten nach dem dekomprimieren manuell wieder gesetzt werden.

Jetzt ist die Festplatte wiederhergestellt. Vor dem Betrieb empfiehlt es sich einen Neustart zu machen.

sudo shutdown -r now

Achtung: Das Wiederherstellen des Backups sollte nur von Linux aus erfolgen. In meinem Test habe ich die Daten über Windows (mit Paragon) auf die Festplatte gespielt. Das Ergebnis war das Metadaten von Dateien nicht korrekt waren (beim Owner von jeder Datei war Unknown hinterlegt).

Tipps & Tricks

Beim erstellen oder wiederherstellen vom Backup waren folgende Kommandos für meine Umgebung hilfreich:

ID's von Benutzern und Gruppen

Sollte es vorkommen sollte das eure SD-Karte kaputt geht und ihr nur noch ein sehr altes Backup wiederherstellen könnt kann es vorkommen das auf der Festplatte Benutzerrechte existieren für Benutzer die nicht im Betriebssystem hinterlegt sind. In dem Fall sollte es ausreichen wenn Ihr die Benutzer und Gruppen auf dem OS anlegt. Sehr wichtig ist aber das diese die korrekten ID's haben (UID und GID).

# Read User- and GroupID
id -u [username]
getent group [groupname]

# Change User- and GroupID
usermod -u [id] [username]
groupmod -g [id] [groupname]

Alle Services beenden

• Samba
• SeaFile
• mySQL

# !/bin/bash

# seafile
echo !Stopping Seafile

/home/seafile/seafile-server-latest/seahub.sh stop
/home/seafile/seafile-server-latest/seafile.sh stop

# Samba
echo !Stopping Samba

sudo service smbd stop

# mySQL
echo !Stopping mySQL

sudo service mysql stop

Starten

# !/bin/bash

# mySQL
echo !Starting mySQL

sudo service mysql start

# Samba
echo !Starting Samba

sudo service nmbd restart
sudo service smbd restart

# Seafile
echo !Startin Seafile

sudo su seafile /home/seafile/seafile-server-latest/seafile.sh start
sudo su seafile /home/seafile/seafile-server-latest/seahub.sh start

Dieser Artikel ist Bestandteil der Artikelserie "Home Server mit dem Raspberry Pi". Zum Inhaltsverzeichnis gelangt ihr hier.

Format der Festplatte

Bevor Ihr eine Festplatte über USB anbindet solltet Ihr euch entscheiden welches Dateiformat Ihr verwenden wollt. Zur Auswahl stehen NTFS und ext4 (es gibt noch weitere Formate aber für unseren Einsatzzweck sind nur diese beiden relevant).

Format - NTFS

NTFS (New Technology File System) ist ein Dateiformat welches von Microsoft entwickelt wurde. Wenn Ihr möglichst plattformunabhängig sein möchtet ist dieses Format zu empfehlen da Linux (über speziellen Treiber NTFS-3G) recht unkompliziert damit umgehen kann. Natürlich müsst ihr einige Nachteile in Kauf nehmen.

Nachteile (unter Linux):

• Deutlich langsamer als ext4
• Benutzerrechte gehen nicht
• Home-Ordner von Usern können hier nicht deklariert werden

Wenn NTFS unter Linux unterstützt werden soll führt folgendes Kommando aus:

sudo apt-get install ntfs-3g

Format - ext4

Das "fourth extended filesystem" ist ein Linux Dateiformat. Unter Windows kann man über Drittprogramme darauf zugreifen (teilweise umständlich).

Meine Empfehlung

Wenn die USB-Platte als Wechselmedium häufig zwischen verschiedenen OS verwendet wird, sollte NTFS verwendet werden.
Wenn allerdings die Platte primär für das Raspberry Verwendung findet, sollte man unbedingt ext4 wählen.

Hinweis: Auf eine ext4 Platte kann man ganz normal von Windows aus über das Netzwerk zugreifen wenn Samba auf dem Pi aktiv ist!
Siehe: blog.rollnut.com/file-server-einrichten/

Festplatte als ext4 formatieren

Steckt die Festplatte an das Raspberry an und gebt anschließend folgenden Befehl ein:

sudo blkid

Es werden nun alle Datenträger (inkl. Partitionen) dargestellt. Mein Ergebnis sieht folgend aus:

/dev/mmcblk0: PTUUID="e5efb5a4" PTTYPE="dos"
/dev/mmcblk0p1: SEC_TYPE="msdos" LABEL="boot" UUID="B176-EFEE" TYPE="vfat" PARTUUID="e5efb5a4-01"
/dev/mmcblk0p2: UUID="0aed834e-8c8f-412d-a276-a265dc676112" TYPE="ext4" PARTUUID="e5efb5a4-02"
/dev/sda1: LABEL="MyHardDrive" UUID="86A8AB18A8AB0631" TYPE="ntfs" PARTUUID="0598a1f7-01"

Sucht aus der Liste nun eure Festplatte (achtet auf den Wert von "LABEL". Dort steht der selbe Name wie in Windows). Wenn Ihr nicht wisst welcher Eintrag der Richtige ist dann steckt die Festplatte einfach ab und führt noch einmal den Befehl aus. Dadurch könnt Ihr sehen welche Platte dazugekommen ist wenn Ihr sie wieder ansteckt.

Wir benötigen lediglich das erste Stück des Eintrags. Also in meinem Falls /dev/sda1.

Mit diesem Befehl wird nun die Festplatte als ext4 formatiert (alle aktuellen Daten darauf gehen verloren!).

sudo mkfs.ext4 /dev/sda1 -L pidisk1

Das letzte Argument bestimmt das Alias der Festplatte (ich habe meine Platte pidisk1 genannt).

Mounten der USB-Festplatte

Meine Version von Raspbian erkennt externe Festplatten automatisch und bindet diese bereits automatisch ein. Die Platte hat den Pfad: /media/pi/pidisk1.

Das automatische Einbinden funktioniert eigentlich recht gut, allerdings können neu erstellte User nicht auf die Festplatte zugreifen (NTFS). Wenn dies sowieso nicht benötigt wird kann man das automatische mounting beibehalten. In meinem Fall wird es aber je Programm einen speziellen User geben und daher ist der Zugriff unbedingt nötig.

Pfad anlegen

Im Gegensatz zu Windows erfolgt der Zugriff auf externe Datenträger in Linux über einen regulären Ordner. Dieser muss erst einmal angelegt werden. Normalerweise erstellt man diesen in /media oder /mnt (ich werde den media-Ordner verwenden). Außerdem geben wir dem User pi Vollzugriff.

// Create mount directory (can be any name)
sudo mkdir /media/pidisk1

// Give user pi permission to disk
sudo chown -R pi:pi pidisk1

UUID auslesen

Zuerst muss die UUID von der USB-Platte herausgefunden werden. Dafür gibt es zwei Wege (geht natürlich nur wenn die Festplatte angeschlossen ist).

// Variante 1:
ls -l /dev/disk/by-uuid

// Variante 2:
sudo blkid

Bei Variante 1. Notiert euch die Zeichen der Zeile die mit sda1 endet (wenn am Pi mehrere Platten/Partitionen angeschlossen sind kann der Name abweichen).
Habt ihr Variante 2. gewählt erkennt Ihr den gesuchten Eintrag anhand des LABLEs. Dort steht der Name der Platte den Ihr auch unter Windows seht.

fstab konfigurieren und mounten

Nun müssen wir Linux erklären welches Medium in unser eben erstelltes Verzeichnis gemountet werden soll. Dies kann man mit der Datei fstab machen.

// Open fstab in order to configurate the mount
sudo nano /etc/fstab

Dort fügen wir am Ende folgende Zeile hinzu.

UUID=YourIndiviuelUUID /media/pidisk1 auto auto,nouser,exec,rw 0 0

Mehr Infos über die Konfigurationsparameter könnt Ihr hier erfahren: wiki.ubuntuusers.de/fstab/

Nach einem Neustart vom Pi dürfte die NTFS-Festplatte auch schon eingebunden sein. Alternativ reicht auch folgender Befehl.

sudo mount -a

Anmerkung: Das Linux-Rechtesystem, welches über chown und chmod gesteuert wird, funktioniert nicht mit NTFS-Festplatten. Man kann lediglich in der fstab-Datei für die komplette Disk einmalig Rechte hinterlegen (siehe gid und uid).

Weitere geht's ...

Die Artikelserie „Home Server mit dem Raspberry Pi“ geht jetzt mit dem Thema File-Server mit Samba weiter.

Dieser Artikel ist Bestandteil der Artikelserie "Home Server mit dem Raspberry Pi". Zum Inhaltsverzeichnis gelangt ihr hier.

SD Card Formatter

Das beste Ergebnis zum Formatieren von SD-Karten soll das offizielle Tool "SD Card Formatter" aufweisen (www.sdcard.org/downloads/formatter_4/index.html).

Es ist sehr leicht zu bedienen. Ihr müsst lediglich den Laufwerkbuchstaben der SD-Karte angeben (im Bild unten ist es F:). Gegebenfalls aktiviert Ihr noch in den Optionen Format Size Adjustment um wirklich allen Speicherplatz wieder zu erhalten (z.b. wenn die SD-Karte partitioniert ist). Mit dem Button Format beginnt das Programm.

Partitionen entfernen mit Diskpart

Wenn man das oben genannte Tool nicht benutzen möchte kann man auch mit Windows ganz normal Formatieren (im Explorer Rechtsklick auf den Datenträger, Formatieren und je nachdem FAT auswählen).

Sollte die SD-Karte allerdings partitioniert sein werden diese auch weiterhin bestehen. Dafür müsst ihr das Programm Diskpart verwenden welches als Administrator ausgeführt werden muss.

Führt folgenden Befehl aus um eine Auflistung aller Datenträger zu bekommen.

list disk

Sucht aus der Liste die SD-Karte heraus und merkt euch die Nummer links (solltet ihr nicht wissen welcher Eintrag der Richtige ist entfernt einfach die SD-Karte vom PC und wiederholt den Befehl. Schiebt die Karte wieder rein und erfragt noch einmal eine Auflistung. Nun solltet ihr sehen welche Disk zur SD-Karte gehört. Ich kann leider nicht sagen ob sich die Reihenfolge beim wieder einschieben ändert).

In meinem Fall war es Disk 1 welche zur SD-Karte gehört (Disk 0 sollte immer das System sein. Auf keinen Fall die 0 wählen!). Führt nun folgende Befehle aus.

select disk #eure Nummer#
list partition

Ihr habt nun die SD-Karte selektiert und euch alle Partitionen dazu anzeigen lassen (das Anzeigen ist optional zum vergewissern das auch die richtige Disk ausgewählt wurde). Zum Löschen aller bestehender Partitionen und neu Erstellen einer Haupt-Partition führt folgendes aus:

clean
create partition primary

Danach müsst ihr zwingend die SD-Karte neu als FAT formatieren.

Ich benötige diese Art der Dateiverwaltung für Dateien wie Dokumente oder Bilder. Es ist wichtig darauf Zugriff zu haben auch wenn man offline ist. Daher sollen diese auf jedem PC vorliegen. Um hohen Aufwand beim Synchronisieren zu verhindern wird eine Software benötigt die den Datenabgleich vollautomatisiert erledigt.

Dieser Artikel ist Bestandteil der Artikelserie "Home Server mit dem Raspberry Pi". Zum Inhaltsverzeichnis gelangt ihr hier.

Anforderung

Neben einem gewöhnlichen FileServer (ohne Synchronisation) benötige ich einen FileServer der seine Daten zentral verwaltet und dezentral zu Verfügung stellt. Damit meine ich das auf dem Server alle Daten zentral vorliegen. Die Clients sollen aber nicht wie bei einem zentralen Datei-Server über das Netzwerk auf diese zugreifen, sondern lokal (wie bei Dropbox).
Wenn auf dem eigenen PC eine Datei verändert, gelöscht oder hinzugefügt wird, soll dieser Zustand mit dem Server synchronisiert werden. Anschließend erhalten alle anderen PC's automatisch den aktuellen Stand vom Server mit den letzten Änderungen.

Für das Raspberry  gibt es drei populäre Dropbox-ähnliche Cloud-Dienste: OwnCloud, NextCloud und Seafile (NextCloud ist eine Weiterentwicklung von OwnCloud).

Achtung: Die nachfolgenden Aussagen zu OwnCloud/NextCloud habe ich ausschließlich durch Recherche in Erfahrung gebracht. Ich habe nie einen Praxistest von diesen durchgeführt.

OwnCloud ist die Eierlegende Wollmilchsau. Es kann alles, aber nichts davon so richtig gut. Es vereint mehrere Aufgaben in einem Programm wie Dateiverwaltung, CalDav und CardDav (und noch mehr). Mein einziger Anspruch ist allerdings die Dateiverwaltung, alle anderen Features sind nicht relevant. Ohne das ich es je getestet hatte (aber nach vielen Recherchen) soll diese Funktion von OwnCloud auf dem Raspberry sehr träge und nicht resourcenschonend sein. Mein Entschluss war, das OwnCloud keine Alternative für mein Pi darstellt.

Seafile

Seafile ist spezialisiert auf die Dateiverwaltung (wie Dropbox) und macht seine Aufgabe sehr gut, außerdem benötigt es nur wenig Resourcen auf dem Pi.

Achtung: Da ich Seafile nur im lokalen Netz betreiben werde, ohne Zugang von außen, verzichtet auch diese Anleitung auf den Sicherheits-SchnickSchnack.

SQL-Server einrichten (MySQL)

Seafile benötigt als Datenbank SQLite oder MySQL.
Die Entwickler empfehlen deutlich MySQL zu verwenden, da SQLite Nachteile gegenüber MySQL hat (z.B. kann Seafile unter MySQL während des Betriebs, ohne Pausierung, ein Upgrade erhalten, auch die Performance ist hier besser). Das Einrichten ist bei SQLite allerdings einfacher da kein SQL-Server benötigt wird.

Leider wird PostgreSQL offiziell nicht/teilweise unterstützt (was meine bevorzugte Technik gewesen währe).

Damit Seafile mit MySQL betriebsfähig ist, muss ein MySQL-Server vor der Einrichtung von Seafile erstellt werden.

MySQL installieren

Installiert MySQL mit unten stehendem Befehl. Beim Installieren werdet ihr nach einem Passwort für den Root-User für MySQL gefragt.

sudo apt-get install mysql-server

Wenn obiger Befehl fehlschlägt könnt ihr noch folgendes ausprobieren:

sudo apt-get install mysql-server --fix-missing --fix-broken

Danach kann man überprüfen ob der SQL-Server erfolgreich installiert wurde und bereits in Betrieb ist.

mysqladmin -u root -p status

Optional (wenn benötigt) kann ein MySQL-Client für das Terminal installiert werden (wird nicht von Seafile gebraucht). Ich habe dies nicht getan.

sudo apt-get install mysql-client

MySQL Daten auf USB-Platte auslagern

Der MySQL-Server sollte sich nun auf die SD-Karte installiert haben. Zukünftige Datenbanken werden automatisch auch auf die SD-Karte gepackt. Ich bevorzuge es allerdings das Bewegungsdaten auf die USB-Platte kommen, da ich von dieser häufiger ein Backup durchführen werde (zudem steht dort mehr Speicherplatz zur Verfügung).

In folgenden Schritten wird MySQL mitgeteilt wohin Daten zukünftig gespeichert werden.

1. Zuerst muss der SQL-Server angehalten werden:

sudo service mysql stop

2. Erstellt auf der USB-Platte ein Verzeichnis in welchem in Zukunft die SQL-Daten liegen werden:

#Create new directory
cd /media/pidisk1
sudo mkdir mysql

#Set directory permission
sudo chown -R mysql:mysql /media/pidisk1/mysql

3. Nun müsst ihr die bestehenden Daten von mySQL in den neuen Ordner kopieren. Dafür sind Root-Rechte nötig. Außerdem müssen alle Dateien dem mysql-User zugewiesen sein:

sudo su -
cp -Rv /var/lib/mysql/* /media/pidisk1/mysql/
sudo chown -R mysql:mysql /media/pidisk1/mysql

Optional könnt ihr den alten Ordner umbenennen damit dieser nicht aus Versehen verwendet wird:

mv /var/lib/mysql /var/lib/mysql.backup

4. Ändert nun die Konfiguration von mySQL damit dieser auch weiß in welchen Ordner zukünftig gespeichert werden soll:

sudo nano /etc/mysql/my.cnf

Dort bitte den Eintrag suchen welcher mit datadir beginnt und folgend abändern:

#Before
datadir                = /var/lib/mysql

#After
datadir                = /media/pidisk1/mysql

5. Verlasst den root-Modus und startet den SQL-Server wieder:

exit
sudo service mysql start

MySQL-User für Seafile anlegen

Seafile bietet ein Setup, welches einen SQL-User und passende Tabellen anlegt. Ihr könnt diesem Setup allerdings auch mitteilen das Seafile bestehende Tabellen verwenden soll (dies wird z.B. benötigt wenn ein Backup eingespielt wird oder wenn mySQL ein zweites Seafile beherbergen soll).

Wenn Ihr keine bestehende Datenbank verwenden möchtet (sondern Seafile alles erledigen soll) könnt Ihr direkt zu Seafile installieren weitergehen und den mySQL-Part überspringen (klick dafür hier).

Wenn Ihr einen neuen User extra für Seafile in SQL anlegt, könnt Ihr genau definieren was Seafile darf. Seafile wird drei Tabellen benötigen und auf diese erhält es dann auch Vollzugriff. Alles Andere wird dem Tool verboten.

Dazu müssen wir uns erstmal als Root bei MySQL anmelden (mit dem Passwort welches bei der Installation von MySQL festgelegt wurde):

mysql -u root -p

Anschließen können wir auch schon den neuen User erzeugen (bitte das letzte Argument 'Password' mit dem echten austauschen):

CREATE USER 'seafile'@'localhost' IDENTIFIED BY 'Password';

Um zu prüfen welche User bereits hinterlegt sind reicht folgender Befehl.

SELECT User,Host FROM mysql.user;

Tabellen anlegen und Rechte zuweisen

Nun hat der User allerdings noch keine Rechte. Ich möchte dem User seafile auch gar keine Rechte außer Vollzugriff auf die Tabellen die Seafile benötigt geben. Um das zu realisieren müssen wir manuell die Tabellen für Seafile erstellen.

Erstellen der von Seafile benötigten Tabellen:

create database `ccnet-db` character set = 'utf8';
create database `seafile-db` character set = 'utf8';
create database `seahub-db` character set = 'utf8';

Dem User seafile Vollzugriff auf genau diese Tabellen geben:

GRANT ALL PRIVILEGES ON `ccnet-db`.* to `seafile`@localhost;
GRANT ALL PRIVILEGES ON `seafile-db`.* to `seafile`@localhost;
GRANT ALL PRIVILEGES ON `seahub-db`.* to `seafile`@localhost;

FLUSH PRIVILEGES;

Übrigens kann man dies auf der offiziellen Doku nachlesen: manual.seafile.com/deploy/using_mysql.html.

Um zu sehen welche Rechte ein bestehender SQL-User hat, kann man folgendes Kommando feuern:

SHOW GRANTS FOR 'seafile'@'localhost';

Seafile installieren und einrichten

Pakete installieren

Folgende Kommandos installieren alle nötigen Pakete die SeaFile benötigt.

sudo apt-get install python2.7 python-setuptools python-simplejson python-imaging python-mysqldb

User anlegen

Unter Linux ist es üblich je Programm einen separaten Linux-User anzulegen. Das Programm wird dann von diesem Benutzer ausgeführt (dadurch ist eine feinere Rechtesteuerung möglich). Zudem kann man die Programmdaten in dessen User's Home-Verzeichniss legen (womit es gut aufgeräumt ist).

sudo adduser seafile --disabled-login

Der eben erzeugte User kann sich nicht unter Linux anmelden, da dies mit --disabled-login deaktiviert wurde (beim Anmeldeversuch erscheint zwar die Passwortaufforderung aber es gibt kein gültiges Passwort). Da unter diesem User nur das Programm ausgeführt werden soll ist ein normaler Login unnötig und würde nur eine Sicherheitslücke darstellen.

Der Admin kann allerdings mit einem Trick zum Seafile-User wechseln. Dazu gibt er folgenden Befehl ein:

sudo su seafile

So kann man unter Linux gut steuern unter welchen Rechten ein Programm laufen darf.

SeaFile downloaden

Wechselt zuerst in das Home-Verzeichnis des seafile Users.

cd ~

Geht auf die offiziele Seite von SeaFile seafile.com/en/download und sucht euch den Link zum letzten Release. Ich hatte die Version 6.0.7.

// Download
wget https://github.com/haiwen/seafile-rpi/releases/download/v6.0.7/seafile-server_6.0.7_stable_pi.tar.gz
// Entpacken
tar -xvf seafile-server_6.0.7_stable_pi.tar.gz
// (optional) Löschen des Packets
rm seafile-server_6.0.7_stable_pi.tar.gz

Seafile installieren

Seafile bringt ein paar Setups mit die beim Installieren helfen. Mit ./setup-seafile.sh könnte man das Setup ausführen allerdings wird dort nur SqlLite untersützt. Wenn man MySQL verwenden möchte muss man ./setup-seafile-mysql.sh aufrufen.

Vor dem Setup muss die IP-Adresse notiert werden (mit ifconfig). Zudem muss überlegt werden wo die Daten von SeaFile später gespeichert werden sollen. Bei mir wird alles auf der externen Festplatte verewigt. Daher muss dort erstmal ein Verzeichnis angelegt werden.
Wenn ihr außerhalb des Home-Verzeichniss Seafile-daten anlegen möchtet muss der Kontext von Benutzer seafile mit dem Befehl exit verlassen werden.

exit
sudo mkdir /media/pidisk1/seafile
sudo mkdir /media/pidisk1/seafile/data
sudo chown -R seafile:seafile /media/pidisk1/seafile

Über einen Symlink im Home-Verzeichnis soll Seafile darauf verwiesen werden. Den Symlink legt man folgenderweiße an. Zuvor solltet ihr aber wieder zum User seafile und dessen Home-Verzeichnis wechseln.

sudo su seafile
cd ~
ln -s /media/pidisk1/seafile/data seafile-data

Der letzte Parameter (seafile-data) gibt den Symlink-Ordnernamen an.

Nun könnt ihr das Setup starten. Der einzige Punkt bei dem man aufpassen muss ist der ob eine Datenbank erstellt werden soll oder eine bestehende verwendet wird.
Ich hatte dem Script das Erstellen der Datenbank überlassen.

Meine Konfiguration des Assistenten sah folgend aus:

server name: seafile
server ip/domain: 192.168.***.***

seafile data dir: /home/seafile/seafile-data/data
fileserver port: 8082

database: create new
ccnet database: ccnet-db
seafile database: seafile-db
seahub database: seahub-db
database user: seafile

Das Script befindet sich in dem entpackten Verzeichnis (dessen Name ändert sich je Release). Also wechseln wir dort hin (mit ls -l könnt ihr prüfen wie euer Verzeichnis heißt):

cd seafile-server-6.0.7

Danach bitte euer Setup der Wahl aufrufen (ich habe das für mysql verwendet):

# Setup for sqlite
./setup-seafile.sh

# Setup for mysql
./setup-seafile-mysql.sh

Bitte entnehmt der obigen Tabelle die Konfiguration des Setups.

Nach dem Setup prüfen wir ob Seafile korrekt installiert wurde und starten sowohl Seafile als auch Seahub:

./seafile.sh start
./seahub.sh start-fastcgi

Das Raspberry sollte nun zeigen das beide Dienste erfolgreich gestartet wurden. Allerdings wird man beim starten von seahub.sh zusätzlich gebeten einen Seahub-Admin einzurichten.

Wenn Ihr Seafile beenden möchtet reichen folgende zwei Befehle:

./seafile.sh stop
./seahub.sh stop

Achtet darauf das Seafile immer vom User seafile gestartet wird und nicht vom pi-User. Ist man mit dem pi-User angemeldet kann man dies mit folgenden Kommandos realisieren:

sudo su seafile /home/seafile/seafile-server-latest/seafile.sh start
sudo su seafile /home/seafile/seafile-server-latest/seahub.sh start-fastcgi

Achtung: Bei  mir (das Raspberry B der ersten Generation) kann man nicht direkt mit Seafile arbeiten. Anscheinend dauert es nach dem Starten noch eine Zeit bis es funktionstüchtig ist.

Seafile verwenden

Nachdem Seafile nun erfolgreich installiert wurde kann vom Client aus über einen Browser mit der Adresse "http://Ip-Address:8000" zugegriffen werden.

Habt Ihr Probleme beim Zugriff auf Seafile dann versucht mal euer Pi neu zu starten und/oder das ./seahub.sh ohne fastcgi zu starten (./seahub sh start).
Ansonsten habt etwas Geduld und versucht mehrfach einen Page-Refresh.

Web-Server einrichten (Nginx)

Möchte man über das Internet via https auf Seafile zugreifen muss man einen Web-Server wie Nginx installieren (Nginx soll auf dem Pi eine bessere Performance liefern wie Apache). Da ich nur den Anspruch habe im lokalen Netzwerk damit zu arbeiten wird dieser bei mir nicht eingerichtet.

Bitte betreibt Seafile niemals ohne https über das Internet!

Hier die Anleitung des Herstellers: manual.seafile.com/deploy/deploy_with_nginx.html

Seafile beim boot starten

Soll Seafile automatisch beim Start des Raspberries verfügbar sein, hilft euch die Anleitung des Herstellers:

https://manual.seafile.com/deploy/start_seafile_at_system_bootup.html

 Weitere geht's ...

Die Artikelserie „Home Server mit dem Raspberry Pi“ geht jetzt mit dem Thema SourceControl mit git weiter.

Ich benötige einen File-Server um Dateien zentral zu speichern die ich nicht oft benötige und die sich in der Regel nie ändern (z.b. Installer von Programmen oder fertige Versionen von Produkten). Hier verzichte ich bewusst auf eine Synchronisationsfunktion um Ressourcen zu schonen.

Dieser Artikel ist Bestandteil der Artikelserie "Home Server mit dem Raspberry Pi". Zum Inhaltsverzeichnis gelangt ihr hier.

Anforderung

Der zukünftige File-Server soll bequem von meinem Windows PC, aus dem Explorer, erreichbar sein und als virtuelles Netzlaufwerk eingebunden werden.

Es wird mehrere Netzlaufwerke geben die sich physikalisch alle auf der USB Platte befinden. Drei Netzlaufwerke sollen es werden. Je ein Netzlaufwerk für private Dinge und für geschäftliches (Ordnung ist das halbe Leben).
Das dritte Laufwerk ist für den Admin welcher Zugriff auf das Root-Verzeichnis des Laufwerks erhalten soll und damit indirekt Zugriff auf oben genannte hat (zusätzlich auch auf Programmdateien die neben dem FileServer auf der USB-Platte gespeichert werden).

Auf das Root-Laufwerk soll nur der Admin Zugriff haben. Die anderen beiden Laufwerke sollen auch mit unterschiedlichen Passwörtern geschützt werden.

Vorbereitung

Bevor wir mit Samba loslegen benötigen wir eine formatierte USB-Festplatte (Anleitung zur Formatierung). Auf dieser können wir bereits die fertige Ordnerstruktur erstellen (dies erleichtert eventuelle Fehlersuche).

Mein FileServer wird zwischen privaten (family) und geschäftlichen (rollnut) getrennt. Die Daten liegen zwar alle auf demselben Datenträger aber mit der passenden Rechtesteuerung lässt sich eine Trennung dennoch realisieren. Empfehlenswert ist es im Root-Verzeichnis der Festplatte den Ordner fileserver anzulegen (falls die Festplatte weitere Aufgaben erledigt). Folgend habe ich meinen Verzeichnisbaum aufgebaut:

fileserver
➥family (Lesen+Schreiben nur für Gruppe family)
...➥images
...➥music
➥rollnut (Lesen+Schreiben nur für Gruppe rollnut)
...➥releases (Schreibrechte nur für Benutzer/Gruppe admin)
...➥software

Es empfiehlt sich in jedem Unterverzeichnis eine neue Textdatei mit beliebigem Inhalt anzulegen. Damit könnt Ihr später Lese- und Schreibrechte testen.

Spätestens jetzt muss die Platte an eurem Pi angesteckt sein. Wie man eine Festplatte über Mounting einbindet hatte ich bereits erklärt: Mounting

Optional: Benutzerrechte

Wenn Ihr kein NTFS sondern ext4 als Format gewählt habt könnt Ihr geschickt mit Linux-Benutzerrechten die Zugriffe auf euren FileServer steuern (Linux-Benutzerrechte werden von NFTS nicht untersützt, daher können Anwender von NTFS direkt zum Absatz Samba springen). Folgend eine Anleitung wie ich meine Ordner konfiguriert habe:

Wechselt in das Verzeichnis fileserver:

cd /media/pidisk1/fileserver

Meine Ordner family und rollnut dürfen nur verwendet werden wenn man der passenden Benutzergruppe angehört. Mit folgenden Befehlen könnt Ihr die Ordner anlegen und passende Rechte vergeben (ersetzt [dir] mit dem passenden Verzeichnisnamen und [group] mit der passenden Benutzergruppe, bitte auch die eckigen Klammern entfernen):

sudo mkdir [dir]
sudo chown :[group] [dir]
sudo chmod 771 [dir]
sudo chmod g+s [dir]
sudo setfacl -Rdm g:[group]:rwx [dir]

Ich erkläre nun kurz was oben geschieht.

• Zuerst wird das neue Verzeichnis erstellt
• Anschließend wird die Gruppe des Verzeichnis geändert (der Owner ist egal)
• Danach werden die Rechte gesetzt. Ich habe mich dafür entschieden das der Owner und jeder Benutzer der Gruppe Vollzugriff hat.
• Mit g+s wird jede neu erstellte Datei unterhalb dieses Ordners die Gruppe von [group] erhalten. Damit möchte ich gewährleisten das alle Dateien jedem Gruppenmitglied zur Verfügung stehen.
• Die Aufgabe des letzten Commands ist ähnlich zu dem vorherigen, nur das diesmal die Dateirechte vererbt werden.

Der Ordner "rollnut->releases" ist nun ein Spezialfall. Ich möchte das jeder Benutzer der Gruppe rollnut den Inhalt lesen darf. Aber nur ich soll Schreibrechte erhalten. Dies habe ich folgend gelöst:

cd rollnut
sudo mkdir releases
sudo chown [username] releases
sudo chmod 751 releases
sudo setfacl -Rdm g:rollnut:rx releases

Zuerst ändere ich den Owner von dem Ordner releases. Anschließend entziehe ich der Guppe rollnut die Schreibrechte (der Befehl unterscheidet sich nur darin das das w bei rwx fehlt).

Übrigens, wenn Ihr die Konfiguration von ACL sehen möchtet könnt Ihr dies mit diesem Kommando machen:

getfacl [dir]

Samba

Mit dem Programm Samba werden alle Anforderungen an den File-Server erfüllt. Samba bringt meinem Raspberry das SMB-Protokoll bei, womit es mit Windows im Netzwerk kompatibel wird.

Samba installieren

Mit folgendem Befehl wird es installiert:

sudo apt-get install samba samba-common-bin

Wenn Ihr Samba anschließend neu startet wird das Raspberry sogar schon im Windows Explorer gefunden (in der Netzwerk-Kategorie). Allerdings ohne Ordnerfreigaben.

sudo /etc/init.d/samba restart

oder 

sudo service nmbd restart
sudo service smbd restart

Samba ist bereits vorkonfiguriert (unter /etc/samba/smb.conf). In der Config stehen sehr viele Zeilen und auch Kommentare als Hinweis was alles möglich ist. Im Praxis-Einsatz empfinde ich diese Datei allerdings als sehr unübersichtlich. Deswegen erstelle ich davon eine Sicherheitskopie und erzeuge eine Neue die noch leer ist und anschließend von mir beschrieben wird (die Kopie dient lediglich als Nachschlagewerk).

// Rename the existing file.
sudo mv /etc/samba/smb.conf /etc/samba/smb.conf.bak

// Create a new empty samba config file.
sudo touch /etc/samba/smb.conf

Samba einrichten - ext4

Samba kann wunderbar mit ext4 formatierten Datenträgern umgehen. Um Samba zu konfigurieren muss die smb.conf Datei mit einem Text-Editor geöffnet werden. Ich verwende dafür Nano:

sudo nano /etc/samba/smb.conf

Nun wird folgender Text eingefügt:

[global]
security = user
encrypt passwords = yes

[Root]
comment = root of external pidisk1 drive
path = /media/pidisk1
read only = no
valid users = [adminuser]
force user = root
force group = root

[Family]
comment = files to share with family
path = /media/pidisk1/fileserver/family
read only = no

[RollNut]
comment = contains business related files
path = /media/pidisk1/fileserver/rollnut
read only = no

Bitte ersetzt [adminuser] mit einem Benutzer welcher, mit Root-Rechten, Zugriff auf die komplette Festplatte erhalten soll. Folgend eine Erklärung der einzelnen Punkte:

[global]: Allgemeine Konfiguration von Samba
security: Setzt die Art der Anmeldung fest
encrypt passwords: Verschlüsselt euer Passwort. Es macht immer Sinn yes zu verwenden außer ihr habt noch Windows 95 im Einsatz.

[Root], [Family], [RollNut]: Der Name unter welcher eure Netzwerkfreigabe später zu finden ist.
comment: Eine Beschreibung der betroffenen Freigabe (kann in Windows als Tooltip gelesen werden).
path: Der physikalische Pfad zum Ordner welcher Freigegeben wird.
read only: Nur Leserechte oder auch Schreib-/Löschrechte.
valid users: Nur bestimmte User dürfen sich an diesem Laufwerk anmelden.
force user/force group: Das Laufwerk Root gibt Zugriff auf die komplette Festplatte. Da neben dem FileServer auch mySQL und anderen Programmdaten liegen werden (welche spezielle Benutzerrechte haben) wird Samba als Benutzer root auf diese zugreifen (die Logindaten werden ignoriert). Wenn eine Datei angelegt wird, wird dessen Owner root sein.

Im Anschluss kann die Datei smb.conf mit folgenden Befehl auf Validität geprüft werden.

testparm

Samba Benutzer anlegen

Nun müsst Ihr noch einen Linux-Benutzer mit einem Samba-Passwort ausstatten. Ohne diesem Schritt kann Samba nicht verwendet werden da es keinen Standardbenutzer für Samba gibt. Wenn ein Windows-Teilnehmer sich mit diesem Benutzer über Samba anmeldet wird Samba mit dessen Rechten auf Dateien zugreifen (das Root-Laufwerk ist hier eine Ausnahme).
Hinweis: Hat euer Linux-User bereits ein Passwort, kann es empfehlenswert sein dasselbe Passwort auch in Samba wieder zu verwenden.

sudo smbpasswd -a [username]

Das -a bedeutet das der User in Samba nach dem anlegen direkt aktiviert wird.

Alternativ: Samba einrichten - NTFS

Wie schon mehrfach angesprochen funktionieren Linux-Benutzerrechte auf NTFS-Geräten nicht. Um einen vergleichbaren Effekt zu haben kann man dennoch folgende Lösung anwenden:

Öffnet die Samba-Config.

sudo nano /etc/samba/smb.conf

Als Inhalt fügt folgenden Text ein:

[global]
security = user
encrypt passwords = yes

[Root]
comment = root of external pidisk1 drive
path = /media/pidisk1
read only = no
valid users = smb-pi

[Private]
comment = files to share with family
path = /media/pidisk1/fileserver/private
read only = no
valid users = smb-pi,smb-private

[RollNut]
comment = contains business related files
path = /media/pidisk1/fileserver/rollnut
read only = no
valid users = smb-pi,smb-rollnut

Der Unterschied zu der Konfig von ext4 ist das valid users bei jedem Laufwerk verwendet wird.

Samba Benutzer anlegen

Zugriffsrechte auf Samba-Laufwerke erfolgen mittels speziellen Samba-Usern. Samba-User können mit smbpasswd angelegt werden, allerdings nur wenn bereits ein Linux-User mit demselben Namen besteht (Samba-User werden nicht automatisch erstellt!).

In meinem Fall möchte ich allerdings eher Samba-Gruppen anstatt User. Daher muss ich 'dummy'-User in Linux anlegen damit ich diese in Samba verwenden kann.

sudo  adduser --no-create-home --disabled-login --shell /bin/false <username>

Das obere Kommando erstellt einen Linux-User der sich nicht einloggen kann, kein Home-Verzeichnis besitzt und sonst nix darf (außer eben als Samba-User zu fungieren).

Da ich drei Samba-User benötige erzeuge ich diese nun, smb-pi, smb-family und smb-rollnut. Anlegen kann man diese ganz einfach mit folgenden Kommando:

sudo smbpasswd -a smb-rollnut

Das -a bedeutet das der User in Samba nach dem anlegen direkt aktiviert wird.

Tipps & Tricks

Netzwerk-Cache löschen (Windows)

Wenn im Windows Client bereits erfolgreich eine SMB-Verbindung zum Raspberry aufgebaut wurde, sich das Passwort aber später ändert, hat Windows ein Problem (zumindest bei mir). Windows speichert Netzwerkpasswörter (anscheinend auch wenn der Hacken nicht aktiv war) und macht eine erneute Verbindung mit einem anderen Passwort unmöglich.

Bei mir hat es funktioniert in der Windows-Kommandozeile folgenden Befehl zu feuern (der Stern bedeutet das alle gespeicherten Verbindungen gelöscht werden):

net use * /DELETE

Mit folgendem Tool kann man bestehende Netz-Passwörter auslesen sollte mal eines verlegt worden sein nirsoft.net/utils/network_password_recovery.html.

Remote Differential Compression (RDC)

Bei meiner Recherche hatte ich ab und zu den Hinweis gelesen das RDC (ab Windows 7 enthalten) zu Problemen mit Samba führen kann, was sich dadurch äußert das ein einfacher Kopiervorgang ungewöhnlich lange dauert.

Sollte dies der Fall sein kann testweise der Hacken bei RDC deaktiviert werden:
"Programme -> Windows Features aktivieren/deaktivieren -> Remote Differential Compression API Support"

Weiter geht's ...

Die Artikelserie „Home Server mit dem Raspberry Pi“ geht jetzt mit dem Thema File-Server mit Seafile weiter.

Dieser Artikel ist Bestandteil der Artikelserie "Home Server mit dem Raspberry Pi". Zum Inhaltsverzeichnis gelangt ihr hier.

SD-Karte Vorbereiten

Das OS für das Raspberry Pi wird auf der SD-Karte installiert. Bevor Ihr mit dem Installieren beginnt muss die SD-Karte erstmal formatiert werden. Beim Formatieren von SD-Karten wird empfohlen den SD Card Formatter von der offiziellen Website zu benutzen (www.sdcard.org/downloads/formatter_4/index.html).

Wählt den korrekten Laufwerksbuchstaben der SD-Karte (in dem Bild unten ist es F:) und öffnet die Optionen. Aktiviert nun Format Size Adjustment. Mit dem Button Format beginnt das Programm.

Wer das Tool nicht installieren möchte kann auch alternativ mit Windows-Bordmitteln arbeiten: blog.rollnut.com/sd-karte-formatieren#Diskpart.

Raspbian installieren

Raspbian kann entweder direkt oder über Noobs installiert werden. Seid Ihr Neulinge und möchted ggf. weitere Betriebssysteme parallel testen dann installiert bitte Noobs. Richtet Ihr ein System für eine produktive Umgebung ein sollte Raspbian direkt als Lite Version installiert werden (die Lite Version enthält weniger vorinstallierte Software wie z.b. LibreOffice).

Raspbian über Noobs installieren

Noobs erhält man unter www.raspberrypi.org/downloads/noobs/. Entpackt die Zip und kopiert den Inhalt auf die SD-Karte. Anschließend muss die SD-Karte ins Raspberry und es kann endlich losgehen mit der Action (naja, fast).

Das Pi wird nach dem Starten einen Dialog zeigen mit verschiedenen Betriebssystemen die zur Installation bereit stehen. Macht den Hacken bei Raspian und startet die Installation. Nach langem warten ist es irgendwann installiert.

Raspbian Lite direkt installieren

Raspbian Lite kann man auf der offizielen Website erhalten www.raspberrypi.org/downloads/raspbian. Entpackt die Zip.

Installiert das Programm Win32DiskImager um das OS Ordnungsgemäß auf die Karte zu bringen. Hier könnt Ihr es runterladen sourceforge.net/projects/win32diskimager.

Startet das Programm, wählt die entpackte Datei und die SD-Karte aus. Mit Write startet ihr den Prozess.

Raspberry einrichten

Nachdem Raspbian gebootet hat fragt es euch nach einem Login und Passwort. Der Standard Benutzername lautet pi und das Passwort raspberry (sollte das Tastaturlayout nicht erkannt worden sein versucht bitte raspberrz).

1. Passwort ändern

Zuerst sollte das Default Passwort geändert werden. Gebt dazu passwd in die Konsole ein und anschließend zweimal euer neues Passwort (bei falschem Tastaturlayout solltet ihr erst den nächsten Punkt ausführen bevor Ihr das Passwort ändert).

passwd: [YOUR-PASSWORD]

2. Grundkonfiguration

Anschließend könnt Ihr die Grundeinrichtung des Pi's vornehmen.

sudo raspi-config

Vergesst nicht die Zeitzone und das Keyboard anzupassen. Überprüft mit dem Befehl date wie die Zeit derzeit hinterlegt ist. Ich musste bei mir UTC zu CET wechseln.

3. Updaten

Jetzt bietet es sich an das System zu aktualisieren. Dafür sind diese Befehle vorgesehen:

sudo apt-get update
sudo apt-get upgrade

Mit update wird eine interne Meta-Liste aktualisiert welche von upgrade benötigt wird. Beim Aktualisieren sollten immer diese beiden Befehle in der Reihenfolge aufgerufen werden.

Fernzugriff über Netzwerk

Mein Pi hat einen festen Standort im Technickraum. Für Wartungsarbeiten möchte ich es nicht extra holen bzw. einen Monitor anschließen. Zum Glück ist das auch nicht nötig. Es gibt gleich zwei Möglichkeiten zum fernsteuern (Putty und XRDP).

Für beide Varianten wird die IP-Adresse des Raspberries benötigt. Mit dem Befehl ifconfig könnt ihr diese erhalten.

SSH mit Putty (Konsole)

Diese Variante ist sehr schonend für Resourcen und empfehlenswerter als eine GUI-Variante da lediglich Commands versendet werden. Putty ist hier erhältlich: www.chiark.greenend.org.uk/~sgtatham/putty/download.html.

SSH aktivieren

Bevor ihr euch mit Putty verbinden könnt müsst Ihr dem Raspberry Zugriff über SSH erlauben. Geht dazu noch einmal in die Raspberry Konfiguration:

sudo raspi-config

Unter Interface Options könnt Ihr nun SSH aktivieren.

Putty einrichten

Beim starten von Putty werdet Ihr folgendes Fenster sehen (rot markiert sind die wichtigsten Felder für unseren Zweck).

1. IP-Adresse: Erhaltet Ihr vom Raspberry mit dem Befehl ifconfig.
2. Saved Sessions: Die aktuelle Konfig unter diesem Namen Speichern (mit dem rot markieren Button "Save").
3. Auto-login username: Optional kann man hier den User angeben mit dem man sich einloggen möchte. Dieser Punkt ist im Bild nicht gekennzeichnet. Zu finden ist er unter "Connection->Data->Auto-login username". Am besten gebt Ihr den User pi dort an.

Bei Doppelklick auf euren gewählten Namen in der Liste oder mit OK startet Ihr eine Konsole mit der Ihr direkt mit dem Raspberry interagieren könnt.

ConnectBot (Android)

Wenn Ihr euch auch vom Bett aus via SSH mit dem Pi verbinden wollt könnt Ihr auf eurem Android einen SSH Client installieren. Ich habe ConnectBot im Einsatz (play.google.com/store/apps/details?id=org.connectbot).

Remote Desktop (XRDP)

Eine Möglichkeit für Fernsteuerung mit GUI-Übertragung (Desktop) bietet Windows von Haus aus (mstsc.exe). Man muss lediglich dem Raspberry RDP beibringen. Im produktiven Einsatz kann man darauf allerdings verzichten da es keinen besonderen Mehrwert bietet gegenüber einer Shell. Installiert XRDP mit diesem Befehl auf dem Pi:

sudo apt-get install xrdp

In Windwos startet einfach mstsc.exe und gebt die IP-Adresse vom Pi und sein Passwort ein.

Danach seht Ihr euren Raspbian-Desktop.

Sollte es Probleme geben dann stellt in der Raspi Konfiguration (sudo raspi-config) ein das es in den Desktop direkt booten soll.

Optionale Schritte

Monitoring (RPI-Monitor)

Wollt ihr wissen wie es eurem Pi geht? Ich schon, am besten als Chart rückwirkend. Das Programm RPI-Monitor eignet sich dafür ganz gut. Es hat eine Web-Oberfläche mit der man die Performance auswerten kann (auch von einem anderen PC aus). Zum installieren führt folgende Befehle nacheinander aus (manche sind optional).

// 1. Raspberry updaten
sudo apt-get update
sudo apt-get upgrade

// 2. Fix broken dependencies (for some reasons I have to do that)
sudo apt-get -f install

// 3. Install required packages
sudo apt-get install dpkg-dev librrds-perl libhttp-daemon-perl libjson-perl libipc-sharelite-perl libfile-which-perl

// 4. Download RPI-Monitor packages (please check if a newer version exists)
wget https://github.com/XavierBerger/RPi-Monitor-deb/raw/master/packages/rpimonitor_2.9.1-1_all.deb

// 5. Install downloaded package
sudo dpkg -i rpimonitor_2.9.1-1_all.deb

// 6. Delete download package after installation (optional)
rm rpimonitor_2.9.1-1_all.deb

Nachdem die Installation erfolgreich verlief führt bitte einen Neustart vom Pi aus. Danach könnt ihr über einen Browser eurer Wahl und dem Port 8888 auf den Monitor zugreifen (im Browser muss die IP-Adresse des Pi + Port angegeben werden, z.b. http://192.168.178.43:8888).

Entrümpeln/Aufräumen

Solltet ihr nicht die Lite-Variante installiert haben dann hat euer Raspberry bereits viel Software vorinstalliert. Wenn Ihr keinen Desktopbetrieb benötigt könnt ihr z.B. LibreOffice entfernen. Mit folgenden Befehl wird es deinstalliert.

sudo apt-get remove --purge libreoffice*
sudo apt-get clean
sudo apt-get autoremove

Benutzer und Gruppen

Wie Windows bietet auch Linux ein Benutzer- und Gruppen-System um Rechte steuern zu können. Eine empfohlene Praxis unter Linux ist es je Programm einen separaten Benutzer anzulegen und das Programm nur unter diesem Nutzer laufen zu lassen. Damit lässt sich besser kontrollieren was das Programm darf.

Neben diesen "Programmusern" möchte ich auch jede echte Person (2 Stück) in unserem Haushalt als Benutzer anlegen. Gruppen wird es nur zwei geben, family und rollnut.

Viele der folgenden Befehle könnten auch in weniger Statements zusammengefasst werden. Ich habe Sie dennoch hier Schritt für Schritt ausgeschrieben.

Einrichten

Achtung: Alle folgenden Befehle müssen mit Root-Rechten ausgeführt werden bzw. mit SUDO!

1. Zuerst werden die beiden Gruppen ganz einfach angelegt:

groupadd family
groupadd rollnut

2. Anschließend legen wir zwei User an welche den passenden Gruppen zugeordnet werden (User können mehr als einer Gruppe angehören).

useradd firstUserName
useradd secondUserName

usermod -a -G family,rollnut firstUserName
usermod -a -G family secondUserName

Mit dem Parameter -G, gefolgt von dem Gruppennamen (auch als Liste möglich wenn mit Komma getrennt), wird usermod mitgeteilt das man vom User die Gruppe ändern möchte. Wenn man -a verwendet werden die Gruppen dem User hinzugefügt ansonsten überschreibt man die bisherige Gruppenzugehörigkeit.

3. Optional kann man das Home-Verzeichniss der beiden User von der SD-Karte auf die USB-Platte verschieben, was aus meiner Sicht absolut Sinn macht. Leider kann man ein Benutzer-Verzeichniss auf keine NTFS-Platte verschieben (man muss ext3 oder 4 verwenden).
Dieser Schritt ist allerdings erst möglich wenn eine USB-Festplatte gemountet wurde (mehr dazu im nächsten Artikel).

usermod -m -d /media/pidisk1/home/homeName userNameHere

Mit -d kann man den neuen Home-Pfad angeben. -m gibt an das der Inhalt des aktuellen Verzeichnisses in das neue verschoben werden soll. Der letzte Parameter ist der Benutzername.

Auswerten

Mit folgenden Befehlen werden alle User und Gruppen als Liste ausgegeben:

compgen -u    // list all users
compgen -g    // list all groups
compgen -u -g // list all users and groups

Mit dem Befehl groups erhaltet ihr eine Auflistung aller Gruppen welcher der aktuell eingeloggte User angehört.

Tipps & Tricks

Shutdown

Übrigens! Wenn Ihr eurer Pi herunterfahren oder neustarten möchtet verwendet bitte folgende Befehle:

// Shutdown the pi
sudo shutdown -h now

// Restart the pi
sudo shutdown -r now

Feste IP-Adresse

Wenn euer Raspberry als Server betrieben wird ist es zudem sinnvoll das er eine feste IP-Adresse in eurem Netzwerk erhält. Ich habe das bei mir direkt auf der Fritz.Box eingerichtet.

Backup

Als nächstes empfiehlt es sich ein Backup eurer SD-Karte zu machen. Falls in den nächsten Schritten etwas schiefgeht oder Ihr später etwas anderes ausprobieren möchtet erspart Ihr euch die Installation und Konfiguration.
Hier habe ich eine Anleitung für euch: backup-des-rasperry

Weitere geht's ...

Die Artikelserie "Home Server mit dem Raspberry Pi" geht jetzt mit dem Thema Mounting weiter.

Das Problem

Derzeit ist es so das Daten die von mehreren Personen im Haushalt verwendet werden redundant vorliegen. Z.B. wenn gemeinsame Fotos oder Dokumente auf den PC geladen werden, wird anschließend per Hand manuell mit den anderen PC's synchronisiert (damit auch jeder die gleichen Familienfotos hat). Um unnötige Backups zu vermeiden wird dieses nur durchgeführt wenn die Daten auf allen PC's bereits synchron sind (somit gibt es ein gemeinsames Backup).

Das ist ein ziemlich großer Aufwand der im Grunde unsinnig ist weil er sich automatisieren lässt. Daher möchte ich meinen Pi als HomeServer einrichten der stupide Aufgaben automatisiert.

Anforderungsliste an den Home-Server

Neben den Problemen die ich heute so habe stelle ich an meinen Pi direkt noch weitere Anforderungen die mir in Zukunft helfen werden. Neben zentralen Dokumenten ist es mir wichtig das Code, den ich zukünftig programmiere, ebenfalls sicher (und ohne viel manuellen Aufwand) archiviert wird. Außerdem kann mein Pi auch automatisiert Aufgaben übernehmen wenn ich mal keine Zeit habe (wie z.B. ein wöchentliches Backup meiner Website).

Funktionen

Folgend sind die Funktionen welche mein HomeServer zu erfüllen hat:

• File-Server (ganz normal)
  Zentrale Festplatte auf die jeder Netzwerkteilnehmer Zugriff hat. Diese soll von Windows aus im Explorer als Laufwerk eingebunden werden.
• File-Server mit Synchronisation zu Client
  Ebenfalls eine zentrale Speichermöglichkeit. Im Gegensatz zum ersten Punkt sollen die Daten auch ohne Server benutzbar und möglichst schnell verfügbar sein.
  Um das zu realisieren muss jeder Client die Dateien vorhalten. Bei Änderungen von Dateien werden diese mit allen Teilnehmern synchronisiert (automatisch). Der Server hält ebenfalls alle Daten damit ein Backup nur dort vorzunehmen ist.
• SourceCode-Verwaltung
  Meine privaten Projekte sollen in Zukunft archiviert werden mit einer Quellcodeverwaltung.
• Backup-Server
  Webprojekte sollen voll automatisiert (in intervalen) über meinen Home-Server gesichert werden. Daten mit FTP runterladen und die Datenbanken von phpmyadmin exportieren.

Eigenschaften

Neben diesen Aufgaben konfiguriere ich den Server in Hinblick auf folgende Punkte:

• Kein Zugriff über Internet
  Alle Funktionen sind nicht über das Internet verwendbar (dies soll mögliche Sicherheitslücken reduzieren da ich sowieso nur aus dem Heim-Netz Zugriff benötige).
• Alles ist Zentral
  Backups müssen nur am Server vorgenommen werden und nicht einzeln bei jedem Client.
• Remotezugriff
  Zugriff bzw. Wartung auf den Server soll von der Ferne möglich sein (der Server soll nicht an einen Monitor angeschlossen sein für einfache Wartungsaufgaben).

Achja, unsere Clients laufen primär mit Windows. Unsere Smartphones verwenden Android und WindowsPhone.

Umsetzung / Anleitung

Da sich das Pi nicht von allein einrichtet und ich nicht wusste welche Software zum Einsatz kommen soll, musste ich mich erstmal schlau machen was es am Makrt für fertige Lösungen gibt mit denen ich meine Wünsche erfüllen kann (und die auch mein Raspberry untersützt). Meine Recherchen und finale Konfiguration habe ich dokumentiert. Über unten stehendes Inhaltsverzeichnis habe ich diese zur Verfügung gestellt.

1. Einrichten
   OS installieren und einrichten (Raspian)
   mehr erfahren
2. Festplatte mounten
   Externe Festplatte über USB einhängen
   mehr erfahren
3. FileServer (normal)
   USB-Festplatte über Netzwerk für Windows freigen (SAMBA)
   mehr erfahren
4. FileServer (spiegeln)
   Synchronisierungssoftware installieren und einrichten (Seafile)
   mehr erfahren
5. SourceControl
   Quellcodeverwaltung installieren und einrichten (Git)
   mehr erfahren
6. Web-Backups
   Ein-Klick-Routine zum Sichern einer WordPress-Instanz

Kleinere Anleitungen

• Backup
  Eine Anleitung wie Ihr ein Backup vom Pi und Festplatte erstellt
  mehr erfahren
• Mounting
  Hier wird erklärt wie man eine externe USB-Festplatte anhängt
  mehr erfahren
• SD-Karte formatieren
  Kurzanleitung zum formatieren der SD-Karte mit dem offiziellen Formatierungstool oder mit Windows-Bordmitteln
  mehr erfahren

Ich habe zur Demonstration ein UserControl erstellt, welches ein Grid mit blauen Hintergrund enthält. In diesem Grid soll der Inhalt gezeigt werden, welcher vom Verwender definiert wird (<ContentPresenter />).

<UserControl 
    x:Class="ContentWPF.MyUserControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>
    <Grid Background="Blue">
        <ContentPresenter />
    </Grid>
</UserControl>

Die Verwendung von dem UserControl wird wie üblich in XAML deklariert mit dem Unterschied das man diesmal direkt im XAML den Content angibt.

<local:MyUserControl>
    Hello World
</local:MyUserControl>

 Das Problem

Nun ist es so das am Ende nichts von der Definition des Controls (‚MyUserControl.xaml‘) gezeigt wird. Es wird nur noch „Hello World“ ohne Grid und ohne Blau dargestellt.

Der Grund ist, dass das Content-Property von UserControl mit dem Content des Verwenders überschrieben wird und dabei die eigentliche Definition verloren geht.

Mit diesem Wissen ist der nächste Schritt nun zu verhindern, dass das Content-Property überschrieben wird. Das machen wir einfach indem wir im CodeBehind von ‚MyUserControl‘ ein separates Content-Property anlegen.

public static readonly DependencyProperty MyContentProperty 
    = DependencyProperty.Register("MyContent", typeof(object), typeof(MyUserControl), null);
public object MyContent
{
    get { return (object)GetValue(MyContentProperty); }
    set { SetValue(MyContentProperty, value); }
}

<UserControl 
    x:Class="ContentWPF.MyUserControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>
    <Grid Background="Blue">
        <ContentPresenter Content="{Binding Path=MyContent,
          RelativeSource={RelativeSource  AncestorType=UserControl}}" />
    </Grid>
</UserControl>

Mit dem neuen Property kann 'MyUserControl' folgenderweiße verwendet werden:

<local:MyUserControl MyContent="Hello World" />

Oder

<local:MyUserControl>
    <local:MyUserControl.MyContent>
        Hello World
    </local:MyUserControl.MyContent>
</local:MyUserControl>

(zweite Variante ist besser wenn kein Text sondern ein kompletter Control-Tree eingefügt wird).

Jetzt funktioniert es zwar, aber nur indem man beim Verwenden des Control mehr Code schreibt als nötig. Wer (so wie ich) sich daran stört unnötigen Code zu produzieren für den habe ich folgende ...

 Lösung

Die Lösung ist so Simpel, allerdings wenn man es nicht weiß kann man nicht darauf kommen.

Man muss lediglich im CodeBehind von ‚MyUserControl‘ das Klassen-Attribute 'ContentPropertyAttribute' deklarieren und als Parameter das gewünschte Property als string angeben.

namespace ContentWPF
{
    [ContentProperty("MyContent")] 
    public partial class MyUserControl : UserControl
    {
        public MyUserControl()
        {
            InitializeComponent();
        }
        
        public static readonly DependencyProperty MyContentProperty
            = DependencyProperty.Register("MyContent", typeof(object), typeof(MyUserControl), null);
        public object MyContent
        {
            get { return (object)GetValue(MyContentProperty); }
            set { SetValue(MyContentProperty, value); }
        }
    }
}

Damit kann man nun im XAML-Code das Einbetten von Sub-Elementen (wie anfangs demonstriert) verwenden:

<local:MyUserControl>
    Hello World
</local:MyUserControl>

Böser Beigeschmack

Leider gibt es selbst jetzt noch einen Nachteil, den man wohl nicht umgehen kann, wenn man ein UserControl verwendet. Wenn ihr ‚MyUserControl‘ nun verwendet und einem Element darin einem Namen gebt werdet ihr vom Compiler informiert das dies nicht erlaubt ist.

<local:MyUserControl>
    <TextBlock x:Name="CompilerErrorIfItemIsNamed">Hello World</TextBlock>
</local:MyUserControl>

Folgender Fehler wird ausgegeben:

Cannot set Name attribute value 'CompilerErrorIfItemIsNamed' on element 'TextBlock'. 'TextBlock' is under the scope of element 'MyUserControl', which already had a name registered when it was defined in another scope.

Den Namen selbst kann man zwar nachträglich über CodeBehind (oder sonstwo) angeben aber zur Designzeit kann man dieses Element im CodeBehind nicht direkt ansprechen.

Wenn man damit nicht Leben kann führt kein weg an einem CustomControl vorbei. Bei diesem können eingebettete Elemente mit einem Namen versehen und vom CodeBehind direkt angesprochen werden.

Achtung: In Silverlight ist dieses Verhalten identisch, allerdings versucht euch der Compiler zu täuschen. Die Fehlermeldung wird dort nicht gezeigt und das Projekt lässt sich compilieren. Allerdings wenn Ihr zur Laufzeit im CodeBehind direkt auf das Element zugreift wird eine NullReferenceException fliegen da das Property immer leer ist.