goffi goffi
later messages

Importer un blog Dotclear dans XMPP

Articles précédents de la série : Installer une instance de Libervia (SàT) en moins de 10 min et Configuration avancée du conteneur Libervia

Pour le troisième article de cette série sur l'installation d'un blog XMPP avec Libervia, je vais vous montrer comment importer un blog Dotclear.

Notez bien que ceci marchera avec Libervia/Salut à Toi, mais devrait fonctionner également avec Movim, ou Jappix, ou autre futur client XMPP gérant le blogage.
Aussi, je parle ici de Dotclear, mais nous avons un système générique d'imports avec pour le moment 2 « importeurs » : Dotclear et Dokuwiki. Dotclear a été choisi car c'est celui que j'ai utilisé pour mon blog, mais le principe est le même si vous voulez importer du Dokuwiki.

À terme, et selon la demande (et notre temps disponible — ou les contributions), nous pourrons ajouter d'autres importeurs, Wordpress ou Pelican par exemple.

J'en profite pour remercier les équipes derrière Dotclear, c'est un moteur de blog que j'ai utilisé pendant plusieurs années et qui est vraiment bien fait. Peut-être qu'un jour il communiquera aussi via XMPP, qui sait ?

Préparation des données à importer

La première chose à faire est d'exporter le blog depuis Dotclear. Pour cela il faut vous rendre dans la console d'administration, puis cliquer sur la section maintenance :

maintenance

Ensuite cliquez sur l'onglet « Backup » (Sauvegarde), selectionnez « Download database of current blog » (charger la base de données du blog courant) puis cliquez sur « Execute task » (Lancer la tâche) :

onglet backup

Vous n'avez plus qu'à sélectionner le répertoire où sauvegarder votre fichier, vous devriez avoir un fichier avec un nom similaire à 2016-03-21-15-15-default-backup.txt.

Utilisation de jp avec le conteneur

Pour le moment, seul le frontal en ligne de commande de « Salut à Toi », jp, permet l'import.
L'idéal serait de l'avoir installé en local sur votre machine, mais comme jusqu'ici nous avons utilisé les conteneurs Docker, continuons avec.

« Salut à Toi » va avoir besoin d'accéder à la sauvegarde Dotclear que nous avons générée précédemment. Comme les conteneurs sont isolés du système de fichier, nous allons devoir demander à Docker de monter le répertoire parent via SAT_CONT_DK_EXTRA, que nous avons vu dans les précédents articles :

export SAT_CONT_DK_EXTRA="-v /tmp/dotclear_backup:/backup"

remplacez « /tmp/dotclear_backup » par le chemin vers le répertoire où se trouve votre sauvegarde. Il faut ensuite redémarrer les conteneurs pour que cela soit pris en compte :

./libervia_cont.sh restart -p

Comme indiqué sur la page wiki des conteneurs, il est possible d'utiliser jp avec le conteneur « Salut à Toi » en utilisant la commande suivante :

alias jp-docker="docker run --rm -ti --link sat:sat salutatoi/jp:latest"

à utiliser après avoir lancé les conteneurs bien entendu. Par la suite j'utiliserai jp ou jp-docker indifféremment, utilisez l'alias que vous avez défini ici (soit jp-docker si vous avez gardé le même).

Assurons-nous ensuite que cela fonctionne :

% jp-docker --version
jp 0.6.0D (rev fd959c8f64b6 (default 2016-03-18 10:25 +0100)) Copyright (C) 2009-2016 Jérôme Poisson, Adrien Cossa
This program comes with ABSOLUTELY NO WARRANTY;
This is free software, and you are welcome to redistribute it under certain conditions.

Si vous avez bien le message de version qui s'affiche, tout va bien, sinon venez demander de l'aide sur notre salon XMPP.

C'est la commande jp blog import que l'on va utiliser, vous pouvez voir les options disponibles avec jp blog import --help.

Assurez-vous d'avoir créé un profil (en utilisant le dialogue de création de compte de Libervia par exemple).
Pour utiliser blog import, votre profil doit être connecté, soit depuis Libervia, soit en demandant à jp de le faire avec les arguments -cp goffi --pwd <mot_de_passe> : -c demande la connexion, -p goffi indique que l'on souhaite utiliser le profil « goffi » (à adapter bien sûr), et « --pwd <mot_de_passe> » est explicite.
Une fois votre profil connecté, seule l'option « -p goffi » est nécessaire, sauf si c'est votre profil par défaut (on reviendra sur cette notion une autre fois).

Commençons par voir les importeurs disponibles :

% jp-docker blog import -cp goffi --pwd totototo
dotclear: import posts from Dotclear blog engine
dokuwiki: import posts from Dokuwiki blog engine

Pour avoir des détails sur l'importeur choisi, indiquez son nom tout simplement :

% jp-docker blog import -pgoffi dotclear
dotclear: import posts from Dotclear blog engine

This importer handle Dotclear blog engine.

To use it, you'll need to export your blog to a flat file.
You must go in your admin interface and select Plugins/Maintenance then Backup.
Export only one blog if you have many, i.e. select "Download database of current blog"
Depending on your configuration, your may need to use Import/Export plugin and export as a flat file.

location: you must use the absolute path to your backup for the location parameter

N.B. comme mon profil « goffi » a été connecté avec la commande précédente, je n'utilise plus « -c » ni « --pwd xxx »

Voilà, il n'y a plus qu'à faire l'import, avec la commande suivante (que j'explique ci-dessous) :

jp-docker blog import -pgoffi dotclear /backup/2016-03-21-15-15-default-backup.txt --ignore-tls-errors --host www.goffi.org  -P --upload-ignore-host goffi.org

Explications :

  • jp-docker blog import -pgoffi dotclear /backup/2016-03-21-15-15-default-backup.txt : nous l'avons vu précédemment, on indique d'importer la sauvegarde Dotclear située à /backup/2016-03-21-15-15-default-backup.txt pour le profile « goffi »

  • --ignore-tls-errors indique de ne pas faire d'erreur en cas de certificat invalide, ce qui est le cas de notre certificat auto-signé. Si vous avez installé un certificat valide comme vu dans l'article précédent, vous pouvez ignorer cette option

  • --host www.goffi.org indique le nom du blog originel, c'est nécessaire pour re-construire les chemins relatifs de la sauvegarde

  • -P permet d'afficher une barre de progression

  • --upload-ignore-host goffi.org indique de ne pas téléverser les images en provenance de l'hôte indiqué, en effet par défaut jp blog import va téléverser (« uploader ») via XMPP toutes les images trouvées sur le blog. Ce comportement peut-être désactivé avec l'option --no-images-upload

Et voilà ! À la fin de l'import (qui ne devrait pas être très long sauf si très gros blog, c'est de l'ordre de quelques minutes), vous allez avoir un long texte s'afficher, ce sont les options à copier/coller dans sat.conf (grâce à ./libervia_cont.sh config) dans la section [libervia]. La deuxième option (url_redirections_dict) permet de rediriger les anciennes URL de votre blog vers les nouvelles dans Libervia, évitant ainsi les liens cassés.

Vous pouvez d’ailleurs ajouter vos propres redirections, par exemple j'ai ajoutés celles-là sur mon blog :

url_redirections_dict = {
    "/": "/blog/goffi",
    "/videos": "file:/videos",
    "/feed/atom": "/blog/goffi/atom.xml",
    "/feed/tag/SàT/atom": "/blog/goffi/atom.xml?tag=SàT",
    [ETC]
}

La première redirige la page principale sur mon blog, plutôt que sur la fenêtre de connexion de Libervia. La deuxième permet d'accéder aux vidéos via le chemin absolu /videos (qui est monté comme vu précédemment via SAT_CONT_DK_EXTRA). Enfin les suivantes permettent de garder les liens vers les flux Atom, nécessaire vu que je suis sur plusieurs « planètes » et que je n'avais pas envie de m'amuser à faire changer tous les liens (j'ai tronqué mais vous comprenez le principe).

Il peut également être utile d'ajouter :

allow_registration = false

qui indique à Libervia de ne pas autoriser les enregistrements de nouveaux comptes depuis l'interface, particulièrement intéressant si vous êtes seul sur votre instance, ou si vous voulez créer les nouveaux comptes vous-même uniquement.

À suivre

À ce stade, vous devriez avoir votre blog importé et disponible via Libervia, bienvenu dans le monde des blogs XMPP ! Les avantages d'avoir son blog sur ce standard sont nombreux, et vont aller en grandissant au fur et à mesure que nous ajouterons des fonctionnalités (par exemple la possibilité de mentionner quelqu'un sur un autre blog est à prévoir probablement avant l'été), n'hésitez pas à venir discuter de ça sur notre salon.

Pour le prochain article, sans doute le dernier de cette mini série, je vous expliquerai comment publier sur ce blog.

Configuration avancée du conteneur Libervia

Cet article fait suite à l'article de la semaine dernière indiquant comment installer Libervia en moins de 10 min. Nous allons voir aujourd'hui comment utiliser un certificat TLS existant, intégrer le conteneur dans une configuration Apache, ou lancer automatiquement le service au démarrage de la machine.

Utiliser votre certificat TLS existant

Au premier lancement des conteneurs, un certificat auto-signé est automatiquement créé pour pouvoir utiliser Prosody ou le serveur HTTPS de Libervia. Ce genre de certificat est très bien pour du test, mais d'une part provoquera un avertissement dans les navigateurs, et d'autre part son authenticité n'est assurée par aucun organisme (les certificats TLS sont signés par des organismes que votre navigateur et/ou système connaissent, ce qui permet de les valider – principe qui n'est pas idéal, mais c'est un autre sujet –).

Pour utiliser votre propre certificat plutôt que celui généré par les conteneurs, il faut utiliser la variable d’environnement SAT_CONT_TLS_DIR avec un chemin absolu vers vos certificats.

Il faut qu'à l'intérieur de ce dossier se trouvent les fichiers « libervia.key » pour votre clef privée, et « libervia.crt » pour votre certificat public. Ces noms de fichiers sont fixés car déjà configurés dans Libervia et Prosody, si vous voulez les changer il faudra changer les 2 configurations à l'aide de ./libervia_cont.sh config et ./libervia_cont.sh config prosody, comme indiqué dans le dernier article.

Au niveau des permissions des certificats, vous pouvez les laisser accessibles uniquement au « group ID » 9999 qui correspond au groupe « tls-cert » sur les conteneurs.

Let's Encrypt

Comme Let's Encrypt est (à juste titre) à la mode, voyons voir de plus près ce cas particulier.

Le but ici est de ne pas avoir à changer la configuration à chaque renouvellement, qui ont lieu au plus tard tous les 3 mois. Let's Encrypt met ses certificats (par défaut, adaptez au besoin) dans /etc/letsencrypt/archive/<votre_nom_de_domaine>, mais les noms de fichiers changent à chaque renouvellement, et met un lien symbolique vers les certificats en cours dans /etc/letsencrypt/live/<votre_nom_de_domaine>.
Vous ne pouvez pas utiliser directement /etc/letsencrypt/live/ car vous auriez des liens symboliques pointant dans le vide, il va falloir monter le dossier archive également.

La variable d'environement SAT_CONT_DK_EXTRA permet de spécifier des paramètres pour la commande « docker run » qui seront utilisés pour tous les conteneurs (sauf sat_data). Nous allons l'utiliser pour monter toute l'arborescence letsencrypt, comme suit :

export SAT_CONT_DK_EXTRA="-v /etc/letsencrypt:/etc/letsencrypt"

Il va falloir éditer les configurations de Libervia et Prosody pour pointer vers les bons fichiers.
Pour Libervia, utilisez ./libervia_cont.sh config puis spécifiez dans la section [libervia] :

[libervia]
tls_private_key = /etc/letsencrypt/live/<nom_domaine>/privkey.pem 
tls_certificate = /etc/letsencrypt/live/<nom_domaine>/cert.pem 
tls_chain = /etc/letsencrypt/live/<nom_domaine>/chain.pem

N'oubliez pas l'option tls_chain qui permet de spécifier la chaîne de validation.

Pour prosody, c'est ./libervia_cont.sh config prosody qu'il faut utiliser, vous devez avoir modifié votre option ssl pour qu'elle ressemble à :

ssl = {
        key = "/etc/letsencrypt/live/<nom_domaine>/privkey.pem";
        certificate = "/etc/letsencrypt/live/<nom_domaine>/fullchain.pem";
}

dans les 2 cas il faut bien évidemment remplacer <nom_domaine> par votre nom de domaine tel qu'il apparaît dans /etc/letsencrypt/live. Assurez vous aussi que les permissions sont correctes, vous verrez si Prosody ou Libervia n'arrivent pas à lire les fichiers à l'aide de docker logs -f prosody et docker logs -f libervia respectivement.

Intégration à un serveur Apache

Si vous avez déjà un serveur Apache qui tourne, vous préfèrez sans doute intégrer Libervia à la configuration existante plutôt que sur un port séparé.

Pour cela nous allons utiliser un « proxy inverse » (reverse proxy) qui va rediriger une adresse de votre domaine sur le serveur de Libervia.

Si vous avez une configuration HTTPS, elle sera gérée par Apache lui-même, donc commençons par désactiver le serveur HTTPS de Libervia, et par supprimer le message d'avertissement en cas de connexion HTTP. Éditez sat.conf à l'aide de ./libervia_cont.sh config, et mettez ceci dans la section [libervia] :

[libervia]
connection_type = http
security_warning = 0

Désormais seul le port HTTP sera disponible.

Maintenant, nous allons configurer apache pour qu'il redirige les URL correspondant à votre instance de Libervia vers le serveur. Dans le répertoire /etc/apache2/mods-available/ créez un fichier libervia.conf qui ressemble à peu près à ça :

<VirtualHost *:80>
    ServerName www.<votre-serveur.tld>
    ServerAlias <votre-serveur.tld> libervia.<votre-serveur.tld>
    ServerAdmin webmaster@votre-server.tld
    ErrorLog /var/log/apache2/libervia-error.log
    CustomLog /var/log/apache2/libervia-access.log
    ProxyPass / http://127.0.0.1:8080/ nocanon
    ProxyPassReverse / 127.0.0.1
    AllowEncodedSlashes On
    RequestHeader set X-Forwarded-Proto "http"

    <proxy *>
        Require all granted
    </proxy>
</VirtualHost>

Il faut bien entendu remplacer <votre-serveur.tld> par votre nom de domaine, adapter SeverName et ServerAlias à ce que vous souhaitez utiliser, ainsi que les ports pour qu'ils correspondent à ceux que vous utilisez en pratique (si vous avez tout laissé par défaut, les ports indiqués sont valables).

Quelques explications sur la configuration : Passons sur les premières lignes et VirtualHost qui sont des classiques de configuration Apache, vous trouverez les informations nécessaires facilement sur le web au besoin. Les directives qui nous intéressent ici sont à partir de ProxyPass.

  • ProxyPass indique à Apache de rediriger les connexions sur le serveur local au port 8080, soit l'instance en cours de Libervia. Notez bien le « nocanon » qui est très important, il indique à Apache de ne pas utiliser des adresses canoniques, soit en d'autres terme de ne pas modifier les URLs envoyées à Libervia.
  • ProxyPassReverse concerne les redirections
  • AllowEncodedSlashes est nécessaire pour accepter les URLs contenant des « / » (%2F), qui sont utilisées dans Libervia.
  • RequestHeader permet d'ajouter l'en-tête « X-Forwarded-Proto » indiquant à Libervia le protocol utilisé au niveau du proxy

Quand un proxy est utilisé, l'adresse utilisée « vue » de l'extérieur (http(s)://www.<votre-serveur.tld>/[…]) n'est pas la même que celle utilisée pour accéder par Libervia, qui est ici http://127.0.0.1:8080. Or Libervia a besoin de connaître cette adresse pour construire des chemins absolus vers les documents, par exemple dans le flux Atom.
Normalement, ceci est fait automatiquement et vous n'avez besoin de toucher à rien pour que Libervia utilise les bonnes URL ; mais si jamais les URL produites n'étaient pas correctes, vous pourriez utiliser l'option « base_url_ext » pour forcer l'utilisation de la base indiquée. Ainsi pour forcer l'utilisation de http://www.goffi.org, je peux indiquer ceci dans ma configuration Libervia :

base_url_ext = http://www.goffi.org

Ou même « //www.goffi.org » pour laisser Libervia gérer le schema (c.-à-d. le protocol : http ou https). Encore une fois tout ceci devrait être géré automatiquement (*), et il est très peu probable que vous ayez à utiliser cette option. Venez me contacter sur sat@chat.jabberfr.org pour plus d'explications si nécessaire.

Une fois la configuration faite, il vous suffit pour activer le proxy de demander à Apache de prendre en compte la nouvelle configuration. Nous allons également nous assurer que le mode proxy_http est activé, aussi nous allons utiliser les commandes suivantes (en root) :

# a2enmod headers
# a2enmod proxy_http
# a2ensite libervia.cont
# systemctl reload apache2

(*) si vous avez téléchargé les images la dernière fois, ce comportement a été modifié depuis, c'est l'occasion de tester « ./libervia_cont.sh update ».

Utilisation d'un cache

Apache a des modules permettant la gestion d'un cache, qui permettra à la fois d'économiser les ressources, et de fournir la dernière page connue en cas d'indisponibilité du serveur (lors d'une maintenance par exemple). Dans le cas de Libervia, c'est principalement utile pour le blog statique.

Assurez-vous d'abord que le cache est activé à l'aide de :

 # a2enmod cache_disk

qui activera à la fois les modules cache et cache_disk. Ensuite à l'intérieur de la configuration du VirtualHost que nous avons faites plus haut :

<IfModule mod_cache_disk.c>
    CacheEnable disk /
    CacheRoot "/var/cache/apache2/mod_cache_disk/libervia/"
    CacheDirLevels 3
    CacheDirLength 5
    CacheIgnoreHeaders Set-Cookie
    CacheMaxFileSize 200000000
    CacheIgnoreNoLastMod On
    CacheDefaultExpire 300
</IfModule>

Vous pourrez vous reporter à la documentation pour la plupart des directives utilisées ici, mais il est nécessaire d’en préciser quelques-unes :

  • CacheIgnoreHeaders Set-Cookie évitera de mettre en cache les cookies qui sont utilisés pour la session dynamique de Libervia, cette directive est essentielle pour la sécurité
  • CacheIgnoreNoLastMod On permet de mettre en cache des documents qui ne possèdent pas de date de dernière modification, ce qui est le cas actuellement des pages servies par Libervia
  • CacheDefaultExpire indique un cache qui expire après 10 min. Libervia ne gère pas (encore) les indications nécessaires à une gestion automatique du cache, aussi on indique ici la durée voulue. Le cache étant essentiellement utilisé pour le blog statique, j'ai mis 10 min pour qu'une mise à jour apparaîsse suffisament vite.

À moins d'avoir un site extrêmement populaire, il ne devrait pas y avoir de problème de performance pour le blog statique même sans cache, il est à mon sens surtout utile ici pour continuer à servir les pages pendant les maintenances.

Utilisation de tls

L'utilisation de TLS n'est pas plus compliquée que pour un autre site Apache.
Voici à quoi peut ressembler une configuration si vous activez le proxy, le chiffrement TLS, et un cache :

<IfModule mod_ssl.c>
<VirtualHost *:443>
        ServerName www.<votre_site.tld>
        ServerAlias <votre_site.tld> libervia.<votre_site.tld>
        ServerAdmin webmaster@<votre_site.tld>
        LogFormat "h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\" %{cache-status}e" with_cache
        ErrorLog /var/log/apache2/libervia-error.log
        CustomLog /var/log/apache2/libervia-access.log with_cache
        ProxyPass / http://127.0.0.1:8080/ nocanon
        ProxyPassReverse / http://127.0.0.1:8080/
        AllowEncodedSlashes On

        <proxy *>
                Require all granted
        </proxy>
        SSLCertificateFile /etc/letsencrypt/live/<votre_site.tld>/cert.pem
        SSLCertificateKeyFile /etc/letsencrypt/live/<votre_site.tld>/privkey.pem
        Include /etc/letsencrypt/options-ssl-apache.conf
        SSLCertificateChainFile /etc/letsencrypt/live/<votre_site.tld>/chain.pem

        <IfModule mod_cache_disk.c>
                CacheEnable disk /
                CacheRoot "/var/cache/apache2/mod_cache_disk/libervia/"
                CacheDirLevels 3
                CacheDirLength 5
                CacheIgnoreHeaders Set-Cookie
                CacheMaxFileSize 200000000
                CacheIgnoreNoLastMod On
                CacheDefaultExpire 300
        </IfModule>

</VirtualHost>
</IfModule>

Notez que le « RequestHeader set X-Forwarded-Proto » a désormais la valeur "https" ainsi que le « with_cache » dans les logs, ajoutant des informations utiles (est-ce que la page est servie par le cache ou Libervia ?).

Pour le reste, reportez-vous à la documentation Apache.

Démarrage automatique

Dernier point de cette partie sur la configuration avancée, nous allons voir comment lancer automatiquement notre instance de Libervia au démarrage de la machine. Nous allons pour cela utiliser SystemD qui est désormais le gestionnaire de démarrage par défaut de la plupart des distributions, donc probablement de la vôtre.
Il vous suffit d'utiliser une configuration similaire à la suivante, dans un fichier libervia.service à placer dans /etc/systemd/system :

[Unit]
Description=Libervia (Salut à Toi) XMPP Docker service
After=docker.service
Requires=docker.service

[Service]
User=libervia

Environment= \
SAT_CONT_DOMAIN=votre_domain.tld \
SAT_CONT_PORT_8080=8000

ExecStartPre=/home/goffi/dev/sat_docs/docker/libervia_cont.sh start -p
ExecStart=/usr/bin/docker wait libervia
ExecStop=/home/goffi/dev/sat_docs/docker/libervia_cont.sh stop

[Install]
WantedBy=multi-user.target

Ce fichier indique que le containeur doit attendre que Docker soit lancé. L'utilisateur ici est libervia, changez-le pour celui que vous avez ajouté au groupe « docker ».
Environment vous permet de configurer les options comme le port ou le nom de domaine utilisé, notez bien le "\" en fin de ligne (dernier caractère avant le retour à la ligne, sans espace) qui indique de considérer la ligne suivante comme la suite de la commande.

Le serveur est en fait lancé avec la directive ExecStartPre, afin de pouvoir connaître sont état avec « docker wait ». C'est une petite astuce qui évite des complications, car les conteneurs sont lancés par le démon Docker et non le script lui-même.

À suivre…

Voilà pour cette seconde partie de la série sur l'installation d'un blog Libervia. Ce n'était pas la partie la plus amusante, mais vous n'avez a priori à faire cette configuration qu'une seule fois, et elle n'est pas si compliquée que cela.

La prochaine fois nous importerons un blog depuis Dotclear.

Installer une instance de Libervia (SàT) en moins de 10 min

Bon avouons le tout de suite, je triche, 2 fois. La première c'est que nous allons utiliser les images Docker autrement dit des versions pré-installées et qui facilitent la vie. La deuxième c'est que quand je dis « moins de 10 min », je ne compte pas le temps de téléchargement de ces images, qui peut bien évidemment varier selon la vitesse de votre connexion.

Ceci dit, voyons comment avoir une instance de Libervia, l'interface web du projet « Salut à Toi », fonctionnelle de manière triviale. Pour mémoire il s'agit d'un outil de communication (d'aucuns parlent de « réseau social ») basé sur le protocole standard et ouvert « XMPP », et donc compatible avec la multitude de logiciels déjà existants.

Préparatifs

Docker

Il vous faut essentiellement avoir Docker installé sur votre machine. Sur une Debian ou dérivée (Ubuntu, Linux Mint – attention dans ce dernier cas, elle a récemment été compromise –, etc) il suffit de faire :

# apt-get install docker.io

En tant que root (c.-à-d. précédez de « sudo » si nécessaire). Dans les autres cas, reportez-vous à la documentation officielle.

Il faut ensuite vous ajouter au groupe « docker », ce qui devrait pouvoir se faire avec

# adduser <votre_nom_d_utilisateur> docker && newgrp docker

Ou, si vous avez sudo installé et configuré (c'est le cas sur Ubuntu par exemple):

# sudo adduser $(whoami) docker && newgrp docker

À partir de maintenant, il n'est plus besoin d'être root, vous pouvez faire la suite avec votre utilisateur normal, qui vient d'être ajouté au groupe « docker ».

libervia_cont.sh

La deuxième chose à faire est d'installer le script libervia_cont.sh qui aide grandement à la gestion des conteneurs de Libervia. Pour cela, il suffit d'entrer :

wget https://repos.goffi.org/sat_docs/raw-file/tip/docker/libervia_cont.sh && chmod a+x libervia_cont.sh

(si wget n'est pas présent, installez-le, par exemple avec « apt-get install wget »)

Lancement

Pour lancer Libervia, il vous faut maintenant entrer :

./libervia_cont.sh

Et c'est tout ! Si si, je vous assure, le script et Docker se chargent de télécharger les images (ce qui peut prendre un peu de temps selon votre connexion) et de les lancer, À la fin, vous allez voir une liste de ports s'afficher, en particulier vous devez avoir une ligne qui ressemble à :

port 8080 (HTTP):                       0.0.0.0:32771

Le numéro à la fin est le port choisi par Docker pour accéder à Libervia via HTTP, il vous suffit d'ouvrir votre butineur sur http://localhost:32771 (en remplaçant 32771 par le port que vous avez bien sûr) et vous devriez voir apparaître la page d'accueil de Libervia. Le serveur n'est accessible qu'après quelques secondes.

Libervia login

Plutôt simple non ? Bon comme c'était trop facile, voyons voir comment configurer tout ça.

Configuration

ports

Une des options les plus importantes est l'option -p, qui permet de lancer Libervia avec des ports fixes, ainsi vous pourrez atteindre Libervia sur le port 8080 et non un port qui change à chaque lancement.

Vous pouvez spécifier des ports différents grâce aux variables d'environnement SAT_CONT_PORT_xxxxxxxx est le port que vous voulez remplacer. Ainsi si vous voulez utiliser les ports 80 et 443 qui sont les ports standard HTTP et HTTPS, plutôt que 8080 et 8443, il vous suffit de faire, avant de lancer libervia_cont.sh :

export SAT_CONT_PORT_8080=80
export SAT_CONT_PORT_8443=443

nom de domaine

Si vous avez déjà votre nom de domaine (l'obtention d'un nom de domaine et sa configuration dépassent le cadre de cet article, mais les explications ne manquent pas sur le web), vous pouvez le spécifier avec l'argument -d ou avec la variable d'environement SAT_CONT_DOMAIN, exemple :

export SAT_CONT_DOMAIN=goffi.org

éditer les fichiers

Vous pouvez éditer le fichier de configuration de SàT/Libervia en tapant simplement

./libervia_cont.sh config

De même, pour éditer la configuration du Prosody intégré, faites

./libervia_cont.sh config prosody

Sauvegardes

Le script gère également les commandes de sauvegardes. Pour faire une sauvegarde, il suffit de taper

./libervia_cont.sh backup

Ceci crééra un fichier sat_data_backup_<date_de_sauvegarde>.tar.gz. Pour le restaurer plus tard, vous n'aurez qu'à faire

./libervia_cont.sh restore sat_data_backup_<date_de_sauvegarde>.tar.gz

À suivre…

Cet article est le premier d'une petite série où je vais vous expliquer comment mettre en place et publier dans un blog comme le mien (qui tourne désormais avec SàT/Libervia) grâce à ce que nous venons d'installer. La prochaine fois (demain ?) j'expliquerai la configuration avancée (certificat personnalisé, lancement automatique).

Si vous parlez anglais, l'utilisation des images Docker et du script libervia_cont.sh sont documentés sur le wiki.

Nous aimerions beaucoup faciliter l'installation de Libervia avec d'autres méthodes, par exemple avec des scripts pour YunoHost, un peu d'aide serait très appréciée, car nous sommes déjà bien chargés. Si vous pensez pouvoir participer, venez en discuter sur le salon sat@chat.jabberfr.org.

N.B. : comme vous l'avez vu l'image contient un serveur XMPP (Prosody) pré-configuré pour simplifier l'installation. Cependant Salut à Toi et donc Libervia marchent bien évidemment avec tout autre serveur (les fonctionnalités seront juste adaptées selon ce qui est disponible), et vous pouvez créer un profil externe, sur un autre serveur (vous pouvez même entrer directement un jid et un mot de passe existant dans Libervia). Il est probable qu'il existe de futures variantes de ces images sans serveur XMPP pré-installé, ou avec un autre.

Guru Meditation

Un petit mot pour m'excuser auprès des lecteurs et en particulier des lecteurs de Planet Libre et de SeenThis : je viens de passer mon blog principal sur Salut à Toi/Libervia et avec lui les flux Atom (qui me permettent d'apparaître sur ces 2 médias), et je pensais qu'avec les dates de mise à jour j'apparaîtrais à la même place qu'avant (soit en décembre pour mon dernier article). Il se trouve que mes 10 derniers articles sont apparus en tête probablement parce qu'il y a eu un changement de liens et d'identifiants, c'est pourquoi vous voyez autant de (vieux) articles d'un coup.

Toutes mes excuses pour ce spam involontaire, il ne devrait plus y avoir de problème désormais, et si jamais c'était le cas je désactiverais la synchronisation le temps de les résoudre.

J'en profite pour annoncer que je vais faire une mini série d'articles pour expliquer comment installer une instance de Libervia et importer son blog dessus.

Libervia (Salut à toi) 0.6.0 : des avancées majeures !

Salut à vous,

Nous avons le plaisir d'annoncer la sortie de Salut à Toi (SàT) 0.6.0 et donc de son interface web « Libervia ». Pour mémoire, SàT est un « couteau suisse de la communication », un outil libre et décentralisé permettant de partager publiquement ou de façon privée des messages, des fichiers, des articles de blog, de microblog, etc.

Le projet a de nombreuses fonctionnalités allant du chiffrement de bout en bout aux jeux, et peut également servir de base pour créer de nouveaux réseaux.
C'est aussi un projet éthique, géré par une association loi 1901, suivant un « contrat social », utilisant exclusivement des logiciels libres, militant pour la décentralisation, et fermement opposé à la publicité.


Cette version a vu un très gros travail sur le système de blogs : Libervia offre un moteur de blog décentralisé, accessible à des groupes restreints ou de l'extérieur, et entièrement basé sur le protocole standard et ouvert « XMPP ». L'utilisation de ce standard permet de communiquer avec d'autres projets comme Movim ou Jappix, créant ainsi un grand réseau libre.

Le partage de fichiers en pair à pair (P2P) a aussi été grandement amélioré grâce au protocole « Jingle », ouvrant la voie pour de futures applications comme la visioconférence.

L'annonce officielle est disponible sur le blog suivant (basé sur Libervia) : https://libervia.org/blog/salut-a-toi.

Une dépêche Linuxfr plus détaillée est en cours de modération et devrait être publiée sous peu.

Une campagne de financement participatif est en cours pour faire une version de bureau (une étape déjà franchie), et une version Android. Cette campagne étant très proche de la fin, c'est le moment de nous soutenir !


 http://ftp.goffi.org/media/screenshots/0.6/overview.png 

 

site officiel : http://salut-a-toi.org
démo : https://libervia.org
campagne de financement : https://www.arizuka.com/fr/projects/libervia
N'hésitez pas à nous contacter (http://salut-a-toi.org/community.html)

L'équipe « Salut à Toi »

Libervia/Salut à Toi à « fêtons Linux » (Lausanne 28/11/2015)

Un rapide billet pour vous dire que nous avons été invités à participer à « fêtons Linux », une journée de rencontre autour des logiciels libres et de Gnu/Linux.

J'y ferai 2 conférences, une technique de 45 min pour expliquer le cœur du projet (à 13h), et une plus grand public de 20 min (à 14h30), et bien sûr je serai présent toute la journée pour discuter (je passerai également par Genève s'il y a du monde qui veut s'y retrouver).

Un grand merci à l'organisation.

Nous avons également passé le premier palier pour notre campagne de financement, c'est à dire que nous sommes engagés à faire un prototype de version de bureau. Mais il nous manque encore un peu moins de 2000 € pour la version Android, et nous avons 2 semaines pour y arriver, aussi faite tourner ce lien partout ou vous pouvez, nous avons besoin d'un coup de pouce pour nous faire connaître : www.arizuka.com/fr/projects/libervia (ou en anglais: www.arizuka.com/en/projects/libervia). Merci !

Je n'ai pas eu le temps d'écrire d'article cette semaine car je suis débordé par le développement : nous espérons sortir la nouvelle version très bientôt.

À bientôt

N.B.: j'ai dû temporairement mettre la modération a priori sur les commentaires, j'ai depuis 2 semaines une vague de spam qui passe les filtres en place.

centralisé, décentralisé, P2P, mais c'est quoi tout ça ?

Une petite mise au point technique, parce que je vois qu'il y a beaucoup de confusion sur les termes « centralisé » (encore lui ça va), « décentralisé », « distribué », « fédéré », « pair à pair », etc.

Il faut dire que la confusion est assez normale, il n'y a pas vraiment de définition de ces termes, et ce que les gens entendent en les employant dépend de leurs lectures, leur compréhension, et leur sensibilité.

Commençons par le plus simple : centralisé. Un système centralisé c'est un système où tout le monde dépend d'une même autorité, un serveur a priori dans le cas informatique. Bien qu'un système centralisé soit beaucoup plus simple à faire sur le plan technique (facile de trouver des gens ou des informations quand ils sont tous au même endroit), il peut avoir ses propres problèmes : montée en charge en particulier ; il est plus difficile d'absorber des données quand il n'y a qu'un centre de traitement, les tuyaux peuvent rapidement se trouver trop petits, etc.

Un système de communication centralisé pose de nombreux problèmes : il est évident qu'il est plus facile d'espionner, censurer ou modifier des données quand elles sont dépendantes d'un seul point. Même sans intention malicieuse, on a un point unique de défaillance (ce que les anglophones appellent « single point of failure »), c.-à-d. qu'une panne, une attaque, une catastrophe naturelle ou pas provoque l'arrêt du service voire la perte des archives.
Dans les cas les plus gros, on prend un hangar et on le remplit d'ordinateurs, ce sont les fameux centres de données ou « data centers ».

Là où ça se complique un peu, c'est qu'un système centralisé peut être physiquement en plusieurs endroits, ou utiliser des systèmes de répartition/répétition des données. Le principe est d'éviter l'engorgement ou les risques de pannes cités plus haut, mais même si ces machines sont séparées et communiquent entre elles à distance, elles sont a priori toujours sous la même autorité.


http://repos.goffi.org/sat_docs/raw-file/tip/schemas/decentralisation/centralised_simple.png


Passons maintenant aux systèmes décentralisés/distribués/fédérés. Certains vont pousser les haut-cris que je mette tout ça ensemble, parce qu'il n'y pas vraiment de définition et que chacun se fait plus ou moins la sienne.

« dé-centralisé » veut dire qui n'a pas de centre, ni plus ni moins. L'idée pour un système de communication, c'est que toute entité (individu, association, organisation, etc) puisse être une partie d'un réseau qui n'a pas d'autorité principale, et que ces autorités puissent parler entre elles.

On essaye ainsi d'éviter les problèmes de la centralisation, mais on se retrouve avec tout un tas de nouveaux problèmes, techniques pour la plupart : il est beaucoup plus difficile de retrouver des données ou des gens en plusieurs endroits, de se mettre d'accord sur la « langue » à utiliser pour communiquer (surtout quand on a des logiciels ou des versions d'un même logiciel différents), ou encore d'être sûr que la donnée qu'on a est à jour (est-ce que le message a été modifié ou supprimé ?).

« fédéré » est généralement employé pour parler de systèmes différents (noms de domaines différents par exemple, voire logiciels différents) qui peuvent communiquer entre eux. Un système décentralisé est fédéré par nature, sinon on a affaire à plusieurs systèmes centralisés indépendants. Disons que si on veut être pointilleux, on peut dire qu'un système décentralisé peut communiquer avec seulement certaines entités (je communique avec les serveurs de mon entreprise internationale, mais pas avec le reste du monde), et que la fédération implique l'idée que c'est ouvert à tous (ou presque, il y a souvent des gens qu'on ne veut pas, les spammeurs par exemple).

« distribué » ne devrait pas être employé pour les systèmes de communication. Le terme est normalement utilisé pour le calcul : si votre ordinateur a plusieurs processeurs, il distribue la charge de calcul entre eux, ou dans le cas de très grosses demandes (recherche par exemple), on peut demander à plusieurs machines distantes de faire chacun une partie d'une grosse opération mathématique. Dans ce cas, l'organisation de la répartition est souvent contrôlé par une même autorité (par exemple le laboratoire qui veut faire cette opération).
Par extension, le terme est aussi utilisé pour les systèmes de fichiers, et certains l'emploient pour les logiciels de communication, mais cela ne veut pas dire autre chose que décentralisé.


http://repos.goffi.org/sat_docs/raw-file/tip/schemas/decentralisation/decentralised_simple.png


Enfin, il y a le terme P2P ou « pair à pair » (« peer to peer » en anglais). En fait une connexion pair à pair n'est rien d'autre qu'une connexion directe entre 2 ordinateurs, mais on l'associe souvent aux technologies plus ou moins apparentées qui ont commencé à apparaître à la fin des années 90/au début des années 2000 et qui servaient (et servent toujours) principalement à partager des fichiers.

Après Napster (lancé mi 1999) qui était un bête système centralisé qui mettait en relation des machines pour une connexion directe, il y a eu beaucoup d'essais et d'évolutions pour trouver un système qui permet de se passer de serveurs, l'idée étant principalement de permettre au réseau de fonctionner même si on lui coupe l'accès à une partie de lui-même.

Je vous passe toutes les techniques qui sont utilisées : c'est un domaine très pointu, très intéressant, et qui demanderait facilement un livre pour être expliqué. Ça part des systèmes de répartition par propagation de proche en proche à la Usenet, jusqu'aux récentes chaînes de blocs (blockchain), en passant par les tables de hachage distribuée (Distributed Hash Table), etc.

Ce qui fait principalement la différence entre un système « décentralisé » et « entièrement P2P », c'est la place du serveur. Un serveur, dans les grandes lignes, c'est ce qui permet à votre logiciel (le « client ») de contacter d'autres clients via d'autres serveurs. Il est là pour tout un tas de raisons : identifier les gens, donner les bonnes données aux bonnes personnes, garder
les fichiers à donner à un client actuellement hors ligne quand il sera disponible, etc.
Si on supprime le serveur, inévitablement c'est votre client (ou un autre) qui va devoir se charger de ce travail, ce qui aura un impact sur votre bande passante, la charge de travail pour votre processeur (et donc la durée de vie de votre batterie le cas échéant), et compliquera la tâche de votre logiciel (plus difficile de savoir à qui parler et à qui faire confiance quand on n'a pas de serveur comme référence).

http://repos.goffi.org/sat_docs/raw-file/tip/schemas/decentralisation/fully_P2P_simple.png

Pour transformer un système décentralisé avec serveurs en système entièrement P2P (c.-à-d. sans serveur), je vais vous donner une recette : vous mettez un seul client sur votre serveur, et vous mettez le serveur et le client sur la même machine.
Bien sûr si vous voulez être vraiment indépendant, il va falloir supprimer le besoin de points de références, et en particulier le système de noms de domaine ou « Domain Name System ». C'est ce qui associe le nom de votre serveur (par exemple « libervia.org ») à l'adresse « IP » qui permet de vous retrouver sur Internet. Il va falloir aussi être capable de retrouver les données ou les gens un peu partout, et là on se retrouve avec les technologies intéressantes mais complexes évoquées plus haut (« D.H.T. », « Blockchain », « SuperPeer », etc).
 

Et XMPP dans tout ça ?

Je vais quand même parler un peu de XMPP. XMPP est un système dit « hybride », c'est à dire qu'il fonctionne normalement sur un modèle client/serveur, mais il peut faire du P2P à la demande (pour transférer un fichier ou faire de la visioconférence par exemple).
Il est même possible de fonctionner sans serveur sur un réseau local (comme expliqué ici), et il peut parfaitement devenir à terme un système entièrement P2P comme expliqué dans le paragraphe précédent.

Ceci dit, même si l'approche entièrement P2P est séduisante, je pense que l'architecture décentralisée sur un modèle client/serveur est un compromis bien plus efficace : elle limite le travail de votre client, permet une meilleure optimisation du trafic ou du calcul, et facilite l'échange asynchrone (quand deux personnes ne sont pas connectées en même temps). Bref, c'est tout sauf un modèle du passé comme on peut le lire parfois, et bien qu'il y ait plusieurs recherches et options intéressantes pour des systèmes entièrement P2P, il ne faudrait pas jeter le bébé avec l'eau du bain.

SàT: Comment ça marche ?

Salut à vous,

En parallèle de la série d'articles sur XMPP, j'en commence une pour expliquer « Salut à Toi », notre logiciel à tout faire basé sur ce protocole. Il y a beaucoup de choses qui tournent autour de ce logiciel, sur son organisation technique, sa philosophie, et ce qu'on peut faire avec. Aussi je vais faire des articles plus ou moins techniques (plutôt moins), et je vais bientôt expliquer quelques cas concrets d'utilisation.

Ce premier article est un peu technique, puisque je vais expliquer l'organisation générale du logiciel, et ce qu'elle a de particulier.

Donc pour vous donner une idée, SàT c'est dans les grandes lignes ça:

http://ftp.goffi.org/media/pictures/schemas/sat_simplified_overview.png

C'est un client XMPP. Si vous avez lu mes articles, vous savez que XMPP ne signifie pas que « messagerie instantanée », mais beaucoup, beaucoup plus de choses. Le projet SàT essaye non seulement de faire le maximum de ces choses, mais aussi d'expérimenter de nouvelles.

La partie centrale  est la partie « d'arrière-plan » ou « backend » en anglais. C'est elle qui gère le plus gros du logiciel. La partie à droite  sont les « frontaux » (« frontends » en anglais) ou encore les interfaces homme/machine. C'est elles qui gèrent tout l'affichage des informations, ou la réception des commandes et autres messages.

Ce qui fait la force de cette architecture, c'est qu'il est très facile de faire un nouveau frontal, et que le tout représente un seul client. Autrement dit : si vous créez un profil (voir plus bas) sur un frontal, il sera disponible sur tous les autres, si vous envoyez un message d'un côté, il sera visible sur tous les frontaux connectés, l'historique est commun, les fonctionnalités aussi.
En effet, quand on ajoute une fonctionnalité (les messages de groupe par exemple, la copie de fichier, les blogs), c'est dans le « backend » que nous le faisons, et elle se retrouve ainsi disponible partout. Évidemment dans certains cas ça demande du développement particulier pour les interfaces : nous avons un jeu de Tarot par exemple, et on ne dessine pas les cartes de la même manière dans l'interface console (appelée Primitivus) et dans l'interface web (appelée Libervia).

Les interfaces (ou frontaux) disponibles aujourd'hui sont:

  • Libervia : interface web 
  • Primivus : interface de console (avec des fenêtres de type ncurses
  • jp: ligne de commande, permet d'automatiser des tâches facilement, d'envoyer un fichier sans parcourir des menus, d'écrire depuis Vim, etc 

Nous avions une autre interface pour le bureau, appelée « Wix », mais nous l'avons abandonnée, car elle était peu pratique et peu utilisée. Notre campagne de financement en cours permettra de remplacer cette interface et par la même occasion de porter le projet sur Android.

Cette architecture a un autre avantage : il est facile d'intégrer SàT dans des logiciels existants, et avec n'importe quel langage de programmation, mais laissons cela de côté pour le moment.

SàT a également une architecture modulaire via l'utilisation de greffons (ou « plugins » en anglais) au niveau du  sur le schéma : le cœur ne gère que l'essentiel (messages simples, liste de contacts, système de logs, gestion des profils, etc), et toutes les fonctionnalités avancées sont disponibles sous forme de greffons (messages de groupe, blog/microblogs, syntaxes avancées, etc). L'idée est d'une part de pouvoir désactiver les fonctionnalités qu'on ne veut pas, et d'autres part de permettre d'étendre facilement le logiciel : un greffon sera d'autant plus intéressant qu'il sera disponible pour toutes les interfaces. Ainsi un de nos greffons gère les marque-pages (c.-à-d. une liste de salons de discussions) : ils sont utilisables à la fois avec Primitivus (en texte), avec Libervia (graphiquement via le web) ou encore avec jp (en ligne de commande). À terme nous comptons faire un système de téléchargement automatisé de greffons, un peu comme les dépôts de logiciels.

Nous avons besoin de travailler un peu côté serveur, pour notre composant PubSub ou notre annuaire par exemple, nous avons donc aussi quelques travaux de ce côté.

Enfin les profils dont je parlais plus haut sont des comptes locaux associés à un compte XMPP. Ainsi j'ai un profil pour mon compte sur le serveur jabber.fr et un autre pour celui sur libervia.org, je peux utiliser l'un ou l'autre ou les 2 en même temps.

Voilà pour une première introduction, un peu technique parce que je voulais expliquer l'originalité de l'architecture. La prochaine fois je pense parler un plus spécifiquement de Libervia, et du système de blogs/microblogs décentralisé.

N'oubliez pas que nous avons une campagne de financement en cours, et nous avons grand besoin de soutien ! Merci.

Powered by Salut à Toi
Subscribe to this news feed Atom feed