Birdie baut sich einen Fileserver

Hier könnt Ihr um das Thema "Rechner" diskutieren.
Benutzeravatar
The G
Beiträge: 1829
Registriert: So 4. Nov 2007, 16:00
Wohnort: Das schöne Allgäu
Kontaktdaten:

Re: Birdie baut sich einen Fileserver

Beitrag von The G » Fr 30. Mär 2012, 15:53

Danke euch beiden für die Infos.
Bild

Benutzeravatar
MEckI
Beiträge: 71
Registriert: Mo 12. Nov 2007, 06:55
Wohnort: Paderborn
Kontaktdaten:

Re: Birdie baut sich einen Fileserver

Beitrag von MEckI » Fr 30. Mär 2012, 18:25

Warum nicht FreeNAS?
Hat doch auch alles, bzw. kann man fehlendes nachrüsten.
Bild

Und ich war immer stolz darauf nur einen Versuch zu brauchen das gefährliche Ende des Lötkolbens zu finden…

Benutzeravatar
Birdie
Administrator
Beiträge: 1130
Registriert: Sa 3. Nov 2007, 17:14
Wohnort: Vatne, Norwegen
Kontaktdaten:

Re: Birdie baut sich einen Fileserver

Beitrag von Birdie » Fr 30. Mär 2012, 19:48

Ich hatte das Projekt im Vorfeld beobachtet (meine Planung lief über einige Monate) und bin für mich zu folgendem Schluß gekommen:

FreeNAS 0.7 => veraltet, unterstützt nicht neue Hardware
FreeNAS 0.8 => noch zu verbuggt, (noch) kein DLNA Server

Das von FreeNAS 0.8 unterstützte ZFS verliert gegenüber Linux mdadm RAID Lösungen, da RAIDs nicht dynamisch um weitere Festplatten (außer Hot-spares) erweitert werden können.

Darüber hinaus ziehe ich die Freiheit vor, mir mein System so zusammenstellen zu können, wie ich es möchte, anstelle auf ein vorgefertigtes System zurückgreifen zu müssen. Dafür nehme ich gerne in Kauf, daß ich kein Klicki-Bunti-Webinterface bekomme. Die notwendigen Informationen suche ich mir dann bei Bedarf in einer SSH Rootshell aus Logdateien zusammen.
Bild

Benutzeravatar
MEckI
Beiträge: 71
Registriert: Mo 12. Nov 2007, 06:55
Wohnort: Paderborn
Kontaktdaten:

Re: Birdie baut sich einen Fileserver

Beitrag von MEckI » Sa 31. Mär 2012, 09:57

Ich merke schon, du bist ein Consolen Fetischist :D
Bild

Und ich war immer stolz darauf nur einen Versuch zu brauchen das gefährliche Ende des Lötkolbens zu finden…

Benutzeravatar
Birdie
Administrator
Beiträge: 1130
Registriert: Sa 3. Nov 2007, 17:14
Wohnort: Vatne, Norwegen
Kontaktdaten:

Re: Birdie baut sich einen Fileserver

Beitrag von Birdie » Fr 27. Apr 2012, 14:48

... und es geht weiter an der Hardware-Front:

Das Backup

Nachdem das Haus nun verkabelt wurde (mit Luft für 10 GBit/s Verbindungen), steht einem Backup auf Zuruf nichts mehr im Wege. Hierzu kommt "rsync" zum Einsatz, das für das Synchronisieren von Verzeichnissen und Dateisystemen gemacht wurde. Ein Vorteil des Werkzeuges liegt darin, daß beim Synchronisieren überprüft wird, ob und wie die Daten an der Zieladresse sich von denen der Sendeadresse unterscheiden. Es werden dann entsprechend weniger Daten übertragen, was man sich zu Nutze machen kann, wenn man ein inkrementelles Backup durchführt.

Zusätzlich soll der Fileserver Datendeduplizierung verwenden, also identische Dateien sollen nicht mehrfach auf der Festplatte gespeichert werden. Linux kann hierzu sogenannte "hard links" verwenden.

Zunächst benötigen wir eine rsync-Version für Windows. Das Programm DeltaCopy, stellt ein grafisches Frontend für rsync zur Verfügung und bringt eine veraltete Version der cygwin rsync.exe mit.
Wir laden den Installer herunter und führen ihn aus. DeltaCopy wird als Service eingerichtet, aber wir lassen Benutzernamen und Paßwort frei. Wir wechseln nun in die Windows Systemsteuerung, navigieren uns zu "Dienste" durch und wählen den DeltaCopyService aus. Dort stellen wir im Reiter "Logon" ein, daß der Dienst mit dem Local System Account ausgeführt wird.
rsync_0.png
Wir starten den Dienst noch nicht, da wie eingangs beschrieben, eine veraltete rsync Version mitgeliefert wurde.

Wir laden uns nun also die Installationsdatei für Cygwin herunter und führen diese aus.
Rsync_7.png
Rsync_8.png
Rsync_9.png
Rsync_10.png
Rsync_11.png
Rsync_12.png
Nach abgeschlossener Installation kopieren wir die Dateien cygwin1.dll und rsync.exe aus dem Verzeichnis h:\cygwin\bin in das Installationsverzeichnis von DeltaCopy. Die dort bereits vorhandenen Dateien werden überschrieben.

Nun starten wir den DeltaCopy Service und legen die notwendigen Verzeichnisfreigaben an, die wir für das Backup verwenden wollen. Um zu verhindern, daß der Dienst von außen ohne weiteres zu erreichen ist, werden die Freigaben mit einer Kombination aus Benutzernamen und Paßwort versehen:
Rsync_1.png
Rsync_2.png
Wo wir gerade bei der Erreichbarkeit von außen sind. Die Windows Firewall macht natürlich erst einmal dicht. Verschiedene Versuche, die DeltaCopy Dateien in der Firewall freizuschalten, haben leider nichts genutzt, so daß ich eine globale Regel von Hand definiert habe, die den notwendigen Port öffnet. Evtl. bestand das Problem darin, daß das letztlich agierende Programm rsync.exe und nicht DCServce.exe, DeltaS.exe war.
Rsync_3.png
Rsync_4.png
Rsync_5.png
Rsync_6.png
Weiter auf dem Fileserver. Hier habe ich mir ein kleines Skript geschustert, daß verwendet wird, um die Daten vom Windowsrechner abzuholen, und per hard links dafür zu sorgen, daß identische Dateien, die in mehreren Backups vorkommen, nicht übermäßig viel Platz wegnehmen.

Code: Alles auswählen

#!/bin/bash
# ----------------------------------------------------------------------
# This script  makes rotating backup-snapshots of REMOTEDIR 
# whenever called
# Limit number of snapshots to MAX_SNAPSHOTS
# ----------------------------------------------------------------------

# ------------- system commands used by this script --------------------

ID=/usr/bin/id;
ECHO=/bin/echo;
RM=/bin/rm;
MV=/bin/mv;
CP=/bin/cp;
TOUCH=/bin/touch;
RSYNC=/usr/bin/rsync;

# ------------- file locations -----------------------------------------

SNAPSHOTDIR=/share/snapshot_c;
REMOTEDIR=rsync://Birdie@192.168.2.10:/rsync_c/
LOGFILE=$SNAPSHOTDIR/log
RSYNCLOG=$SNAPSHOTDIR/log2
EXCLUDE=" --exclude Temp/ --exclude Temporary*/ --exclude temp/ --ignore-errors"

    # ----- Modifiable RSync Options -----

    # Explanation of default options
    # a = archive mode; equals rlptgoD
    #    r = recurse into directories
    #    l = copy symlinks as symlinks
    #    p = preserve permissions
    #    t = preserve modification times
    #    g = preserve group
    #    o = preserve owner
    #    D = preserve device and special files
    # c = skip based on checksum, not mod-time & size
    # v = increase verbosity
    # x = don't cross filesystem boundaries
    # H = preserve hard links
    # S = handle sparse files efficiently
    # h = make units "human-readable"

    RSYNC_OPTIONS="-avcxHSh --delete --log-file=$RSYNCLOG --stats --progress $EXCLUDE --delete-excluded"

MAX_SNAPSHOTS=40;

# ------------- the script itself --------------------------------------

# make sure we're running as root
if (( `$ID -u` != 0 )); then { $ECHO "Sorry, must be root.  Exiting..."; exit; } fi

CURRENT_SNAPSHOT=$MAX_SNAPSHOTS;
$ECHO "" >> $LOGFILE;
$ECHO "Rsyncsnapshot: Am `date` gestartet mit max. $MAX_SNAPSHOTS Speicherabbildern." >> $LOGFILE;
while [ $CURRENT_SNAPSHOT -gt 0 ] ; do
	let NEXT_SNAPSHOT=$CURRENT_SNAPSHOT+1;
	CURRENTDIR=`$ECHO snapshot.$CURRENT_SNAPSHOT`;
	NEXTDIR=`$ECHO snapshot.$NEXT_SNAPSHOT`;
	
	if [ $CURRENT_SNAPSHOT -eq $MAX_SNAPSHOTS ]; then
		#
		# Delete oldest snapshot in case that it exists
		#
		if [ -d $SNAPSHOTDIR/$CURRENTDIR ] ; then                     
			$RM -rf $SNAPSHOTDIR/$CURRENTDIR ;                            
			$ECHO "Rsyncsnapshot: Lösche ältestes Speicherabbild Nr. $CURRENT_SNAPSHOT." >> $LOGFILE;
		fi ;
	else
		#
		# Increment snapshots
		#
		if [ -d $SNAPSHOTDIR/$CURRENTDIR ] ; then                     
			$MV $SNAPSHOTDIR/$CURRENTDIR $SNAPSHOTDIR/$NEXTDIR ;     
			$ECHO "Rsyncsnapshot: Verschiebe Speicherabbild Nr. $CURRENT_SNAPSHOT nach $NEXT_SNAPSHOT." >> $LOGFILE;
		fi;
	fi;
	let CURRENT_SNAPSHOT=$CURRENT_SNAPSHOT-1;
	if [ $CURRENT_SNAPSHOT -eq 0 ]; then
		let NEXT_SNAPSHOT=$CURRENT_SNAPSHOT+2;
		let PRESENT_SNAPSHOT=$CURRENT_SNAPSHOT+1;
		CURRENTDIR=`$ECHO snapshot.$PRESENT_SNAPSHOT`;
		NEXTDIR=`$ECHO snapshot.$NEXT_SNAPSHOT`;
		#
		# Hardlink newest snapshot to previous one in order to reduce
		# data transfer
		#
		if [ -d $SNAPSHOTDIR/$NEXTDIR ] ; then                     
			$CP -al $SNAPSHOTDIR/$NEXTDIR $SNAPSHOTDIR/$CURRENTDIR ; 
			$ECHO "Rsyncsnapshot: Verbinde Speicherabbild Nr. $PRESENT_SNAPSHOT mit $NEXT_SNAPSHOT zur Speicherdeduplizierung." >> $LOGFILE;
		else
			mkdir $SNAPSHOTDIR/$CURRENTDIR ;
			$ECHO "Rsyncsnapshot: Erstelle Verzeichnis $SNAPSHOTDIR/$CURRENTDIR" >> $LOGFILE;
		fi;
	fi;
done

# rsync from the system into the latest snapshot
$ECHO "Rsyncsnapshot: Starte Synchronisierung am `date`" >> $LOGFILE

$RSYNC $RSYNC_OPTIONS $REMOTEDIR $SNAPSHOTDIR/$CURRENTDIR ;
$ECHO "Rsyncsnapshot: Beende Synchronisierung am `date`" >> $LOGFILE
$ECHO 

# update the mtime of the most recent snapshot directory
$TOUCH $SNAPSHOTDIR/$CURRENTDIR ;
In der Variable REMOTEDIR sind verschiedene Informationen zusammengefaßt:
1. Der Benutzername für die rsnyc Verzeichnisfreigabe (im Beispiel "Birdie")
2. Die IP oder der Hostname des Windowsrechners, von dem die Daten abgeholt werden sollen (192.168.2.10)
3. Der Name der Verzeichnisfreigabe (rsync_c)

Beim Aufruf des Skripts erfolgt die Abfrage des Paßworts, das für die Verzeichnisfreigabe definiert wurde.
In der Variable EXCLUDE sind Verzeichnisse definiert, die nicht ins Backup übertragen werden sollen. Während des Backups ist immer mal wieder die ein oder andere Datei geöffnet und läßt sich damit nicht übertragen. Dies wird von rsync als Fehler aufgefaßt, der verhindert, daß irgendwelche Dateien auf der Empfängerseite gelöscht werden. Mit --ignore-errors und --delete wird sichergestellt, daß Dateien, die seit dem letzten Backup auf dem Windowsrechner gelöscht wurden, aus dem neu angelegtem Backup entfernt werden, selbst wenn Übertragungsfehler vorliegen sollten.

Das Skript löscht das älteste Backup, falls die maximale Anzahl definiert in MAX_SNAPSHOTS schon erreicht sein sollte.
Danach werden alle Backupbezeichnungen um 1 angehoben.
Dann wird das neueste Backup per hard links geklont, so daß rsync eine gute Ausgangsbasis hat, um nur ein inkrementelles Backup durchführen zu müssen.
Schließlich wird das eigentliche Backup per rsync gestartet.
Zum Schluß wird die Änderungszeit des neuesten Backups aktualisiert, so daß man jederzeit im Blick hat, von wann die einzelnen Backups stammen.

Im Ergebnis liegen damit mehrere Backups auf dem Rechner mit Namen snapshot.1 bis snapshot.40. Jedes dieser Backups ist für sich genommen ein vollständiges Abbild des zu sichernden Verzeichnisses zum Zeitpunkt des Backups. Durch Verwendung von hard links und rsync, haben wir jedoch weiterhin die Vorteile von inkrementellen Backups ausgenutzt (geringere Datenübertragung und geringere Datenmenge/Datendeduplizierung).
Bild

Benutzeravatar
Birdie
Administrator
Beiträge: 1130
Registriert: Sa 3. Nov 2007, 17:14
Wohnort: Vatne, Norwegen
Kontaktdaten:

Re: Birdie baut sich einen Fileserver

Beitrag von Birdie » So 13. Jan 2013, 13:29

Weitere Anpassungen
Dateisystem
Bereits nach etwa einem halben Jahr traten die ersten Dateifehler auf der CF-Karte auf. Diese wurde daher durch eine USB 2.0 Festplatte erstetzt, die nun die Aufgabe des Bootlaufwerks übernimmt. Das Dateisystem wurde dazu auf ext3 umgestellt.

Die Überwachung der Festplatten wurde umkonfiguriert. Mir war nicht klar, daß Debian die Festplatten nicht automatisch in den Energiesparmodus wechseln läßt. Dazu in der /etc/rc.local

Code: Alles auswählen

hdparm -S120 /dev/sd[abcdef]
Standby nach 120x5 Sekunden = 10 Minuten aktivieren.

Weiterhin werden erweiterte Selbsttests der Festplatten aktiviert und regelmäßig früh morgens durchgeführt. Dazu in der /etc/smartd.conf

Code: Alles auswählen

DEVICESCAN -d removable -n standby,13 -a -s (S/../.././02|L/../../1/03) \
    -I 194 -I 231 -I 9 -W 5 -o on -S on \
    -m root -M exec /usr/share/smartmontools/smartd-runner
Wechselfestplatten ignorieren (-d removable)
Festplatten im Standby ignorieren, jedoch nur maximal 13mal aufeinanderfolgend (-n standby,13)
Temperaturen in °C überwachen und Warnungen bei Temperaturschwankungen über 5°C ausgeben (-I 194 -I 231 -I 9 -W 5)
Kurzer Selbsttest jeden Tag um 2 Uhr morgens (S/../.././02)
Langer Selbsttest (braucht mehrere Stunden) jeden Montag um 3 Uhr morgens (L/../../1/03)
Fehlermeldungen an root senden (-m root -M exec /usr/share/smartmontools/smartd-runner)

IMAP Mailserver
Man hat im Laufe der Zeit einige Mailadressen gesammelt und möchte diese gebündelt abrufen können. Weiterhin sollen alle Smartphones, Rechner und sonstiger elektronischer Schnick-Schnack die gleichen Mails sehen können. Ein IMAP Server mit automatischem Sammeldienst bietet sich hierfür an. Viele Mailprovider bieten einen solchen Dienst an, verlangen dafür aber montaliche Gebühren (z.B. web.de) oder lesen einfach alle Post mit, um bessere Reklame zeigen zu können (Gmail). Da der eigene Server ohnehin schon läuft, kann er auch diese Aufgabe übernehmen. Eingesetzt wird eine Kombination aus Cyrus (IMAP), Postfix (Zuordnung Mailadressen zu lokalen Benutzern) und Fetchmail (Mails regelmäßig vom Provider abholen).

Fetchmail
Fetchmail installieren mit

Code: Alles auswählen

apt-get install fetchmail
Lokale Benutzer einrichten, die die Mails erhalten sollen:

Code: Alles auswählen

adduser birdie
adduser birdieseinefrau
Fetchmail konfigurieren:

Code: Alles auswählen

/etc/fetchmailrc:
     # alle 60 Sekunden was machen
     set daemon 60
     # jedes 5. mal Mail abrufen für folgenden Account und Daten an lokalen Benutzer birdie weiterreichen
     poll mx.freenet.de protocol POP3 interval 5 user "birdiesmailadresse@freenet.de" pass "birdies Passwort im Klartext" is "birdie"
     # jedes 5. mal Mail abrufen für folgenden Account und Daten an lokalen Benutzer birdie weiterreichen
     poll pop.gmx.net port 995 protocol POP3 interval 5:  
           user "birdiesmailadresse@gmx.de" pass "birdies Passwort im Klartext" is "birdie"
           ssl
     # jedes 15. mal Mail abrufen für folgenden Account und Daten an lokalen Benutzer birdieseinefrau weiterreichen
     poll pop3.web.de protocol POP3 interval 15 :
           user "birdiesfrau@web.de" pass "frauenpasswort" is "birdieseinefrau"
           sslproto "TLS1"
    # Wenn die Mails nach Abruf nicht von den Server gelöscht werden sollen, folgendes Kommando benutzen
keep
Die Konfigurationsdatei enthält Passwörter im Klartext. Wir setzen daher die Rechte so, daß nur root bzw. der fetchmail Prozess die Datei sehen darf:

Code: Alles auswählen

chmod 600 /etc/fetchmailrc
chown fetchmail /etc/fetchmailrc
Per runleveleditor nun fetchmail beim Systemstart starten lassen:

Code: Alles auswählen

sysv-rc-conf
und Runlevels 2 - 5 aktivieren.

Cyrus
Installieren:

Code: Alles auswählen

apt-get install cyrus-common-2.2 cyrus-imapd-2.2 cyrus-admin-2.2 mailutils
Passwörter vergeben, mit denen die Mail vom IMAP Server abgeholt werden soll

Code: Alles auswählen

saslpasswd2 cyrus
saslpasswd2 birdie
saslpasswd2 birdieseinefrau
IMAP Mailboxen anlegen:

Code: Alles auswählen

cyradm --user cyrus --server localhost
   cm user.birdie
   cm user.birdieseinefrau
Die Mails sollen SSL/TLS gesichert abgerufen werden können. Dazu erstellen wir ein selbstsigniertes Zertifikat:

Code: Alles auswählen

openssl req -new -x509 -nodes -out /etc/ssl/certs/imap.pem -keyout /etc/ssl/private/imap.key -days 365
Bei der Generierung können beliebige Daten eingegeben werden. Nur im Feld "Common Name", muß der Hostname des Servers eingetragen werden, unter dem er später im Netz erreichbar ist. Also z.B. birdie.dyndns.org.

IMAP konfigurieren:

Code: Alles auswählen

/etc/imapd.conf:
admins: cyrus
tls_cert_file: /etc/ssl/certs/imap.pem 
tls_key_file: /etc/ssl/private/imap.key


/etc/cyrus.conf:
#imap cmd="imapd -U 30" listen="imap" prefork=0 maxchild=100
imaps cmd="imapd -s -U 30" listen="imaps" prefork=0 maxchild=100
Postfix
Postfix konfigurieren:

Code: Alles auswählen

/etc/postfix/main.cf
sender_dependent_relayhost_maps = hash:/etc/postfix/relaymap
smtp_sender_dependent_authentication = yes
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/passes
smtp_sasl_security_options = noanonymous
smtp_tls_security_level = encrypt
smtp_tls_CAfile = /etc/postfix/cacert.pem
smtp_tls_CApath = /usr/share/ca-certificates/

append_dot_mydomain = no

inet_interfaces = localhost, 192.168.2.140
myorigin = $myhostname
mydestination = $myhostname localhost.$mydomain localhost $mydomain
myhostname = fileserver
mynetworks = 127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128, 192.168.2.0/24

mailbox_transport = cyrus
Welche SMTP Server sollen wir für ausgehende Mails verwenden? Mapping von Absendermailadresse auf Mailaccount vornehmen:

Code: Alles auswählen

/etc/postfix/relaymap:
@gmx.de mail.gmx.net:587
@web.de smtp.web.de:587
@freenet.de mx.freenet.de:587
Passwörter hinterlegen:

Code: Alles auswählen

/etc/postfix/passes:
adresse1@gmx.de GMX-Kundennummer1:Passwort
adresse2@gmx.de GMX-Kundennummer2:Passwort
adresse@freenet.de adresse@freenet.de:Passwort
@web.de Benutzername:Passwort
Mail für root an birdie umleiten:

Code: Alles auswählen

/etc/aliases:
postmaster: root
root: birdie
Dateien hashen und nur für root lesbar machen:

Code: Alles auswählen

postmap /etc/postfix/relaymap
postmap /etc/postfix/passes
postmap /etc/aliases
Anbindung an Cyrus vornehmen:

Code: Alles auswählen

/etc/postfix/master.cf:
cyrus     unix  -       n       n       -       -       pipe
    flags= user=cyrus argv=/usr/sbin/cyrdeliver -e -r ${sender} -m ${extension} ${user}
SASL Autentifizierung starten:

Code: Alles auswählen

/etc/default/saslauthd:
START=yes
MECHANISMS="pam"

Damit ist folgende Kette aufgebaut worden:
1. Fetchmail holt Post von den POP3 Postfächern ab und ordnet sie lokalen Benutzernamen zu
2. Cyrus nimmt die lokale Post an und legt sie per lokalem Benutzer in IMAP Datenbanken ab,
3. Per Smartphone/PC verbindet man sich zum Fileserver per IMAPS mit dem lokalen Benutzername und dem lokalen Passwort.
4. Per Smartphone/PC abgelieferte Mail wird von Postfix ohne Abfrage eines Passworts entgegengenommen und aufgrund der Absenderadresse über den passenden Provider mit Benutzername/Passwort weitergereicht. Um zu verhindern, daß jeder seinen SPAM bei diesem Server abliefert, sind nur Verbindungen aus dem eigenen privaten Netzwerk zugelassen.
5. Von Systemdiensten bei Postfix abgelieferte Mail wird an Cyrus weitergereicht und dort ggf. in ein IMAP Postfach einsortiert.

Router konfigurieren
Port Forwarding:
Eingehender Port 993 (IMAPS) auf Port 993 IP 192.168.3.200 weiterleiten
Bild

Benutzeravatar
Birdie
Administrator
Beiträge: 1130
Registriert: Sa 3. Nov 2007, 17:14
Wohnort: Vatne, Norwegen
Kontaktdaten:

Re: Birdie baut sich einen Fileserver

Beitrag von Birdie » So 13. Jan 2013, 14:26

Eine Virtuelle Maschine aufsetzen
Zu Testzwecken wurde eine virtuelle Maschine installiert. Der Fileserver verfügt über zwei physische Netzwerkkarten, so daß eine davon ausschließlich der VM zur Verfügung gestellt werden kann. Für die Virtuelle Maschine wird dann eine Netzwerkbrücke zwischen der einen Netzwerkkarte und einem TAP Device gespannt, das von der VM angesprochen werden kann.

Zunächst werden die notwendigen Pakete installiert:

Code: Alles auswählen

aptitude install kvm qemu-kvm libvirt-bin virtinst bridge-utils uml-utilities iproute
Wir erstellen die Netzwerkbrücke:

Code: Alles auswählen

/usr/sbin/brctl addbr br0
#oder /sbin/brctl addbr br0
Wir aktivieren Forwarding:

Code: Alles auswählen

sysctl -w net.ipv4.ip_forward=1
Wir aktivieren eine eigene Filterregel, um das korrekte Routing sicherzustellen. Wenn Anfragen auf der ersten Netzwerkkarte ankommen, sollen diese auch nur über die erste Netzwerkkarte beantwortet werden. Gleiches gilt für die zweite Netzwerkkarte.

Code: Alles auswählen

echo "1 table2" >> /etc/iproute2/rt_tables
Die zugehörige Routingtabelle "table2" wird beim Konfigurieren der Netzwerkkarte mit Leben gefüllt.

Wir konfigurieren die Netzwerkkarten:

Code: Alles auswählen

# The loopback network interface
auto lo
iface lo inet loopback

# Die Netzwerkkarte für das Heimnetz
allow-hotplug eth1
iface eth1 inet static
 address 192.168.2.140
 netmask 255.255.255.0
 broadcast 192.168.2.255
 gateway 192.168.2.1
 up /sbin/ip route add 192.168.2.0/24 dev eth1 src 192.168.2.140 table table2
 up /sbin/ip route add default via 192.168.2.1 dev eth1 table table2
 up /sbin/ip rule add from 192.168.2.140/32 table table2
 up /sbin/ip rule add to 192.168.2.140/32 table table2

# Die Netzwerkkarte für die VM
iface eth0 inet manual

# Die Netzwerkbrücke
auto br0
iface br0 inet static
 address 192.168.3.200
 netmask 255.255.255.0
 broadcast 192.168.3.255
 bridge_ports eth0
 bridge_fd 9
 bridge_hello 2
 bridge_maxage 12
 bridge_stp off
Wir installieren die VM. Zunächst laden wir uns die Installations-CD des Betriebssystems als ISO Image herunter, das wir installieren wollen. Dann legen wir uns eine virtuelle Festplatte an. Aus Performancegründen bleiben wir beim raw Format:

Code: Alles auswählen

qemu-img create -f raw /srv/VM_Platte.raw 100G
Nun starten wir die Installation der VM. Im Beispiel installieren wir eine weitere Linuxvariante:

Code: Alles auswählen

/usr/sbin/tunctl -u `whoami` -t tap0
/sbin/ip link set tap0 up
sleep 0.5s
/usr/sbin/brctl addif br0 tap0
#oder /sbin/brctl addif br0 tap0
kvm -enable-kvm -m 4G -hda VM_Platte.raw -cdrom Debian_Installer.iso -net nic,model=virtio,macaddr=DE:AD:BE:EF:FF:00 -net tap,script=no,downscript=no,ifname=tap0 -k de -vnc :1 -usbdevice tablet 
Nun kann man sich z.B. dem TightVNCViewer von Windows aus auf 192.168.2.140:1 verbinden und die Installation des neuen Betriebssystems durchgehen.

Nach erfolgreicher Installation wird die IP Adresse der VM statisch auf 192.168.3.201 festgelegt.

Bandbreitenmanagement
Um zu verhindern, daß sich die VM die gesamte verfügbare Internetbandbreite schnappt, wird beim Start folgendes durchgeführt und damit ein Limit auf 10MBit/s festgelegt wird. Zusätzlich starten wir die VM beim Systemstart

Code: Alles auswählen

/etc/rc.local:
/usr/sbin/tunctl -u `whoami` -t tap0
/sbin/ip link set tap0 up
sleep 0.5s
/usr/sbin/brctl addif br0 tap0

tc qdisc del dev tap0 ingress 2> /dev/null > /dev/null
tc qdisc del dev tap0 root    2> /dev/null > /dev/null

tc qdisc add dev tap0 root handle 1:0 htb default 10
tc class add dev tap0 parent 1:0 classid 1:10 htb rate 10mbit

tc qdisc add dev tap0 handle ffff: ingress
tc filter add dev tap0 parent ffff: protocol ip prio 50 u32 match ip src \
  0.0.0.0/0 police rate 10mbit burst .5mbit drop flowid :1

/srv/vm1_up

Code: Alles auswählen

/srv/vm1_up:
#!/bin/sh

macaddress=DE:AD:BE:EF:FF:00
screen -mdS VM1 kvm -enable-kvm -m 4G -drive file=/VM_Platte.raw -net nic,model=virtio,macaddr=$macaddress -net tap,ifname=tap0,script=no,downscript=no -vnc :1 -k de -usbdevice tablet
Trennung der Netzwerke
Der Fileserver befindet sich aufgrund seiner beiden Netzwerkkarten in zwei Subnetzen gleichzeitig:
192.168.2.0/24 => "privates Netz" durch Zweitrouter zusätzlich gesichert
192.168.3.0/24 => "offenes Netz" durch NAT/Portforwarding gesichert/geöffnet

Diese Trennung hilft aber nicht viel, wenn die VM einfach Dateien von der lokalen Festplatte des Fileservers oder lokale Dienste (IMAP, NFS, DLNA, etc.) ansprechen kann. Wir ziehen also noch eine Firewall hoch, die die beiden Interfaces weitgehend von einander abschotten soll:

Code: Alles auswählen

#!/bin/bash
#
# Firewall Skript
#
# Aufgabe:
#
# Schutz des Fileservers vor der/den VMs:
# 1. Lasse keine Verbindungen von eth0 (192.168.3.200) oder br0 (192.168.3.201) auf 192.168.2.140 zu.
# 2. Führe ein Forwarding von eth0 auf br0 durch
#
# Dienste, die auf 192.168.3.200 angeboten werden sind nur entweder von Geräten möglich,
# die direkt im Subnetz 192.168.3.0/24 oder 192.168.2.0/24 operieren, oder durch ein direktes Portforwarding
# von extern auf die IP 192.168.3.200 möglich.
#
# OBS: Im Falle einer Umstellung auf IPv6 ohne NAT werden einige Dienste damit direkt von außen
#       sichtbar !!!
#

EXTERN_IP="192.168.2.140"
INTERN_IP="192.168.3.200"
VM1_IP="192.168.3.201"

EXTERN_IF="eth1"
INTERN_IF="eth0"
VM1_IF="br0"

LO_IF="lo"
LO_IP="127.0.0.1"

IPTABLES="/sbin/iptables"

#
# Load some required modules
#
/sbin/modprobe ip_tables
/sbin/modprobe ip_conntrack
/sbin/modprobe iptable_filter
/sbin/modprobe iptable_mangle
/sbin/modprobe iptable_nat
/sbin/modprobe ipt_LOG
/sbin/modprobe ipt_limit
/sbin/modprobe ipt_state
/sbin/modprobe ipt_owner
/sbin/modprobe ipt_REJECT
/sbin/modprobe ipt_MASQUERADE
/sbin/modprobe ip_conntrack_ftp
/sbin/modprobe ip_conntrack_irc

#
# Aktiviere Forwarding - dies wird benötigt, um die Netzwerkbrücke eth0 => br0 zu verwenden
#
echo 1 > /proc/sys/net/ipv4/ip_forward

$IPTABLES -F
$IPTABLES -X

$IPTABLES -P INPUT ACCEPT
$IPTABLES -P OUTPUT ACCEPT
$IPTABLES -P FORWARD ACCEPT

#
# Blockiere globale multi-casts
#
$IPTABLES -A OUTPUT -p udp -d 255.255.255.255 -j DROP
$IPTABLES -A OUTPUT -p tcp -d 255.255.255.255 -j DROP
$IPTABLES -A OUTPUT -p icmp -d 255.255.255.255 -j DROP

#
# Blockiere neu eingehende TCP Verbindungen mit verkehrtem Flag
#
$IPTABLES -A INPUT -p tcp --tcp-flags SYN,ACK SYN,ACK -m state --state NEW -j REJECT --reject-with tcp-reset
$IPTABLES -A INPUT -p tcp ! --syn -m state --state NEW -j DROP

#
# Erlaube aufgebauten Verbindungen fortzusetzen
#
$IPTABLES -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPTABLES -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

#
# Erlaube Kommunikation auf loopback Schnittstelle
#
$IPTABLES -A INPUT -i lo -j ACCEPT
$IPTABLES -A OUTPUT -o lo -j ACCEPT

#
# Blockiere Fragmente
#
$IPTABLES -A INPUT -p ip -d $EXTERN_IP -f -j DROP
$IPTABLES -A INPUT -p ip -d $INTERN_IP -f -j DROP

#
# Blockiere nicht angeforderte FTP-Daten
#
$IPTABLES -A INPUT -p tcp --source-port 20 --destination-port 1024:65535 -j DROP

#
# Blockiere interne Verbindungen in das verkehrte Subnetz - Schütze Fileserver vor VM
#
$IPTABLES -A INPUT -i $EXTERN_IF -s $INTERN_IP -j DROP
$IPTABLES -A INPUT -i $EXTERN_IF -s $VM1_IP -j DROP

#
# VNC Server zulassen
#
$IPTABLES -A INPUT -p tcp --destination-port 5900:5901 -j ACCEPT
$IPTABLES -A OUTPUT -p tcp --source-port 5900:5901 -j ACCEPT

#
# miniDLNA unterbinden auf allen IPs außer der EXTERN_IP
#
$IPTABLES -A INPUT -p tcp ! -d $EXTERN_IP --destination-port 8200 -j DROP
Um die Firewallregeln auch nach einem Neustart zu erhalten, installieren wir noch ein weiteres Paket:

Code: Alles auswählen

apt-get install iptables-persistent
Nachdem die Firewall hochgefahren ist, speichern wir die Regeln und stellen per runlevel editor ein, daß die Firewall beim Systemstart hochgefahren werden soll:

Code: Alles auswählen

iptables-save > /etc/iptables/rules
sysv-rc-conf
Wozu die VM?
Ein konkretes Einsatzszenario für eine virtuelle Maschine existiert noch nicht. Es hat sich erst einmal um eine Machbarkeitsstudie gehandelt. Da über den FTTH Zugang bis zu 100 MBit symmetrische Bandbreite gebucht werden kann (zur Zeit 25MBit gebucht), besteht genug Potential, um eigene Serveranwendungen ins Internet zu bringen. Der Fileserver hat noch mehrere PCIe Steckplätze frei und könnte damit noch weitere Netzwerkkarten verpaßt bekommen, die jeweils exklusiv einzelnen VMs zur Verfügung gestellt werden können. Der Quadcore-Prozessor im Fileserver steht auch die meiste Zeit still und langweilt sich, so daß CPU-Resourcen für VMs verfügbar wären.

Mögliche Szenarien sind:
FTP-Server, Homepage, eigenes Dropbox-System, TS, Gameserver, eigene Cloud, Musikstreaming ...
Bild

Henrise
Beiträge: 8
Registriert: Fr 13. Mär 2015, 14:49

Re: Birdie baut sich einen Fileserver

Beitrag von Henrise » Fr 10. Apr 2015, 10:44

Und ich dachte, ich wäre cool mit mit meinem Level 8 Paket des Linux Root Server von Strato. Für meine Bedürfnisse und Fähigkeiten ideal, aber eine amtliche Anleitung und Dokumentation ist das, selten sowas so intensiv überflogen, Respekt!

Antworten