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.

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.

Installation et Configuration

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

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:

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

Dans /etc/apt/preferences il faut:

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

Ensuite, appeler:

# ~> aptitude update

Installer Tahoe

Il suffit de taper:

# ~> aptitude install python-twisted tahoe-lafs

Pour vérifier, il faut taper:

# ~> tahoe --version

La réponse devrait ressembler à:

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

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.

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.

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.

~ > mkdir .tahoe-introducer
~ > tahoe create-introducer .tahoe-introducer

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.
[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

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.

~ > tahoe start .tahoe-introducer

Ceci devrais créer le fichier ~/.tahoe-introducer/introducer.furl . Il faut garder son contenu sous le coude, qui ressemble à:

pb://flsd4bklaabgk67smgzuhyd5h5yo3ndn@91.224.149.227:44190,127.0.0.1:44190/introducer

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.

~ > tahoe create-node

ou

~ > tahoe create-client

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)
[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

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.
  • 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.
  • 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é.

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é:
    openssl genrsa -out mykey.pem 2048
  • Créer un certificat:
    openssl req -new -x509 -key mykey.pem -out servercert.pem -days 1095
  • Dans le fichier .taohe/tahoe.cfg, éditer la ligne web.port:
    web.port = ssl:3457:privateKey=private/mykey.pem:certKey=private/mycert.pem

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

Utilisation

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:

URI:DIR2:cr465654iwtpwpalmw33e2ouku:w52bopuluy47mx4yiingo344hk5ta5wq63tzjn4bby45cxdadxya

Accès en SFTP via Fuse

Le serveur dois accepter l'accès via SFTP:

$ cd .tahoe
$ ssh-keygen -f private/ssh_host_rsa_key
$ cat "theuser thepassword URI:DIR2:cr465654iwtpwpalmw33e2ouku:w52bopuluy47mx4yiingo344hk5ta5wq63tzjn4bby45cxdadxya" >> private/ftp.accounts

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:

$ mkdir tahoe-sshfs
$ sshfs -o port=8022 -o sshfs_sync -o no_readahead -o cache=no theuser@127.0.0.1:/ ./tahoe-sshfs/

(Pour démonter il faut la commande suivante: )

$ fusermount -u tahoe-sshfs/

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:

rsync -Pa mon_rep_backup/ ./tahoe-sshfs/

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

Démo

Voici un serveur sur lequel j'ai installé un noeud Tahoe: https://87.238.175.129:3457/
(Certificat self-signé).

J'ai créé une URI:
URI:DIR2-RO:5476xjdxkci4a4vc7vzpgahdxe:76yb3kyycte7otah2iskxdqltm75tqlatbp4lpt6dcynvrkapwbq

ce qui donne l'URL suivante:
https://87.238.175.129:3457/uri/URI:DIR2-RO:5476xjdxkci4a4vc7vzpgahdxe:76yb3kyycte7otah2iskxdqltm75tqlatbp4lpt6dcynvrkapwbq/

Liens divers

Une alternative à TAHOE-LAFS , qui semble plus rapide car appuyant sur GlusterFS, en mode kernel: