Planet Libre

Angristan : Compiler et installer Nginx avec le module PageSpeed sous Debian 8

Compilier et installer Nginx avec le module PageSpeed sous Debian 8

Ceux qui suivent un peu mon blog doivent savoir que j'ai déjà fait un article sur PageSpeed et Nginx, il y a quelques mois. Dans cet article, j'utilisais les sources des dépôts pour Debian afin d'arriver, au final, à un paquet .deb à installer.

Cette méthode est pratique puisque nginx est installé directement avec tout ce qu'il faut et est facilement désinstallable. Cependant, le désavantage principal c'est que c'est que du bidouillage pas super propre, et c'est très difficilement scriptable donc pas pratique à installer et mettre à jour.

Dans cet article, nous allons voir comment compiler et installer Nginx Mainline depuis les sources officielles de nginx.org, avec le module PageSpeed. En bonus, un script qui permet de la faire sans se fatiguer :)

Installation manuelle Installation des dépendances

On commence par installer les paquets nécessaires à la compilation :

apt install build-essential ca-certificates zlib1g-dev libpcre3 libpcre3-dev tar unzip libssl-dev

On récupère le module et on le prépare. Tout d'abord on définit une variable avec la version, ce sera plus pratique. Vous pouvez soit regarder la version sur cette page et le faire manuellement :

NPS_VER=1.11.33.0

Soit on récupère la version depuis cette même page et on joue avec des commandes pour n'avoir que le numéro de version :

NPS_VER=$(curl -s https://developers.google.com/speed/pagespeed/module/build_ngx_pagespeed_from_source | grep NPS_VERSION= | cut -c13-22)

Ensuite, on télécharge et on extrait les différents fichiers :

cd /opt wget https://github.com/pagespeed/ngx_pagespeed/archive/release-${NPS_VER}-beta.zip unzip release-${NPS_VER}-beta.zip rm release-${NPS_VER}-beta.zip cd ngx_pagespeed-release-${NPS_VER}-beta wget https://dl.google.com/dl/page-speed/psol/${NPS_VER}.tar.gz tar -xzvf ${NPS_VER}.tar.gz rm ${NPS_VER}.tar.gz

Le module est prêt ! On peut passer à Nginx.

Compilation et installation de Nginx

Comme précédemment, vous pouvez définir votre variable manuellement :

NGINX_VER=1.9.14

Ou via le site de Nginx :

NGINX_VER=$(curl -s http://nginx.org/en/CHANGES | awk 'NR==2' | awk '{print $4}')

Vous pouvez aussi utiliser la version stable :

NGINX_VER=1.8.1

Ensuite on télécharge le code source de Nginx :

cd /opt wget -qO- http://nginx.org/download/nginx-${NGINX_VER}.tar.gz | tar zxf -

Puis on configure les paramètres et les modules. Il y a plein de combinaison de modules possible, voici celle que j'utilise. Faites ce que vous voulez avec :)

cd nginx-${NGINX_VER} ./configure \\ --prefix=/etc/nginx \\ --sbin-path=/usr/sbin/nginx \\ --conf-path=/etc/nginx/nginx.conf \\ --error-log-path=/var/log/nginx/error.log \\ --http-log-path=/var/log/nginx/access.log \\ --pid-path=/var/run/nginx.pid \\ --lock-path=/var/run/nginx.lock \\ --http-client-body-temp-path=/var/cache/nginx/client_temp \\ --http-proxy-temp-path=/var/cache/nginx/proxy_temp \\ --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp \\ --user=nginx \\ --group=nginx \\ --without-http_ssi_module \\ --without-http_scgi_module \\ --without-http_uwsgi_module \\ --without-http_geo_module \\ --without-http_map_module \\ --without-http_split_clients_module \\ --without-http_memcached_module \\ --without-http_empty_gif_module \\ --without-http_browser_module \\ --with-threads \\ --with-file-aio \\ --with-http_ssl_module \\ --with-http_v2_module \\ --with-ipv6 \\ --with-http_mp4_module \\ --with-http_auth_request_module \\ --with-http_slice_module \\ --add-module=/opt/ngx_pagespeed-release-${NPS_VER}-beta

On voit qu'on a ajouté le chemin vers le module PageSpeed :)

Il ne nous reste plus qu'à compiler :

make -j $(nproc)

L'option -j $(nproc) permet de compiler en utilisant tous les coeurs disponibles sur le CPU, et ainsi accélérer la manoeuvre.

Et on installe :

make install

Voilà !

Il ne nous reste plus qu'à vérifier que le module est bien présent avec la commande nginx -V :

Compilier et installer Nginx avec le module PageSpeed sous Debian 8

Installation automatique grâce à nginx-autoinstall

Bon, maintenant, vous connaissez la marche à suivre et vous avez plus ou moins compris le fonctionnement. Même si cette méthode reste plus légère que celle que je vous avais présenté, il y a quand même quelques désavantages :

  • il faut le faire à la main
  • pas de script d'init pour Systemd
  • la conf de base marche pas...

C'est pour cela que j'ai créé un script qui permet de tout automatiser. Il vous permet d'installer plusieurs modules, dont PageSpeed.

Il est très pratique puisqu'il s'occupe d’absolument tout ! Lorsqu'une mise à jour d'un module ou de Nginx est dispo, il vous suffit de relancer le script. Lors de votre première installation, il s'occupera aussi de vous mettre une configuration fonctionnelle et un script Systemd. Ainsi, votre Nginx sera totalement fonctionnel.

On récupère le script :

wget --no-check-certificate https://bit.ly/nginx-autoinstall -O nginx-autoinstall.sh

On le rend exécutable :

chmod +x nginx-autoinstall.sh

Et on l'exécute !

./nginx-autoinstall.sh

Compilier et installer Nginx avec le module PageSpeed sous Debian 8

Je tiens à préciser que c'est un script perso et qu'il est possible qu'il ne convienne pas à tout le monde. Aussi, il ne fonctionne que sous Debian 8.

Configuration de PageSpeed

Maintenant que Nginx est installé avec PageSpeed, il va falloir le configurer. La doc du module l'explique très bien mais voici une base.

Activation

Dans votre nginx.conf (entre les balises http)

pagespeed off; # Needs to exist and be writable by nginx. # Use tmpfs for best performance. pagespeed FileCachePath /var/ngx_pagespeed_cache;

On désactive PageSpeed de base, pour pouvoir l'activer dans un vhost précis. En ce qui concerne l'emplacement du cache, je vous conseille de lire mon article : Mettre le cache du module PageSpeed en RAM avec tmpfs.

Puis, rajouter ceci dans le vhost de votre choix (entre les balises server) :

pagespeed on; # Don't show PageSpeed version in the header pagespeed XHeaderValue "blablabla"; # Ensure requests for pagespeed optimized resources go to the pagespeed handler # and no extraneous headers get set. location ~ "\\.pagespeed\\.([a-z]\\.)?[a-z]{2}\\.[^.]{10}\\.[^.]+" { add_header "" ""; } location ~ "^/pagespeed_static/" { } location ~ "^/ngx_pagespeed_beacon$" { }

On active donc PageSpeed et on met les règles de bases. On modifie aussi la valeur du header pour éviter de montrer la version.

Les filtres

Actuellement PageSpeed ne fait rien. On va donc rajouter des filtres !

Pour ma part, j'utilise ceux-là (à rajouter dans le server block):

# Filters pagespeed EnableCachePurge on; pagespeed RewriteLevel PassThrough; pagespeed EnableFilters remove_comments; pagespeed EnableFilters collapse_whitespace; pagespeed EnableFilters rewrite_images; pagespeed EnableFilters rewrite_javascript; pagespeed EnableFilters rewrite_css;

C'est ceux qui me paraissaient le plus pertinent. Il y en a plein d'autres, par exemple :

pagespeed EnableFilters move_css_above_scripts; pagespeed EnableFilters insert_dns_prefetch; pagespeed EnableFilters combine_javascript; pagespeed EnableFilters defer_javascript; pagespeed EnableFilters inline_javascript; pagespeed EnableFilters outline_javascript; pagespeed EnableFilters combine_css; pagespeed EnableFilters inline_css; pagespeed EnableFilters outline_css; pagespeed EnableFilters inline_google_font_css;

À vous de les tester et de voir leur impact sur votre site. Tout est expliqué en détails concernant les filtres dans la doc.

Administration

L'administration permet de voir des statistiques et de gérer certaines choses, notamment la purge du cache.

Encore une fois, c'est expliqué dans la doc, mais elle n'est pas super claire donc voici :

Dans votre nginx.conf (entre les balises http)

pagespeed StatisticsPath /ngx_pagespeed_statistics; pagespeed GlobalStatisticsPath /ngx_pagespeed_global_statistics; pagespeed MessagesPath /ngx_pagespeed_message; pagespeed ConsolePath /pagespeed_console; pagespeed AdminPath /pagespeed_admin; pagespeed GlobalAdminPath /pagespeed_global_admin;

Dans votre vhost :

# PageSpeed Admin location /ngx_pagespeed_statistics { allow all; auth_basic "Denied"; auth_basic_user_file /srv/.htpasswd; } location /ngx_pagespeed_global_statistics { allow all; auth_basic "Denied"; auth_basic_user_file /srv/.htpasswd; } location /ngx_pagespeed_message { allow all; auth_basic "Denied"; auth_basic_user_file /srv/.htpasswd; } location /pagespeed_console { allow all; auth_basic "Denied"; auth_basic_user_file /srv/.htpasswd; } location ~ ^/pagespeed_admin { allow all; auth_basic "Denied"; auth_basic_user_file /srv/.htpasswd; } location ~ ^/pagespeed_global_admin { allow all; auth_basic "Denied"; auth_basic_user_file /srv/.htpasswd; }

Ici, je bloque l'accès à l'admin avec un mot de passe, sinon c'est entrée libre. Il faudra donc générer un .htpasswd et modifier le chemin en conséquence. Vous pouvez utiliser cet outil.

PageSpeed c'est sympa, mais attention...

Vous êtes maintenant un pro du module PageSpeed. Mais faites attention, étant en beta, c'est un module assez instable, et d'une version à l'autre ça peut tout foutre en l'air. Utilisez le sur des petits sites, mais surtout pas sur de la grosse prod. Les filtres que vous utilisez peuvent aussi casser des choses (Piwik ne fonctionnera pas avec PageSpeed par exemple).

Petit exemple : hier je me prenais des erreurs 499 de Nginx dans l'admin WordPress. Après une demi-journée de recherche, j'ai finalement trouvé que ces erreurs donnaient parfois ERR_SPDY_PROTOCOL_ERROR dans le navigateur, et que c'était lié à ce bug... Du coup j'ai désactivé PageSpeed en attendant la prochaine version.

Pour résumer : PageSpeed c'est pratique pour optimiser un site web, mais :

  • L'optimisation ne se fait pas que à ce niveau
  • PageSpeed est instable et peut péter un truc d'une version à l'autre
  • Les filtres peuvent aussi causer des problèmes, donc vérifiez bien
  • PageSpeed fait consommer un peu plus de CPU à Nginx.

Ça reste un bon module, je l'utilise depuis plus d'un an ! Mais soyez sûr de bien le maîtriser pour éviter de tout casser ;)

L'article Compiler et installer Nginx avec le module PageSpeed sous Debian 8 a été publié sur Angristan

Gravatar de Angristan
Original post of Angristan.Votez pour ce billet sur Planet Libre.

Articles similaires

nIQnutn : Désactiver le message d'avertissement de xscreensaver au lancement

Pour désactiver le message d'avertissement de xscreensaver au lancement de votre session, voici une solution simple.

Pour désactiver ce message un peu agaçant au démarrage, il suffit de modifier le fichier de configuration .xscreensaver en passant la variable lock à True :

~/.xscreensaver ... lock: True ... Vous voilà débarrasser. Ressources
2016 nIQnutn CC-BY

Gravatar de nIQnutn
Original post of nIQnutn.Votez pour ce billet sur Planet Libre.

Monitoring-FR : Logstash 2.3.0 : forte amélioration des performances

Logstash est un outil de collecte, de traitement et de transport de données. Logstash est disponible en version 2.3.0 depuis le 30/03/2016 et cette nouvelle version apporte, en autres, une augmentation significative des performances.

Présentation rapide de Logstash

Logstash a pour but d’ingérer des logs (fichiers journaux des systèmes et applications) ou des messages (provenant de RabbitMQ par exemple), de les analyser (filtrer les messages inutiles, les découper, extraire l’information utile, les formater) puis de les stocker, généralement dans ElasticSearch pour être indexées. La force de Logstash est de pouvoir ingérer tout type de logs :

  • des logs au format syslog : très répandus sur les systèmes GNU/Linux et Unix
  • des logs en texte brut
  • des logs Apache et Log4j
  • des logs Windows Event Logs
  • des messages au format JSON
  • des messages passant par des files de messages (RabbitMQ, ZeroMQ)

Bien entendu, vous pouvez étendre le système et faire ingérer vos propres formats. Une fois les messages ingérés, Logstash les filtre, prend des actions et/ou les formate pour les stocker dans ElasticSearch, MongoDB, Riak, …

Logstash évolue très rapidement et de nouvelles versions apportent souvent de nouveaux connecteurs, tant en entrée qu’en sortie.

Version 2.3.0 : forte amélioration des performances

La version 2.3.0 de Logstash est sortie le 30/03/2016 et cette version apporte une forte amélioration des performances. Elle se traduit par un traitement plus rapide des messages, une augmentation de la vitesse de traitement jusqu’à, dans certains cas, 79%. Cette augmentation est due à la ré-écriture en pure Java d’un composant de l’application, préalablement écrit en Ruby. L’équipe de développement de Logstash a fait des tests et a publié les résultats dont voici un résumé :

 améliorations des performances diagramme

Lostash 2.3.0 : améliorations des performances diagramme

Lostash 2.3.0 améliorations des performances tableau

Lostash 2.3.0 améliorations des performances tableau

 

 

Relecture à chaud de la configuration

Cette version 2.3.0 introduit la relecture de la configuration à chaud. Cela permet de ne pas avoir à redémarrer le service lorsqu’un paramètre de la configuration est modifié : en effet, Logstash va vérifier régulièrement (toutes les 3 secondes, par défaut) si une modification a été faite sur les fichiers de configuration. Dans ce cas, il va relire les fichiers et adapter son comportement. Pratique lorsqu’on développe mais aussi lorsque la configuration est modifiée par des outils externes, en fonction de règles dynamiques : cela évite de redémarrer Logstash par un script.

Pour activer la relecture à chaud, il faut passer l’option --auto-reload lors du démarrage de Logstash.

Si jamais vous souhaitez maîtriser le moment où LogStash doit relire la configuration, il vous suffit de ne pas passer l’option  --auto-reload et d’envoyer le signal SIGHUP au processus.

Gravatar de Monitoring-FR
Original post of Monitoring-FR.Votez pour ce billet sur Planet Libre.

Articles similaires

Tuxicoman : Que change le chiffrement de WhatsApp?

L’ « annonce » de WhatsApp utilisant le chiffrement de bout en bout ne doit pas vous leurrer:

  • Le chiffrement de bout en bout utilisé fait abstraction du problème des métadonnées.
    Leur page sur la sécurité et le whitepaper sur le chiffrement prend bien soin de ne pas parler du traitement réservé aux métadonnées. Or les métadonnées sont les données les plus efficaces aujourd’hui pour décrire un comportement. Elles sont faciles à analyser.
    WhatsApp récupère toujours tout votre carnet de contacts et vous identifie par votre numéro de téléphone.
    Il note pour chaque message envoyé les numéros de téléphone de l’émetteur et du destinataire, l’heure, les IP. Donc si DSK appelle Julie Gayet à tous les jours à 2H du matin, WhatsApp a cette info, l’enregistre et la transmet à des tiers.
    C’est bien caché mais écrit noir sur blanc dans leur conditions légales, dans le paragraphe « The Information WhatsApp Does Not Collect » : « Notwithstanding the above, WhatsApp may retain date and time stamp information associated with successfully delivered messages and the mobile phone numbers involved in the messages, as well as any other information which WhatsApp is legally compelled to collect. »
    Donc vous ne pouvez même pas dire que vous ne saviez pas.
  • Derrière le vernis de la communication, personne ne peut vérifier ce qu’il en est réellement. On ne peut pas vérifier le code tournant sur le téléphone ni vérifier le contenu du serveur.
  • Si dans une prochaine mise à jour, WhatsApp coupe court au chiffrement pour faire du MitM, vous n’aurez aucun moyen de le voir.
  • Le serveur de WhatsApp est l’unique délivreur des clés publiques temporaires utilisées pour le chiffrement des messages. Il est donc aisé pour lui de faire un MITM quand ça lui chante sans aucune modification du code client.
  • WhatApp comme Signal, utilise Google Cloud Messaging pour acheminer les messages. Pour l’utiliser, il faut avoir les GoogleApps installées et donc donner les droits root sur son téléphone à Google. Donc rien n’empêche Google de récupérer votre clé privée de WhatsApp quand ça lui chante. Si c’est pour se protéger de Google/NSA/USA, c’est raté.
  • Facebook (la maison mère de WhatsApp) n’est pas philanthrope. Le but est de faire le maximum de thune. Avec WhatsApp, je pense qu’ils essayent aussi de conquérir 90% du marché pour remplacer les opérateurs de téléphonie classique. Si bien que demain on sera obligé de donner son carnet d’adresse et le détail de ses communications à WhatsApp/USA.

facture_detaillée

A mon avis, l’onion routing est une bien meilleure façon d’avoir une vie privée. Il faudrait contrôler chacun des nœuds intermédiaires pour avoir accès aux métadonnées.

Sinon, contrôler son serveur de connexion (celui qui manipule les métadonnées) peut également être une solution. Par exemple dans le cas serveur de connexion de WhatsApp, seul WhatsApp sait qui communique avec qui.

Voila, personnellement, j’utilise Conversations (un logiciel libre) depuis Fdroid (un dépôt d’application de logiciels libres recompilés et qui ne demande pas de droits root). Conversation fait du chiffrement de bout en bout (y compris sur le transfert des photos/audios/fichiers) avec OMEMO, OTR ou PGP au choix.
J’ai mon serveur XMPP sous Prosody.

Related Posts: J'aime!(7)Tu dis de la merde!(1)

Gravatar de Tuxicoman
Original post of Tuxicoman.Votez pour ce billet sur Planet Libre.

Articles similaires

Carl Chenet : « La » communauté du Logiciel Libre, ça n’existe pas

Suivez-moi aussi sur Diaspora*diaspora-banner ou Twitter 

J’avais depuis quelques temps envie d’écrire un billet de blog au sujet de la soi-disant communauté du Logiciel Libre et le dernier article de Frédéric Bezies , où il regrette le manque de coordination et d’unité de cette communauté, m’a donné la motivation pour finalement expliquer pourquoi tant de gens se désillusionnent quant à « cette » communauté.

« La » communauté du Logiciel Libre, ça n’existe pas

Il est en effet vain dans la plupart des cas de parler de « la » communauté du Logiciel Libre. On peut – et je le fais souvent moi-même – parler de la communauté du Logiciel Libre pour regrouper dans un même sac tous les acteurs touchant de près ou de loin au Logiciel Libre, mais c’est une dénomination vague, peu précise et que l’on ne doit pas employer à tort et à travers.

Et pour cause, car aussi bien d’un point de vue technique que d’un point de vue idéologique, nous, les acteurs de cette soi-disant communauté, sommes profondément et sûrement irrémédiablement divisés.

Les communautés techniques

Rappelons-le car beaucoup de personnes même proches du Logiciel Libre ont tendance à l’oublier. 99% du temps, un projet du Logiciel Libre, c’est au départ un individu isolé non rémunéré qui se motive et prend son courage à deux mains pour écrire du code et porter seul – au moins au début – un projet pour répondre à un besoin existant qui le dérange lui.

Ce faisant, il s’insère dans une communauté technique, celle des outils qu’il utilise pour régler son problème, puis le jour où son projet est prêt, s’il fait le choix de le rendre public, dans une communauté idéologique répondant aux critères que l’on verra au chapitre suivant.

python-logo-master-v3-TMLa communauté Python, avec sa propre licence : la PSF, sa propre vision, ses propres objectifs

Au premier niveau, le développeur du Logiciel Libre, c’est donc un utilisateur des outils qui sont mis à disposition par une communauté technique. Il adhère souvent aux idées derrière les outils qu’ils utilisent au quotidien parce qu’il y voit un avantage direct et ressent la cohérence des choix techniques et idéologiques faits par la communauté l’ayant précédé.

Maintenant si on parle de « la » communauté du Logiciel Libre, ça sous-entend que le premier niveau dont je parlais à l’instant se fond  dans un deuxième niveau, un niveau plus vaste, plus abstrait, plus global. Donc plus éloigné du développeur au quotidien, touchant des problématiques qu’il ne ressent peut-être pas tous les jours.

Alors qu’au quotidien pour lui, « sa » communauté, c’est par exemple le langage Python et ses membres, pas Perl. Ou la distribution Debian et les buts du projet Debian, pas les systèmes BSD. On se construit donc aussi en opposition à d’autre communautés techniques et idéologiques.

freebsdFreeBSD, système d’exploitation et suite d’outils qui privilégient la licence BSD

Les développeurs contribuent donc – le plus souvent dans le cadre de leur temps libre, le plus souvent de façon non-rémunérée, et dans ce domaine seule la motivation permet d’avancer – aux sujets qui nous intéressent et nous motivent au sein d’une communauté technique et idéologique et pas sur les sujets dont « la communauté du Logiciel Libre » aurait besoin.

La diversité des acteurs et de leurs idées, de leurs approches techniques et des solutions qu’ils trouvent au quotidien  sont les éléments qui rendent aussi attractif pour beaucoup d’entre nous ce milieu technique et idéologique.

GPL contre BSD/MIT

J’ai évoqué et développé ce point dans l’un de mes précédents articles le danger Github : d’un point de vue idéologique, principalement deux idées du Logiciel Libre coexistent.

La vision incarnée par la licence GPL peut être résumée à une notion fondamentale intégrée par ses défenseurs et ses détracteurs : contaminante.  La GPL va nourrir d’elle-même la communauté en réinjectant automatiquement dans le parc logiciel sous GPL tous les dérivés des logiciels eux-mêmes sous GPL. La communauté sert la communauté. Les utilisateurs de la GPL trouvent cohérents de n’utiliser que du Logiciel Libre pour ne pas nourrir l’ennemi , c’est-à-dire le logiciel privateur.

Les licences BSD/MIT sont pour leur part plus permissives, permissives à l’extrême. Rappelons qu’un logiciel dérivé d’un logiciel sous licence  BSD/MIT peut être déposé sous une licence propriétaire. Les licences BSD/MIT sont donc non-contaminantes. On a donc la liberté de rendre un logiciel – libre à la base – privateur. Ce qui se fait beaucoup et l’on retrouve les systèmes d’exploitation BSD dans nombre de système d’exploitation propriétaires. voir à ce sujet la liste à couper le souffle des produits commerciaux reposant sur FreeBSD.

Les défenseurs des licences BSD/MIT parlent de liberté réelle face à la GPL, ses détracteurs de la liberté de se tirer une balle dans le pied. Étant donné que les défenseurs de ces licences permissives type BSD/MIT trouvent normal la coexistence du Logiciel Libre et du logiciel privateur, ils utilisent eux-mêmes les deux sans problème, ce qui est cohérent idéologiquement.

bsdvsgpl

Donc au final deux visions très différentes du Logiciel Libre – la GPL plus conquérante, les BSD/MIT plus flexibles – coexistent.

Des communautés constituent le Logiciel Libre

On l’a vu, il serait donc plus précis de parler des communautés qui constituent le Logiciel Libre. Elles sont à la fois techniques et idéologiques et apportent des outils concrets à leurs membres. Elles se définissent par rapport à ce qu’elles construisent, à leurs contributions, mais aussi par opposition aux autres communautés techniques et idéologiques. Il est donc impossible de parler d’une communauté du Logiciel Libre, à moins de la réduire au peu d’idées transverses aux différentes communautés techniques et idéologique la constituant.

J’ai pu remarquer que de nombreux intervenants parlent souvent de la communauté du Logiciel Libre pour parler en fait d’un sous-ensemble de celle-ci, en fait de leur communauté.Par exemple un défenseur de la GPL va parler de la communauté du Logiciel Libre en omettant l’idée de liberté complète derrière les licences BSD/MIT. Ou un idéologue auto-proclamé du Logiciel Libre va déclarer de grandes directions que « le Logiciel Libre » devrait prendre dans une approche top-down alors que, comme nous l’avons vu, tous les contributeurs techniques du Logiciel libre intègrent avant tout une communauté technique et idéologique précise, un sous-ensemble de « la » communauté du Logiciel libre.

trollLes trolls, une activité prisée des Libristes

Au final il est peut-être rageant de voir au quotidien des projets s’affronter, se troller, de voir des projets réinventer ce qui existent déjà au lieu de l’améliorer. Il semble même incompréhensible de voir des projets entièrement recoder pour des questions de licences ou parfois juste d’ego entre membres de ce qu’on croit être une même communauté. Mais cela tient à une incompréhension de l’organisation et des interactions des projets du Logiciel Libre entre eux.

L’explication tient au fait que le Logiciel Libre est constitué de nombreuses communautés, qui partagent quelques grandes idées communes certes, mais qui portent chacune des solutions techniques, une vision et une identité propres. Elles arrivent à se rejoindre très ponctuellement autour d’un effort commun sur un point extrêmement consensuel, mais il sera tout simplement impossible de les faire toutes et en permanence converger vers des grands objectifs qui bénéficieraient (ou pas) à  une vague communauté globale dans laquelle se reconnaîtraient tous les acteurs du Logiciel Libre.

La diversité des communautés qui le compose fait la force du Logiciel Libre, nous partageons quelques grandes idées et nous inventons au quotidien nos propres solutions. Et c’est de cette façon que nous avons avancé jusqu’à aujourd’hui.


Gravatar de Carl Chenet
Original post of Carl Chenet.Votez pour ce billet sur Planet Libre.

Articles similaires

Dimitri Robert : Initiation GIMP : la retouche photo

Dans les formations professionnelles que je propose via la coopérative Artefacts il y a l’initiation GIMP à la retouche photo.

Chacune de mes formations fait l’objet d’un support de cours afin de laisser plus que des notes aux stagiaires. Afin de respecter la philosophie du logiciel libre (et la mienne) ces supports sont mis à disposition sous une licence libre (en l’occurrence Creative Commons Attribution – Partage dans les Mêmes Conditions 4.0 International comme le reste de ce site).

Ces supports feront l’objet d’une publication en ligne au fur et à mesure de leur état d’avancement. Voici donc celui sur GIMP : initiation GIMP à la retouche photo. Vous pouvez également consulter le support sur la mise en page avec Scribus (qui a fait l’objet de substantielles améliorations récemment). Vous pouvez vous abonner à la lettre d’informations pour être tenu au courant des évolutions (dans la barre de gauche du site).

N’hésitez pas à commenter (sur la page de contact) et à revenir le consulter ultérieurement, il ne peut que se bonifier avec le temps, des évolutions sont ajoutées régulièrement, notamment après une formation, afin de mieux adapter le discours.

Couverture GIMP débuter en retouche photo et graphisme libreEn complément vous pouvez aussi vous procurer mon livre GIMP 2.8 débuter en retouche photo et graphisme libre dans une librairie.

Voici la table des matières actuelle :

Cet article Initiation GIMP : la retouche photo est publié sous licence CC By-SA 4.0 par Dimitri Robert sur Formation logiciel libre - Reprenez le contrôle de votre informatique !.

Gravatar de Dimitri Robert
Original post of Dimitri Robert.Votez pour ce billet sur Planet Libre.

Articles similaires

genma : Ubuntu et trois écrans ? Oui c'est possible

Un petit billet rapide qui fait suite à un message sur le forum d'Ubuntu-fr.org (Voir à ce sujet mon billet assez ancien mais toujours d'actualité Les forums d'Ubuntu-fr).

Il est tout à fait possible de faire du tri-écran avec un PC.Le tri-écran, c'est comme le bi-écran, mais avec trois écran.

J'ai en prêt via mon entreprise un PC portable de la gamme Lenovo, modèle Thinkpad. Ce PC, qui tourne très bien sous Ubuntu (voir à ce sujet mon billet Ubuntu sur un disque externe ? Oui c'est possible). Ce PC possède un écran (c'est un portable), et deux sorties écran : une sortie VGA (analogique) et une sortie Mini-display port (numérique, sur laquelle on peut mettre un convertisseur vers une sortie HDMI ou DVI). Le tout utilisant la carte graphique Intel HD intégrée au processeur (un Intel Core i5).

Si l'on branche un écran sur la sortie VGA et un autre écrans sur la sortie mini-display port, on a alors 3 écrans (on compte l'écran du PC portable). On peut gérer les résolutions et disposition de l'espace/du bureau de chacun indépendamment via le paramétrage écran inclus dans Ubuntu (dire que tel écran est au-dessus et tel autre sur la droite). On a alors un bureau étendu, ce qui est bien pratique pour avoir plusieurs fenêtres ouvertes (agrégateur RSS, navigateur, autre) en même temps, réparties sur les différents écrans. On gagne en confort et en productivité.

Gravatar de genma
Original post of genma.Votez pour ce billet sur Planet Libre.

Thuban : Par quoi remplacer xscreensaver?

Nous avons récemment eu la mauvaise surprise de recevoir un avertissement injustifié de xscreensaver. Sans parler du manque de respect que représente cette agression à l'utilisateur, la meilleure solution reste la suppression pure et simple de xscreensaver.

Plusieurs personnes vous rappeleront qu'il n'est plus nécessaire "d'économiser les écrans" récents. Mais on peut souhaiter vouloir faire défiler les photos de famille ou simplement bloquer l'écran après quelques minutes d'inactivité pour éviter des manipulations indésirées pendant la pause café.

Mais par quoi le remplacer?

Nous allons utiliser des petits outils KISS pour ça. Je vous invite à installer le paquet xautolock, qu'on lancera en début de session. Il se chargera de lancer une application après un certain temps d'inactivité. Il s'utilise ainsi pour lancer une commande après 5 minutes d'inactivité :
xautolock -time 5 -locker commande_à_lancer

Voyons quelques cas :

** Je veux seulement bloquer l'écran après 10 minutes d'inactivité : vous pouvez utiliser le petit outil slock disponible dans le paquet suckless-tools. Il se contente de mettre l'écran en noir. Tapez votre mot de passe et valider pour débloquer
xautolock -time 10 -locker slock
** Je veux voir un diaporama après 5 minutes d'inactivité (méthode KISS) : Installez le paquet qiv, qui se chargera du diaporama. Au début de la session, lancez la commande suivante :
xautolock -time 5 -locker "qiv -u -s -r -d 3 -i -c -f /home/moi/Images"
Remplacez /home/moi/Images vers le dossier contenant vos photos.
(-u va chercher dans les sous-dossiers, -s lance le diaporama, -r le rend aléatoire, -d 3 change les photos toutes les 3 secondes, -i cache la barre d'information, -c lit les images en boucle, -f met en plein écran)
** Je veux voir un diaporama après 5 minutes d'inactivité (méthode bidouille) : Vous pouvez utilisez ce que vous préférez pour le diaporama. Je vais ici créer un script qui s'en charge avec cyclope, la visionneuse d'image disponible sous handylinux.
On enregistre le script suivant dans /home/utilisateur/scripts/diaporama. Ce script a besoin du paquet xdotool
#!/bin/sh # dépendance : xdotool # répertoire contenant les photos PHOTOS=/home/xavier/Images cyclope "$PHOTOS" & sleep 1 xdotool search --class cyclope key --window %@ f p exit 0
On n'oublie pas de rendre le script éxécutable :
chmod +x /home/utilisateur/scripts/diaporama

Enfin, en début de session, on lance la commande suivante :
xautolock -time 10 -locker /home/utilisateur/Scripts/diaporama
Oui, cyclope n'est certainement pas le plus adapté pour cette tâche, mais vous aurez compris le principe

** À ce stade, toutes les folies sont permises. Par exemple, on peut lancer un film tiens :
xautolock -time 10 -locker "vlc -f /home/moi/Vidéos/film.mp4

Je vous laisse imaginer les choses les plus folles.

Dernière astuce avant de vous laisser : vous pouvez conserver xscreensaver sans le démarrer en début de session. PAr contre, il vous est possible de lancer votre écran de veille favori en allant directement le chercher dans /usr/lib/xscreensaver. Par exemple en lançant :
/usr/lib/xscreensaver/xmatrix

On peut même les mettre en fond d'écran :
/usr/lib/xscreensaver/glmatrix -root
— (permalink)

Gravatar de Thuban
Original post of Thuban.Votez pour ce billet sur Planet Libre.

Marco : Django: enregistrer une entité en utilisant plusieurs pages

Le but de cet article est de vous présenter la méthode que j’ai utilisée pour enregistrer une entité en plusieurs étapes, donc en utilisant plusieurs pages. La sauvegarde en base de données s’effectue seulement lors de la dernière étape.

Contexte technique: Django 1.9.5, Python 3.5.1

Cas concret: enregistrement d’un profil utilisateur sur plusieurs pages. Ici nous nous limiterons à deux pages mais il est très facile de l’étendre à n pages. Donc sur la page 1 nous permettrons à l’utilisateur de saisir certains champs. Ensuite sur la page 2 il renseignera les champs restants et l’enregistrement en base de la totalité des éléments (page 1 + page 2) s’effectuera.

Installation de l’application django
  • Initialisation de l’application
pip install django django-countries django-admin start project user_profile_several_pages cd user_profile_several_pages # Notre application de création de profil utilisateur s'appelle ici website ./manage.py startapp website # Création du super utilisateur pour la partie admin ./manage.py createsuperuser
  • Éditer le fichier user_profile_several_pages/settings.py et ajouter l’application:
INSTALLED_APPS = [ ... 'website', ]
  • Éditer le fichier user_profile_several_pages/urls.py et ajouter les urls:
from django.conf.urls import include, url from django.contrib import admin urlpatterns = [     url(r'^admin/', admin.site.urls),     url(r'^', include('website.urls', namespace='website')), ]
  • Depuis la racine du projet Django, créer ensuite le répertoire des templates: website/templates/website
Le modèle (fichier website/models.py) from django.db import models from django.contrib.auth.models import User as DjangoUser from django_countries.fields import CountryField class UserProfile(models.Model): user = models.OneToOneField(DjangoUser, on_delete=models.CASCADE) sex = models.CharField( u"Sexe", max_length=1, choices=(('m', u'Masculin'), ('f', u'Féminin')) ) city = models.CharField(u"Ville", max_length=20) country = CountryField(verbose_name=u"Pays", default="FR") web_site = models.URLField(u"Site web", blank=True, null=True) age = models.PositiveSmallIntegerField(u"Age", null=True, blank=True) information = models.TextField(u"Autres informations", null=True, blank=True)     class Meta:         verbose_name = u"Profil utilisateur"         verbose_name_plural = u"Profils utilisateur"     def __str__(self):         return "%s %s" % (self.user.first_name, self.user.last_name)

Rien de bien compliqué dans ce modèle. On notera simplement la référence vers django.contrib.auth.models.User pour les éléments spécifiques au compte utilisateur « système » (first_name, last_name, email, password).

Les forms (fichier website/forms.py) from django import forms from django.utils.translation import ugettext, ugettext_lazy as _ from website.models import DjangoUser, UserProfile class DjangoUserForm(forms.ModelForm):     error_messages = {         'password_mismatch': _("The two password fields didn't match."),     }     first_name = forms.CharField(required=True, label=u'Nom')     last_name = forms.CharField(required=True, label=u'Prénom')     email = forms.EmailField(required=True, label=u'Mail')     password = forms.CharField(required=True, label=u'Password', widget=forms.PasswordInput)     password_conf = forms.CharField(required=True, label=u'Password (confirmation)', widget=forms.PasswordInput)     def clean_password_conf(self):         """         Cette méthode est exécutée automatiquement         lorsque form.is_valid() est invoquée dans la vue         """         password = self.cleaned_data.get('password')         password_conf = self.cleaned_data.get('password_conf')         if password and password_conf:             if password != password_conf:                 raise forms.ValidationError(                     self.error_messages['password_mismatch'],                     code='password_mismatch',                 )         return password_conf     class Meta:         model = DjangoUser         fields = ['first_name', 'last_name', 'email',] class UserProfileFormStep1(forms.ModelForm):     class Meta:         model = UserProfile         exclude = ['user', 'web_site', 'age', 'information'] class UserProfileFormStep2(forms.ModelForm):     class Meta:         model = UserProfile         fields = ['web_site', 'age', 'information']

On peut noter ici la présence de trois formulaires:

  • DjangoUserForm: va être utilisé pour afficher dans la page les champs qui nous intéressent pour la gestion du compte Django. A noter la présence de la méthode clean_password_conf, qui va etre automatiquement appelée lorsqu’on va appeler la méthode is_valid() sur le formulaire dans la méthode post de la vue. Ainsi cette méthode de validation commence par clean_ suivi du nom du champ à valider.
  • UserProfileFormStep1: formulaire pour la première page. On exclut donc les champs qui vont être affichés dans la seconde page.
  • UserProfileFormStep2: formulaire pour la seconde page. On inclut donc seulement les champs qui vont être affichés dans la seconde page.
La vue (fichier website/views.py)

On utilise ici une vue générique basique pour bénéficier d’un minimum de traitements automatiques du framework Django. J’hérite ici de la TemplateView qui est assez rudimentaire. Je n’ai pas utilisé de vue de plus « haut niveau » (type FormView) car j’avais besoin d’effectuer des traitements manuels pour coller à mes besoins.

from django.core.urlresolvers import reverse from django.db import transaction from django.views.generic.base import TemplateView from django.http import HttpResponseRedirect from django.shortcuts import render from django.contrib import messages from django.contrib.auth.models import User from website.forms import * class ProfileAdd(TemplateView):     template_name = 'website/profile_edit.html'     def get(self, request, step, **kwargs):         context = super(ProfileAdd, self).get_context_data(**kwargs)         if step == '1':             context['up_form'] = UserProfileFormStep1(prefix='user_profile')             context['user_form'] = DjangoUserForm(prefix='user')         elif step == '2':             context['up_form'] = UserProfileFormStep2()         else:             logger.error("Step number invalid: '%s'" % step)         context['step'] = step         return render(             request,             self.template_name,             context,         )     def post(self, request, step, **kwargs):         context = super(ProfileAdd, self).get_context_data(**kwargs)         context['step'] = step         if step == '1':             user_form = DjangoUserForm(request.POST, prefix='user')             up_form = UserProfileFormStep1(                 request.POST, prefix='user_profile'             )             context['user_form'] = user_form             context['up_form'] = up_form             if up_form.is_valid() and user_form.is_valid():                 user = User.objects.filter(email=user_form.cleaned_data['email'])                 if user.exists():                     user_form.add_error('email', u'Ce mail existe déjà.')                     return render(                         request,                         self.template_name,                         context,                     )                 request.session['user_form'] = user_form.cleaned_data                 request.session['up_form'] = up_form.cleaned_data                 return HttpResponseRedirect(                     reverse('website:profile_add', args=[2])  # step=2                 )             else:                 return render(                     request,                     self.template_name,                     context,                 )                          elif step == '2':             up_form2 = UserProfileFormStep2(                 request.POST             )             context['up_form'] = up_form2             if up_form2.is_valid():                 user_form = DjangoUserForm(                     request.session['user_form']                 )                 up_form1 = UserProfileFormStep1(request.session['up_form'])                 with transaction.atomic():                     user = user_form.save(commit=False)                     # Dans notre système le mail est aussi le nom d'utilisateur                     user.username = user_form.cleaned_data['email']                     # Le formulaire contient un mot de passe en clair                     unencrypter_pass = user.password                     # Donc on utilise set_password pour le chiffrer                     # Afin qu'il ne soit pas en clair dans la base de données                     user.set_password(unencrypter_pass)                     user.save()                     user_profile = up_form1.save(commit=False)                     user_profile.user = user                     user_profile.web_site = up_form2.cleaned_data['web_site']                     user_profile.age = up_form2.cleaned_data['age']                     user_profile.information = up_form2.cleaned_data['information']                     user_profile.save()                 return HttpResponseRedirect(                     reverse('website:user_profile_created')                 )         return render(             request,             self.template_name,             context,         ) La méthode get

Elle est appelée lorsqu’on accède à la première ou seconde page. Le paramètre step est passé en paramètre lorsqu’on appelle cette vue (voir plus loin la configuration des urls). Cette méthode effectue essentiellement deux choses:

  • Initialisation des forms à passer dans le template via le contexte.
  • Passer dans le contexte le paramètre step afin de savoir dans le template à quelle étape nous nous trouvons.
La méthode post

Elle est évidemment un peu plus compliquée et comme son nom l’indique récupère les données saisies dans la première page et dans la seconde page suite à l’envoi du formulaire.

  • Cas de la première page (step == 1)
    • On récupère les données de la requête et on les met dans les deux formulaires user_form et up_form. On les insère dans le contexte ce qui permettra de réafficher les données saisies en cas d’erreur.
    • On vérifie la validité des formulaires en faisant appel à la méthod is_valid() ce qui implique l’appel automatique des méthodes de validation du formulaire (comme clean_password_conf de DjangoUserForm).
    • On vérifie que l’email n’existe pas déjà.
    • Les données sont ensuite stockées en session pour pouvoir les récupérer lorsqu’on voudra enregistrer l’ensemble des données après l’envoi du formulaire correspondant à la page 2.
    • Si tout est bon, on appelle la vue mais avec le paramètre step=2.
  • Cas de la seconde page (step == 2)
    • On crée le formulaire en récupérant les données saisies dans la seconde page.
    • Si les données sont valides, on restaure les formulaires de la page 1, c’est à dire le formulaire utilisateur système (user_form) et le formulaire profile utilisateur partie 1 (up_form).
    • Ensuite on initie une transaction car on va sauvegarder en bases deux entités distinctes: celle de l’utilisateur système (django.contrib.auth.models.User) et celle du profile d’utilisateur (website.models.UserProfile). Ainsi si l’un des deux enregistrements échoue, on ne souhaite pas que l’autre soit sauvegardé en base.
    • Ensuite on récupère une instance de User suite à sa sauvegarde. Cependant on n’effectue pas de commit immédiatement afin de pouvoir chiffrer le mot de passe saisi.
    • En ce qui concerne le UserProfile on utilise la même technique d’enregistrement différé pour pouvoir affecter à l’instance UserProfile une instance User créée au point précédent.
Les urls (fichier website/urls.py) from django.conf.urls import url from django.views.generic import TemplateView from website import views urlpatterns = [ url( r'^$', TemplateView.as_view( template_name='website/index.html' ), name="home" ),     url(         r'^profile_add/(?P\\d+)/$',         views.ProfileAdd.as_view(), name="profile_add"     ), url( r'^user_profile_created/$', TemplateView.as_view( template_name='website/user_profile_created.html' ), name="user_profile_created" ), ]

On a trois urls qui correspondent aux trois vues qui nous redirigent vers trois templates:

  • Page d’accueil
  • Page de saisie des informations du profil
  • Page de confirmation de la création du profil
Les templates

website/templates/index.html

Page d'accueil

Créer un nouveau profil utilisateur

website/templates/profile_edit.html

Il est commun pour la saisie des données en page 1 et en page 2.

{% csrf_token %}   {% if up_form.errors or user_form.errors %}     

Le formulaire contient des erreurs :

  {% endif %} {% if step == "1" %} {{ user_form.as_table }} {{ up_form.as_table }} {% endif %} {% if step == "2" %} {{ up_form.as_table }} {% endif %} {% if step == "1" %}Suivant{% elif step == "2" %}Enregistrer{% endif %}>

A noter qu’à la limite on aurait pu se passer du test sur la variable step pour l’affichage des formulaires. A l’étape 2 user_form n’est pas instancié donc il n’aurait pas été affiché. Mais une des règles de Python est bien « explicite est mieux qu’implicite » non ?

website/templates/user_profile_created.html

Création utilisateur

L'utilisateur a bien été créé

Création du module d’administration (fichier website/admin.py)

Il est simplement utilisé ici pour vérifier que la création du profil utilisateur s’est effectuée correctement.

from django.contrib import admin from website.models import UserProfile admin.site.register(UserProfile) Lancement de l’application ./manage.py makemigrations ./manage.py migrate ./manage.py runserver
  • Dans le navigateur accéder à la page d’accueil (par défaut: localhost:8000).
  • Vérifier dans la partie admin que l’utilisateur a bien été crée (par défaut: localhost:8000/admin).
Remarques sur cet article
  • Dans un contexte réel d’application, on aurait fait une vue pour éditer un profil existant. Mais l’article est déjà long et ce n’est pas son but.
  • Je n’ai pas trop détaillé les commandes Django. Je pars du principe que si on s’intéresse à ce genre d’article c’est qu’on sait utiliser un minimum Django.

Voilà j’espère que cet article a pu vous être utile. Ceci dit en aucun cas je ne prétends que c’est la meilleur façon de faire, que c’est la solution la plus rapide. D’ailleurs si vous avez des remarques je suis preneur, car parfois quand on code et qu’on souhaite à tout prix résoudre un problème, on a du mal à prendre du recul.

Gravatar de Marco
Original post of Marco.Votez pour ce billet sur Planet Libre.

Articles similaires

Thuban : Blogotext mis à jour

Je suis totalement passé à côté de la nouvelle version de blogotext.
Alors que tout le monde parle de PluXML en version 5.5, je passe ce blog sous blogotext en version 3.2.8 sortie en mars 2016. Toutes les informations pour mettre à jour sont disponible ici.

J'adore blogotext. Pour avoir testé les 2, il est nettement mieux que PluXML. Oui, je le dis carrément, mais je justifie :

** Pluxml est vendu comme génial car sans bases de données. Ouais, ok, ça simplifie les choses à côté d'un wordpress et son gros MySQL. MAIS, pour un blog, qui va contenir des commentaires, une base de données est tout à fait adaptée pour éviter une surcharge du serveur. Car sinon, c'est php qui se charge d'aller parser un tas de fichiers XML. Alors même si c'est bien fait sous pluxml, je rappelle que blogotext utilise la base SQLite. En gros, vous n'avez rien à faire pour l'installer. SQlite est génial pour ça, c'est blogotext qui se charge de l'installer, et la sauvegarde de la base tient en un seul fichier.
De toutes façons, blogotext intègre tout ce qu'il faut pour sauvegarder un site sous forme de .zip.
** Dans blogotext, tout est intégré pour faire une veille efficace : flux rss, partage de liens à la shaarli, hébergement de fichiers, prise de note. Et franchement, même si on n'utilise peut-être pas tout tous les jours, ça dépanne. Et dans une archive de 482ko, pourquoi s'en priver?
** La gestion des commentaires est à mon avis nettement plus simple.
** Il s'agit d'un ensemble de petites choses bien pensées, peaufinées comme il faut. Bref, Timo fait vraiment du bon boulot!

Blogotext, je t'aime! ❤
— (permalink)

Gravatar de Thuban
Original post of Thuban.Votez pour ce billet sur Planet Libre.

genma : Yunohost - Comment installer Spip

Prérequis :
- Avoir YunoHost d'installer et savoir utiliser "la moulinette"
- Connaître SPIP (savoir l'installer)
- Savoir taper quelques commande shell

Spip n'est pas une application officielle. Comme indiquée dans la documentation Ces applications n'ont pas été validées par l'équipe YunoHost et ne sont pas officiellement prises en charge. Vous pouvez les tester et les utiliser à vos risques et périls.

Ce qui signifie qu'il faudra veiller à ce que ces applications soient bien à jour (pour éviter les failles de sécurité potentielles).

Installation

Pour installer, SPIP, conformément à la documentation de YunoHost, on passera par le dépôt git :
https://github.com/magikcypress/spip_ynh
et la commande
yunohost app install https://github.com//

Ce dépôt n'était pas à jour, j'ai interagi avec Cyp pour qu'il le soit.

Une fois SPIP installé, on y aura donc accès via mondomaine.tld/spip/ sur le même principe que pour les autres applications YunoHost. Le script aura crée le répertoire /var/www/spip/ avec les droits qui vont bien (appartient à l'utilisateur www-data)

Rq : Cela reste SPIP et il fonctionnera comme n'importe quel SPIP. Il faudra finaliser l'installation etc. via son navigateur avec l'url du type https://mondomaine.tld/spip/ecrire/

MySQL

Le script d'installation de SPIP crée automatiquement une base de données SPIP dans Mysql. J'ai choisi, via phpmyadmin, de créer un utilisateur dédié pour cette base SPIP (avec les bons droits). Lors de la configuration de l'installation de SPIP, on choisit donc "localhost" pour le serveur de la base de données, "SPIP" pour la base de données, l'utilisateur et le mot de passe crée spécifiquement et éventuellement un prefixe si on souhaite héberger plusieurs instances SPIP dans la même base de données.

Migration d'un SPIP existant

Rq : cette partie est indépendante du fait que ce soit SPIP est peut être appliquée à d'autres "logiciels".

La version de SPIP installée est la version par défaut. Il faut donc transférer les fichiers images, squelettes etc. si on veut migrer un SPIP existant.

Rq : on ne peut pas se connecter en ssh à son serveur avec les utilisateurs YunoHost. Seul l'utilisateur admin peut se connecter en ssh aux serveur YunoHost (ce que j'ai désactivé par sécurité), j'ai donc créer un utilisateur dédié pour ssh, qu'on appellera ryoga pour la suite

Pour ce faire, je me connecte avec "ryoga" via sftp (FTP + SSH via Filezilla) et je dépose les fichiers dans /home/ryoga. On peut également le faire par "scp", la commande de copie via ssh.

Ensuite on doit changer le propriétaire de ces fichiers et les déplacer au bon endroit.

ryoga@yunohost$chown -R www-data:www-data ./css/* #par exemple pour les css
# On déplace ensuite les fichiers dans le répertoire de spip.
ryoga@yunohost$sudo mv ./css /var/www/spip/

Une fois que j'ai les fichiers, je peux réimporter un dump de base de données (que j'ai déposé dans /var/www/spip/tmp/dump selon les quelques commandes données ci dessus).

Gravatar de genma
Original post of genma.Votez pour ce billet sur Planet Libre.

Journal du hacker : Liens intéressants Journal du hacker semaine #13

Pour la 13ème semaine de 2016, voici 5 liens intéressants que vous avez peut-être ratés, relayés par le Journal du hacker, votre source d’informations pour le Logiciel Libre francophone !

Pour ne plus rater aucun article de la communauté francophone, voici :

De plus le site web du Journal du hacker est « adaptatif (responsive) ». N’hésitez pas à le consulter depuis votre smartphone ou votre tablette !

Le Journal du hacker fonctionne de manière collaborative, grâce à la participation de ses membres. Rejoignez-nous pour proposer vos contenus à partager avec la communauté du Logiciel Libre francophone et faire connaître vos projets !

Et vous ? Qu’avez-vous pensé de ces articles ? N’hésitez pas à réagir directement dans les commentaires de l’article sur le Journal du hacker ou bien dans les commentaires de ce billet :)

Gravatar de Journal du hacker
Original post of Journal du hacker.Votez pour ce billet sur Planet Libre.

Articles similaires

Carl Chenet : Nouveau forum pour l’emploi dans la communauté du Logiciel Libre et opensource

Suivez-moi aussi sur Diaspora*diaspora-banner ou Twitter 

Un rapide message pour annoncer le lancement d’un forum dédié à l’emploi dans la communauté du Logiciel Libre et opensource :

Le forum de LinuxJobs.fr : https://forum.linuxjobs.fr

forum-small

Devant le succès de LinuxJobs.fr , le site d’emploi de la communauté du Logiciel Libre et opensource, et la communauté d’utilisateurs qui s’est constitué autour, il était dommage de s’arrêter à l’échange d’offres d’emplois. C’est pourquoi LinuxJobs.fr créé un lieu d’échange et de discussions pour sa communauté, avec des catégories comme les rémunérations, le droit du travail, les questions des jeunes diplômés, des les étudiants ou l’entrepreunariat.

banieres linux vert

Ce nouveau forum est fièrement propulsé par le nouveau moteur de forums Flarum, un logiciel libre sous licence MIT.

Au plaisir de discuter bientôt avec vous sur le forum de LinuxJobs.fr.

Quelques liens pour finir :


Gravatar de Carl Chenet
Original post of Carl Chenet.Votez pour ce billet sur Planet Libre.

Articles similaires

Planet Libre : Brèves du Planet Libre - lundi 04, avril 2016

La surveillance de masse fait taire les opinions minoritaires sur internet - Slate.fr pistage institution Web

antistress : "Une nouvelle étude montre que les révélations sur les écoutes poussent un peu plus les gens à s’autocensurer en ligne."
(via le Standblog)

Pour Amnesty International le chiffrement doit être un droit fondamental - Numerama pistage chiffrement institution droit

antistress : "Amnesty International prie les États et les entreprises de reconnaître le chiffrement comme un droit fondamental de tout citoyen, et de garantir le niveau optimum de protection des communications. Faudra-t-il un traité ?"

Gravatar de Planet Libre
Original post of Planet Libre.Votez pour ce billet sur Planet Libre.

Articles similaires

Philippe Scoffoni : Owncloud : optimiser la vitesse de transfert des gros fichiers

fuploadJe commence à avoir un peu de recul sur la mise en pratique d’Owncloud dans divers contextes d’utilisation professionnelle. Le dernier en date m’a permis de mettre le doigt sur un « détail » important à connaître.

Le cas en question consistait à synchroniser les fichiers stockés sur un serveur motorisé par Openmediavault vers une instance Owncloud afin de permettre à mon client de mettre à disposition des fichiers, mais aussi de disposer d’une sauvegarde externalisée.

J’ai utilisé la version « ligne de commande » du client de synchronisation d’Owncloud afin de lancer les synchronisations directement depuis le serveur. Openmediavault utilise une version 7 de Debian. J’ai fait l’installation du client Owncloud de façon assez classique en ajoutant les dépôts pour Debian 7. À l’installation on récupère pas mal de dépendances, mais rien de catastrophique. L’utilisation de la commande owncloudcmd est documentée sur le site du projet.

C’est environ 700 Go de données qu’il s’agissait de synchroniser. Ayant accès à une fibre de 300 Mbps, je n’étais pas trop inquiet. J’avais estimé à environ 6/7 heures la durée de la synchronisation initiale.

Lancé durant un week-end afin de disposer de toute la bande passante, je constate au bout de 10 heures que le transfert n’est pas terminé. Seuls 450 Go ont été transférés. Je laisse passer encore quelques heures pour constater que la synchronisation n’a avancé que de quelques dizaines de Go. Fatalement, coup de stress, je commence à investiguer.

Premier constat, la machine virtuelle où est installé Owncloud mouline furieusement. Le serveur web et la base de données tournent à plein régime. J’augmente les ressources allouées à la machine virtuelle qui bien évidemment ne fait que mouliner davantage. Le plus suspect est qu’il n’y a que très peu de trafic réseau.

Mes investigations se portent sur le client de synchronisation et son historique. Je constate alors que ce dernier envoi des rafales de requêtes pour certains fichiers. Il s’agit de gros fichiers. En l’occurrence des rushs de vidéo. Il y a là des fichiers qui font jusqu’à 14 Go pièces. De belles bêtes :-) !

En creusant un peu, je découvre le fonctionnement « intime » du client de synchronisation. Lorsque les fichiers sont gros (disons plus de 5 à 10 Mo), le client les saucissonne pour les envoyer dans un répertoire de cache sur le serveur. Ces petits fichiers portent le doux nom de « chunk ». Par défaut, leur taille est de 5 Mo. L’objectif est de permettre une reprise en cas de coupure du transfert d’un gros fichier. Une fois tous transférés, les fichiers sont réassemblés sur le serveur pour constituer le fichier final. Sur le serveur Owncloud, les fichiers partiellement transférés portent une extension .part et grossissent par à-coups.

Mais, lorsque l’on dispose d’une liaison haut débit, cette taille de fichier n’est plus adaptée. À 5 Mo, le transfert des données prend environ 0,20 seconde. De fait, le client de synchronisation passe plus de temps à établir la connexion avec le serveur Owncloud, lui donner quelques informations qu’il enregistre dans la base de données, qu’à faire le transfert. Résultat le transfert devient épouvantablement lent au regard des possibilités de la liaison. C’est un souci que j’ai retrouvé sur les forums d’Owncloud à plusieurs reprises.

La solution consiste à modifier la taille par défaut du chunk pour privilégier le transfert de données par rapport au dialogue entre le client et le serveur.

Pour cela, vous devez sous GNU/Linux positionner des variables d’environnement. J’ai fait cela dans le fichier .profile de l’utilisateur qui lance la commande de synchronisation.

export OWNCLOUD_CHUNK_SIZE=5242880 export OWNCLOUD_MAX_PARALLEL=3

La première variable vous l’aurez compris permet de définir (en octets) la taille du chunk. Le second définit le nombre de connexions parallèles maximum pour le transfert de fichiers. La valeur par défaut est de 3.

Dans mon cas, j’ai donc poussé la taille du chunk à 100 Mo et monté la valeur de la seconde à 5. Résultat, 3 heures plus tard le transfert était terminé. La charge du serveur est restée relativement faible.

À noter que j’ai quand même dû faire le ménage dans le dossier cache sur le serveur. En changeant la valeur, visiblement le client à recommencé les transferts en cours. Il restait donc plein de fichiers de 5 Mo que j’ai supprimé manuellement.

Ces variables doivent fonctionner aussi pour le client de synchronisation traditionnel, bien que je n’en ai pas fait le test. De même, il doit être possible sous Windows de spécifier ces variables d’environnement, là encore je vous laisse vous dépatouiller avec ce dernier :-)

Réagir à cet article

Article original écrit par Philippe Scoffoni le 03/04/2016. | Lien direct vers cet article

Cette création est mise à disposition sous un contrat Creative Commons BY à l'exception des images qui l'illustrent (celles-ci demeurent placées sous leur mention légale d'origine).

.

Gravatar de Philippe Scoffoni
Original post of Philippe Scoffoni.Votez pour ce billet sur Planet Libre.

Articles similaires

alterlibriste : Zim, un vrai couteau suisse

Depuis que j’ai commencé ce blog, je me suis dit que je devais parler des outils que j’utilisais afin de faire connaître les raisons de leur choix et pourquoi pas, vous convaincre de les essayer. Je ne l’avais toujours pas fait ou juste évoqué en passant mais aujourd’hui je passe à l’action avec un outil que j’utilise quasiment au quotidien : Zim.

Avant de l’utiliser, j’avais toujours des fichiers texte à droite à gauche que je créais dans un bête éditeur. Il y avait un peu de tout : des idées, des brouillons d’articles, des listes, des notes, des astuces, ...

Alors à un moment j’ai décidé de chercher un logiciel me permettant de regrouper tout ça. J’ai essayé plusieurs usines à gaz ou trucs trop lourds pour gérer ce genre de choses qui ne m’ont pas convaincu. D’un autre côté, je voulais aussi éviter le systèmes de post-it un peu trop simplistes qui en mettent partout sans être faciles à organiser.

C’est pourquoi j’ai choisi Zim qui est un bon compromis entre les deux : une grande fenêtre centrale permettant de se concentrer sur le texte à taper, une barre d’outil très sobre et une colonne à gauche que l’on peut organiser en pages et sous-pages selon les catégories que l’on veut utiliser. Je l’utilise souvent sur la moitié de l’écran avec de l’autre un navigateur ou un terminal par exemple selon les besoins.

Zim

Le but premier de ce logiciel est de créer des wiki avec des renvois entre les pages que l’on crée, je dois dire que je ne l’ai jamais utilisé pour ça mais pour plusieurs autres fonctions proposées comme une todo list avec des cases à cocher par exemple pour les livres que je veux lire et dont je veux garder une trace de lecture (date et appréciation).

La mise en forme du texte est minimale mais largement suffisante pour faire des textes avec des titres de chapitres, des listes et quelques effets de caractère de base. Encore une fois, on est entre le trop lourd et complet traitement de texte et le trop basique éditeur de texte.

Autre gros avantage, la sauvegarde se fait régulièrement au cours de l’ajout du texte. On peut donc laisser l’outil ouvert, y jeter ses idées et liens tout en farfouillant sur le net et tout est sauvegardé au fur et à mesure.
Seul inconvénient à cela, lorsque l’on sélectionne tout ou partie du texte pour faire un copier-coller par exemple, il faut éviter de taper accidentellement sur une touche car la sélection est supprimée et sauvegardée assez rapidement et les retours en arrière sont limités (c’est juste que j’ai eu le coup avec un ordi qui pète parfois les plomb et se met à faire des lignes de œœœœœœœœœœœœœ, ce qui m’a bousillé tout un brouillon de plusieurs pages).

J’utilise donc maintenant cet outil pour toutes mes notes, idées et brouillons de billet (comme celui-ci) et certaines pages sont permanentes (listes de commandes bash, guide de migration perso avec les logiciels et config utilisées, listes de documents à emprunter en médiathèques, ...) et d’autres temporaires avec des idées ou des brouillons de textes que j’ai à écrire. Je l’utilise même pour les premiers jets avant de mettre des écrits en forme dans un traitement de texte pour me consacrer entièrement au fond plutôt qu’à la forme.

L’avantage aussi, c’est que tous ces textes centralisés et accessibles sans avoir à naviguer dans les dossiers sont tous au format texte donc très légers et facilement réutilisables à partir d’un autre logiciel. Je fais des synchronisations régulières du répertoire où ils sont stockés sur un périphérique de stockage (type clé USB) afin de toujours les avoirs au cas où.

Il est aussi possible d’exporter chaque page ou ensemble de pages en html (forcément pour un wiki) mais aussi en markdown ou en LaTeX pour les amateurs ; l’outil ne permet par contre pas de faire de l’impression directe, ce qui peut se comprendre car ce n’est pas son but. N’oublions pas l’outil bien utile de correction d’orthographe pour éliminer les plus grosses fautes. Enfin, il est disponible pour toutes les distributions et même pour ceux qui sont sur des OS non libres. Bien entendu, il est sous licence GPL.

Bon, voilà, il y a sans doute plein d’autres fonctionnalités à découvrir avec ce genre d’outil. J’ai simplement essayé de vous présenter l’utilisation que j’en fait et peut-être aurez-vous l’envie de le tester ou de me dire ce que vous en pensez.

Gravatar de alterlibriste
Original post of alterlibriste.Votez pour ce billet sur Planet Libre.

RaspbianFrance : Installer Mac OS X sur la Raspberry Pi 3, ce sera bientôt possible !

Nous avons régulièrement des mails de lecteurs qui souhaitent installer l’OS d’Apple sur la Raspberry Pi et qui se retrouvent bloqués.

Jusqu’à présent, nous ne pouvions que leur indiquer qu’OS X ne fonctionnait pas sur la Raspberry Pi. En cause, l’architecture ARM 32 bits du processeur de la framboise.

Cependant, nous avons reçus des informations directement des services de communication d’Apple qui viennent changer la donne !

Apple vise la domotique et compte passer par la Raspberry Pi

La semaine dernière, nous avons eu la chance (comme Framboise 314 notamment) d’être contactés par mail par la branche française des services de communication d’Apple « en raison de notre forte implication dans l’environnement technique français autour de la Raspberry Pi ».

Pour faire simple, Apple pense que la Raspberry Pi sera un pierre angulaire de la domotique dans les années à venir, un marché dont la marque à la pomme compte bien s’emparer, comme ils l’ont fait lors des débuts des smartphones (quand on sait combien ça leur a rapporté, on comprend bien pourquoi).

Après Microsoft avec Windows 10, c’est donc au tour d’Apple de rendre son système OS X compatible avec la Raspberry Pi !

Apple suit Microsoft et change sa politique concernant le libre

Le problème, c’est que ces dernières années, Apple ne s’est pas fait une très bonne réputation auprès de la communauté libriste, laquelle fait vivre tout l’écosystème de la Raspberry Pi.

Depuis quelques temps les deux acteurs majeurs des systèmes d’exploitations grand public, Microsoft avec Windows et Apple avec OS X, changent un peu de position concernant le libre en général et notamment Linux.

Récemment, Apple a ouvert la porte en rendant open source son langage de programmation Swift, et en clamant haut et fort qu’Apple aime le libre. Si l’initiative est louable (même si cela ressemble beaucoup à de l’Open-Washing), après des années à tout verrouiller autant vous dire que l’accueil par la communauté a été mitigé.

Le géant de Cupertino cherche donc à se rapprocher de la communauté et veut pour cela passer par les blogueurs spécialisés, lesquels disposent de plus de légitimité auprès du public (et soyons honnête, lesquels seront disponibles pour faire du support de qualité et accompagner les utilisateurs, ce qu’Apple ne semble pas très décidé à faire).

La nouvelle Raspberry Pi 3 permet à Apple de faire tourner OS X

Si vous avez lu notre article sur la nouvelle Raspberry Pi 3, vous savez que celle-ci dispose désormais d’un processeur ARM avec une architecture 64 bits.

Après discussion avec Apple, nous avons appris que la firme s’intéressait fortement à la Raspberry Pi depuis à peu près 8 mois, mais qu’ils étaient jusqu’à présent limités par l’architecture ARM 32 bits du processeur.

Cependant, avec la nouvelle Raspberry Pi 3, la situation a changé. En effet, le nouveau processeur 64 bits de la Raspberry Pi se rapproche davantage de l’A7 utilisé par Apple pour certains produits mobiles.

Ce changement a permis à Apple de travailler sur une adaptation de Mac OS X sur la Raspberry Pi 3.

Et bonne nouvelle, il ne s’agirait pas d’un simple iOS, mais bien d’une version adaptée à la Raspberry Pi (probablement plus légère donc) de OS X. Nous avons pu obtenir un premier aperçu du produit (encore en plein développement) qui montre ce que devrait donner l’interface (il n’est pas certain que le produit final aura effectivement cette apparence, de notre côté nous pensons qu’Apple la modifiera probablement pour diminuer les ressources graphiques, mais il ne s’agit que d’une simple supposition de notre part).

Os X sur la Raspberry Pi en mode flat design

Une date non officielle mais un système d’exploitation gratuit

Vous l’avez compris, si Apple nous a contacté, c’est évidemment pour être sûr que nous parlerions d’OS X lors de sa sortie sur la Raspberry Pi, mais également pour être certain que nous assurerions une certaine forme de support auprès de la communauté.

Nous n’avons pas pu obtenir de date officielle quant au lancement du produit, celui-ci n’étant pas encore totalement finalisé, mais en insistant sur le fait que nous avions besoin d’au moins une estimation, nous avons tout de même pu obtenir une indication.

Une annonce officielle devrait donc être faite au début du mois de juillet pour présenter au public le produit dans sa forme quasi finie, et une première bêta publique devrait être disponible courant septembre !

En revanche, Apple a été très clair sur un point, ce nouveau système d’exploitation sera gratuit ! Une stratégie qui semble cohérente avec le tournant prix par Apple ces dernières années concernant les mises à niveau gratuites des anciens systèmes vers El Capitain par exemple !

Vous n’avez rien remarqué d’étrange ? Vraiment rien ? Poisson d’avril !

Cet article Installer Mac OS X sur la Raspberry Pi 3, ce sera bientôt possible ! est apparu en premier sur Raspbian-France.

Gravatar de RaspbianFrance
Original post of RaspbianFrance.Votez pour ce billet sur Planet Libre.

Articles similaires

Framablog : Le Guide Libre Association 2016 est arrivé ! (avec l’APRIL)

Toute association, quelle que soit sa taille, a besoin de communiquer avec ses membres, produire des documents, diffuser de l’information vers l’extérieur, bref elle a besoin d’un système d’informations structuré et adapté à ses besoins.

Pour autant, toutes les associations ne sont pas logées à la même enseigne lorsqu’il s’agit de choisir et de mettre en place des logiciels adaptés à leurs activités et à leur mode de fonctionnement. Bien souvent, l’achat de matériel informatique et de logiciels est un budget qui pèse lourd et, par manque de compétences sur le sujet, les choix se font par défaut.

Des logiciels libres pour les associations

Combien d’associations restent dépendantes d’outils privateurs ? La plupart du temps sans locaux dédiés, les associations fonctionnent avec les logiciels et les machines possédés par leurs bénévoles. Très peu d’entre eux sont prêts à investir du temps dans la recherche d’outils libres adaptés aux besoins de l’association quand « tout semble si simple » avec les logiciels imposés et vendus avec l’achat d’un ordinateur. Il peut sembler légitime de dédier le plus de temps possible à l’objet de l’association. Pourtant, pour la gestion des adhérents, la comptabilité, les tâches administratives diverses ou encore la communication, choisir des logiciels libres n’est pas qu’une question technique, c’est d’abord une question éminemment stratégique et politique à laquelle il convient de répondre pour renforcer la cohérence avec les valeurs portées par le monde associatif.

Extrait de l'expolibre de l'APRIL

Extrait de l’expolibre de l’APRIL

Le premier enjeu est de saisir l’importance de s’affranchir des contraintes imposées par les logiciels privateurs. On peut citer les mises à jour payantes et souvent remises à plus tard (et donc causes de dysfonctionnements dans la gestion de l’asso), les questions liés à la confidentialité des données (en particulier lorsqu’on stocke des données d’adhérents dans les nuages), les problèmes d’interopérabilité dans la diffusion de fichiers (surtout lorsqu’on cherche à rédiger un document à plusieurs mains), etc.

L’offre de logiciels libres permet non seulement d’effectuer des choix pertinents en identifiant les besoins mais elle permet aussi un très haut niveau d’appropriation des logiciels. Cela est rendu possible par l’exercice des libertés logicielles qui les rendent auditables, partageables et modifiables. Chaque logiciel libre peut se partager : l’utilisation d’un même logiciel chez chaque membre d’une association est facilité. En d’autres termes, utiliser des logiciels libres, pour une association, cela revient à augmenter son niveau de productivité. Et l’utilisation, ici, de termes habituellement adaptés à l’entreprise, est non seulement volontaire mais aussi révélatrice.

Le second enjeu réside dans la spécificité de création des logiciels libres. Ces derniers sont issus de communautés œuvrant pour le bien commun. La plupart de ces communautés sont structurées à la fois par des armées (ou un simple noyau) de contributeurs autour de formes associatives ou apparentées. Autrement dit, avec les logiciels libres, les associations parlent aux associations. On peut s’appuyer sur une communauté pour assurer un support, on peut aussi s’entraider. Le logiciel libre encourage le contact humain et se rapprocher des acteurs de la communauté est souvent un bon moyen d’avancer dans ses choix et ses usages. Dans le cas de structures associatives importantes, il sera sans doute préférable de se tourner vers des entreprises spécialisées dans l’intégration et dans la formation aux logiciels libres. Dans tous les cas, les logiques de collaboration et l’éthique propre aux logiciels libres seront vraisemblablement présentes.

Une nouvelle version du Guide Libre Association

Ce rapport entre logiciel libre et association est le principal thème de travail du groupe de travail Libre Association de l’April dont la volonté est de « créer des ponts entre le logiciel libre et le monde associatif ». Ce groupe a mené deux enquêtes (une première en 2009 et une seconde en 2015) auprès d’associations pour connaître leurs rapports à l’informatique et aux logiciels libres en particulier. Une conclusion de la comparaison de ces deux enquêtes révèle que la question principale en 2009 « que sont les logiciels libres ? » est devenue en 2015 « Comment fait-on pour les adopter ? ». En effet, avec l’extension des accès à Internet et l’évolution positives de l’accès aux logiciels libres, les associations sont devenues non seulement plus réceptives aux libertés logicielles mais sont devenues aussi très attentives aux usages des données informatiques ; en particulier dans une ère post- affaire Snowden. Cela est d’autant plus vrai, qu’un nombre conséquent d’associations attache une importance cruciale à la notion de droits fondamentaux et en particulier à la liberté d’expression.

Forte de ces connaissances, en 2012, l’April a lancé une première version du Guide Libre Association avec le soutien de la fondation du Crédit Coopératif. L’objectif était ambitieux : diffuser des milliers d’exemplaires gratuits d’un guide exposant les enjeux du Libre pour les associations, assorti d’une sélection pertinente de logiciels libres disponibles et constituant une offre mature. En 2014, devant le succès de la première diffusion, c’est au tour de la MACIF de s’associer à cette action pour distribuer à nouveau gratuitement plus de 7000 guides aux associations.

Guide Libre Association

Cliquez sur la couverture pour télécharger ou acheter le guide

Cette fois, en 2016, l’April et Framasoft proposent une nouvelle version mise à jour de ce guide. Disponible en couleurs ou en noir et blanc, il est possible de le télécharger au format e-pub et PDF, pour une diffusion libre sur tous les supports. Deux versions PDF imprimables sont elles aussi disponibles pour les associations désirant faire imprimer autant d’exemplaires qu’elles le souhaitent.

Vous pouvez retrouver tout cela sur la page Framabook dédiée au guide du Groupe Libre Association.

Nota : Sur le modèle de la collection Framabook, Framasoft propose aussi la vente unitaire du Guide, ou de faire imprimer à tarif intéressant des centaines ou des milliers d’exemplaires.

Gravatar de Framablog
Original post of Framablog.Votez pour ce billet sur Planet Libre.

Articles similaires

Carl Chenet : Le danger Github (revu et augmenté)

Suivez-moi aussi sur Diaspora*diaspora-banner ou Twitter 

Alors que le projet CPython (implémentation historique du projet Python) a annoncé son passage chez Github (avec quelques restrictions, nous reviendrons là-dessus), il est plus que jamais important de s’interroger sur les risques encourus d’utiliser un logiciel propriétaire dans notre chaîne de création du Logiciel Libre.

Des voix critiques s’élèvent régulièrement contre les risques encourus par l’utilisation de Github par les projets du Logiciel Libre. Et pourtant l’engouement autour de la forge collaborative de la startup Californienne à l’octocat continue de grandir.

codercatL’octocat, mascotte de Github

Ressentis à tort ou à raison comme simples à utiliser, efficaces à l’utilisation quotidienne, proposant des fonctionnalités pertinentes pour le travail collaboratif en entreprise ou dans le cadre d’un projet de Logiciel Libre, s’interconnectant aujourd’hui à de très nombreux services d’intégration continue, les services offerts par Github ont pris une place considérable dans l’ingénierie logicielle ces dernières années.

Quelles sont ces critiques et sont-elles justifiées ? Nous proposons de les exposer dans un premier temps dans la suite de cet article avant de peser le pour ou contre de leur validité.

1. Points critiques 1.1 La centralisation

L’application Github appartient et est gérée par une entité unique, à savoir Github, inc, société américaine. On comprend donc rapidement qu’une seule société commerciale de droit américain gère l’accessibilité à la majorité des codes sources des applications du Logiciel Libre, ce qui représente un problème pour les groupes utilisant un code source qui devient indisponible, pour une raison politique ou technique.

github-logo

De plus cette centralisation pose un problème supplémentaire : de par sa taille, ayant atteint une masse critique, elle s’auto-alimente. Les personnes n’utilisant pas Github, volontairement ou non, s’isolent de celles qui l’utilisent, repoussées peu à peu dans une minorité silencieuse. Avec l’effet de mode, on est pas « dans le coup » quand on n’utilise pas Github, phénomène que l’on rencontre également et même devenu typique des réseaux sociaux propriétaires (Facebook, Twitter, Instagram).

1.2 Un logiciel privateur

Lorsque vous interagissez avec Github, vous utilisez un logiciel privateur, dont le code source n’est pas accessible et qui ne fonctionne peut-être pas comme vous le pensez. Cela peut apparaître gênant à plusieurs points de vue. Idéologique tout d’abord, mais peut-être et avant tout pratique. Dans le cas de Github on y pousse du code que nous contrôlons hors de leur interface. On y communique également des informations personnelles (profil, interactions avec Github). Et surtout un outil crucial propriétaire fourni par Github qui s’impose aux projets qui décident de passer chez la société américaine : le gestionnaire de suivi de bugs.

windowsWindows, qui reste le logiciel privateur par excellence, même si d’autres l’ont depuis rejoint1.3 L’uniformisation

Travailler via l’interface Github est considéré par beaucoup comme simple et intuitif. De très nombreuses sociétés utilisent maintenant Github comme dépôt de sources et il est courant qu’un développeur quittant une société retrouve le cadre de travail des outils Github en travaillant pour une autre société. Cette fréquence de l’utilisation de Github dans l’activité de développeur du Libre aujourd’hui participe à l’uniformisation du cadre de travail dudit développeur.

L'uniforme évoque l'armée, ici l'armée des clonesL’uniforme évoque l’armée, ici l’armée des clones2. Validité des points critiques 2.1 Les critiques de la centralisation 2.1.1 Taux de disponibilité du service

Comme dit précédemment, Github est aujourd’hui la plus grande concentration de code source du Logiciel Libre. Cela fait de lui une cible privilégiée.  Des attaques massives par dénis de service ont eu lieu en mars et août 2015. De même, une panne le 15 décembre 2015 a entraîné l’indisponibilité de 5% des dépôts. Idem le 15 novembre. Et il s’agit des incidents récents déclarés par les équipes de Github elles-mêmes. On peut imaginer un taux d’indisponibilité moyen des services bien supérieur.

githubdown

2.1.2 Blocage de la construction du Logiciel Libre par réaction en chaîne

Aujourd’hui plusieurs outils de gestion des dépendances comme npm dans le monde javascript, Bundler dans le monde Ruby ou même pip pour le monde Python sont capables d’aller chercher le code source d’une application directement depuis Github. Les projets du Logiciel Libre étant de plus en plus intriqués, dépendants les uns des autres, si l’un des composants de la chaîne de construction vient à manquer, c’est toute la chaîne qui s’arrête.

Un excellent exemple de cet état de fait est la récente affaire du npmgate (voir l’article Du danger d’un acteur non-communautaire dans votre chaîne de production du Logiciel Libre). Github peut très bien demain être mis en demeure par une entreprise de retirer du code source de son dépôt, ce qui pourrait entraîner une réaction en chaîne menant à l’impossibilité de construire de nombreux projets du Logiciel Libre, comme cela vient d’arriver à la communauté Node.js à cause de la société Npm, inc. gérant l’infrastructure de l’installeur automatisé npm.

2.2 Un peu de recul historique : SourceForge

Même si l’ampleur du phénomène n’a pas été la même, il est bon de rappeler que Github n’est pas apparu ex-nihilo et avait un prédécesseur ayant joui en son temps d’un engouement important : SourceForge.

Fortement centralisé, reposant également sur de fortes interactions avec la communauté, SourceForge est un SAAS fortement vieillissant  ces dernières années et subit une véritable hémorragie de ses utilisateurs au profit de Github. Ce qui signifie beaucoup d’ennuis pour ceux qui y sont restés. Pour le projet Gimp, il s’agit tout d’abord d’abus publicitaires trompeurs indignes, qui entraînent également le départ du projet VLC , puis l’apparition d’installeurs comprenant des adwares se faisant passer pour l’installeur officiel Windows de Gimp. Et enfin purement et simplement le piratage du compte SourceForge du projet Gimp par… les équipes de SourceForge elle-même.

Nous voyons ici des exemples récents et très concrets des pratiques dont sont capables les sociétés commerciales lorsqu’elles sont sous la pression de leurs actionnaires. D’où la nécessité de bien comprendre l’enjeu représenté par le fait de leur confier une centralisation des données et des échanges ayant de fortes conséquences sur le fonctionnement et les usages de la communauté du Logiciel Libre et opensource.

 

2.3 Les critiques relatives à utiliser un logiciel privateur 2.3.1 Une communauté, différents rapports au logiciel propriétaire

Cette critique, avant tout idéologique, se heurte à la conception même que chacun des membres de la communauté se fait du Logiciel Libre et opensource, et en particulier d’un critère : contaminant ou non, qu’on résume en général par GPL versus MIT/BSD.

 

bsdvsgpl

Les défenseurs du Logiciel Libre contaminant vont être gênés d’utiliser un logiciel propriétaire car ce dernier ne devrait pas exister. Il doit être assimilé, pour citer Star Trek,  car il est une boîte noire communicante, qui met en danger la vie privée, détourne nos usages à des fins commerciales, gêne ou contraint la liberté de jouir entièrement de ce qu’on a acquis, etc.

gplv3

Les pendants d’une totale liberté sont moins complexés dans leur utilisation des logiciels privateurs puisqu’ils acceptent l’existence desdits logiciels privateurs au nom d’une liberté sans restriction. Ils acceptent même que le code qu’ils développent aboutissent dans ces logiciels, ce qui arrive bien plus souvent qu’on ne le croit, voir à ce sujet la liste à couper le souffle des produits commerciaux reposant sur FreeBSD. On peut donc voir dans cette aile de la communauté du Logiciel Libre une totale sérénité à utiliser Github. Et ce qui est cohérent vis-à-vis de l’idéologie soutenue. Si vous êtes déjà allé au Fosdem, un coup d’œil dans l’amphithéâtre Janson permet de se rendre compte de la présence massive de portables Apple tournant sous MacOSX.

FreeBSD, principal projet des BSD sous licence MITFreeBSD, principal projet des BSD sous licence BSD2.3.2 Les pertes de données et obstructions liées à l’usage d’un logiciel privateur

Mais au-delà de cet aspect idéologique pur et pour recentrer sur l’infrastructure de Github elle-même, l’utilisation du gestionnaire de suivi de bugs de Github pose un problème incontournable. Les rapports de bugs sont la mémoire des projets du Logiciel Libre. Il constitue le point d’entrée des nouveaux contributeurs, des demandes de fonctionnalités, des rapports de bugs et donc la mémoire, l’histoire du projet qui ne peut se limiter au code seul. Il est courant de tomber sur des rapports de bugs lorsque vous copiez/collez votre message d’erreur dans un moteur de recherche. Mémoire précieuse non seulement pour le projet lui-même, mais aussi pour ses utilisateurs actuels et à venir.

Github propose d’extraire les rapports de bugs via son API, certes, mais combien de projets anticiperont une éventuelle défaillance de Github  ou un retournement de situation arrêtant brusquement le service ? Très peu à mon avis. Et comment migrer vers un nouveau système de suivi de bugs les données fournies par Github ?

L’exemple de l’utilitaire de gestion de listes de choses à faire (TODO list) Astrid, racheté par Yahoo! il y a quelques années reste un très bon exemple de service ayant grandi rapidement, largement utilisé et qui a fermé du jour au lendemain, proposant pendant quelques semaines seulement d’extraire ses données. Et il s’agissait là d’un simple gestionnaire de tâches à faire. Le même problème chez Github serait dramatiquement plus difficile à gérer pour de très nombreux projets, si on leur laisse la possibilité de le gérer. Certes le code reste disponible et pourra continuer de vivre ailleurs, mais la mémoire du projet sera perdue, alors qu’un projet comme Debian approche aujourd’hui les 800000 rapports de bugs. Une vraie mine d’or d’informations sur les problèmes rencontrés, les demandes de fonctionnalités et le suivi de ces demandes. Les développeurs du projet CPython passant chez Github ont anticipé ce problème et ne vont pas utiliser le système de suivi de bugs de Github.

mastering-issuesIssues, le suivi de bug propriétaire de Github

Autre perte si Github disparaît ou devient inaccessible : le travail de revue des « push requests » (abrégées par PRs) en cours. Pour les lecteurs qui ne connaîtraient pas cette fonctionnalité de Github, il s’agit d’adresser de cloner le dépôt Github d’un projet, de modifier ce clone pour l’adapter à vos besoins, puis ensuite de proposer vos modifications au dépôt d’origine. Le propriétaire du dépôt d’origine va alors étudier les modifications qui lui ont été proposées et si elles lui conviennent les fusionner à son propre dépôt. Il s’agit donc d’une fonctionnalité très importante offerte de Github, qui propose de réaliser les différentes opérations graphiquement via son interface.

Toutefois le travail de revue des modifications proposées peut être long et il est courant d’avoir, pour un projet qui marche bien, plusieurs PRs en cours. Et il est également courant d’échanger des commentaires via ces PRs et/ou via le système de suivi de bugs propriétaires de Github dont nous avons parlé plus haut.

Le code en lui-même n’est donc pas perdu si Github devient inaccessible (quoique, voire plus bas un cas spécifique), mais le travail de revue matérialisée par les éventuels demandes et commentaires présents dans les PRs et les suivis de bugs associés l’est bien, lui. Rappelons également que Github permet de cloner des projets via son interface web propriétaire, puis d’y apporter toujours via la même interface des modifications et ensuite de générer des PRs sans télécharger aucunement le code sur son poste. Dans ce cas de figure, si Github devient indisponible, la perte du code et du travail en cours est totale.

Enfin certains utilisateurs se servent de Github entre autre comme d’une application de favoris, afin de suivre l’activité de leurs projets préférés en s’abonnant à ces projets par la fonctionnalité « Watch ».  Ce travail de réunion de données pour la veille technologique est perdu  en cas d’indisponibilité du service Github.

Proposed Debian LogoDebian, l’un des principaux projets du Logiciel Libre avec autour de 1000 contributeurs officiels

 

2.4 L’uniformisation

La communauté du Logiciel Libre oscille sans cesse entre un besoin de normes afin de réduire le travail nécessaire pour l’interopérabilité et l’attrait de la nouveauté, caractérisée par l’intrinsèque besoin de différence vis-à-vis de l’existant.

Github a popularisé l’utilisation de Git, magnifique outil qui aujourd’hui touche des métiers bien différents des programmeurs auxquels il était initialement lié. Peu à peu, tel un rouleau compresseur, Git a pris une place si centrale que considérer l’usage d’un autre gestionnaire de sources est quasiment impossible aujourd’hui, particulièrement en entreprise, malgré l’existence de belles alternatives qui n’ont malheureusement pas le vent en poupe, comme Mercurial.

git-logo

Un projet de Logiciel Libre qui naît aujourd’hui, c’est un dépôt Git sur Github avec un README.md pour sommairement le décrire. Les autres voies sont totalement ostracisées. Et quelle est la punition pour celui qui désobéit ? Peu ou pas de contributeurs potentiels. Il semble très difficile de pousser aujourd’hui le contributeur potentiel à se lancer dans l’apprentissage d’un nouveau gestionnaire de sources ET une nouvelle forge pour chaque projet auquel on veut contribuer. Un effort que fournissait pourtant tout un chacun il y a quelques années.

Et c’est bien dommage car Github, en proposant une expérience unique et originale à ses utilisateurs, taille  à grands coups de machette dans les champs des possibles. Alors oui, sûrement que Git est aujourd’hui le meilleur des système de gestion de versions. Mais ça n’est pas grâce à cette domination sans partage qu’un autre pourra émerger. Et cela permet à Github d’initier à Git les nouveaux arrivants dans le développement  à un ensemble de fonctionnalités très restreint, sans commune mesure avec la puissance de l’outil Git lui-même.

3. Centralisation, uniformisation, logiciels privateurs et bientôt… fainéantise ?

Le combat contre la centralisation est une part importante de l’idéologie du Logiciel Libre car elle accroît le pouvoir de ceux qui sont chargés de cette centralisation et qui la contrôlent sur ceux qui la subissent. L’aversion à l’uniformisation née du combat contre les grandes firmes du logiciel souhaitant imposer leur vision fermée et commerciale du monde du logiciel a longtemps nourri la recherche réelle d’innovation et le développement d’alternatives brillantes. Comme nous l’avons décrit, une partie de la communauté du Libre s’est construit en opposition aux logiciels privateurs, les considérant comme dangereux. L’autre partie, sans vouloir leur disparition, a quand même choisi un modèle de développement à l’opposé de celui des logiciels privateurs, en tout cas à l’époque car les deux mondes sont devenus de plus en plus poreux au cours des dernières années.

 

L’effet Github est donc délétère au point de vue des effets qu’il entraîne : la centralisation,  l’uniformisation, l’utilisation de logiciels privateurs comme leur système de gestion de version, au minimum. Mais la récente affaire de la lettre « Cher Github… » met en avant un dernier effet, totalement inattendu de mon point de vue : la fainéantise. Pour les personnes passées à côté de cette affaire, il s’agit d’une lettre de réclamations d’un nombre très important de représentants de différents projets du Logiciel Libre qui réclament à l’équipe de Github d’entendre leurs doléances, apparemment ignorées depuis des années, et d’implémenter de nouvelles fonctionnalités demandées.

Mais depuis quand des projets du Logiciel Libre qui se heurtent depuis des années à un mur tentent-ils de faire pleurer le mur et n’implémentent pas la solution qui leur manquent ? Lorsque Torvald a subi l’affaire Bitkeeper et que l’équipe de développement du noyau Linux n’a plus eu l’autorisation d’utiliser leur gestionnaire de versions, Linus a mis au point Git. Doit-on rappeler que l’impossibilité d’utiliser un outil ou le manque de fonctionnalités d’un programme est le moteur principal de la recherche d’alternative et donc du Logiciel Libre ? Tous les membres de la communauté du Logiciel Libre capable de programmer devrait avoir ce réflexe. Vous n’aimez pas ce qu’offre Github ? Optez pour Gitlab. Vous n’aimez pas Gitlab ? Améliorez-le ou recodez-le.

gitlabLogo de Gitlab, une alternative possible à Github

Que l’on soit bien d’accord, je ne dis pas que tout programmeur du Libre qui fait face à un mur doit coder une alternative. En restant réaliste, nous avons tous nos priorités et certains de nous aiment dormir la nuit (moi le premier). Mais lorsqu’on voit 1340 signataires de cette lettre à Github et parmi lesquels des représentants de très grands projets du Logiciel Libre, il me paraît évident que les volontés et l’énergie pour coder une alternative existe. Peut-être d’ailleurs apparaîtra-t-elle suite à cette lettre, ce serait le meilleur dénouement possible à cette affaire.

Finalement, l’utilisation de Github suit cette tendance de massification de l’utilisation d’Internet. Comme aujourd’hui les utilisateurs d’Internet sont aspirés dans des réseaux sociaux massivement centralisés comme Facebook et Twitter, le monde des développeurs suit logiquement cette tendance avec Github. Même si une frange importante des développeurs a été sensibilisée aux dangers de ce type d’organisation privée et centralisée, la communauté entière a été absorbée dans un mouvement de centralisation et d’uniformisation. Le service offert est utile, gratuit ou à un coût correct selon les fonctionnalités désirées, confortable à utiliser et fonctionne la plupart du temps. Pourquoi chercherions-nous plus loin ? Peut-être parce que d’autres en profitent et profitent de nous pendant que nous sommes distraits et installés dans notre confort ? La communauté du Logiciel Libre semble pour le moment bien assoupie.

cat-sleeping-fireplaceLe « lion » devant la cheminée

Texte sous licence Creative Commons CC BY-ND 3.0 FR


Gravatar de Carl Chenet
Original post of Carl Chenet.Votez pour ce billet sur Planet Libre.

Articles similaires

Pages