h1. Principe de TAHOE-LAFS

Le but de ce tutoriel est de déployer TAHOE-LAFS sur plusieurs machines.

Ce système de fichier distribué écrit en python s'utilise comme un RAID logiciel:
Les données sont découpées et distribués sur les _nœuds de stockage_.

Les _nœuds clients_ permettent d'ajouter, lire, écrire et supprimer des fichiers dans ce système.

*Note:* Un nœud de stockage peut être simultanément un nœud client

Enfin, il existe deux autres types de nœuds:

* Un _introducer_ qui constitue un point de rendez-vous entre tous les nœuds participants (C'est donc aussi un SPOF).
Ce rôle est exclusif, mais rien n'empêche d'installer un nœud client ou stockage sur la même machine.
* Un ou plusieurs _helpers_, optionnels, qui prennent en charge à la place d'un nœuds client l'ajout de fichiers dans
le système. C'est utile par exemple pour les nœuds clients situés derrière une ligne ADSL, car l'ajout de fichiers
implique la réplication. Donc si il faut répliquer 3 fois les données, alors il faut les envoyer 3 fois: Vu la bande
passante d'upload d'une ligne ADSL ça peux devenir lourd. Un helper récupère donc ces données, et se chargent de les
distribuer sur les nœuds de stockage. Il est donc intéressant qu'un helper soit aussi un nœuds de stockage, et qu'il
soit sur une ligne rapide.

Le système TAHOE-LAFS ne respecte pas la sémantique POSIX, et défini plusieurs rôles pour l'accès aux fichiers, qui
se traduisent par des URL d'accès aux fichiers différents.

Pour accéder au système de fichier, il est souhaitable qu'une machine ait installé et fasse tourner un
noeud. Néanmoins il est possible d'accéder à un nœuds à distance, par l'interface Web ou par SSH.

h2. Objectif

Mon objectif a été de faire un système sécurisé avec lequel on puisse échanger des données de manière privés, mais
aussi de créer un système de backup privé, ou encore un système de stockage type "cloud" privé.

*Note:* J'ai cherché à faire un montage type "JBOD", sans redondance donc, pour maximiser l'espace disque disponible.

Pour manipuler les fichiers, TAHOE-LAFS dispose de plusieurs interface:

* Ligne de commande _tahoe [...]_
* Interface Web locale
* FTP/SFTP, utilisable en particulier avec sshfs.

Dans un version future il est prévu que tahoe-lafs puisse automatiquement insérer dans le système de fichier
des fichiers qui sont ajoutés à un répertoire.

Je ne décrirais pas tous les mécanismes possible mais seulement ceux que j'ai mis en œuvre.

h1. Installation et Configuration

Cette page décrit comment monter un cluster Tahoe sur Debian, y compris en VM.

h2. Distribution

La distribution Debian/SID (testing) a packagé une version récente de Tahoe-LAFS.

Sur une version stable (actuellement: Squeeze) , nous allons déclarer les packages SID en mode non prioritaires.

Dans _/etc/apt/source.list_ il faut:
<pre>
deb http://ftp.fr.debian.org/debian squeeze main
deb http://ftp.fr.debian.org/debian sid main contrib non-free
deb http://security.debian.org/ sid/updates main contrib non-free
</pre>

Dans _/etc/apt/preferences_ il faut:
<pre>
Package: *
Pin: release o=apt-build
Pin-Priority: 989

Package: *
Pin: release o=Debian,a=stable,l=Debian-Security
Pin-Priority: 987

Package: *
Pin: release o=Debian,a=stable,l=Debian
Pin-Priority: 985

Package: *
Pin: release o=Debian,a=testing,l=Debian-Security
Pin-Priority: 99

Package: *
Pin: release o=Debian,a=testing,l=Debian
Pin-Priority: 97
</pre>

Ensuite, appeler:

<pre># ~> aptitude update</pre>

h2. Installer Tahoe

Il suffit de taper:

<pre># ~> aptitude install python-twisted tahoe-lafs</pre>

Pour vérifier, il faut taper:

<pre># ~> tahoe --version</pre>

La réponse devrait ressembler à:
<pre>
allmydata-tahoe: 1.8.3,
foolscap: 0.6.1,
pycryptopp: 0.5.29,
zfec: 1.4.5,
Twisted: 11.0.0,
Nevow: 0.10.0,
zope.interface: unknown,
python: 2.6.7,
platform: Linux-debian_6.0.2-x86_64-64bit_ELF,
pyOpenSSL: 0.13,
simplejson: 2.2.0,
pycrypto: 2.3,
pyasn1: unknown,
mock: 0.7.2,
sqlite3: 2.4.1 [sqlite 3.7.3],
setuptools: 0.6 [distribute]

Warning: dependency twisted-web (version 11.0.0) found by pkg_resources not found by import.
Warning: dependency twisted-core (version 11.0.0) found by pkg_resources not found by import.

For debugging purposes, the PYTHONPATH was
None
install_requires was
['setuptools >= 0.6c6', 'zfec >= 1.1.0', 'simplejson >= 1.4', 'zope.interface', 'Twisted >= 2.4.0', 'foolscap[secure_connections] >= 0.6.1', 'Nevow >= 0.6.0', 'pycrypto == 2.0.1, == 2.1.0, >= 2.3', 'pyasn1 >= 0.0.8a', 'mock', 'pycryptopp >= 0.5.20']
sys.path after importing pkg_resources was
/usr/bin:
/usr/lib/python2.6:
/usr/lib/python2.6/plat-linux2:
/usr/lib/python2.6/lib-tk:
/usr/lib/python2.6/lib-old:
/usr/lib/python2.6/lib-dynload:
/usr/local/lib/python2.6/dist-packages:
/usr/lib/python2.6/dist-packages:
/usr/lib/pymodules/python2.6
</pre>

*Attention:* S'assurer que la version est au moins 1.8.3 : Les version précédentes ont un problème de sécurité qui permet à un attaquant de supprimer des fichiers sans autorisation.

h1. Déploiement

J'ai voulu l'architecture suivante:

- obinou.tetaneutral.net: Introducer (VPS)
- vps205: Stockage, 20Go (VPS)
- tavernier: Stockage, 100Go (chez moi, donc derrière une ADSL)
- baileys: Client (chez moi, machine à sauvegarder)
- obconseil.eu: Client (source de fichiers a partagé de manière privée)

A venir: Un GuruplugServer à Tetaneutral (Stockage, 1.5 To) qui remplacera aussi obinou.tetaneutral.net.

*Note:* Les commandes sont a faire en tant qu'utilisateur. Tahoe-Lafs n'a jamais besoin de tourner en tant que _root_.

h2. Installation de l'introducer

*Note:* Il est indispensable que l'introducer soit accessible en direct depuis tous les autres nœuds. Dans le cas d'un système de fichier distribué sur Internet, il est donc nécessaire que soit l'introducer soit sur une machine publique, soit qu'une redirection de port soit mise en place.

<pre>
~ > mkdir .tahoe-introducer
~ > tahoe create-introducer .tahoe-introducer
</pre>

Ensuite il est possible d'éditer le fichier _~/.tahoe-introducer/tahoe.cfg_ et d'y modifier

* Le nom de ce nœud introducer,
* Le port d'écoute de l'interface web de monitoring de cet introducer.

<pre>
[node]
nickname = obinou_tetaneutral_introducer
web.port = tcp:3457
web.static = public_html
#tub.port =
#tub.location =
#log_gatherer.furl =
#timeout.keepalive =
#timeout.disconnect =
#ssh.port = 8022
#ssh.authorized_keys_file = ~/.ssh/authorized_keys
</pre>

*Note*: L'introducer est le seul nœud sur lequel on peux savoir la liste des nœuds connectés (stockage et clients), et d'autres
infos globales. Les autres nœuds n'ont qu'une vision partielle du cluster.
Il est donc *critique* de ne PAS laisser accessible cette interface web, soit en la protégeant via un firewall, soit en la désactivant.
Pour cela il suffit de laisser la variable _web.port_ vide.

*Note*: L'introducer n'est nécessaire qu'au démarrage du système et à l'ajout de nouveaux nœuds. En fonctionnement, le système de fichier
distribué marche très bien sans lui.

<pre>
~ > tahoe start .tahoe-introducer
</pre>

Ceci devrais créer le fichier *~/.tahoe-introducer/introducer.furl* . Il faut garder son contenu sous le coude, qui ressemble à:
<pre>pb://flsd4bklaabgk67smgzuhyd5h5yo3ndn@91.224.149.227:44190,127.0.0.1:44190/introducer</pre>

h2. Création des nœuds de stockage ou d'un nœud client

*Note:* Un tel nœud peut être installé sur la même machine que l'introducer.

<pre>
~ > tahoe create-node
</pre>

ou

<pre>
~ > tahoe create-client
</pre>

selon le cas souhaité.

Par défaut les fichiers sont créés dans _~/.tahoe_

Ensuite il est possible d'éditer le fichier _~/.tahoe/tahoe.cfg_ et d'y modifier

* Le nom de ce nœud de stockage,
* Le port d'écoute de l'interface web de monitoring/accès de ce nœud.
* La spécification de l'introducer (contenu du fichier _~/.tahoe-introducer/introducer.furl_ comme ci-dessus)
* Le choix de savoir si ce nœud est un Helper (En général oui si la machine est derrière une ligne avec un upload rapide)
* Le choix de savoir si ce nœud doit utiliser un Helper (car un nœud de stockage est aussi potentiellement client)

<pre>
[node]
nickname = obinou_tavernier
web.port = tcp:3456:interface=127.0.0.1
web.static = public_html
tub.port = tcp:8097
tub.location = obconseil.pck.nerim.net:8097,192.168.1.100:8097,127.0.0.1:8097
#log_gatherer.furl =
#timeout.keepalive =
#timeout.disconnect =
#ssh.port = tcp:8022
#ssh.authorized_keys_file = ~/.ssh/authorized_keys

[client]
# Which services should this client connect to?
introducer.furl = pb://flsd4bklaabgk67smgzuhyd5h5yo3ndn@91.224.149.227:44190,127.0.0.1:44190/introducer
helper.furl = pb://tkrtft5tj7qfa2zavoobtio3noqug6kt@87.238.175.129:41817,127.0.0.1:41817/5lsivzdkckjhg6iip4jfjfopegvkxzm2
#key_generator.furl =
#stats_gatherer.furl =

# What encoding parameters should this client use for uploads?
shares.needed = 1
shares.happy = 1
shares.total = 2

[storage]
# Shall this node provide storage service?
enabled = true
#readonly =
reserved_space = 100G
#expire.enabled =
#expire.mode =

[helper]
# Shall this node run a helper service that clients can use?
enabled = false

[sftpd]
enabled = true
port = tcp:8022:interface=127.0.0.1
host_pubkey_file = private/ssh_host_rsa_key.pub
host_privkey_file = private/ssh_host_rsa_key
accounts.file = private/ftp.accounts
</pre>

Valeurs importantes:

* nickname: Le nom du nœud
* web.port: Le port & l'interface de l'interface Web, qui est aussi une interface JSON. La mise en place du HTTPS est possible. JSON
* tub.port , tub.location: Si le nœud est derrière un NAT, il faut spécifier ici l'IP/nom public. Il faut aussi rediriger le port au niveau du routeur.
* ssh.port, ssh.authorized_key_file: Ceci créer une interface CLI directe (A mon avis redondant avec la commande tahoe [..]
* introducer.furl: La référence de l'Introducer
* helper.furl: La référence d'un Helper, si l'un est utilisé
* shares.needed: Nombre minimal de fragment de fichiers a générer. 1 veux dire "Tout le fichier".
* shares.happy: Nombre de fragment à disperser. 1 veux dire : Si 1 fragment est diffusé sur 1 noeud de stockage, l'ajout de ce fichier est un succès. success.
* shares.total: Nombre maximal de fragment qui seront dispersé (redondance)
* [storage] enabled: Active la fonction "noeud de stockage". C'est la seule différence entre un noeud client & un noeud de stockage.
* reserved_space: Taille de l'espace de stockage alloué.
* [helper] enabled: A _True_ si ce noeud fait office de Helper (Ligne en upload rapide). Activer ce flag crée le fichier _~/.tahoe/private/helper.furl_ , dont le contenu ira dans la clé _helper.furl_ des nœuds qui voudront utiliser ce helper.
* [sftpd] enabled: Active le service de loopback SFTP
* [sftpd] port,host_pubkey_file, host_privkey_file: Configuration du service SFTP
* [sftpd] accounts.file: Liste des user/password acceptés pour le service sftp. Ce ne sont PAS les comptes système !



Une fois ceci fait, il suffit d’exécuter *tahoe start* pour lancer la connexion à l'introducer et donc au système distribué.

h2. Configuration du HTTPS sur l'interface HTTP de contrôle.

Si l'on veux mettre à disposition un serveur HTTP public il est préférable de le placer en SSL.

Il faut, dans cet ordre:

* Aller dans le dossier .tahoe/private/
* Créer une clé privé: <pre>openssl genrsa -out mykey.pem 2048</pre>
* Créer un certificat: <pre>openssl req -new -x509 -key mykey.pem -out servercert.pem -days 1095</pre>
* Dans le fichier _.taohe/tahoe.cfg_, éditer la ligne _web.port_:
<pre>web.port = ssl:3457:privateKey=private/mykey.pem:certKey=private/mycert.pem</pre>

*Attention* La ligne ci-dessus *ouvre* le serveur web à toutes les clients, et non
seulement sur la machine locale...

h1. Utilisation

h2. Interface HTTP

Sur l'un des noeuds, il suffit de pointer le navigateur sur http://127.0.0.1:3456.
On arrive alors sur l'interface Web de contrôle, qui permet de créer des répertoires et naviger les
répertoires existants. Il faut pour cela connaitre l'URI du point d'entré dans le système de fichier.

Il est possible créer ce point d'entré depuis l'interface web elle-même, ou via la ligne de commande.

Voici à quoi ressemble une URI:
<pre>URI:DIR2:cr465654iwtpwpalmw33e2ouku:w52bopuluy47mx4yiingo344hk5ta5wq63tzjn4bby45cxdadxya</pre>

h2. Accès en SFTP via Fuse

Le serveur dois accepter l'accès via SFTP:
<pre>
$ cd .tahoe
$ ssh-keygen -f private/ssh_host_rsa_key
$ cat "theuser thepassword URI:DIR2:cr465654iwtpwpalmw33e2ouku:w52bopuluy47mx4yiingo344hk5ta5wq63tzjn4bby45cxdadxya" >> private/ftp.accounts
</pre>

On constate que chaque user est lié à une URI particulière, son "point d'entré" dans le système de fichier.

Ensuite il suffit de monter ce SFTP en local:
<pre>
$ mkdir tahoe-sshfs
$ sshfs -o port=8022 -o sshfs_sync -o no_readahead -o cache=no theuser@127.0.0.1:/ ./tahoe-sshfs/
</pre>

(Pour démonter il faut la commande suivante: )
<pre>$ fusermount -u tahoe-sshfs/</pre>

*Attention*: Après test, il s'avère que rsync par exemple ne sais pas détecter les différences entre les fichiers.

Donc une ligne comme celle-ci:

<pre>rsync -Pa mon_rep_backup/ ./tahoe-sshfs/</pre>

Copiera tout le répertoire systématiquement. Comme l'opération est longue, ca peut être un problème.



h1. Liens divers

* http://bigasterisk.com/tahoe-playground/
* http://juralibre.net/~sebastien/wiki/doku.php?id=tahoe-lafs