# [HOWTO] OpenAFS

## Ey

Bon voilà je me lance, pour mon premier howto j'ai décidé de faire simple.

Oui ça a l'air long mais c'est essentiellement une reprise de ce qui se trouve sur gentoo.org avec les modifications nécessaire suite au renomage des fichiers de conf. Il y a aussi quelques petites choses qui proviennent de la doc officielle de openafs.

Vous pouvez trouver ces 2 docs ici :

Documentation de gentoo.org en français

Documentation de gentoo.org en anglais (en partie mise à jour)

La documentation officielle de OpenAFS (en anglais)

J'ai fait ce howto parce que la doc sur gentoo.org n'est pas forcément à jour (la version anglaise n'est pas beaucoup plus à jour). Je conseille quand même sa lecture car elle est plus précise que mon howto sur bien des points.

Pour les moins téméraires j'ai quand même refait une petite introduction.

Qu'est ce que AFS ?

AFS est un système de fichiers réseau (i.e: accessible à travers une connexion réseau) distribué (i.e: dont les fichiers peuvent ne pas se situer sur un seul serveur). AFS est donc similaire à NFS ou Samba pour le côté système de fichier réseau mais ajoute à cela un aspect distribué.

AFS dispose aussi d'un système de liste de contrôle d'accès (ACL) absent de la NFS. Son implémentation disponible sous linux (openafs) existe pour la partie serveur comme la partie client sur un très grand nombre de plateformes (Linux, AIX, HP-UX, IRIX, OpenBSD, Solaris, MacOS X et Windows). Il peut donc parfaitement servir de système de fichiers réseau standard sur l'ensemble d'un parc informatique.

Quelques notions sur AFS

Un ensemble de partitions AFS est appelé une cellule. Chaque cellule est indépendante et dispose de sa propre liste d'utilisateurs, de ses ACLs, de ses serveurs de fichiers. (Un client peut se connecter à plusieurs cellules)

Les partitions sont appelées des volumes. Les volumes sont mountés à des points de l'arborescence de la cellule de façon identique au monde UNIX. Les volumes sont répartis sur les différents serveurs de la cellule, chaque volume peut se trouver sur plusieurs serveurs en même temps pour permettre une meilleure disponibilité du volume (attention toutefois il faut mettre en place un moyen de réplication du volume. Cette fonctionnalité n'est donc souvent utilisée que pour des cellules contenant uniquement des fichiers qui ne changent que rarement). En parcourant l'arborescence d'une cellule on peut donc passer d'un serveur de fichier à un autre en changeant de répertoire.

Les volumes sont stockés dans des partitions locale du serveur de fichier et peuvent à l'aide des outils d'administration être déplacé soit d'une partition à une autre sur un serveur de fichier soit même être déplacé d'un serveur de ficheir à un autre pour répartir plus efficacement la charge. Une partition peut héberger autant de volumes que l'on veut le facteur limitant étant bien sur l'occupation disque. 

Pour faire fonctionner tout cela, il existe donc plusieurs types de serveurs dans une cellule AFS (ou plutôt plusieurs services pouvant être hébergés sur des serveurs différents) :

Les services de la cellulevlserver : volume location serveur est la base de donnée référençant les serveurs hébergeant les différents volumes

kaserver : c'est le serveur d'authentification, il s'agit en fait d'un serveur kerberos 4. Il est aussi possible d'utiliser un serveur kerberos 5 externe à openafs pour réaliser l'authentification, mais n'ayant pas exploré cette possibilité je laisse à d'autre le soin de la détailler.

buserver : c'est le serveur responsable des backups

ptserver : le serveur qui gère la base de données des ACLs

Les services d'un serveur de fichiersfileserver

volserver

salvager

Petite photo-finish avant de se lancer

Avant d'expliquer comment installer tout ce beau monde, je vais commencer par donner un aperçu de ce que ça donne une fois fini.

Le répertoire /afs est automatiquement créé et mounté lors du démarrage du client afs. L'arrêt du client afs entraine le unmount de /afs. C'est le seul point de montage visible sur le poste client. Les cellules sont accessible via /afs/nom-de-la-cellule et on accède au fichier mon/fichier du volume volume/machin de la cellule ma-cellule en allant dans /afs/ma-cellule/volume/machin/mon/fichier.

Installation de OpenAFS

L'installation de openafs sous gentoo se fait sans difficulté, il suffit de demander a portage. Pour les téméraires il y a un useflag kerberos pour kerberos5.

```
emerge openafs
```

On a maintenant un client configuré pour se connecter sur les cellules publiques standard et le serveur n'est absolument pas configuré pour le moment. La configuration du client est dans /etc/openafs (celle du serveur dans /etc/openafs/server).

Les fichiers intéressant sont ThisCell et CellServDB. ThisCell contient le nom de la cellule, CellServDB les informations permettant de contacter les différentes cellules.

Le fichier qu'il est particulièrement important de regarder est /etc/openafs/cacheinfo, car le répertoire qu'il utilise doit impérativement être sur une partition ext2 (ou du moins pas sur une reiserfs, je ne sais pas trop ce qu'il en est pour xfs et co) sinon le client refusera de démarrer.

Le client se démarre via la commande 

```
/etc/init.d/openafs-client start
```

.

L'authentification se fait à l'aide de la commande klog.

Mise en place d'une cellule AFS

Passons donc au vif du sujet, installer une cellule. Cette partie va se focaliser sur les services de la cellule, la partie suivante traitant des services propres au serveur de fichier.

Pour ce faire nous allons donc commencer par supprimer /etc/openafs/ThisCell et /etc/openafs/CellServDB pour le moment. Si vous avez peur de perdre la base CellServDB ne vous inquiétez pas elle est dans /usr/share/doc/openafs-1.4.1/CellServDB.gz. Il est probablement préférable d'arrêter le client avant cette étape si il est démarré (/etc/init.d/openafs-client stop).

```
cd /etc/openafs/

rm ThisCell CellServDB
```

Puis nous allons démarrer un service qui a pour unique rôle de superviser tous les autres services openafs : bos (Basic OverSeer Server)

```
bosserver -noauth
```

Le -noauth permet de désactiver pour le moment l'authentification vu qu'elle n'est pas encore configurée.

On a à priori maintenant 2 liens symboliques dans /etc/openafs/ vers /etc/openafs/server/(ThisCell|CellServDB).

On va donc maintenant pouvoir donner un nom à notre cellule.

```
bos setcellname <server name> <cell name> -noauth
```

Il va sans dire qu'il faut remplacer <server name> et <cell name> par le nom du serveur (machin.domaine.ext) et le nom de la cellule (usuellement domaine.ext) respectivement.

Il est maintenant temps de démarrer les services de la cellule

```
$ bos create <server name> kaserver simple /usr/libexec/openafs/kaserver -cell <cell name> -noauth

$ bos create <server name> buserver simple /usr/libexec/openafs/buserver -cell <cell name> -noauth

$ bos create <server name> ptserver simple /usr/libexec/openafs/ptserver -cell <cell name> -noauth

$ bos create <server name> vlserver simple /usr/libexec/openafs/vlserver -cell <cell name> -noauth
```

On peut vérifier leur bon fonctionnement grâce à la commande

```
$ bos status <server name> -noauth

Instance kaserver, currently running normally.

Instance buserver, currently running normally.

Instance ptserver, currently running normally.

Instance vlserver, currently running normally.
```

Maintenant il est temps de mettre en place l'authentification dans notre cellule. Pour cela nous allons devoir définir deux choses : un compte permettant au bos de discuter avec le kaserver et un compte administrateur. Le compte administrateur va simplement s'appeler admin dans la suite mais ce n'est pas une obligation. Le serveur bos quand à lui utilise le compte afs.

Première étape : créer les 2 comptes (admin et afs) dans le serveur d'authentifcation (kaserver ou le serveur kerberos 5 pour les courageux).

```
$ kas -cell <cell name> -noauth

ka> create afs

initial_password:

Verifying, please re-enter initial_password:

ka> create admin

initial_password:

Verifying, please re-enter initial_password:

ka> examine afs

User data for afs

key (0) cksum is 2651715259, last cpw: Mon Jun  4 20:49:30 2001

password will never expire.

An unlimited number of unsuccessful authentications is permitted.

entry never expires.  Max ticket lifetime 100.00 hours.

last mod on Mon Jun  4 20:49:30 2001 by <none>

permit password reuse

ka> setfields admin -flags admin

ka> examine admin

User data for admin (ADMIN)

key (0) cksum is 2651715259, last cpw: Mon Jun  4 20:49:59 2001

password will never expire.

An unlimited number of unsuccessful authentications is permitted.

entry never expires.  Max ticket lifetime 25.00 hours.

last mod on Mon Jun  4 20:51:10 2001 by <none>

permit password reuse

ka>
```

(Un petit CTRL+D ou un "quit permettent de sortir de kas)

La commande setfields permet de rendre le compte admin effectivement administrateur.

On déclare maintenant le compte admin dans bos

```
$ bos adduser <server name> admin -cell <cell name> -noauth
```

Et on va indiquer à bos le mot de passe du compte afs utilisé pour se connecter (lorsqu'il demande l'input key, il demande en fait le mot de passe du compte afs)

```
$ bos addkey  <server name> -kvno 0 -cell <cell name> -noauth

input key:

Retype input key:
```

Pour finir notre installation, nous allons créer les entrées dans le service de controle d'accès ptserver pour le compte admin. Cette opération va assigner un uid AFS au compte admin. Cet uid est complètement indépendant des uids unix, mais il est préférable autant que possible d'utiliser le même uid car les commandes systeme de base comme ls se basent sur /etc/passwd pour indiquer le nom du propriétaire d'un fichier.

La définition de l'uid se fait à l'aide du flag -id. 

```
$ pts createuser -name admin -cell <cell name> [-id <AFS UID>] -noauth
```

Puis on ajoute cet utilisateur au groupe administrateur :

```
$ pts adduser admin system:administrators -cell <cell name> -noauth
```

On peut lister les groupes de l'utilisateur grâce à :

```
$ pts membership admin -cell <cell name> -noauth

Groups admin (id: 1) is a member of:

system:administrators
```

Pour terminer on redémarre tous les services de la cellule :

```
$ bos restart <server name> -all -cell <cell name> -noauth
```

Et voilà, on a une cellule.

Mise en place d'un serveur de fichiers

Avant tout il faut disposer d'une partition *VIDE* sur le serveur dans laquelle on va stocker les volumes. Cette partition est mounté dans /vicepa par convention (vicepb pour la deuxième et ainsi de suite jusqu'à vicepz puis vicepaa, vicepab...)

Démarrons les services du serveur de fichiers :

```
$ bos create <server name> fs fs /usr/libexec/openafs/fileserver /usr/libexec/openafs/volserver /usr/libexec/openafs/salvager -cell <cell name> -noauth
```

On peut vérifier que tout le monde tourne bien avec un petit

```
$ bos status <server name> -long -noauth

Instance kaserver, (type is simple) currently running normally.

Process last started at Mon Jun  4 21:07:17 2001 (2 proc starts)

Last exit at Mon Jun  4 21:07:17 2001

Command 1 is '/usr/libexec/openafs/kaserver'

Instance buserver, (type is simple) currently running normally.

Process last started at Mon Jun  4 21:07:17 2001 (2 proc starts)

Last exit at Mon Jun  4 21:07:17 2001

Command 1 is '/usr/libexec/openafs/buserver'

Instance ptserver, (type is simple) currently running normally.

Process last started at Mon Jun  4 21:07:17 2001 (2 proc starts)

Last exit at Mon Jun  4 21:07:17 2001

Command 1 is '/usr/libexec/openafs/ptserver'

Instance vlserver, (type is simple) currently running normally.

Process last started at Mon Jun  4 21:07:17 2001 (2 proc starts)

Last exit at Mon Jun  4 21:07:17 2001

Command 1 is '/usr/libexec/openafs/vlserver'

Instance fs, (type is fs) currently running normally.

Auxiliary status is: file server running.

Process last started at Mon Jun  4 21:09:30 2001 (2 proc starts)

Command 1 is '/usr/libexec/openafs/fileserver'

Command 2 is '/usr/libexec/openafs/volserver'

Command 3 is '/usr/libexec/openafs/salvager'
```

Je pars du principe que l'on est sur le premier serveur de fichiers de la cellule pour la suite des évennements.

On va maintenant créer le volume racine (celui qui contient /afs) :

```
vos create <server name> <partition name> root.afs -cell <cell name> -noauth
```

 où il faut remplacer <partition name> par /vicepa (ou /vicepb, /vicepc, ...)

On démarre ensuite le upserver (c'est un service qui a pour objectif de maintenir les binaires à jour... sachant que gentoo n'est pas franchement une distribution binaire je ne sais pas si il sert vraiment à quelquechose sous gentoo mais la doc de gentoo.org en parle donc...)

```
bos create <server name> upserver simple "/usr/libexec/openafs/upserver -crypt /etc/openafs/server -clear /usr/libexec/openafs" -cell <cell name> -noauth
```

Bien maintenant c'est le moment de ne plus suivre à la lettre la doc de gentoo.org. On va gentilment dévier.

On va créer la root.cell qui est le volume racine de notre cellule.

```
vos create <server name> <partition name> root.cell
```

Pour la suite des évennements il faut démarrer le client openafs.

Avant ça on va arreter les process du serveur openafs et les démarrer normalement.

```
bos shutdown -server <server name> -wait

/etc/init.d/openafs-server start
```

Et maintenant le service client openafs :

```
/etc/init.d/openafs-client start
```

Maintenant que le service est démarré normalement, il faut s'authentifier à la cellule.

```
$ klog -principal admin

Password:
```

En l'absence de -principal, le nom de l'utilisateur est utilisé comme principal.

Ensuite on peut donner l'accès en lecture à tout le monde sur la cellule.

```
fs setacl /afs/<cell name> system:anyuser rl
```

Pour les détails sur les droits AFS, consulter la documentation officielle (en anglais)

Création d'un nouveau volume

La création d'un volument est très simple, il suffit d'utiliser la commande vos create.

```
vos create <server name> <partition> <volume name>
```

Le nom des volumes est limité à 22 caractères. Les volumes mandataires sont root.afs (/afs) et root.cell (/afs/<cell name>).

Le volume une fois créé doit être mounté dans l'arborescence de la cellule. Pour cela il faut utiliser la commande fs mkmount.

```
fs mkmount <mount point> <cell name>
```

Le volume a un quota par défaut de 1 mega. Pour changer le quota il faut utiliser la commande fs setvol. Un quota de 0 signifie qu'il n'y a pas de quota sur ce volume. La taille est exprimée en kilobytes.

```
fs setvol <mount point> -max <quota size>
```

Last edited by Ey on Sun Jun 03, 2007 10:22 am; edited 4 times in total

----------

## cooldje

Merci pour ce guide, je m'interroge actuellement sur l'utilisation de ce système pour le taff  :Very Happy: 

----------

