Differences between revisions 7 and 8
Revision 7 as of 2008-01-10 21:39:24
Size: 15839
Comment:
Revision 8 as of 2009-03-16 03:33:38
Size: 15839
Editor: anonymous
Comment: converted to 1.6 markup
No differences found!

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: EXAMPLE.COM: Kerberos Realm (ersetzt diesen bitte durch euren Domainnamen in Großbuchstaben) krb.example.com: Kerberos KDC Server Adresse afs.example.com: OpenAFS Datenbank Server example.com: OpenAFS Zelle afsadmin: Name des AFS Administrators home: Home Volumen

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 (Da AFS meines Wissens *noch* nicht alle Verschlüsselungstypen versteht erstellen wir eine Schlüssel mit nur einem Typ)

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]

Hier könnt ihr die KVNO ablesen. Nun verlassen wir die Console und übergeben AFS seinen Schlüssel

  • kadmin.local: quit

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

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

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

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 afs.example.com example.com -noauth

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

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

Starten des Backupservers:

  • :/$ bos create server buserver simple /usr/libexec/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 ptserver simple /usr/libexec/openafs/ptserver -cell example.com -noauth

Der Protectionserver übernimmt die Verwaltung der Zugriffsrechte

Starten des Volume Location Servers:

  • :/$ bos create server vlserver simple /usr/libexec/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 afsadmin system:administrators -cell example.com -noauth :/$ pts membership afsadmin -cell example.com -noauth :/$ bos adduser afs.example.com afsadmin -noauth

Starten der restlichen Dienste

  • :/$ bos create afs.example.com fs fs /usr/libexec/openafs/fileserver usr/libexec/openafs/volserver /usr/libexec/openafs/salvager -cell example.com -noauth

Herrunterfahren des Bosservers

  • :/$ bos shutdown afs.example.com -noauth

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

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 :/$ fs mkm /afs/.example.com/home home :/$ 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