Vorbemerkung

Was ist OpenAFS

OpenAFS ist die freie Implementierung von AFS, eines verteilten Dateisystem. Im Gegensatz zu anderen Netzwerkdateisystem wie z.B. NFS oder CIFS muß der Client nicht wissen auf welchem Server die eingebundenen Volumen liegen, da er sie von jedem AFS-Server in der jeweiligen Zelle einbinden kann. Zudem wird der Datenstrom verschlüsselt und kann beinahe von jedem Betriebssystem eingebunden werden (es existieren sowohl Clients für Linux wie auch für Windows und Mac)

Wieso MIT-Kerberos5

Zwar liefert OpenAFS einen Authentifizierungsserver mit, allerdings basiert dieser auf einer abgewandelten Version des Kerberos4-Protokolls, weshalb ich hier das Kerberos5-Protokoll bevorzuge.

Namensdefinition

Ich benutze in meinen Beispielen folgende Namen:

Kerberos

Installation

 :/$ apt-get install krb5-admin-server krb5-kdc libkrb53 krb5-config krb5-clients

Konfiguration

KDC

(Key Distribution Center).

/etc/krb5kdc/kdc.conf:

 [kdcdefaults]
 kdc_ports = 750,88

 [realms]
 EXAMPLE.COM = {
 database_name = /var/lib/krb5kdc/principal
 admin_keytab = /etc/krb5kdc/kadm5.keytab
 acl_file = /etc/krb5kdc/kadm5.acl
 key_stash_file = /etc/krb5kdc/stash
 kdc_ports = 750,88
 max_life = 10h 0m 0s
 max_renewable_life = 8d 0h 0m 0s
 master_key_type = des3-hmac-sha1
 supported_enctypes = des3-hmac-sha1:normal des-cbc-crc:normal des:normal des:v4 des:norealm des:onlyrealm des:afs3
 default_principal_flags = +preauth
 }

 [logging]
 kdc = FILE:/var/log/krb5kdc.log
 admin_server = FILE:/var/log/kadmin.log
 default = FILE:/var/log/krb5lib.log

Kerberos Client

/etc/krb5.conf:

 [libdefaults]
 default_realm = EXAMPLE.COM

 [realms]
 EXAMPLE.COM = {
 kdc = krb.example.com:88
 admin_server = krb.example.com:749
 default_domain = example.com
 }

 [domain_realm]
 .example.com = EXAMPLE.COM
 example.com = EXAMPLE.COM

 [kdc]
 profile = /etc/krb5kdc/kdc.conf

Initialisieren der Datenbank

 :/$ kdb5_util create -s

Anlegen der Principals

Wir benötigen zunächst zwei Principals. Einen für den Administrator und einen für AFS.

Dazu gehen wir in die Kerberos Console:

 :/$ kadmin.local

und fügen die Principals wie folgt hinzu:

 kadmin.local: ank afsadmin
 kadmin.local: ank -randkey afs

(ank ist die Kurzform von addprinc, was wiederum die Kurzform von add_principal ist.)

Jetzt extrahieren wir den Schlüssel für AFS

 kadmin.local:  ktadd -e des-cbc-crc:afs3 -k /etc/krb5.keytab.afs afs

Nun lassen wir uns den Principal anzeigen:

 kadmin.local: getprinc afs

Ihr solltet ungefähr sowas sehen:

 Principal: afs@EXAMPLE.COM
 Expiration date: [never]
 Last password change: Wed Mar 29 23:24:32 CEST 2006
 Password expiration date: [none]
 Maximum ticket life: 0 days 10:00:00
 Maximum renewable life: 7 days 00:00:00
 Last modified: Wed Mar 29 23:24:32 CEST 2006 (root/admin@EXAMPLE.COM)
 Last successful authentication: [never]
 Last failed authentication: [never]
 Failed password attempts: 0
 Number of keys: 1
 Key: vno 3 , DES cbc mode with CRC-32, no salt
 Attributes:
 Policy: [none]

In der Zeile "Key: vno 3" könnt ihr die KVNO ablesen. (Wird später gebraucht.) Nun verlassen wir die Console.

 kadmin.local: quit

Starten des Kerberos Servers

  :/$ /etc/init.d/krb5-kdc start
  :/$ /etc/init.d/krb5-admin-server start

OpenAFS

Installation

 apt-get install openafs-client openafs-krb5 openafs-modules-source openafs-dbserver openafs-fileserver

Wir übergeben AFS seinen Schlüssel:

 :/$ asetkey add 3 /etc/krb5.keytab.afs afs

(Die Zahl 3 kommt von der "Key: vno" aus "getprinc afs", es kann auch sein, dass ihr eine andere Zahl bekommt, also bitte darauf achten)

Konfiguration

Zunächst überprüft, daß kein AFS Dienst läuft:

  :/$ ps ax | grep bos

(Sollte einer laufen killt ihn!)

Setzen des Zellnamen

  :/$ echo "example.com" > /etc/openafs/server/ThisCell

Eintrag in die CellServ Datenbank

  :/$ echo ">example.com #Example Cell" > /etc/openafs/server/CellServDB
  :/$ echo "192.168.1.1 #afs.example.com" >> /etc/openafs/server/CellServDB

!ACHTUNG! "#" ist in diesem Fall KEIN Kommentarzeichen!!!!!

Starten des Basic Overseer Servers

  :/$ bosserver -noauth

Das -noauth bewirkt, daß der Bosserver keine Authentifizierung verlangt.

<!> Achtung, in diesem Zustand hat jeder Zugriff auf euren Server!

Starten der einzelnen Dienste

Zunächst setzen wir nochmal über den Bosserver den Zellnamen

  :/$ bos setcellname -server afs.example.com -name example.com -noauth

Nun überprüfen wir, ob unser Server auch wirklich der erste Datenbankserver ist

  :/$ bos listhosts -server afs.example.com -noauth

Starten des Backupservers:

  :/$ bos create -server afs.example.com -instance buserver -type simple -cmd /usr/lib/openafs/buserver -cell example.com -noauth

Der Backupserver ist später dazu da automatisch Backups ganzer Volumensets zu erstellen und sie an einen Tape Coordinator zu schicken

Starten des Protectionservers:

  :/$ bos create -server afs.example.com -instance ptserver -type simple -cmd /usr/lib/openafs/ptserver -cell example.com -noauth

Der Protectionserver übernimmt die Verwaltung der Zugriffsrechte

Starten des Volume Location Servers:

  :/$ bos create -server afs.example.com -instance vlserver -type simple -cmd /usr/lib/openafs/vlserver -cell example.com -noauth

Der Volume Location Server achtet darauf, auf welchen Servern die einzelnen Volumen liegen.

Normalerweise würde man jetzt noch den kasserver starten, der für die Authentifizierung zuständig ist, aber diese Aufgabe übernimmt in unserem Fall der MIT-Kerberos Server

Erstellung des Administrators

Nun erstellen wir den User, den wir vorhin in Kerberos erstellt haben, in der Openafs Datenbank. Dazu erstellen wir ihn erst ganz normal über den Protection Server, fügen ihn der Gruppe "System:administrators" hinzu und erstellen ihn nochmal beim Bosserver.

  :/$ pts createuser -name afsadmin -cell example.com -noauth
  :/$ pts adduser -user afsadmin -group system:administrators -cell example.com -noauth
  :/$ pts membership -name afsadmin -cell example.com -noauth
  :/$ bos adduser -server afs.example.com -user afsadmin -noauth

Starten der restlichen Dienste

  :/$ bos create -server afs.example.com -instance fs -type fs -cmd /usr/libexec/openafs/fileserver usr/libexec/openafs/volserver /usr/libexec/openafs/salvager -cell example.com -noauth

Herrunterfahren des Bosservers

  :/$ bos shutdown -server afs.example.com -noauth
  :/$ /etc/init.d/openafs-fileserver stop

Erstellung des Dateisystems

Der OpenAFS Datenbankserver benötigt min. eine Partition (loop device würde auch gehen). Diese muß ext2 als Dateisystem haben (ob ext3 oder reisefs funktioniert habe ich nicht getestet).

Nun mountet ihr diese nach /vicepa (für jede weitere Partition benutzt /vicepb,/vicepc,...). Sollte das Verzeichnis /afs bei euch noch nicht existieren erstellt es bitte auch noch

  :/$ mkdir /afs

Starten von OpenAFS

  :/$ /etc/init.d/openafs-fileserver start
  :/$ /etc/init.d/openafs-client start

(Achtet darauf, dass der Kerberos Server auch läuft!!)

Erstellung der Verzeichnisstruktur

Zunächst müssen wir uns als Administrator anmelden, da nun der Bosserver ohne das -noauth flags läuft

 :/$ kinit afsadmin
 :/$ aklog

Jetzt können wir zunächst die einzelnen Volumen auf unserer ersten Partition erstellen:

 :/$ vos create afs.example.com /vicepa root.afs -cell example.com
 :/$ vos create afs.example.com /vicepa root.cell -cell example.com
 :/$ vos create afs.example.com /vicepa home -cell example.com

Ich habe dem Volumen wo später die Volumen meiner User drin liegen den Namen "home" gegeben, diesen Namen verwendet ich auch in späteren Scripts.

Mountpoints und Replika erstellen

Zunächst wechseln wir in das AFS Verzeichnis:

 :/$ cd /afs

Und erstellen einen Mountpoint für root.cell sowie einen zweiten mit Schreib/Lese-Rechten.

 :/$ fs mkm /afs/example.com root.cell
 :/$ fs mkm /afs/.example.com root.cell -rw
 :/$ fs mkm /afs/example.com/home home

Nun können die Read-Only Replikas erstellt werden:

 :/$ vos addsite afs.example.com /vicepa root.afs
 :/$ vos release root.afs
 :/$ vos addsite afs.example.com /vicepa root.cell
 :/$ vos release root.cell
 :/$ vos addsite afs.example.com /vicepa home
 :/$ vos release home

Zum Schluß überprüfen wir noch ob auch wirklich alles funktioniert hat und setzen Leserechte für alle User auf /afs und /afs/example.com

 :/$ fs checkvolumes
 :/$ fs sa /afs system:anyuser l
 :/$ fs sa /afs/example.com system:anyuser l

Ihr solltet nun in der Lage sein, in das Verzeichnis /afs/example.com/home zu wechseln.

Gruppe anlegen

 :/$ pts creategroup <group>

Benutzer anlegen

Um einen Benutzer anzulegen, muß dieser in Kerberos und in AFS eingetragen werden:

 :/$ kadmin.local -q "ank <user>"
 :/$ pts createuser <user> -id <uid>
 :/$ pts adduser <user> -group <group>

!ACHTUNG! die <uid> des Users sollte mit der uid des Users im normalen System übereinstimmen, am besten ihr benutzt LDAP oder erstellt auf jedem Rechner den selben User (wird auf dauer vielleicht *etwas* anstrengend)

Verzeichnis anlegen

Da wir im vorherigen Schritt einen User angelegt haben, sollte dieser nun auch ein Verzeichnis bekommen:

Zunächst erstellen wir einen neues Volumen mit maxquota 0 (unendlich), ihr könnt natürlich auch einen exakten Wert benutzen.

 :/$ vos create afs.example.com /vicepa home.<user> -maxquota 0

Danach wird ein Mountpoint in unser home-Volumen erstellt:

 :/$ fs mkm /afs/.example.com/home/<user> home.<user>

Nun noch die Zugriffsrechte setzen und die Änderung übernehmen:

 :/$ fs sa /afs/.example.com/home/<user> <user> all
 :/$ vos release home
 :/$ fs checkvolumes

Zudem erstellen wir noch ein Backup-volumen und erstellen den Mountpoint .backup, dadurch kann der User jederzeit auf das letzte Backup zugreifen.

 :/$ vos backup home.<user>
 :/$ fs mkm /afs/example.com/home/<user>/.backup home.<user>.backup

(Am besten ihr macht daraus ein Bash script *g*)

Um die Sache mit dem Backup ein bißchen zu automatisieren hab ich hier mal ein total schlechtes Bashscript vorbereitet:

 #!/bin/sh
 vos listvol afs.example.com -localauth | sed 's/ .*//' | grep -e ^home | grep -v -e home$ -e readonly$ -e backup$ > /root/backupvol
 exec < /root/backupvol
 while read line
 do
 echo "Creating Backup of $line"
 vos backup $line -localauth
 echo "done"
 done

das ganze kann man nun in einen Crontab packen und jede Nacht durchlaufen lassen.

Backup

Zunächst sollte man sich überlegen, von was man ein Backup machen will, wie oft und wohin? Ich mache derzeit jeden Monat ein Full-Backup (alle Daten werden gesichert) und jeden Tag ein Incrementelles-Backup (Nur die Veränderungen werden gesichert) von den Backup-Volumen und speichere dieses auf einem zweiten Server. Aber ihr könnt euch da frei entfalten wie und wo ihr was machen wollt.

Tape Coordinator

Um ein Backup machen zu können müßt ihr zuerst den Tape Coordinator konfigurieren. Eigentlich ist er dazu gedacht Backups auf ein Tape zu schreiben, aber er kann auch so eingestellt werden, daß er auf eine gewöhnliche Festplatte speichert. Dazu erstelle wir nun zunächst auf dem Backupserver (der Einfachheit halber benutz ich jetzt den selben Server wie für den AFS Datenbank Server) das Verzeichnis "backup"

 :/$ mkdir /var/lib/openafs/backup

In diesem Verzeichnis erstellen wir zuerst die Konfigurationsdatei des Tape Coordinators:

/var/lib/openafs/backup/tapeconfig:

 500GB 0 /dev/FILE 0

die 500GB ist der freie Speicherplatz auf der jeweiligen Backupfestplatte. Jetzt erstellen wir die Konfiguration für unser *imaginäres* Tape-Device (/dev/FILE)

/var/lib/openafs/backup/CFG_FILE:

 FILE YES
 MOUNT /root/afsbackup
 UNMOUNT /root/afsbackup
 NAME_CHECK No
 ASK No

In dieser Konfigurationsdatei teilen wir dem Tape Coordinator mit, daß das Backup-Tape in Wirklichkeit eine Datei ist (FILE YES) und geben ihm auch gleich den Pfad zu einem Script an, welches er beim Mounten/Unmounten eines Tapes (wenn er sozusagen mit dem Backup anfangen will) ausführen soll, zudem soll er uns nicht nach weiteren Tapes fragen und keine Namensüberprüfung bei den Tapes durchführen. Dieses ist nützlich, da das ganze später automatisiert werden soll.

Nun fehlt nur noch das genannte Script, welches ich von der offiziellen OpenAFS Dokumentation übernommen habe

/root/afsbackup:

 #! /bin/csh -f
 set devicefile = $1
 set operation = $2
 set tries = $3
 set tapename = $4
 set tapeid = $5
 set exit_continue = 0
 set exit_abort = 1
 set exit_interactive = 2
 #--------------------------------------------
 if (${tries} > 1) then
 echo "Too many tries"
 exit ${exit_interactive}
 endif
 if (${operation} == "labeltape") then
 echo "Won't label a tape/file"
 exit ${exit_abort}
 endif
 if ((${operation} == "dump") |\
 (${operation} == "appenddump") |\
 (${operation} == "restore") |\
 (${operation} == "savedb") |\
 (${operation} == "restoredb")) then
 /bin/rm -f ${devicefile}
 /bin/ln -s /pfad/zum/backup/${tapename}_${tapeid} ${devicefile}
 if (${status} != 0) exit ${exit_abort}
 endif

 exit ${exit_continue}

Nun können wir den Tape Coordinator mal starten, wie ich bereits erwähnte habe ich zum testen den Tape Coordinator auf dem selben Server wie den OpenAFS Datenbank Server laufen, deshalb benutze ich hier das -localauth flag, solltet ihr zwei Server benutzen, müßt ihr entweder die ?KeyFile von AFS auf den anderen Server kopieren oder für das Backup einen neuen User anlegen der die entsprechenden Berechtigungen hat.

 :/$ butc -localauth

(Am besten ihr startet ihn in einer neuen Console oder gleich über "screen" was am einfachsten geht.)

Buserver

Nun wechseln wir in die interaktive console des Buservers:

 :/$ backup

Dort erstellen wir zunächst ein Volumeset, d.h. es wird nicht ein einziges Volumen gesichert sondern eine beliebige Anzahl die einem bestimmten Regulären Ausdruck entspricht. Über addvolset geben wir dem Volumenset einen eindeutigen Namen.

 backup> addvolset -name home
 backup> addvolentry -name home -server afs.example.com -partition /vicepa -volumes home..*.backup

Nun fügt euren Backupserver der Hostliste hinzu

 backup> addhost -tapehost afs.example.com -portoffset 0

Und erstellt ein Dumplevel, die Struktur ist eine relativ einfache Baumstruktur, ganz oben steht das Full-Dump und alle unteren sind Incrementelle-Dumps des Full-Dumps (und die darunter wieder Incrementelle des übergeordneten Incrementellen-Dumps)

 backup> adddump -dump /week -expires 6d

Wenn ihr alles zu eurer Zufriedenheit eingestellt habt können wir unseren ersten Dump ausführen

 backup> dump -volumeset home -dump /week -portoffset 0

Überprüft dabei beide Consolen sowohl die Backup Console wie auch die, wo der Tape Coordinator läuft

PAM

 :/$ apt-get install libpam-krb5 libpam-openafs-session

http://www.openafs.org http://web.mit.edu/kerberos http://grand.central.org