Metal3d

Oui, python peut rivaliser avec C et Rust

Sun, 28 Sep 2025 09:27:35 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Je ne sais pas si c’est par frustration ou par snobisme, mais Python n’a jamais été aussi critiqué pour sa “lenteur” que depuis qu’il est le langage le plus utilisé au monde.

On ne choisit pas Python pour sa vitesse d’exécution, mais pour sa vitesse de production.

Cependant, la plupart des détracteurs de Python oubli une chose importante, c’est que Python est utilisé comme un langage d’interface à des modules développés dans d’autres langages.

Python est très utilisé dans le domaine de l’IA. Vous êtes conscient que s’il y a bien un domaine dans lequel il est nécessaire d’avoir de la vitesse, c’est bien celui-là ! Pourtant, il reste le langage favori des chercheurs en data-science. C’est tout simplement parce que TensorFlow, PyTorch, NumPy et autres bibliothèques de calcul intensif ne sont pas directement développés en Python. Python nous donne accès à des trucs codés en C, C++, Rust, etc.

Alors, sommes-nous limité à devoir développer des modules en C/C++/Rust pour faire du calcul intensif ? Pas forcément.

Depuis 2007, une série d’outils dont vous avez certainement entendu parler, permettent de compiler du code Python et accéder à des performances proches de celles de C/C++/Rust. Et son nom, vous l’avez certainement déjà croisé, c’est Cython

TL;DR

Importez from cython import int, ccall dans votre module Python, ajoutez @ccall au-dessus de vos fonctions. Importez aussi les types que vous voulez utiliser (float, double, char, etc) depuis cython.

Ajoutez les annotations de type aux arguments et aux retours de vos fonctions.

from cython import int, float, ccall

@ccall
def votre_fonction(arg1: int, arg2: float) -> float:
    # votre code ici
    pass

Compilez votre module avec la commande :

cythonize -i -3 votre_module.py

Fini… Votre module rivalise avec C et Rust.

Maintenant, si vous voulez comprendre ce qu’il se passe, lisez la suite.

Cython

À ne pas confondre avec CPython qui est le nom que l’on donne à Python pour le différencier des autres implémentations (Jython, PyPY, mypy…). Cython, j’en avais déjà parlé dans un vieil article, mais il traitait essentiellement d’accéder à des librairies partagées.

Là, on va vraiment faire du code, et mesurer.

Cython peut faire plusieurs choses :

Compiler du code Python en passant par du C
Utiliser un langage adapté, le Pyrex, qui permet d’utiliser des types statiques
S’intégrer dans un module pour proposer des types et des décorateurs pour améliorer la compilation
Et pas mal de choses…

J’aime beaucoup Pyrex, mais je vais vous montrer une chose que j’ai pris l’habitude de faire pour gagner du temps.

Si vous avez pris l’habitude d’annoter vos fonctions (avec des types que Python n’utilise pas), alors ça va être ultra-simple.

Prenons l’exemple d’une suite de Fibonacci. C’est un classique, mais c’est un bon exemple pour faire un test de performances.

# fib.py
def fib(n: int) -> int:
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

Ce bout de code, si je l’appelle avec “n=40”, sur ma machine, il va prendre 10 secondes.

Pour les mesures, je vais l’appeler avec ce bout de code :

import sys
from fib import fib

iteration= sys.argv[1] if len(sys.argv) > 1 else 1
for i in range(int(iteration)):
  fib(40)

Si je le fait tourner plusieurs fois, c’est pour éviter d’avoir un biais dû au “warm up”. Parce que si je ne l’appelle qu’une seule fois, Python bat Rust à pleines coutures. Cette hérésie me vaudrait un bon vieux shitstorm et j’ai pas envie de passer mon temps à bannir des trolls.

En pur Python : pythnon main.py ne va appeler fib(40) qu’une seule fois et va prendre 10 secondes. 10 secondes, c’est énorme. Et là, oui, Python est lent. Plus lent que la majorité des langages compilés.

Première compilation, à la bourrin

On peut déjà compiler le code tel quel, sans rien changer. Le gain ne sera pas énorme, mais vous allez voir que ça a déjà un impact.

cythonize -i -3 fib.py

Cela produit un fichier “.so” (sur Linux) et Python est assez malin pour savoir qu’il doit importer la librairie à la place de “fib.py”.

Testons le temps d’exécution.

time python main.py

Cette fois, le temps d’exécution de fib(40) tombe à 7 secondes. Donc, un gain de 30%. Pas mal, mais on n’est toujours pas proche de ce que je vois en C, en Rust, ou Java ou en Go.

On va donc passer aux choses sérieuses.

Le coup de pouce

La documentation est vraiment claire. Soit, vous refaites votre code en Pyrex, soit vous utilisez un peu de magie. Et voici ce que je vous propose : ne pas toucher au code Python à part forcer les types et décorer la fonction.

Donc on ajoute juste deux lignes :

from cython import int, ccall

@ccall
def fib(n: int) -> int:
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

Le fait d’avoir annoté les types a été une bonne chose, car maintenant, le type “int” n’est plus le “type natif” de Python, mais un int qui sera vu tel quel dans le code C que Cython va produire.

Et, ccal, à lire “C Call” (appel en C), va faire en sorte de produire une fonction en C et une fonction accessible depuis Python lors de la compilation.

On va compiler le module avec la commande suivante :

cythonize -i -3 fib.py

Et là, le temps d’exécution de fib(40) tombe à… 0.14 seconde. Oui, vous avez bien lu, 0.14 seconde. Soit un facteur de réduction de 100 !

Non mais attend, c’est quoi tout ça ?

Je vous laisse aller lire les documentations, mais je vais essayer de vous résumer ce qu’il se passe.

Cython, à la base, permet de compiler du code Python en C. À l’origine, il fallait utiliser un langage dédié, le Pyrex, très proche de Python. Pyrex propose des définitions spécifiques pour définir les types, les fonctions et les classes. Et en soit, on aurait pu réécrire la fonction en Pyrex :

# fichier fib.pyx

cdef _fib(int n):
  # sera compilé en C
  if n <= 1:
      return n
  return fib(n - 1) + fib(n - 2)

def fib(int n):
  # enveloppe l'appel C pour la rendre accessible depuis Python
  return _fib(n)

La définition cdef permet de définir une fonction qui ne sera pas accessible depuis Python. C’est une fonction qui sera traduite en C.

Pyrex accepte aussi def qui permet de définir une fonction qui sera accessible depuis Python. Et donc non compilée. C’est pour cela que je fais, ici, une fonction qui permet d’envelopper l’appel C.

Cython propose aussi cpdef qui permet de faire les deux en même temps. C’est-à-dire, qu’il fait pour nous la fonction en C et l’enveloppe Python.

cpdef fib(int n):
  if n <= 1:
      return n
  return fib(n - 1) + fib(n - 2)

Pratique, mais on reste dans un langage dédié.

Mais depuis quelques années, nous avons pris l’habitude d’annoter nos fonctions Python avec des types. Python se fout de ses annotations, c’est surtout pratique pour les IDE et les outils de vérification de type comme mypy.

Sauf que les auteurs de Cython ont eu la bonne idée de proposer de les gérer. A condition de bien définir qu’un “int” est un “int” du langage C. C’est pour cela que j’importe int depuis cython.

Et, @ccall permet de dire que cette fonction doit être compilée en C et qu’une enveloppe Python doit être créée, tout comme on le ferait avec cpdef dans un script Pyrex.

Cela rend vraiment la vie plus simple. On peut garder son code Python, et juste ajouter des annotations de type et des décorateurs. Sans compilation, le code Python est exactement le même et fonctionne de la même manière. Un coup de cythonize et nous avons toutes les optimisations de Cython.

Dans un projet

On ne va pas s’amuser à taper des commandes cythonize à la main. Ce que l’on va faire, c’est adapter notre fichier pyproject.toml pour définir un module d’extension.

[build-system]
requires = ["setuptools", "cython"]

[tool.setuptools]
packages = ["example"]

[tool.setuptools.ext_modules]
fib = { sources = ["example/fib.py"], language = "c" }

Et quand votre projet sera installé, le module sera compilé automatiquement.

On compare avec C

Alors, on pourrait se demander si en C, on ferait mieux, et bien tentons :

#include <stdio.h>
#include <stdlib.h>

uint fib(int n) {
    if (n <= 1) {
        return n;
    }
    return fib(n - 1) + fib(n - 2);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <n>\n", argv[0]);
        return 1;
    }
    int n = atoi(argv[1]);
    printf("%u\n", fib(n));
    return 0;
}

Si je compile avec :

gcc -Ofast -march=native -o fib fib.c
time ./fib 40

Et que je lance ./fib 40, j’obtiens un temps d’exécution de 0.10 seconde. Donc, oui, c’est plus rapide, mais pas de beaucoup.

Avec Clang :

clang -O3 -march=native -ffast-math -o fib fib.c
time ./fib 40

Cette fois, on est à 0.04 seconde. Donc, on est 3.5 fois plus rapide que Cython.

Oui, Clang est vraiment un bon compilateur. Et sur des tâches mathématiques, il est souvent plus rapide que GCC.

Benchmark

Pour ne pas se faire avoir par le “warm up”, il faut appeler plusieurs fois la fonction dans le même processus. Sinon, vous allez avoir un biais monstre. Je me suis amusé à coder la fonction en C, Go, en Rust, en Java, en pur Python avec et sans compilation cythonize.

Pour C, je tente avec deux compilateurs : clang et gcc.
Je n’ai pas trouvé comment bien utiliser clang avec cythonize, tous mes tests avaient un temps catastrophique. Je suis donc resté sur GCC.
J’utilise OpenJDK 21.0.8 pour la version Java
Go 1.25

Les options de compilation sont prévues pour optimiser au mieux :

rustc prend les options -C opt-level=3
clang prend les options -O3 -march=native -ffast-math
gcc utilise les options -Ofast -march=native

Il y a certainement de meilleures options, mais le but ici est de montrer que Cython donne un vrai gain.

C’est sans appel…

Clairement, Python “pur” est complètement à la ramasse. Cython fait une énorme différence.

On peut, bien entendu, mettre le graphique en échelle logarithmique pour mieux voir les différences entre les langages compilés.

Si je supprime Python, on voit mieux les différences entre les langages compilés.

Bien entendu que Rust est plus rapide (et encore heureux, c’est son seul atout¹…). Go semble très lent, mais je vous rappelle que Go n’utilise pas d’optimisation agressive comme Rust ou C/C++. Go est un langage qui compile vite, qui a des performances honorables, mais qui n’est pas fait pour faire du calcul intensif.

Java est dans la moyenne, mais il faut savoir que la JVM a un “warm up” important. Encore une fois, le but de Java n’est pas de faire du calcul intensif, mais d’avoir des performances honorables dans un environnement spécifique.

On reviendra sur le sujet dans quelques instants, mais j’insiste : on ne choisit pas un langage seulement pour sa vitesse d’exécution. On le choisit pour ses qualités d’intégration, de structuration, de maintenabilité etc. Sinon, on ferait tous de l’assembleur…

On remarque aussi que CLang est particulièrement bon. Je l’utilise plus souvent que GCC depuis quelques années, et je ne m’étais pas vraiment penché sur ses qualités d’optimisation. Il n’est clairement pas mauvais le bougre.

Attention

Il ne faut pas faire de déduction hâtive. Le code de Fibonacci est récursif et n’utilise pas de structures de données. C’est un cas particulier. Mais il montre que Cython peut faire une grosse différence.

Soyez sympas de ne pas utiliser cet article de manière fallacieuse. Oui, Rust est super rapide, oui Go est largement plus lent que Rust ou C.

Si je choisis très souvent le Go, c’est parce qu’il est largement assez rapide, que son langage est simple pour traiter des cas complexes d’asynchronisme, que son écosystème est riche. Je choisis Python pour traiter des données hétérogènes, accéder aux modules d’IA de manière simple, et comme je suis près à attendre 100 ms pour qu’une réponse HTTP arrive.

Je choisis rarement Rust, même si je suis parfaitement conscient de ses qualités. Mais sa syntaxe est lourde pour mon domaine d’activité.

J’ai arrêté le Java puisqu’il ne m’apporte absolument rien par rapport à Go, Python ou Rust.

Est-ce que vous devez faire pareil que moi ? NON !

Par contre, je donne un conseil général, apprenez plusieurs langages. Cela vous permet d’appréhender plusieurs méthodologies, plusieurs concepts que vous pouvez adapter à d’autres langages. Cela vous permet d’aller plus vite sur certaines tâches.

Par exemple, j’ai souvent besoin de “post-process” avec Helm, pour modifier du YAML à la volée. Croyez-moi, je ne le ferai jamais en Rust ou en C. Python est parfait pour ça.

Je vais le répéter, mais le but d’un langage n’est pas nécessairement la vitesse d’exécution. Python est exceptionnel pour travailler vite, traiter des données complexes sans avoir à passer des heures sur l’implémentation.

Rust a ses qualités, Go en a d’autres, Java aussi. Et dans les faits, tous les langages sont valables, tous ont une qualité que les autres n’ont pas.

Ce que je voulais vous montrer ici, c’est que pour Python, il existe un moyen de le faire calculer très vite, bien plus vite que si on le laissait en “pur Python”.

Je le répète, on passe de 10 secondes à 0.14 seconde !

Le code pour les benchmarks

Le code utilisé est le suivant, pour chaque langage :

use std::env::args;

fn fibo(n: u32) -> u32 {
    if n <= 1 {
        return n;
    }
    fibo(n - 1) + fibo(n - 2)
}

fn main() {
    let iteration: i32 = args()
        .collect::<Vec<_>>()
        .get(1)
        .expect("Please provide the iteration argument")
        .parse()
        .expect("Iteration must be an integer");


    let n = 40;
    for _ in 0..iteration {
        _ = fibo(n);
    }
}

package main

import (
	"os"
	"strconv"
)

func fibo(n uint) uint {
	if n <= 1 {
		return n
	}
	return fibo(n-2) + fibo(n-1)
}

func main() {
	iteration := os.Args[1]
	nbIteration, err := strconv.Atoi(iteration)
	if err != nil {
		panic(err)
	}

	for range nbIteration {
		_ = fibo(40)
	}
}

public class Main {
  public static void main(String[] args) {
    int iteration = Integer.parseInt(args[0]);
    for (int i = 0; i < iteration; i++) {
      fibonacci(40);
    }
  }

  public static int fibonacci(int n) {
    if (n <= 1) {
      return n;
    } else {
      return fibonacci(n - 1) + fibonacci(n - 2);
    }
  }
}

#include <stdint.h>
#include <stdlib.h>

uint32_t fibo(uint32_t n) {
  if (n <= 1)
    return n;

  return fibo(n - 1) + fibo(n - 2);
}

int main(int argc, char **argv) {
  if (argc != 2)
    return EXIT_FAILURE;

  char *count = argv[1];
  int n = atoi(count);

  // launch
  for (int i = 0; i < n; i++)
    fibo(40);

  return EXIT_SUCCESS;
}

Pour Python, le code du module est celui donné dans l’article, et le script de lancement est le suivant :

import sys

from fibo import fibo

if __name__ == "__main__":
    iteration = int(sys.argv[1]) if len(sys.argv) > 1 else 1
    for _ in range(iteration):
        fibo(40)

Toutes les importations sont appelées pour lancer 10 fois le calcul de fibo(40). Il m’a suffi de prendre le temps total et le diviser par 10 pour avoir le temps moyen.

Au final

Bien entendu, Python est un langage interprété, et il ne sera jamais aussi rapide que C, Rust ou Go. Je ne cesserai de le rappeler, mais on ne choisit pas un langage pour sa vitesse d’exécution. On le choisit pour sa capacité à nous permettre de travailler dans de bonnes conditions.

Cython apporte de la compilation à Python, et permet de faire du calcul intensif. Ce n’est pas la panacée, mais c’est une vraie solution pour améliorer les performances de certains modules.

Si les performances sont un critère important, alors il faut savoir que Python peut faire du calcul intensif. Au prix d’un peu de configuration, on peut obtenir des performances très honorables, proche du C, voire de Rust.

Mais, si la vitesse est le premier critère, alors il faut se tourner vers des langages compilés, adaptés à la tâche.

Je ne choisis Rust que dans les cas où j’ai besoin de performances extrêmes, et où je ne peux pas me permettre d’attendre 100 ms pour une réponse. Dans ce cas je suis prêt à passer du temps à écrire du code plus lourd et moins productif. Oui, vous l’avez compris, je ne suis pas fan de Rust…

Go propose un bon compromis entre vitesse, simplicité et productivité. C’est pour cela que je l’utilise très souvent.

Cependant, j’utilise énormément Python, parce que c’est un langage qui me permet de faire plein de choses rapidement. Si la vitesse me pose un souci (ce qui est rare), alors j’utilise Cython. Si je pense qu’un autre langage est plus approprié, je l’utilise. Je neme fige pas, j’ai appris une quinzaine de langages justement pour être à l’aise dans un maximum de situations.

Chaque langage a sa place.

oui je trolle un peu, j’ai le droit, c’est mon blog. ↩︎

PDM + uv, duo de choc pour vos projets Python

Sat, 20 Sep 2025 13:39:46 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si vous êtes un développeur Python, et que vous travailez avec des environnements virtuels et la gestion des dépendances, vous avez probablement entendu parler de pipenv et poetry.

Le principe reste le même : un outil pour gérer les dépendances, créer des environnements virtuels, et faciliter la gestion d’un projet Python. Aussi, ces outils permettent de construire et pousser les paquets sur PyPI. Moins de galère qu’un setup.py, plus sécurisant en terme de “lock” de version. Tout le monde est content. Ou pas…

Vous allez vite comprendre de quoi je parle, et je vais vous faire un topo des trucs lourdingues avant de vous parler de uv et de pdm. Mais si vous êtes pressé, un “too long; didn’t read” ça fait gagner du temps.

TL;DR

Ce que vous allez gagner :

Gain de place drastique sur le disque, résolution de dépendances très rapide grâce à uv et un excellent support pour les CI (build, test) et CD (publish avec gestion OIDC vers Gitlab par exemple)

Installez “uv” et “pdm”, personnellement j’utilise homebrew sur Linux:

brew install uv pdm

Sinon, uv est dans les paquets de Fedora. Pour pdm, allez voir la doc d’installation pour toutes les options (pipx, pip, usr, etc.).

Puis :

pdm config use_uv true

Créez votre projet avec :

pdm init

Et vous pouvez installer les dépendances avec :

pdm add package1 package2  # pour les dépendances normales
pdm add --group devel package3  # pour les dépendances de dev
pdm run python script.py # pour lancer un script dans l'env virtuel
pdm build # crée un paquet python
pdm publish # pousse le paquet sur PyPI

Vous aurez un cache d’installation globale, donc aucune réplication de paquets, les paquets sont liés avec des liens hard (hard links). C’est super rapide, et la création de paquets est très simple.

PDM permet de pousser vos paquets sur PyPI, et gère les scripts, les dépendances de développement, etc. C’est poetry mais dopé comme un coureur du tour de France.

pip, puis poetry

Qu’on se le dise, “pip” est l’outil “legacy”, le vieux pépère qui accompagne Python pour installer des paquets. Il fonctionne, il fait le job, et il sera toujours présent. Sauf que voilà… très vite vous vous prenez au jeu, vous faites des environnements virtuels, vous gérez des dépendances, et là, “pip” devient vite limité. Si si, soyon honnêtes, avoir un fichier de “requirements.txt” ça devient vite l’enfer. Outre la gestion de versions, quand vous voulez séaprer les dépendances de développement, de production, etc. Vous avez l’impression de bricoler.

Avant, on faisait ce genre de sorcellerie :

python -m venv .venv
source .venv/bin/activate
pip install flask
pip freeze > requirements.txt

Et on était content hein, on donnait ça à manger à nos collègues, et tout le monde tapait pip install -r requirements.txt. Et ils oubliaient de lancer source .venv/bin/activate et hop ça mettait les lib dans le répertoire utilisateur, et ça foutait le bazar. Bref, on se prenait les pieds dans le tapis.

Alors sont nés des outils comme pipenv et poetry pour nous simplifier la vie. Et franchement, ils font le job. J’ai clairement préféré poetry à pipenv, pour la simple et bonne raison qu’il utilise un fichier pyproject.toml qui est respectueux des standards Python.

Voir PEP 518 pour plus de détails.

Tout devient plus clair, on passe par la commande “poetry” pour tout. Démarrer le projet, ajouter des dépendances, grouper les packages de développement, etc. C’est vraiment top.

Mais… mais… je suis développeur Go, et un truc me chagrinait avec Python…

La centralisation

Quand on fait du Go, on utilise la commande “go get” pour récupérer des dépendances. Et tout est centralisé dans un seul et même répertoire, le fameux mod cache. Ça veut dire que si vous avez 10 projets Go, et que vous utilisez la même librairie et la même version, elle n’est téléchargée qu’une seule fois. Et, comme Go utilise un compilateur, il fait le lien entre la version qui se trouve dans le cache.

En clair, vous n’avez pas réellement d’environnement virtuel. Vous avez un cache de dépendances, et Go s’occupe de tout.

Beaucoup d’autres langages savent faire cela, par exemple Java avec Maven, Nodejs avec “pnpm”, etc.

Il y a des gens bien sur LinkedIn, et quand j’ai posé la question, un certain Thomas PEDOT me dit simplement “bah utilise UV !”

J’avais déjà regardé ce projet, construit par les mêmes auteurs que “ruff” (un excellent linter pour Python), mais je n’avais pas compris à quel point c’était génial.

uv est un gestionnaire de paquets et d’environnements virtuels pour Python qui a l’idée géniale d’utiliser des “hard links” pour faire des liens entre les paquets dans le cache et l’environnement. Mais ce n’est pas tout ! Uv gère la résolution de dépendance de manière très (non mais vriament très) efficace. Il réduit le temps d’installation à son maximum.

Leur exemple pour installer le package “Trio” sur le page de présetnation est très parlant :

Je vous disais, l’installation est centralisée, donc les packages s’installent dans un cache global. Et lorsque vous “installez” le package dans un environnement virtuel, il crée un lien “hard link” vers le cache.

En gros, voilà ce que ça donne :

Dans le graph ci-dessus, comprenez bien que les flèches représentent des liens “hard links” entre les paquets dans le cache et les environnements virtuels. Et non pas des copies !

Donc, uv, c’est cool. Il a un alias uv pip, et j’ai deux énormes avantages :

C’est vraiment rapide;
je réduis considérablement l’occupation disque.

En passant mes projets Python sous uv, sachant que j’ai régulièrement besoin de PyTorch (torch), qui pèse 700Mo… sur 40 projets… faites le calcul. Avec toutes les autres dépendances qui étaient dupliquées, et maintenant centralisées, mon disque qui était à 90% d’occupation est redescendu à 60%.

C’est juste énorme.

MAIS !

Ouais il fallait bien un “mais”…

uv est bien plus soupe au lait que poetry. La gestion dans le ficher pyproject.toml est un peu lourdingue, il faut forcer le chemin des sources du projet, ça demande de taper de la conf. Je suis pas fénéant, mais j’aime bien éviter de passer trop de temps à optimiser un simple fichier de conf.

Et là, arrive PDM.

PDM, l’autre Poetry

PDM est un gestionnaire de projet à la “poetry”, mais avec une approche plus fidèle aux derniers standards. Et, vous savez quoi, il sait aussi faire des installations “linkées”, donc faire ce que fait uv : un cache centralisé des installations.

Du moins en mettant ceci dans ~/.config/pdm/config.toml :

[install]
cache = true

Tout comme uv, il fait des liens entre le cache central et les environnements virtuels.

Mais, à l’inverse de uv, il est beaucoup plus simple à utiliser. Je retrouve le confort de poetry, avec des options plus claires à utiliser dans pyproject.toml.

Pour créer un projet, c’est aussi simple que :

pdm init

Il sait même partir des options de poetry si vous avez déjà un fichier pyproject.toml existant. Mais j’ai préféré refaire le fichier de conf, pour être sûr que tout soit propre.

Bon, seul bémol, bien qu’il sache faire des installations “linkées”, il utilise pip, et donc c’est lent.

Et d’un coup, dans la doc, le Graal.

Je lis la doc (oui, je lis les docs, c’est fou hein), et je tombe sur ça : https://pdm-project.org/en/latest/usage/uv/

Attends !!! on peut utiliser uv avec pdm ?

Le duo de choc, PDM + Uv

Une simple ligne de commande à taper, et je me dis que je suis passé à côté de ça pendant tellement de temps.

pdm config use_uv true

Cela ajoute une simple entrée dans le fichier de conf dans ~/.config/pdm/config.toml :

use_uv = true

Et là, la vache… quand vous faites un pdm add torch, paf, ça utilise uv. Les dépendances “Nvidia” de la mort, avec leur Gigaoctets de données, se pointent.

Un second projet ? Bim, quelques millisecondes pour installer la même dépendance.

Et c’est vraiment efficace dans le CI/CD

Le CD, pour “Continuous Delivery”, c’est le fait de déployer des trucs automatiquement depuis un outil qui gère ça en fonction de règles. Par exemple, Gitlab CI/CD, Github Actions, Jenkins, etc.

Mon délire avec uv est allé loin, je fais pas mal de projets IA/ML et j’ai un JupyterHub (un Jupyter Lab multi-utilisateurs) qui tourne sur ma bécane de dev. Et j’avais un vrai dileme à propos des “kernels python” pour gérer des versions de paquets différentes, par notebook, etc. Mon idée a été de forcer un environnement virtuel notebook et de forcer aussi uv pip en lieu et place de pip.

Et ça marche !

Donc, une soirée à mettre ça au propre, et je crée un dépôt Gitlab.

Jupyter kernel uv venv

Jupyter Lab / Hub kernel using uv to manage one virtual environment per notebook, and stop duplicating package installation.

Voir le projet

Mais ça, c’est que dalle. Ce que j’ai vraiment kiffé, c’est la gestion de la publication de paquets sur PyPI. Dans mon .gitlab-ci.yml, j’ai ça :

stages:
  - release

publish-package:
  image: python:3.12-bookworm
  stage: release
  id_tokens:
    PYPI_ID_TOKEN:
      aud: "pypi"
  before_script:
    - pip install pdm
  script:
    - pdm publish
  rules:
    - if: $CI_COMMIT_TAG =~ /^v.*/

Juste ça, rien que ça…

C’est quoi cette magie là ?

Gitlab et PyPI supportent l’authentification OIDC (OpenID Connect), il faut aller configurer son compte ici et définir une entrée pour GitLab, avec le nom du projet, le chemin du fichier CI, etc. Ça prend 10 secondes.

Le id_tokens dans le .gitlab-ci.yml permet de récupérer un token d’authentification temporaire pour pousser le paquet. Entendez bien, je n’ai absolment pas besoin de stocker un token dans les “variables” ou “secrets” du projet Gitlab. C’est automatique. Et c’est expliqué dans la documentation de PDM - quand je vous dis que lire les docs, c’est important…

Bref, je vous le dis

Tentez l’expérience, lisez les doc de uv et pdm, faites des tests.

Je sais, j’ai utilisé un ton très enthousiaste, mais je vous assure que ces deux outils m’ont vraiment soulagé. Je ne dis pas que poetry est mauvais, je ne rejette pas pip et le fait que beaucoup de projets utilisent encore requirements.txt. Ce que je dis, c’est que si vous passez votre temps à gérer des dépendances, des environnements virtuels, et que vous codez beaucoup en Python, ce couple d’outils va vous faire gagner un temps précieux, et de la place sur votre disque.

J’ai réellement gagné 20% de mon disque, j’ai été le premier surpris. Bien sûr, passer mes projets sous pdm m’a demandé un peu de temps (supprimer les vieux venv, refaire les fichiers de conf, etc.), mais franchement, ça vaut le coup. Linux commençait vraiment à ne pas être content et malgré des phases de nettoyage podman, bleachbit, etc. j’étais à 80-90% d’occupation disque.

Non, les Taskfile ne sont pas plus simples que Makefile

Wed, 03 Sep 2025 08:57:49 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Voilà des mois que les “Taskfiles”, fichiers utilisés par “GoTask”, censé être le remplaçant de Makefile, font débat dans la communauté des développeurs. Les Makefile sont jugés trop compliqués, illisibles, vieux, pas adaptés… j’entends tout et n’importe quoi. Alors que la promesse des Taskfile est de rendre tout magiquement simple, lisible, etc.

Donc, avant de vous lancer dans GoTask parce que c’est la mode, et de répondre à l’appel des sirènes du “c’est moderne”, on va simplement faire un TL;DR pour savoir faire un Makefile. Et je voue le dis, ce qui suit est tout ce que vous devez savoir pour faire un Makefile. Alors que GoTask, vous allez avoir besoin d’une doc (très belle, je ne dis pas le contraire) assez conséquente.

Mais, d’abord, avant de passer à la pratique, parlons un peu de ce qui m’énerve avec les fans de GoTask.

Prêt ?

Avant de lire la suite, c’est IMPORTANT

Détendez-vous, je vais être sarcastique et volontairement jouer le nerveux. C’est pour rire. Je suis un gars gentil et je respecte vos préférences. Ce n’est qu’un billet de blog ! 😄 💋 ❤️

J’aime GoTask, je l’utilise parfois. Je suis développeur Go, j’aime Go, j’aime le YAML. Mais je suis pragmatique. Je ne sombre pas dans le fanatisme crasse et l’argumentation fallacieuse sous prétexte qu’un truc me vante ses mérites.

Je sais que Makefile peut devenir un bordel sans nom, qu’il peut devenir illisible, compliqué, etc. Mais je sais aussi qu’on peut faire les choses proprement. J’ai appris à faire un Makefile à peine quelques jours après avoir fait mes premiers pas en C. Je vous le dis, j’avais 20 ans, je n’avais jamais touché un PC de ma vie, et pourtant j’ai trouvé Makefile ultra-simple à comprendre et à utiliser.

GoTask, il a plein d’avantages. C’est indéniable. Mais comme énormément de nouvelles choses qui sortent, je vois passer des posts LinkedIn, Mastodon, ou je ne sais quoi, avec un objectif clair : faire passer GoTask / Taskfile comme “le héros de tous les temps”, et chier sur Makefile avec des arguments fallacieux.

Je suis toujours prêt à discuter, échanger, débattre. Les désaccords sont normaux. Mais là, je lis des trucs qui me font bondir.

Je vous échauffe un peu, mais au final, je vais vous demander juste une chose :

build:
	commande qui builde un truc
	par exemple:
	go build -o ./dist/app .

clean:
	rm -rf ./dist

Est-ce que ça, ça vous dépasse ?

Si oui, partez de cet article. Ça ne sert à rien, vous allez refuser d’écouter mes arguments.
Sinon, alors vous allez pouvoir accepter un échange d’idées.

Maintenant, clairement, je vais volontairement casser un peu de sucre sur le dos de GoTask. C’est normal, c’est une exagération pour faire réagir, pour que vous compreniez ce que moi, utilisateur averti des deux outils, je ressens.

Si vous acceptez ce ton, le sarcasme, et que vous savez sourire à tout ça, vous êtes les bienvenus pour lire la suite.

Les arguments qui ne passent pas

J’entends et je lis énormément d’arguments de “pro Taskfile / GoTask” et beaucoup de trucs contre Makefile. Et quand je les lis, je reste pantois, bouche bée, ébahi, estomaqué… choisissez dans la liste.

C’est parti…

“GoTask est plus moderne que Makefile”.
Non… utiliser YAML ne rend pas un truc “moderne”. Par contre, ça le rend sujet à tout un merdier que YAML apporte. Je vous donne une énigme à résoudre juste après, juste pour vous rendre compte que YAML, ce n’était pas l’idée du siècle pour “coder des tâches”.
“La syntaxe de Makefile est compliquée”.
Non… la syntaxe de Makefile est simple. Simple parce qu’il n’y a aucun mot clef à connaitre pour démarrer. Vous donnez un nom de tâche, et les commande à effectuer pour cette tâche. Voilà, point.
Par contre, avec Taskfile, vous allez devoir apprendre deux syntaxes : YAML (et les noms des directives autorisées…) et GoTmpl. Je ne vois vraiment pas comment on peut estimer qu’utiliser GoTmpl est “sympa”. Pourtant, je développe en Go hein, et je fais des Helm Chart. Mais je vous le dis, c’est loin d’être idéal. Taskfile, il vous impose de connaitre sa sémantique, ses noms d’attributs…
“C’est clair, le fichier se décrit lui-même”.
Non… Pourquoi “run: once” ? pourquoi la règle c’est pas ce que ça génère ? pourquoi on doit dire “generates:”? Ça demande à connaitre les directives de Taskfile. La moindre erreur, le moindre truc qu’on n’a pas vu dans la doc, le Taskfile ne fait pas ce qu’on veut. Makefile n’a pas de langage de directive. Il applique les tâches / cibles / ce que vous voulez, et c’est tout. La cible, c’est ce que vous voulez faire. Si c’est un fichier, la cible est un fichier, si c’est une tâche, alors ça effectue une tâche. Makefile = pas la peine de lui expliquer l’évidence.

Je vous parlais d’une énigme à résoudre. Amusons-nous. 😉

Voici un Taskfile :

version: "3"
silent: true

vars:
  REFUSED: no

tasks:
  ask:
    cmds:
      - |
        read -p "Would you really delete your entire hardirve ? (yes/no): " answer
        if [ "$answer" == ${REFUSED} ]; then
          exit 0
        else
          echo "ok, let's delete all your data"
        fi

Vous lancez task ask et vous répondez “no”. Bonne chance…

$ task ask
Would you really delete your entire hardirve ? (yes/no) no
ok, let's delete all your data

What ? Mais j’ai répondu “no” ! Pourquoi il a pas compris ?

Vous voulez la solution de cette énigme ?

Eh oui, en YAML no est un booléen. C'est l'équivalent de false. Donc, dans le script, on compare "$answer" à false, ce qui n'est jamais vrai.

Il faut écrire REFUSED: "no" pour que ça marche, avec des doubles quotes. Et ça, c'est une des conneries que le YAML apporte... Parce que oui, YAML c'est bien, mais y'a un paquet de trucs qui foutent le zbeul.

Effectivement mon exemple est volontairement dangereux, mais ça peut être un vrai souci à déboguer.

Ce que je veux dire, dans cet exemple, c’est qu’utiliser YAML qui, de base, n’est pas fait pour ce genre de chose, c’est introduire des risques.

On a déjà bien mangé nos nerfs sur Ansible à cause des conneries de ce genre, GoTask ne va pas magiquement passer à travers. YAML, c’est un point de friction, que vous le vouliez ou non, et cette petite énigme en est une preuve, et j’en ai plein sous la main !

Alors pourquoi les gens pensent que Makefile est compliqué ?

Parce que le souci, c’est que quand vous le maitrisez, je veux dire quand vous allez loin, très (trop) loin, alors vous risquez de rendre le contenu imbuvable. Je le sais, c’est un de mes défauts… Parfois, je pousse trop.

Sauf que là, on parle d’une utilisation très spécifique et surtout technique des Makefile.

Sur un projet web, pour un truc qui lance des conteneurs, build du NodeJS, installe des dépendances PHP… Vous n’aurez absolument pas à utiliser des options poussives.

Prenons un exemple simple, un truc que je fais presque à chaque fois :


# docker ou podman
CONTAINER=docker

up:
  $(CONTAINER) compose up -d

down:
  $(CONTAINER) compose down

# alias vers bin/myapp
build: bin/myapp

bin/myapp: *.go
  go build -o app/bin .

Je vais tout détailler après, mais là, ne me faites par croire que ce Makefile est compliqué.

Vraiment, quand vous me dites que ça, vos collègues ne savent pas comment l’utiliser, je ne vous crois pas.

Non mais vraiment, qu’est-ce qui vous rebute là ???

make up démarre les conteneurs, make down les arrête, make build appelle make app/myapp qui construit le binaire si un fichier .go a changé. Y’a rien à étudier, pas une doc à ouvrir, c’est évident.

En Taskfile, ça donne ça :

version: "3"

vars:
  container: "docker"

tasks:
  up:
    cmds:
      - "{{.container}} compose up -d"

  down:
    cmds:
      - "{{.container}} compose down"

  build:
    deps:
      - "bin/myapp"

  bin/myapp:
    cmds:
      - "go build -o bin/myapp ."
    sources:
      - "*.go"

Non mais soyez honnête… En quoi c’est plus lisible ? En quoi c’est plus simple ? En quoi c’est plus court ? En quoi c’est plus moderne ? C’est le bordel !

C’est une série de directives dont il faut se souvenir (deps, cmds, et d’autre dont j’oublis toujours le nom…, sources, etc.) et une arborescence longue comme un roman de Ken Follett.

Et bon sang… faire des listes de 1 seul élément, c’est cool ?

On double le nombre de lignes, ça va gueuler si je me trompe dans la syntaxe GoTmpl..

Je suis désolé, mais l’argument de la modernité et de la lisibilité ne passent pas. Mais alors pas du tout

Je veux bien entendre plein d’arguments qui sont pour GoTask, mais pas ceux-là.

Créer un Makefile, tout ce que vous devez savoir

Donc, on va se mettre d’accord. Vous lisez cette partie, ça va durer 10 minutes en gros. Ensuite, si vous continuez de me dire que Makefile, c’est compliqué, je pense qu’on n’est pas de la même planète et je vous demanderai de garer votre soucoupe sur un espace réservé.

Un Makefile, c’est un fichier nommé “Makefile” (ou “GNUmakefile”) qui contient des cibles, des dépendances en options et des commandes. Voilà…

Avant de vous prendre la tête, gardez à l’esprit ce crédo valable pour tout le document qui suit :

Un Makefile est une description de trucs à faire. C’est pas une structure, pas un objet et encore moins un programme à coder, c’est une des-crip-tion

Une cible, c’est arbitraire. C’est soit un simple nom de tâche (build, test, clean, deploy, etc.), soit un nom de fichier à générer. Si la cible est un nom de fichier, make vérifiera s’il est à jour en fonction des dépendances.

Et les dépendances, ce sont aussi des cibles. Donc soit une tâche à effectuer, soit un fichier existant ou à générer.

Donc, arrêtez de vous prendre la tête, une cible, c’est tout ce que vous voulez. Y’a pas de règle à connaitre. C’est la même chose dans GoTask, vous n’avez pas à vous faire saigner du nez pour comprendre ça.

Et, la première cible est la cible par défaut. Si vous faites make sans argument, c’est la première cible qui sera exécutée.

La syntaxe est simplement :

cible1: dépendance1 dépendance2
	commande1
	commande2

Les dépendances sont optionnelles, bien entendu. Si une dépendance est listée, elle sera exécutée avant la cible.

🏁 STOP !!! Arrêtez-vous ici.

Là, vous avez déjà tout ce qu’il faut pour faire un Makefile. Vous pouvez arrêter de lire et utiliser ce que vous avez appris. Ça suffit pour faire le travail demandé. Alors oui, la suite vous apprendra d’autres trucs, et je vous conseille d’aller au bout. Mais, ce bout de code là, c’est suffisant pour faire ce que vous voulez !

Donc, me dire que c’est trop compliqué, c’est de la mauvaise foi.

Important:

Dans les exemples qui suivent, je mets “@” pour ne pas que make n’affiche les commandes. Vous pouvez aussi utiliser .SILENT: au début du Makefile pour rendre toutes les commandes silencieuses. Ou, l’option make -s à l’appel de make. Je vous rappelle, une fois de plus, que c’est pareil sur GoTask.

Ensuite, les variables. Vous pouvez en créer autant que vous voulez :

# des variables
FOO = bar
BAR = baz

# testons:
test:
	echo $(FOO)
	echo $(BAZ)

Les variables sont référencées avec $(NOM_DE_LA_VARIABLE).

Un truc cool, vous pouvez utiliser d’autres symboles d’affectation :

= veut dire “la valeur est évaluée une fois, au moment de son expansion, quand elle apparait dans une cible”
:= “la valeur est évaluée une fois, au moment de la déclaration, quand on lance make”
+= concaténation
?= la valeur est affectée seulement si la variable n’existe pas déjà (utile pour les valeurs à passer en ligne de commande)

On va juste parler de la subtilité entre = et :=, parce que je sais que c’est un point de friction pour beaucoup.

Si le contenu de la variable est “simple”, pas long à assigner, donc comme dans 99% des cas, utilisez “=”. Si par contre, vous préférez que la variable soit évaluée une fois pour toutes, genre son contenu est long à générer, utilisez “:=”.

Mais franchement, on s’en tape dans notre cas d’utilisation, utilisez “=” partout, ça ira très bien.

Et enfin, pour ?= :

FOO ?= la valeur par défaut

test:
	echo $(FOO)

C’est simple :

$ make -s
la valeur par défaut

$ make -s FOO=couou
coucou

Holala c’était dur… 🥱

Plus loin

Comme je vous le disais, les “cibles” sont tout et n’importe quoi. Si un fichier porte le nom de la cible, alors make va évaluer son existence et sa date de modification par rapport aux dépendances. Si le fichier n’existe pas ou s’il est plus vieux, alors la cible sera exécutée. Si le fichier existe et est plus récent que toutes les dépendances, alors la cible ne sera pas exécutée (sauf si on appelle make avec l’option -B).

Surprise, c’est pareil dans GoTask… 😒

example.txt: dépendance1 dépendance2
	echo "Génération de example.txt"
	touch example.txt

$ make -s
Génération de example.txt

$ make -s
make: « example.txt » est à jour.

Sérieux, qu’est-ce qui vous rebute là ?

Avec les dépendances :

example.txt: *.foo
	echo "Génération de example.txt"
	touch example.txt

Quel que soit le fichier qui se termine par .foo dans le répertoire, si l’un d’eux est plus récent que example.txt, alors la cible sera exécutée.

$ touch a.foo
$ make -s
Génération de example.txt

$ make -s
make: « example.txt » est à jour.

$ touch a.foo
$ make -s
Génération de example.txt

Et, si on utilisait make pour générer “b.foo” ?

example.txt: *.foo b.foo
	echo "Génération de example.txt"
	touch example.txt

b.foo:
	touch b.foo

En appelant make ou make example.txt, si b.foo n’existe pas, il sera généré avant, puis example.txt sera généré.

Et, c’est ~~différent~~ ha non zut, c’est pareil dans GoTask… sauf que c’est implicite avec Makefile. J’ai pas eu à lui expliquer un truc bateau, normal, logique. En gros, Makefile est plus intelligent.

Les variables spéciales à connaitre pour aller plus loin

Voilà, là oui, je l’admets, c’est la partie qui est le vrai sujet de discorde. Parce que oui, il y a des variables “magiques” dans Makefile et ça peut vraiment poser un problème à ceux qui ne les connaissent pas.

Si c’est ce point qui bloque, je peux le comprendre. Il n’y en a pas beaucoup, mais elles ne sont pas hyper intuitives.

Mais, dans ce cas, ne les utilisez pas. Voilà… ça règle le problème !

Il y a des variables spéciales utilisables n’import où :

$@, c’est “le nom de la cible”.
$<, le premier élément dans la liste des dépendances.
$^, tous les éléments dans la liste des dépendances.
$?, tous les éléments dans la liste des dépendances qui sont plus récentes que la cible.
$*, le nom de la cible sans son suffixe (utile pour les règles génériques).

Et aussi :

% dans une cible ou une dépendance, c’est un joker qui représente n’importe quelle chaîne de caractères. Sa valeur est reportée partout, vous allez voir c’est génial.

En gros une cible %.html: %.md est générique, je peux demande foo.html, automatiquement make va vérifier foo.md (et le générer si une règle existe pour ce fichier). Dans l’exemple ci-dessous, je m’en sers pour générer des fichiers HTML avec pandoc :

Je vous donne un exemple :

# quelque soit le fichier HTML qu'on veut générer, on prend son
# équivalent Markdown dans le répertoire src
doc/%.html: src/%.md
	pandoc -o $@ $^

# pour générer plein de docs
docs: doc/index.html doc/about.html doc/contact.html

# ou, on utilise des fonctions spéciales
docs: $(wildcard doc/*.html)

Vous pouvez appeler make docs pour générer toute la doc, ou générer un seul fichier avec make doc/index.html, ou make doc/about.html…

Comprenez que :

pandoc -o $@ $^
# équivaut à prendre la cible dans $@ et les dépendances dans $^, donc
# make doc/index.html produit:
pandoc -o doc/index.html src/index.md

Astuce mnémotechnique :

$<, c’est une flèche qui pointe vers la première dépendance,

$^, c’est une flèche vers le haut qui pointe sur les dépendances…

Donc, maintenant :

make doc/index.html va générer doc/index.html à partir de doc/index.md
make docs va générer doc/index.html, doc/about.html et doc/contact.html à partir de doc/index.md, doc/about.md et doc/contact.md

C’est vrai, ça je vous l’accorde, ces variables, ça peut rebuter… Mais au point de partir sur GoTask qui va vous demander plus de boulot, et ne pas vous proposer ce genre d’options ? Et donc, de vous taper du GoTmpl qui rend fou ? J’ai du mal à le comprendre.

Les cerises sur le gâteau

Makefile a plein de petites options qui rendent l’outil d’une puissance rare.

.PHONY est une cible spéciale qui indique que les cibles listées ne sont pas des fichiers. Comme ça on évite les “machin est à jour” alors qu’on ne veut pas…
.ONE_SHELL: à partir de GNU Make 4.0, cette directive indique que toutes les commandes d’une même cible doivent être exécutées dans le même shell. Par défaut, chaque ligne est exécutée dans un shell séparé, ce qui peut poser des soucis sur les changements de répertoire, les variables d’environnement, etc.
$(MAKE) permet d’appeler make, ça évite des problèmes sur certains OS donc la commande n’est pas focément make.
-include fichier permet d’inclure un autre Makefile. Le - indique que l’inclusion est optionnelle (si le fichier n’existe pas, pas d’erreur)
$(shell commande) exécute une commande shell et retourne son résultat. Utile pour affecter des variables.
@ au début d’une commande empêche l’affichage de la commande avant son exécution. Utile pour éviter le bruit dans la sortie. On peut utiliser .SILENT: pour rendre toutes les commandes silencieuses.
- au début d’une commande indique que les erreurs de cette commande doivent être ignorées.
$(wildcard motif) retourne une liste de fichiers correspondant au motif. Utile pour les dépendances.
$(patsubst motif, remplacement, texte) remplace les occurrences du motif dans le texte par le remplacement.

Et en dernier lieu, on peut faire des tests conditionnels :

LOCAL_INSTALL=1

install:
ifeq ($(LOCAL_INSTALL),1)
	echo "Installation locale"
	cp machin ~/.local/bin/machin
else
	echo "Installation globale"
	sudo cp machin /usr/local/bin/machin
endif

Comparé à GoTask / Taskfile

Make sait faire du parallélisme avec l’option -j (nombre de jobs en parallèle). On me sort cet argument pour GoTask, j’ai l’impression que les détracteurs de make n’on pas ouvert la doc 😉

La gestion de dépendances est automatique avec make, il n’y a pas besoin de les lister partout.

Et pareillement, la gestion de construction de fichier est implicite, pas besoin de définir une tâche de 8 lignes pour dire “alors si ça, c’est pas à jour, il faut que tu regardes ces fichiers”. Dans un Makefile, c’est automatique.

On me sort souvent que le YAML c’est pratique et moderne. Pratique oui, moderne… ça se discute. YAML c’est avant tout un format de sérialisation de données. Pas un langage de script. Donc, on se retrouve avec un format qui n’est pas directement prévu pour cela. Et de ce fait, on va faire des routines tordues pour effectuer des tâches sous conditions, alors que le langage de Makefile est prévu pour cela.

J’entends que vous aimez YAML, et je ne dis pas que GoTask est mauvais. Je dis simplement que si vous prenez quelques minutes pour lire cet article, ou une doc condensée sur Makefile, vous verrez que Makefile est simple à utiliser.

Oui, il y a des variables spéciales, oui, il y a des subtilités, mais franchement :

y’en a peu, vous les retenez et vous commentez votre Makefile, ça ira tout seul
vous n’êtes pas obligé de les utiliser, vous pouvez faire votre tambouille avec des règles simples, sans gérer les variables spéciales, sans faire de règles génériques, etc. Vous pouvez faire un Makefile textuel bateau.

Je refuse de croire que des ingénieurs, des gens qui codent tous les jours des machins tordus avec des langages compliqués, n’arrivent pas à comprendre un Makefile avec des règles simples. J’ai peut-être trop confiance en les capacités des techniciens, peut-être que je suis trop optimiste… Mais bon sang, j’ai appris à faire un Makefile en 10 minutes, à 20 ans, sans jamais avoir touché un PC de ma vie…

Qu’est-ce qui a fait que moi, sans compétences, sans aucune expérience, à 20 balais, j’ai absorbé la simplicité de Makefile, et pas vous ?

Conclusion

Les gens qui me disent que Makefile est compliqué sont les mêmes qui me disent “mais si, la programmation des “generics” en C# / Java / C++ c’est super simple”. Ou encore “comment ça l’injection de dépendance de Symfony est compliquée ? C’est juste du XML”.

Ce sont aussi les mêmes qui me disent que la syntaxe de template Go utilisée dans Taskfile est simple. Je suis développeur Go, j’aime beaucoup Go, je l’adore, mais je ne trouve pas la syntaxe de template évidente. Loin de là…

Donc, là, cette page que j’ai produit, elle recense 90% de ce que vous devez savoir pour faire un Makefile.

À moins que vous ayez des étapes de compilation de bourrin (genre des projets en C/C++ avec des tonnes de fichiers), le Makefile que vous ferez sera simple, lisible, efficace et rapide à écrire. Beaucoup plus lisible et plus simple que du Taskfile.

Tiens, vous voulez voir le Makefile que j’utilise pour ce site web ? Le voilà :

.ONE_SHELL:

# contains KUBECONFIG, S3_ROOT, S3_BUCKET
-include .env


# start the website locally
dev:
	hugo server -s src

# build the website
build:
	mkdir -p public
	hugo -s src -d ../public

# deploy the new version
deploy: build push-on-s3 restart-website clean

# push code to scaleway S3 bucket, using "rclone"
push-on-s3:
	rclone sync -Pv \
		--fast-list --checksum \
		--no-update-modtime \
		./public/ ${S3_ROOT}:${S3_BUCKET}/

restart-website:
	KUBECONFIG=$(KUBECONFIG) kubectl -n metal3d \
		rollout restart deployment blog-metal3d-blog

# remove the generated site
clean:
	rm -rf public

# create a new blog post
# in blog/<yeear>/<name>/index.md
# NAME is the title, replace ' ' by '-'
NAME?=default-title
NAME:=$(shell printf "%s" "$(NAME)"|tr ' ' '-')
YEAR:=$(shell date +"%Y")

blog-post:
	hugo -s src new content "blog/$(YEAR)/$(NAME)/index.md"

Alors, je peux comprendre l’intérêt de GoTask, et j’accepte volontiers que vous le préfériez. Mais, je refuse l’argument de la complexité de Makefile. make est simple du moment où vous décidez de l’utiliser simplement, c’est justement son atout majeur !

Makefile a plusieurs niveaux de complexité, mais c’est vous qui décidez quand vous arrêter de faire de l’optim.

Dans vos projets, tout ce que vous devez faire, c’est :

tache: dependance1 dependance2
	commande1
	commande2

C’est tout ce qu’il y a à retenir. Le reste, c’est du bonus.

Et je conclus : les gars (et les dames), bien entendu que je trouve GoTask sympa, pratique dans certains cas, et que je l’utilise. Ne me prenez pas pour un vieux con archaïque qui ne jure que par la vieille méthode. Mais je refuse de lâcher des trucs qui marche bien, qui sont pratiques et clairement adaptés, sous prétexte que la mode est d’infantiliser les développeurs.

Apprendre, maitriser et utiliser plein d’outils, de langages, c’est quand même plus passionnant.

Livebox limitée, Aidons-la avec Dnsmasq

Mon, 11 Aug 2025 13:14:34 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Depuis des années, les utilisateurs avancés¹ râlent, mais Orange s’en soucie autant que de la durée de vie d’un poil pubien. Après tout, si ça ne concerne pas 90% des utilisateurs, pourquoi s’en soucier ? Pourtant, c’est un vrai casse-tête pour ceux qui veulent avancer dans le paramétrage de leur réseau local.

En gros, impossible de manipuler les DNS des Livebox. Pas de noms de machines supplémentaires, pas de sous-domaines, et encore moins de DNS autres que ceux d’Orange. Pas de filtrage, pas de sécurisation pour la famille. Heureusement, on peut contourner le problème en déléguant ce travail à une autre machine, comme un Raspberry Pi ou un vieux PC.

Dans cet article, on va utiliser dnsmasq sur une Fedora (mais n’importe quelle distribution fera l’affaire). Il sera notre serveur DNS et DHCP. Voici ce qu’on va faire :

Configurer une machine (un Raspberry Pi) en IP statique
En faire un serveur DNS et DHCP
Couper le DHCP de la Livebox et ne plus utiliser son service DNS (elle ne servira plus que de routeur)

Trois étapes, mais il faudra un peu jongler pour ne pas se retrouver dans le noir.

Pas de panique, suivez les explications et tout ira bien.

Un Raspberry Pi 3 ou 4 suffira amplement pour faire tourner dnsmasq.

Et oui, je connais Pi-Hole, une solution très intéressante, mais j’ai eu pas mal de soucis avec. Configurer DNSMasq demande un peu plus d’efforts, mais ça a marché sans problème. J’ai mis seulement 20 minutes à tout configurer sur mon Raspberry Pi, surtout parce que j’avais les traces de mes erreurs à chaque test.

Faire les choses soi-même, c’est aussi apprendre, comprendre, et réaliser à quel point on peut aller plus loin.

Prérequis

Ayez une machine dédiée, comme un Raspberry Pi ou un vieux PC, connectée en permanence au réseau, de préférence en Ethernet. Vous devez pouvoir vous y connecter à distance via SSH ou physiquement avec un clavier/écran.

Un éditeur de texte comme vim, nano, ou même emacs si vous êtes un peu fou, est nécessaire pour corriger les fichiers.

Mon setup : un Raspberry Pi 4 avec Fedora 41, branché sur une Livebox 6. Adaptez les instructions à votre environnement.

Assurez-vous d’avoir nmcli (client NetworkManager) sur votre machine dédiée. Sinon, adaptez la configuration de l’IP statique.

Toutes les commandes doivent être exécutées avec les droits administrateur, donc utilisez sudo ou connectez-vous en tant que root.

Prenez un café ou un remontant pour rester concentré.

Avant de vous lancer

Ne vous lancez pas sans savoir à quoi servent ces configurations. Vous devez comprendre :

ce qu’est un serveur DNS,
et ce qu’est un serveur DHCP,
et que vous allez perdre la connexion réseau sur certaines machines pendant la configuration.

Premier point : On va désactiver le DHCP de la Livebox. Pendant quelques minutes, votre réseau local va être perturbé. Votre machine dédiée (un Linux toujours allumé, un Raspberry Pi chez moi) prendra le relais.

Donc, assurez-vous de pouvoir vous connecter à votre machine DHCP/DNS soit avec un clavier et un écran, soit en ajustant le paramétrage réseau.

Pas de panique, je vais vous donner les clés pour éviter de rester dans le noir trop longtemps.

Mais avant, quelques définitions…

C’est quoi un DHCP ?

Dynamic Host Configuration Protocol : Un service qui automatise la configuration de votre réseau local. Quand une machine rejoint le réseau, elle n’a pas d’adresse IP, pas de DNS, etc. Elle envoie un message en Broadcast pour obtenir ces informations. Votre Livebox (ou Freebox) fait office de serveur DHCP… pour le moment.

C’est quoi un serveur DNS ?

Domain Name Server : Un serveur qui traduit les noms de domaine en adresses IP. Votre Livebox, comme beaucoup de routeurs, fait office de serveur DNS. Elle résout les noms de domaine internet et les noms de machines de votre réseau.

Les deux ensemble, c’est mieux ?

Le DNS et le DHCP peuvent être séparés, mais les avoir ensemble est très pratique. Dnsmasq, par exemple, enregistre le nom de la machine dans le DNS quand il lui attribue une IP. Actuellement, c’est votre box internet qui gère les deux.

Configuration réseau de la machine dédiée

Votre machine qui va servir à faire office de DNS et de DHCP doit être configurée pour avoir une adresse IP statique et ne plus utiliser systemd-resolved.

Première chose, passer la machine dédiée en IP statique

Pourquoi une IP statique ? Parce que cette machine deviendra le DNS du réseau local. Si son adresse change, vous risquez une désynchronisation des adresses IP sur les machines du réseau. On fige donc l’IP.

Je pars du principe que vous avez connecté cette machine dédiée en Ethernet directement sur la Livebox. C’est plus stable, plus rapide et ça évite bien des problèmes.

C’est une étape délicate, car vous allez perdre la connexion à cette machine lorsque vous changerez son IP.

On va utiliser l’adresse IP 192.168.1.250. Normalement, la Livebox n’assigne pas d’adresse IP au-delà de 192.168.1.150. Vérifiez quand même que cette adresse n’est pas déjà utilisée par une autre machine. Pour le moment, on garde le DNS de la Livebox.

La manipulation est simple, mais si vous faites cela sur un shell SSH, vous allez perdre la connexion à votre Raspberry Pi, ce qui est normal. Il faudra se reconnecter avec la nouvelle adresse IP.

On garde la Livebox comme serveur DNS et le domaine “home”. Pour le moment, on continue de l’utiliser.

On va utiliser nmcli (client NetworkManager). Si votre machine est configurée différemment, utilisez l’outil adéquat.

Pour trouver le nom de la connexion réseau, utilisez :

nmcli connection --show
NAME                UUID                                  TYPE      DEVICE
Wired connection 1  9b63ca3f-bbf2-3567-8c24-39cc956e92fe  ethernet  end0
lo                  f5674142-e3f6-468d-b8a7-b89bb8e609c0  loopback  lo
podman1             f27ed4fc-043e-4671-aab8-f3f1b294342d  bridge    podman1
Livebox-0730        440b56e8-7407-4ff1-84b3-d78d76722594  wifi      --

Le nom “Wired connection 1” est le nom de la connexion réseau à changer chez moi, elle peut être différente chez vous. Gardez aussi en tête le nom de l’interface utilisée, chez moi est end0, ça peut être un truc différent chez vous.

Vous remarquez que j’ai Podman sur cette machine, ça induit de faire attention quand on va paramétrer le serveur DNS de Dnsmasq, car Podman utilise aussi un DNS interne. On va le voir plus tard.

## nom de la connexion réseau
CONNECTION="Wired connection 1"
## votre nouvelle IP pour le raspberry pi
NEW_IP=192.168.1.250
## on va garder le même domaine que la Livebox
DOMAIN=home

## on met la connexion en statique
nmcli connection modify "$CONNECTION" \
  ipv4.addresses $NEW_IP/24 \
  ipv4.gateway 192.168.1.1 \
  ipv4.dns  192.168.1.1 \
  ipv4.dns-search $DOMAIN \
  ipv4.method manual
systemctl restart NetworkManager

Donc voilà, on a mis une nouvelle adresse IP, une passerelle (la Livebox), un DNS (la Livebox) et un domaine (“home”). On a bien spécifié que la méthode est “manuelle”, donc que l’on ne veut pas une IP assignée par le DHCP de la Livebox.

Là, vous allez certainement perdre la connexion SSH. Donc, reconnectez-vous sur 192.168.1.250 et vérifiez que tout va bien. Faites un ping sur “google.com”, une machine du réseau, etc…

Suppression de systemd-resolved

Vous devriez avoir retrouvé la connexion SSH sur votre machine dédiée (le Raspberry Pi chez moi). On continue la configuration.

On va supprimer systemd-resolved, c’est un outil sympa sur les postes clients, mais sur un serveur avec réseau statique, qui plus est un serveur DNS, c’est une plaie. Il va nous faire des misères de conflits de port, ça va nous énerver plus que nous rendre service. Allez ça dégage !

Supprimer systemd-resolved ne suffit pas, il faut forcer le système à régénérer un fichier /etc/resolv.conf qui ne soit pas un lien symbolique vers /run/systemd/resolve/stub-resolv.conf.

sudo systemctl stop systemd-resolved
systemctl disable --force systemd-resolved

## et on supprime /etc/resolv.conf qui est un lien symbolique
rm -f /etc/resolv.conf

Attention à partir de maintenant, vous n’avez plus de serveur DNS**, relancez la connexion et vérifiez que le fichier /etc/resolv.conf est bien créé.

systemctl restart NetworkManager
cat /etc/resolv.conf

S’il est vide ou manquant, vérifiez que le service systemd-resolved est bien arrêté et désactivé. Regardez les erreurs avec journalctl -e -u NetworkManager. Bref, trouvez pourquoi…

Checkpoint de votre config réseau

On résume, votre petit serveur qui va faire DNS / DHCP, est à présent maitre de sa configuration réseau.

À ce stade, son adresse IP n’est plus assignée par la Livebox. La Livebox sert encore de routeur et de serveur DNS, mais ça ne va pas durer.

Configurer DNSMasq pour faire le job

On va enfin installer l’outil magique qui va remplacer ce que la Livebox fait très mal : dnsmasq.

DNSMasq, partie DNS

Pour le moment, c’est votre Livebox qui fait office de serveur DNS.

On va maintenant faire en sorte que cette machine dédiée devienne un serveur DNS.

Vous commencez par installer dnsmasq et deux ou trois outils pour tester notre configuration (dig, ping…).

dnf install -y dnsmasq bind-utils iputils
## utilisateurs de Debian/Ubuntu, débrouillez vous avec apt...

Très important : il faut accepter d’être contacté pour les requêtes DNS et DHCP, donc ouvrir le firewall sur les bons ports ; on peut donner les noms de services, plus clair :

## je vous rappelle que je suis sur Fedora, donc firewall-cmd
## est l'outil de gestion du firewall
firewall-cmd --add-service=dns --permanent
firewall-cmd --add-service=dhcp --permanent
firewall-cmd --reload

## si vous utilisez une Debian/like, vous pouvez utiliser ufw
ufw allow dns
ufw allow dhcp
ufw reload

La chose bien foutue sur Fedora (je ne sais pas pour les autres distributions) est que dnsmasq propose un fichier de configuration de base complètement commenté dans /etc/dnsmasq.conf. Et je vous conseille de ne pas le modifier. Il doit servir de référence. La configuration perso, on la place dans des fichiers à l’intérieur du répertoire /etc/dnsmasq.d/. C’est une bonne pratique, car ça permet de séparer les configurations.

En tout cas, chez Ubuntu, leur doc, c’est la fête de la saucisse, édition à la bourrin dans le fichier de base ! Ils me tuent…

On va créer un fichier de configuration dans /etc/dnsmasq.d/main.conf pour les trucs de base :

# interface réseau à écouter (end0, eth0 ...)
INTERFACE=$(ip r | awk '/default/{print $5; exit}')

cat 1>/etc/dnsmasq.d/main.conf << EOF
## port à écouter
port=53
## quelles interfaces écouter
bind-interfaces
interface=$INTERFACE

## Ajoutez des DNS externes pour le web
## on va prendre les DNS de Cloudflare et de Quad9
server=1.1.1.1
server=9.9.9.9
EOF

Juste un détail, mais tout à l’heure, je vous ai dit que j’ai Podman, donc je suis obligé de spécifier l’interface end0 (détectée avec ma commande “ip r...”). Sinon, Dnsmasq voudrait écouter sur toutes les interfaces réseau, y-compris “podman1”. Et comme un serveur DNS est déjà présent ici, DNSMasq plantera.

Vous pouvez lancer dnsmaq :

sudo systemctl enable --now dnsmasq

Si vous avez un message d’erreur, allez voir journalctl -e -u dnsmasq pour comprendre ce qui ne va pas. Ne continuez pas tant que dnsmasq ne fonctionne pas !

Si tout va bien, alors on va changer le DNS utilisé sur cette machine pour qu’elle utilise dnsmasq comme serveur DNS.

## nom de la connexion réseau
CONNECTION="Wired connection 1"
NEW_IP=192.168.1.250
## on change le DNS de la connexion réseau
nmcli connection modify "$CONNECTION" \
  ipv4.dns  $NEW_IP
nmcli device reapply "$CONNECTION"

# je ne sais plus si c'est utile :
systemctl restart NetworkManager

Vous remarquez que je mets l’adresse de DNS sur le Raspberry pi sur “lui-même”. C’est normal ! parce que le Raspberry Pi est le serveur DNS.

Testons ! C’est important, il faut absolument que dnsmasq fonctionne proprement en tant que serveur DNS.

## On regarde si NetworkManager a bien pris en compte
## la nouvelle configuration
cat /etc/resolv.conf
## doit ressembler à ça:
## Generated by NetworkManager
## search home
## nameserver 192.168.1.250

## on teste une résolution avec dnsmasq...
dig @127.0.0.1 +short google.com

## et faites le sans dire quel DNS utiliser
dig google.com | grep SERVER:
## répondra quelque chose comme:
##;; SERVER: 192.168.1.250#53(192.168.1.250) (UDP)

Si aucune adresse IP n’est retournée ou que ce n’est pas l’adresse de votre machine qui sert de DNS, c’est que dnsmasq ne fonctionne pas. Vous devez corriger ça !

Si tout se passe bien, d’abord “bravo à vous”, et on passe à la suite !

DNSMasq, partie DHCP

C’est le moment de dire adieu au DHCP de la Livebox.

Maintenant, on va dire à notre DNSMasq qu’il va faire office de DHCP. C’est donc lui qui répondra à toutes les machines qui vont arriver sur le réseau.

Il faut qu’il leur fournisse une adresse IP, un DNS, une passerelle.

l’adresse IP, on va lui dire qu’on ne dépassera pas 192.168.1.249, on va même dire qu’on veut des adresses entre 192.168.1.10 à 192.168.1.249. Ça nous permet de se réserver les adresses IP que personne ne peut avoir à moins de le faire à la main,
le nouveau DNS, donc l’IP de la machine dédiée,
la passerelle, c’est l’adresse IP de la Livebox (192.168.1.1 par défaut)

Pour garder la même logique que ce que faisait la Livebox, on va utiliser un suffixe DNS en “.home”. On l’a spécifié tout à l’heure pour configurer notre connexion statique.

Donc, configurons :

DOMAIN=home
IP_ADDR=$(hostname -I | awk '{print $1}')

cat 1> /etc/dnsmasq.d/dhcp.conf <<EOF
log-dhcp
## rang d'ip qu'on peut donner aux machines, on
## se réserve les IPs de 0 à 10 et au delà de 249
dhcp-range=192.168.1.10,192.168.1.249,12h
dhcp-option=option:netmask,255.255.255.0
dhcp-option=option:router,192.168.1.1
dhcp-option=option:dns-server,$IP_ADDR
dhcp-option=option:domain-name,$DOMAIN
dhcp-option=option:domain-search,$DOMAIN
enable-ra

## et on est dans un domaine
domain=$DOMAIN
local=/$DOMAIN/

# et on notre DHCP c'est un peu comme Sauron
dhcp-authoritative
EOF

En gros (et en simplifiant) :

On assigne un intervalle d’adresses IP de 192.168.1.10 à 192.168.1.249, nos machines auront une adresse IP pendant 12 heures (12h). Si elles ne sont plus là pendant ce laps de temps, alors elles perdent la réservation. Une nouvelle IP pourra leur être assignée. Augmentez la durée si vous voulez, mais 12 heures est une valeur assez commune.
Quand on configure une machine, on lui assigne un masque de sous-réseau, le DNS (notre raspberry Pi) et la passerelle (la Livebox)
domain=home : on dit à dnsmasq que le domaine de notre réseau est “home”
local=/home/ : on dit à dnsmasq de considérer que les machines du réseau sont dans le domaine “home” (donc il retrouvera les noms de machines avec un suffixe .home)
dhcp-authoritative : on dit à dnsmasq qu’il est le seul serveur DHCP du réseau, et qu’il n’y a pas de conflit possible avec la Livebox.
enable-ra : on active les annonces de routeur (Router Advertisements) pour que les machines puissent découvrir la passerelle et le DNS (optionnel, mais recommandé)

Pourquoi mettre un domaine ? Pour deux raisons…

Parce que c’est plus propre, qu’on va éviter des conflits avec les noms de domaines internet si une machine fait n’importe quoi,
et puis systemd-resolved va nous râper les raisins à ne pas accepter de faire des résolutions de noms sans domaine. En conséquence, on est obligé de lui en donner un.

Notez que c’est la raison qui a fait que j’ai rendu mon routeur TP-Link qui n’assigne aucun suffixe DNS…

Si vous voulez forcer une IP pour une machine en particulier, faitez un fichier de configuration qui s’appelle par exemple /etc/dnsmasq.d/reserved.conf :

## dhcp-host=<MAC>,<IP> ou encore...
## dhcp-host=<MAC>,<IP>,<NOM>,<TEMPS>
## par exemple, pour mon poste fixe:
dhcp-host=a6:db:13:b0:df:45,192.168.1.98

Et enfin, on configure le fichier /etc/dnsmasq.d/home.conf pour les options de base du DNS:

cat 1> /etc/dnsmasq.d/home.conf <<EOF
no-resolv
no-negcache
no-hosts
domain-needed
bogus-priv

## mon Raspberry Pi sert aussi de NAS
address=/nas/192.168.1.250
address=/nas.home/192.168.1.250
EOF

Houlla… Alors, je vous explique ce que ça veut dire:

no-resolv: on ne va pas utiliser le fichier /etc/resolv.conf pour les requêtes DNS
no-negcache: on ne va pas mettre en cache les réponses négatives (celles qui disent que le nom n’existe pas)
no-hosts: on ne va pas utiliser le fichier /etc/hosts pour les résolutions de noms
domain-needed: on ne va pas répondre aux requêtes DNS sans domaine (c’est important)
bogus-priv: si aucune adresse IP n’est trouvée, on ne va pas répondre aux requêtes pour les adresses privées (192.168.x.x, 10.x.x.x, etc.)

Pourquoi j’ajoute address=/nas/... et address=/nas.home/... ?

Mon Raspberry pi qui sert de DHCP/DNS est configuré en IP statique. Il ne s’enregistre pas tout seul dans le DNS.

Donc, je dois le déclarer manuellement. Parce que le DHCP ne s’est pas occupé de lui-même.

Évidemment que vous pouvez utiiliser un autre nom. Mon Raspberry Pi est aussi un NAS, je l’appelle comme ça. Vous pouvez l’appeler “rpi”, “domain” ou “jean-michel”, c’est vous qui voyez.

Maintenant, on passe aux choses sérieuses !

On redémarre le service dnsmasq :

systemctl restart dnsmasq

Il ne faut aucune erreur !

À partir de maintenant, la machine dédiée est le serveur DNS et le serveur DHCP de votre réseau local.

C’est le moment fatidique, on coupe le DHCP de la Livebox.

Attention, toutes les machines vont avoir un souci pendant quelques secondes, voir plusieurs minutes. Leur configuration réseau ne sera pas à jour, donc il faut relancer la phase de négociation DHCP. En gros, couper le réseau des machines et le redémarrer.

Pour le moment, votre réseau est aussi bordélique qu’une chambre d’ado élevé avec la méthode Montessori.

C’est la phase “critique”, tant que vos machines ne se reconnectent pas, elles n’ont pas reçu les informations du DHCP.

On teste sur une machine du réseau

Sur mon laptop (ouais, mon “ordinateur portable”), j’ai coupé le wifi et je l’ai relancé. Puis je vérifie :

ip r get 1                                                         metal3d@patrice-laptop
## m'affiche
## 1.0.0.0 via 192.168.1.1 dev wlo1 src 192.168.1.98 uid 1000

J’ai bien une IP et la passerelle par défaut, ouf !

Et sinon, coté DNS:

resolvectl status
## affiche:
##...
Link 3 (wlo1)
    Current Scopes: DNS LLMNR/IPv4 LLMNR/IPv6
         Protocols: +DefaultRoute LLMNR=resolve -mDNS -DNSOverTLS DNSSEC=no/unsupported
Current DNS Server: 192.168.1.250
       DNS Servers: 192.168.1.250
        DNS Domain: home
     Default Route: yes

Tout va bien ! Le DHCP m’a assigné le DNS qu’on a configuré, et le domaine “home”.

Vous pouvez être fiers de vous, tout est OK !

Quelques vérifications supplémentaires

Sur le raspberry Pi ou la machine dédié qui fait DHCP/DNS, vous pouvez vérifier que les machines sont bien enregistrées :

 cat /var/lib/dnsmasq/dnsmasq.leases
1754853901 20:4e:f6:30:2b:2e 192.168.1.213 Roomba-DB09C7BAA7C54FC881662B9B88592317 *
1754855117 d8:6c:63:5f:34:e8 192.168.1.94 Chromecast *
1754853936 6a:07:a8:80:6e:19 192.168.1.90 patrice-desktop 01:6a:07:a8:80:6e:19
1754853936 50:14:79:1b:dc:7a 192.168.1.62 iRobot-85DB52B2707343789E585364D0C28099 *
1754867719 a6:db:13:b0:df:45 192.168.1.98 patrice-laptop 01:a6:db:13:b0:df:45
1754854162 66:e0:43:eb:2b:e9 192.168.1.26 Z-Flip6-de-Patrice 01:66:e0:43:eb:2b:e9
 #... etc

On peut aussi vérifier que le DNS fonctionne, en prenant un nom de machine :

ping -c 2 patrice-desktop
PING patrice-desktop.home (192.168.1.90) 56(84) bytes of data.
64 bytes from patrice-desktop.home (192.168.1.90): icmp_seq=1 ttl=64 time=3.31 ms
64 bytes from patrice-desktop.home (192.168.1.90): icmp_seq=2 ttl=64 time=3.15 ms

On voit par ailleurs que le nom de domaine “.home” est bien utilisé et que ça répond.

Et maintenant, on peut aller beaucoup plus loin !

Ce que Livebox ne permettait pas, on peut le faire

D’abord, on utilise désormais les DNS qu’on veut. On a mis 1.1.1.1 et 9.9.9.9 mais vous pouvez mettre ceux de Orange, de Google, de votre FAI…

Et dorénavant, vous pouvez aussi ajouter des noms de machines, des alias, des domaines, etc.

Reprenons l’exemple initial, j’ai une machine “patrice-desktop” qui est une machine sur laquelle j’ai installé pas mal de trucs. Je veux pouvoir y accéder avec plusieurs noms.

Un truc intéressant avec un vrai serveur DNS, c’est qu’au lieu de dire “alors ce nom correspond à telle adresse IP”, on peut lui dire “ce nom, il est un alias de tel nom”. Je vulgarise un peu hein… C’est ce qu’on appelle un CNAME (Canonical Name).

Donc, on va créer un fichier de configuration pour des alias, par exemple /etc/dnsmasq.d/alias.conf :

cname=ai.home,patrice-desktop.home

Relancez le service dnsmasq :

systemctl restart dnsmasq

Et sur un poste…

dig ai.home
##...
;; ANSWER SECTION:
ai.home.                0       IN      CNAME   patrice-desktop.home.
patrice-desktop.home.   0       IN      A       192.168.1.90

Comprenez bien, je peux désormais accéder à mon serveur avec le nom ai.home.

J’ai ensuite configuré ma machine pour que ai.home pointe sur le conteneur OpenWebUI pour utiliser des modèles locaux d’IA. J’ai aussi ajouté ollama.home qui pointe sur le même serveur, mais qui est un alias pour aller sur mon conteneur Ollama.

Et vous pouvez faire autant de bordel que vous voulez.

Tiens, un bonus : https://github.com/KnightmareVIIVIIXC/AIO-Firebog-Blocklists contient des fichiers à placer dans votre /etc/dnsmasq.d/ pour bloquer des domaines, des publicités, etc.

J’ai plutôt utilisé la liste simple de OISD:

curl https://small.oisd.nl/dnsmasq2 > /etc/dnsmasq.d/oisd-blocklist.conf
systemctl restart dnsmasq

Mais vous pouvez tout à fait en faire autant avec n’importe quel domaine :

## par exemple dans /etc/dnsmasq.d/blacklist.conf
##ipv4 et ipv6
local=/foo.com/

Pourquoi “local” ? En fait, vous dites à DNSMasq de tenter de résoudre le nom de domaine localement. Et comme aucune entrée locale n’existe, il ne trouvera pas le nom de domaine. Donc, il ne répondra pas. Ça rend donc la résolution de ce domaine impossible. C’est un moyen hyper simple de bloquer un domaine.

Résultat, par exemple sur le site Futura Sciences, réputé blindé de pubs…

Bref, gérer son DNS c’est cool.

Alors, heureux ?

La plupart des box internet du marché, pour les particuliers, ne sont pas à la hauteur en termes de gestion réseau. Ce sont de très bons routeurs internet pour la majorité, mais elles limitent vraiment les utilisateurs avancés.

Configurer son propre DHCP/DNS peut faire peur. Ça demande un peu de patience, de temps et le courage d’affronter la crainte de casser le réseau. Mais tout est rapidement réversible.

DNSMasq ne m’a jamais déçu, je m’en suis servi à mainte reprise en local (pour réduire les latences de résolution de nom ou avec Docker/Podman), je l’avais réglé pour supprimer les publicités sur une de mes machines, et je l’avais même intégré dans un cluster pour corriger un gros souci de résolution interne.

Il est léger, et donc tourne sans accroc sur un tout petit Raspberry Pi. Il est simple à configurer (c’est très lisible).

Là, je l’utilise pour mon réseau local depuis des semaines. Aucun souci.

Donc oui, moi, je suis heureux d’avoir la maitrise de mon DNS, de pouvoir faire du cache, de mieux contrôler mon domaine et de pouvoir faire des alias, couper les pubs, etc.

Je parle d’utilisateurs avancés, pas forcément des ingénieurs réseaux. Une personne qui bidouille un Raspberry Pi, un NAS, ou n’importe quel appareil connecté… ↩︎

Exit Kaniko et BuildX, place à Buildah

Wed, 06 Aug 2025 13:20:53 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Kaniko est mort, et tout le monde se rue sur BuildX. Parce que Docker en parle, car ça parait simple. Et au milieu de tout ça, se trouve Buildah. Et il devrait être la réponse par défaut chez les DevOps.

TL;DR

Utilisez Buildah pour construire des images OCI dans vos pipelines CI/CD. Avec les commandes :

buildah build -t mon-image:latest /tmp/monimage
buildah push ...

Ou bien: utilisez l’API pour faire des images sans Containerfile / Dockerfile si cela vous simplifie la vie.

Pour les actions GitHub, ce template vous servira, en adaptant (par exemple pour créer le tag avec github.ref_name et ajouter le “latest”, en ajoutant des labels, etc.) :

name: Build image

# changez en on push, on release, etc. selon vos besoins
on: workflow_dispatch

# pour la suite
env:
  IMAGE_NAME: ${{ github.repository }}
  REGISTRY: ghcr.io

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Install Buildah
        run: |-
          sudo apt-get update
          sudo apt-get install -y buildah
      - name: Buildah build
        run: |-
          buildah build -t $REGISTRY/${IMAGE_NAME} -f ./oci/Containerfile .
          # puis... 
          # buiildah tag $REGISTRY/${IMAGE_NAME} $REGISTRY/${IMAGE_NAME}:latest
          # buildah tag $REGISTRY/${IMAGE_NAME} $REGISTRY/${IMAGE_NAME}:${{ github.ref_name }}
      - name: Buildah Push
        run: |-
          buildah login $REGISTRY -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
          buildah push $REGISTRY/${IMAGE_NAME,
          # et si vous avez taggé, vous pouvez faire
          # buildah push $REGISTRY/${IMAGE_NAME}:latest
          # buildah push $REGISTRY/${IMAGE_NAME}:${{ github.ref_name }}
          # ...

Ou utilisez les actions de Red Hat :

env:
  IMAGE_NAME: ${{ github.repository }}
  REGISTRY: ghcr.io

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Build image
        id: build-image
        uses: redhat-actions/buildah-build@v2
        with:
          image: ${{ env.REGISTRY}}/${{ env.IMAGE_NAME }}
          tags: latest ${{ github.ref_name }}
          containerfiles: |
            ./oci/Containerfile
      - name: Push image
        uses: redhat-actions/push-to-registry@v2
        with:
          image: ${{ steps.build-image.outputs.image }}
          tags: ${{ steps.build-image.outputs.tags }}
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

Maintenant, si vous voulez en savoir plus sur Buildah, continuez la lecture.

L’origine du bazar

Sur votre machine, vous “buildez” vos images Docker tranquille avec un petit docker build, tout roule.

Puis arrive la CI/CD… et là, c’est le drame. Les runners tournent souvent en conteneur, et Docker, lui, a besoin d’un daemon, d’un socket, de droits root… bref, tout ce qu’on veut éviter.

Oui… Docker a un mode “rootless” merci, je sais. Mais il va quand même vous demander un daemon, un socket… Et regardez la méthode pour le mettre en place, je vous laisse juger.

Du coup, vous testez DinD (Docker in Docker), et après quelques sueurs, ça fonctionne. À peu près.

Google tente de nous sauver avec Kaniko : pas besoin de daemon, ça build des images OCI comme un chef. On y croit. Même Gitlab le propose dans sa documentation, on se dit que ça y est, on est soulagé.

Et là… pouf, projet archivé. Plus de support. Rideau.

Résultat : tout le monde retourne chez BuildX. Parce que Docker, c’est Docker, hein.

Sauf que BuildX, c’est un peu comme DinD en costard. Toujours dépendant du daemon, avec une stack à rallonge pour le faire tourner proprement en CI. Alors oui, il pourrait fonctionner sans daemon local, mais je vous passe les détails, c’est un setup demandant des compétences assez avancées.

Spoiler : Buildah fait ça sans broncher, et sans daemon foireux à configurer.

Podman, un début de réponse

Pendant que Docker et ses potes foutent le zbeul en CI/CD, y’a un petit héros discret qui traîne dans mon terminal depuis des années : Podman.

C’est clairement mon remplaçant préféré de Docker pour bosser en local. Les commandes sont quasiment les mêmes (podman run, podman build, tout ça), donc pas besoin de réapprendre l’alphabet. Mais sous le capot, c’est une autre histoire.

Alors, en vrai, depuis un bon moment, pour moi c’est Docker qui est une alternative à Podman. Sans rire, je trouve Docker trop lourd, moins bien pensé, voire problématique. Sans méchanceté, je préfère Podman.

Il m’a supprimé une grosse charge mentale…

Parce qu’il est daemonless — pas de service qui tourne en arrière-plan à l’insu de mon plein gré — et rootless — pas besoin de lui filer les clés de l’appart pour retrouver la vaiselles dégeux dans l’éviers (et je ne vous parle pas de l’état des chiottes).

Cerise sur le conteneur : il fonctionne dans votre répertoire utilisateur, avec votre ID, votre user, vos petits droits propres. Il construit des images OCI aussi bien que Docker (ou plutôt comme Kaniko avant son décès), compatibles avec Docker / RunC / Nerdctl, etc.

Mais voilà le twist : Podman, c’est surtout pour le développeur ou l’utilisateur qui veut faire tourner des machins sur son poste. Il est parfait pour lancer un conteneur vite fait pendant que vous tisez votre café, ou avec un fichier “compose” (à la docker-compose), voire utiliser des Quadlets (bon sang que j’aime ce truc). Mais il n’est pas réellement pensé pour des pipelines CI/CD à la chaîne.

Même s’il le peut, ce ne serait pas une vraie bonne idée.

L’astuce ? Le vrai cerveau de la construction d’image derrière Podman, c’est pas Podman lui-même. C’est son binôme discret : Buildah.

Et lui, on va en reparler…

Buildah, la solution

Le “builder” d’image sous-jacent de Podman, c’est Buildah.

Buildah est, en gros, la sous-partie utilisable pour créer des images. Et vous allez voir qu’il propose des fonctionnalités avancées qui peuvent vraiment vous intéresser.

En gros, quand vous faites podman build, vous faites l’équivalent de buildah build. On peut donc ne pas installer Podman et n’utiliser que Buildah si notre but est de seulement construire des images et les pousser sur un registre.

Buildah peut fonctionner selon deux modes :

avec un fichier Containerfile (ou Dockerfile), via buildah build (ce qui est la méthode la plus courrante, proche de ce que vous connaissez déjà)
de manière programmatique, en utilisant son API et donc de scripter une création d’image avec des conditions fines

La construction simple

Amusons-nous et créons un fichier /tmp/monimage/Containerfile et dedans, vous mettez :

FROM alpine:latest

RUN apk add --no-cache nginx
CMD ["nginx", "-g", "daemon off;"]

Et tapez la commande suivante :

buildah build -t mon-image:latest /tmp/monimage

Vous le voyez, c’est super simple. La commande est typiquement la même que pour Docker ou Podman.

Dans certaines documentations, vous allez voir “bud” au lieu de “build”. C’est la même chose, c’est juste un alias. En fait la commande historique était buildah bud pour “build using Dockerfile”. Mais depuis un certain temps, la commande “buildah --help” ne liste que “build” bien que l’alias “bud” existe encore.

Tentons de faire la même chose dans un conteneur. Vous avez besoin de “capabilities” pour taper dans /proc alors, on va utiliser --privileged pour l’occasion, mais on pourrait tout à fait utiliser des “capabilities” plus fines.

# avec podman ou docker, vous pouvez faire
podman run --rm -it --privileged \
  -v /tmp/monimage:/tmp/monimage:z \
  fedora:42

Maintenant, dans le conteneur, installez Buildah et faite un “build” de l’image :

dnf install buildah -y
# On force le driver de stockage à vfs
export STORAGE_DRIVER=vfs

# puis
buildah build -t mon-image:latest /tmp/monimage

On force Buildah à utiliser le driver “vfs” car dans un conteneur, FUSE posera des problèmes. Il a besoin de modules pour faire des points de montages, et nous avons des restrictions. VFS est un poil plus lent, mais il fonctionne très bien dans un conteneur.

Ça a marché. Sans monter de socket Docker/Podman, sans lancer de service, sans rien faire de spécial. Buildah a simplement construit l’image OCI. C’est net.

Petite note avec les distributions Debian like, genre Ubuntu, bien entendu, ils font les choses mal (oui, je trolle) et vous avez des étapes supplémentaires à faire…

apt update && apt upgrade ca-certificates -y && apt install buildah -y
# puis, faire le reste
export STORAGE_DRIVER=vfs
buildah build -t mon-image:latest /tmp/monimage

Ce n’est pas insurmontable, mais sans la mise à jour de “ca-certificates”, vous allez avoir des erreurs de validation des certificats pour récupérer les images de base.

Le scripting avec Buildah

Mais là où Buildah devient intéressant, c’est qu’il permet de construire des images OCI de manière programmatique. Vous pouvez effectuer les étapes de build les une après les autres, et agir en fonction de vos besoins. Donc, entendez bien ce que je dis, vous pouvez éviter d’utiliser un Dockerfile ou un Containerfile et utiliser un script Bash. Faisons la même image que précédemment, mais en scriptant la construction.

Toujours dans un conteneur Alpine, avec Buildah installé, vous pouvez faire :

# dans un conteneur
export STORAGE_DRIVER=vfs

# on construit étape par étape
container=$(buildah from alpine:latest)
buildah run $container apk add --no-cache nginx
buildah config --cmd 'nginx -g "daemon off;"' $container
buildah config --port 80 $container
buildah config --port 443 $container
buildah commit $container mon-image:latest

Alors ATTENTION, ne vous méprenez pas. Le “run” de Buildah n’est pas le “run” de Docker ou Podman. Il ne lance pas un conteneur mais effectue l’opération “RUN” d’un Containerfile / Dockerfile. Je vous rappelle que Buildah est un outil de construction d’image OCI, pas un outil de gestion de conteneurs.

Je ne sais pas si vous réalisez l’intérêt de ce genre de construction. Imaginez par exemple que je veuille créer une image en fonction de paramètres extérieurs, ajouter des labels depuis des résultats de commandes… tiens par exemple :

container=$(buildah from alpine:latest)
buildah run $container apk add --no-cache nginx
buildah config --cmd 'nginx -g "daemon off;"' $container
# on ajoute un label pour se souvenir de l'envirinnement de build
# avec uname, date etc:
buildah config --label "build.env=$(uname -a)" $container
buildah config --label "build.date=$(date)" $container

buildah commit $container mon-image:latest

Vous allez pouvoir faire des scripts qui vont construire des images de manière conditionnelle, en fonction de configuration, d’environnement, de paramètres passés en ligne de commande, etc.

Alors effectivement, en règle générale, on préfèrera utiliser des Containerfile, mais le simple fait de pouvoir descendre dans les couches d’abstraction vous confère un pouvoir et de grandes possibilités.

Expérimenter dans une Action GitHub

Avant de vous parler des deux actions de Red Hat, on peut s’amuser à tester si Buildah fonctionne sans trop se taper la tête contre le clavier.

On va donc créer un petit test. J’ai un simple Containerfile dans un dépôt GitHub qui part de “nginx”, dépose un fichier index dans le répertoire /usr/share/nginx/html/. Ça suffit amplement.

FROM docker.io/nginx

COPY index.html /usr/share/nginx/html/index.html

Maintenant, dans .github/workflows/build-oci.yml, on va faire un petit test :

name: Build image

on: workflow_dispatch

# pour la suite
env:
  IMAGE_NAME: ${{ github.repository }}
  REGISTRY: ghcr.io

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Install Buildah
        run: |-
          sudo apt-get update
          sudo apt-get install -y buildah
      - name: Buildah
        run: |-
          buildah build -t $REGISTRY/${IMAGE_NAME} -f ./oci/Containerfile .

L’événement workflow_dispatch permet de lancer le workflow manuellement depuis l’interface de GitHub. C’est plus simple pour tester deux trois choses.

Bref, voilà le résultat :

# ...
STEP 1/2: FROM docker.io/nginx
Trying to pull docker.io/library/nginx:latest...
Getting image source signatures
Copying blob sha256:1d9f51194194364d2bbc948f82bc5161b65f277c6da4b0e47764e4fee2136e42
Copying blob sha256:140da4f89dcb7e49c2985bdd85b5c1c4e800916ee22abf7ada6b0bc2a99642a2
Copying blob sha256:59e22667830bf04fb35e15ed9c70023e9d121719bb87f0db7f3159ee7c7e0b8d
Copying blob sha256:2ef442a3816e24347655167c51e8d4fd033bf7da8f954f2f1cfd456cf6a06a80
Copying blob sha256:96e47e70491e3d5a8a65384c656bf4db13930a353c92252338e1167dfb1aeb84
Copying blob sha256:4b1e45a9989f25a049b0eace36b5405e64b4c2a31de65a92abfd86dbfb2b4a78
Copying blob sha256:f30ffbee4c546383f6ad349c50f8a2d2db5a83292489bbae5284b425960bcd42
Copying config sha256:2cd1d97f893f70cee86a38b7160c30e5750f3ed6ad86c598884ca9c6a563a501
Writing manifest to image destination
STEP 2/2: COPY index.html /usr/share/nginx/html/index.html
COMMIT imagetest
Getting image source signatures
Copying blob sha256:7cc7fe68eff66f19872441a51938eecc4ad33746d2baa3abc081c1e6fe25988e
Copying blob sha256:30837a0774b97fd5fd6306e4a67b9dba10fff174d82f0e7d2c6104dc79716fc3
Copying blob sha256:a6b19c3d00b104e9f5ae798917606b4706bf27748a008a5b44211b801ede45d8
Copying blob sha256:6b1b97dc92853f9880a37c378d2fe582eaca6567f3962d6d69dcbf35f65d95f9
Copying blob sha256:5c91a024d899eb09709296029b21f98722fa446ac7e37bb85b36f6484c499a2e
Copying blob sha256:0662742b23b26cd3b0c231ac4003d7343e3df50c62765b0baf6336c58156fa76
Copying blob sha256:f17478b6e8f3dcfdeb55c9e82529529ff6a984b3f72daa2fd723435f9ee9f93f
Copying blob sha256:6912176a43ddce467ba1cb2897ad73b6dbc97706370c1ce5ce9c55a8f439d06a
Copying config sha256:e3438ea014a5d5026f692e244b6190f53aeba0e0ea9604fcc8edf55e3da53c93
Writing manifest to image destination
--> e3438ea014a5
Successfully tagged localhost/imagetest:latest
e3438ea014a5d5026f692e244b6190f53aeba0e0ea9604fcc8edf55e3da53c93

C’est tout bonnement OK.

Et si vous voulez utiliser le registre GitHub de votre projet, ajoutez :

buildah login $REGISTRY -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
buildah push $REGISTRY/${IMAGE_NAME}

Bien entendu, vous pouvez le faire dans un “step” séparé. Aussi, pensez à {{github.ref_name}} pour tagger les images, ajoutez les labels pour avoir une description, etc.

Et donc, par conséquent, on peut se passer de Containerfile:

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Install Buildah
        run: |-
          sudo apt-get update
          sudo apt-get install -y buildah
      - name: Buildah
        run: |-
          container=$(buildah from alpine:latest)
          buildah run $container apk add --no-cache nginx
          buildah copy $container index.html /usr/share/nginx/html/index.html
          buildah config --port 80 $container
          buildah config --port 443 $container
          buildah config --cmd 'nginx -g "daemon off;"' $container

Bref, Buildah est un outil puissant et flexible pour construire des images OCI, que ce soit avec un Containerfile ou de manière programmatique. Il est idéal pour les environnements CI/CD, car il ne nécessite pas de service en arrière-plan et peut être utilisé dans des conteneurs sans problème de sécurité.

GitHub Actions Red Hat

Red Hat vous propose deux actions pour faire du build d’image OCI avec Buildah.

https://github.com/redhat-actions/buildah-build permet de build l’image
https://github.com/redhat-actions/push-to-registry pour pousser

Ce qui veut dire que votre workflow n’aura besoin que de deux étapes :

build de l’image
push de l’image

Ce qui va ressembler à ça:

steps:
  - name: Checkout repository
    uses: actions/checkout@v4
  - name: Build image
    id: build-image
    uses: redhat-actions/buildah-build@v2
    with:
      image: ${{ env.REGISTRY}}/${{ env.IMAGE_NAME }}
      tags: latest ${{ github.ref_name }}
      containerfiles: |
        ./oci/Containerfile
  - name: Push image
    uses: redhat-actions/push-to-registry@v2
    with:
      image: ${{ steps.build-image.outputs.image }}
      tags: ${{ steps.build-image.outputs.tags }}
      registry: ${{ env.REGISTRY }}
      username: ${{ github.actor }}
      password: ${{ secrets.GITHUB_TOKEN }}

Comparaison avec BuidX à la sauce Github…

On nous propose :

une action de login vers le registre
une action pour installer Qemu (ha ?)
une action pour installer BuildX (bah ouais)
une action “build and push”

En d’autres termes, avec BuildX à la sauce GitHub, ça va ressembler à ça :

name: Build OCI image
on:
  release:
    types:
      - published
  push:
    branches:
      - "features/**"
env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Log in to the Container registry
        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      - name: Build and push
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./oci/Containerfile
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

Ça ne parait pas énorme à première vue, mais regardez bien les étapes. On passe de 2 étapes à 4 étapes. Des setups assez lourds, et un build bien plus long. Rappelez-vous que, plus vous ajoutez de “steps”, plus vous risquez un plantage du setup, et plus ce sera difficile à corriger.

Avec Buildah, vous pouvez le faire à la main, ou utiliser les actions de Red Hat, dans les deux cas c’est plus souple, plus léger et plus facile à adapter. J’aime éviter l’accumulation de couches trop abstraites.

Je fais partie des gens qui estiment qu’il est souvent plus simple de faire un truc soi-même que de se reposer sur des intégrations obscures, à la limite de la boite noire, et de passer des heures à faire des diagnostics pour comprendre qu’il manquait une option perdue dans les bas-fonds d’une doc mal écrite. On sait coder bordel, on sait scripter. Arrêtez de vous laisser bouffer par des surcouches qui vous promettent la lune.

Le multi-arch, le point sensible

Buildah sait très bien gérer le build multi-arch. Cependant, il faut l’admettre, c’est un point un peu plus technique et moins évident à comprendre.

Pour préciser, un build “multi-arch” permet de construire une image qui peut être utilisée sur plusieurs architectures (arm64, amd64, etc.). C’est essentiel pour les environnements modernes où les conteneurs peuvent tourner sur des machines ayant différents types de microprocesseurs.

Les registres OCI/Docker en version 2.2 savent bien différencier ces architectures pour une image donnée. Pour cela, il faut créer un manifest et indiquer les images à utiliser. Docker rend ce truc un peu plus simple. Je l’avoue sans mal. Pour autant, quand on a compris l’astuce, ça parait évident avec Buildah.

Faisons deux images :

# image de base AMD64
buildah build -t mon-image:latest-amd64 --arch amd64 /tmp/monimage

# image ARM64
buildah build -t mon-image:latest-arm64 --arch arm64 /tmp/monimage

On peut pousser ces images telles quelles dans un registre, mais pour simplifier la vie des utilisateurs, on va créer un “manifest” qui va regrouper ces deux images. Pour cela, on va utiliser la commande buildah manifest.

buildah manifest create mon-image:multi-arch
buildah manifest add mon-image:multi-arch mon-image:latest-amd64
buildah manifest add mon-image:multi-arch mon-image:latest-arm64

# pour pousser le manufest
buildah manifest push --all mon-image:multi-arch $REGISTRY/$IMAGE_NAME:latest

Si maintenant un utilisateur lance une de ces commandes :

# avec docker
docker pull $REGISTRY/$IMAGE_NAME:latest
# avec podman
podman pull $REGISTRY/$IMAGE_NAME:latest
# ou encore avec nerdctl
nerdctl pull $REGISTRY/$IMAGE_NAME:latest

Alors, l’image adaptée pour son CPU sera automatiquement récupérée. C’est le principe du manifest OCI.

C’est ce poit qui est un peu douloureux, Buildah vous demande de faire des choses à la main. Ce n’est pas insurmontable, mais il faut l’avouer, c’est moins simple qu’avec Docker.

Et Gitlab ? Ils ont déjà fait le job

Si vous jetez un œil sur cette page de documentation, vous allez voir que GitLab a déjà fait le job pour vous.

Vous remarquerez qu’ils proposent d’utiliser l’image quay.io/buildah/stable qui a déjà tout le bazar pour utiliser les outils Buildah. Et pour parfaire le tout, cette image contient aussi les outils pour faire du “multi-arch”. Chose que fait très bien Buildah.

Quand vous comparer Buildah avec la page de doc pour Docker ou celle pour utiliser BuildKit, vous êtes en droit de vous demander pourquoi vous continuez à vous faire autant de mal.

Mais je vous l’avoue, je me suis surtout penché sur GitHub pour le moment.

Conclusion

J’ai du mal à comprendre pourquoi BuildX est autant mis en avant. Je suis conscient que Docker est roi, que Podman n’a pas la force de frappe en termes de communication, et que les vieilles habitudes sont dures à abandonner.

Mais, nous sommes en 2025, le monde du DevOps est de qualité, les ingénieurs sont ultra-compétents et adorent fouiller et tester. Podman (et notamment la version Desktop qui plait énormément sur Windows) est un outil fantastique. Buildah fonctionne du tonnerre. Ces deux outils simplifient notre travail, ils soulagent les machines, ils font le job comme on l’entend.

Je pense, en toute honnêteté, que Buildah devrait être l’outil par défaut dans les pipelines CI/CD.

Je l’ai déjà dit sur différents réseaux sociaux, j’admire le travaille effectué par Docker, ils ont révolutionné le monde de l’informatique en proposant un système de conteneurs simple et efficace. Docker a changé la donne, a modifié les paradigmes et permis l’avènement de Kubernetes. Cependant… Docker se concentre sur les postes de travail, sur le hub et sur sa version Desktop sous licence. C’est un choix assumé et je le respecte. Mais, nous, ingénieurs DevOps, nous devons nous concentrer sur l’efficacité, la sécurité et la simplicité.

Buildah répond à ces conditions.

Quant à Podman, devenu l’outil par défaut pour Fedora / RockyLinux / Alma / Red Hat, il est temps que vous y prêtiez attention si vous êtes développeurs.

Effet Bleach Bypass, les maths c'est cool

Wed, 05 Mar 2025 00:00:00 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Je bosse sur de la photo, des images, et je vais vous montrer pourquoi les maths c’est vraiment sympa quand on se penche un peu sur la question. Et c’est “tous niveaux”, ou presque. Allez, disons niveau lycée.

Vous ne connaissez peut-être pas le nom de l’effet “Bleach Bypass” (passage à l’eau de javel dans la langue de Jean-Claude Van Damme), mais vous avez sûrement déjà vu des images traitées avec cet effet. C’est un effet qui donne une impression “délavée”, très dramatique, brûlée. Steven Speilberg l’a utilisé dans “Il faut sauver le soldat Ryan”, mais on le retrouve dans plein d’autres oeuvres cinématographiques. Par exemple “300” de Zack Snyder, ou encore dans “Seven” de David Fincher.

Et les photographes se sont aussi emparé de cet effet.

Vous avez le droit de ne pas aimer cet effet, mais ce n’est pas le sujet de l’article.

Cet effet, expliqué sur la page Wikipedia, est assez simple à mettre en place dans la plupart des logiciels. Sans math, juste avec quelques paramètres et un peu de flair.

(By Soerfm - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=29205537)

L’effet est simple, sur Blender par exemple

J’adore Blender. C’est un superbe outil pour faire des images de synthèse, du montage vidéo, des animations, et plein d’autres trucs. Je l’utilise depuis 1999, c’est dingue ce qu’il a évolué.

Et il a aussi un outil de “compositing”, en d’autres termes, on peut manipuler des vidéos et des photos pour faire du montage et du travail de “post production”.

Et je peux faire ce genre d’effet dans le “compositeur” d’image. C’est pas très compliqué :

désaturer l’image (lui enlever de la couleur)
passer par une courbe pour écraser les ombres et forcer les lumières
et faire un “overlay” (une surcouche) de ce résultat sur l’image originale

Et ça marche plutôt bien.

L’image de référence, elle vient de cet article de Tristan Kneschke, que je vous recommande fortement : https://www.premiumbeat.com/blog/color-grading-bleach-bypass-look-in-davinci-resolve/. Le résultat m’a permis de comparer mes opérations à ce qu’il propose, et franchement ça m’a énormément aidé.

Dans Blender, clairement, il y a assez d’outils pour faire ça vite. Mais y’a pas que Blender dans la vie…

ComfyUI, un outil pour faire des images avec l’IA

Et puis je me dis que ce serait cool de faire ce “nœud” de traitement dans ComfyUI, c’est un outil qui permet de créer des images avec des modèles (de l’IA en veux-tu), et qui permet de faire des “flux” (workflow).

Sauf que ComfyUI n’a pas de nœud pour manipuler une courbe. Cela ne veut pas dire qu’on ne peut pas le faire, mais il va falloir changer de méthode. Le plus simple, pour moi, développeur, c’est de créer mon propre nœud en Python.

Mais, si je ne peux pas faire un éditeur de courbe comme sur Blender, quel outil me reste-t-il ?

La réponse…

Les maths !

Holla, avant de lire la suite

L’idée de cet article, ce n’est pas de faire le kéké en math. Ce que je vais vous montrer, n’importe quel mathématicien ou bon matheux vous dira que c’est “super simple”.

Moi, je suis conscient que ce n’est pas évident pour tout le monde.

Mon but, là, ce n’est pas de vous faire peur ou de vous faire sentir comme étant idiot parce que ce que vous ne comprenez pas le principe que je vais montrer. C’est tout l’inverse !

En fait, je vais vous demander, en lisant ces lignes, de partir du principe que ça va être assez simple.

Vous allez voir que je ne cherche pas à expliquer des trucs difficiles en math, mais au contraire de passer outre des concepts et ne s’intéresser qu’à ce qui va nous servir.

C’est exactement le but. Vous allez voir qu’on va se foutre royalement de ce que fait telle fonction ou telle opération. On va juste se servir des outils et y aller à l’arrache.

Et donc, au final, je vous dirai un truc sur les math en conclusion qui va vous “étonner”… mais lisez d’abord le boxon qui suit 😄

La courbe en “S”

Ce que j’essaie de faire, c’est d’arriver à reproduire un minimum de choses que je fais avec des machins à la souris, mais en calcul pur. Alors, autant la formule pour la partie de traitement appelée “overlay” est chiante à mourir, autant la courbe en “S” est assez sympa à manipuler.

Si si, je vous assure que c’est sympa, mais il va falloir accepter un truc : ne pas avoir peur des symboles mathématiques, des noms de fonction ou encore de l’écriture.

Les courbes en “S”, il en existe des tas qui sont définies en math. On les appelle comme ça parce que leur forme ressemble à un “S”.

Sans être un gros matheux, si votre mémoire est bonne (mais je vais vous la rafraichir), il existe une courbe qu’on a déjà vue au lycée qui a cette forme de “S”. La fonction “tangente hyperbolique”.

$$tanh(x)$$

Alors, on va être clair, on se fout de savoir d’où elle vient, ce qu’elle fait dans la vie, le nom de son chat etc. Ce qui nous intéresse, c’est la forme qu’elle a.

Voilà, ça ressemble à un “S” et c’est ce qu’on veut.

Et là j’insiste, c’est ce qu’on veut, POINT. On sait que cette fonction a, à peu près, la forme qu’on veut, et c’est tout ce dont on a besoin pour le moment.

Dans Blender, on dessinait cette courbe à la main, avouez que ça ressemble à la fonction mathématique $tanh$ :

Bon par contre y’a un ou deux trucx qui ne vont pas…

De manière pragmatique, la courbe dans Blender, elle part de 0 et elle va vers 1, alors que la tangente hyperbolique, elle pond aussi des valeurs négatives et elle s’étire pratiquement vers “2”. Ça, c’est pas cool pour nous.
Et puis, dans Blender, je peux vraiment bouger la courbe comme je veux, la rendre plus plate, plus tendue, forcer les valeurs hautes, etc. alors que là, bah j’ai juste une fonction qui fait un “S”.

En gros, je veux ça, dans le carré vert, on se fiche de ce qui dépasse :

Vous devez bien capter ce que vous voyez : là, la courbe, elle passe par $0,0$ et $1,1$, c’est à dire les coins du carré vert. C’est hyper important, il faut que la courbe passe par ces deux points. sinon, on va perdre plein de pixels de notre image quand on va la traiter.

Sploier alert : on va y arriver.

C’est à ce moment qu’il faut prendre son courage à deux mains, et se dire que bon, OK c’est pas complètement bon, mais on doit pouvoir “modifier” cette fonction $tanh(x)$ pour qu’elle colle au besoin.

La formule magique (c’est pas “s’il te plait”", c’est des maths)

Alors, il faut soit se souvenir des cours de maths du lycée, soit aller poser la question à des gens, des IA, potes, ce que vous voulez.

Mais je vous donne la réponse, elle se résume en cette formule :

$$k*(x-b)+c$$

En fait, dans cette formule qui semble barbare, seules $x$ est variable, c’est la valeur d’un pixel, la note des élèves, un niveau sonore, votre salaire mensuel dans votre tableau Excel…

Les trois autres, c’est nous qui choisissons les valeurs, au besoin, selon la situation.

Il faut se souvenir que :

$k$ change la pente d’une courbe
$b$ déplace la courbe à droite et à gauche (on appelle ça un “offset horizontal)”
$c$ déplace la courbe de haut en bas (on appelle ça un “offset vertical”)

C’est le truc le plus compliqué de l’article… vous notez cette formule quelque part, vous le gardez, c’est vraiment un truc à retenir. Je m’en sers plus souvent que vous ne pouvez le croire, pour travailler sur un tableur (pas Excel), quand je dois analyser des données, en imagerie, partout je vous dis.

On n’a pas besoin de bouger la courbe verticalement, donc on va virer $c$ de notre formule pour le reste de l’article.

Et ça marche avec n’importe quoi. Ces règles, bien appliquées, vous pouvez les utiliser sur toutes les fonctions qui prennent “x” en entrée. Vous choisissez des valeurs “k” et “b” (appelez les comme vous le voulez hein), et ça fonctionne.

La preuve en image interactive (réglez k et b pour voir):

Par contre, faut pas se planter, je dois bien multiplier l’ensemble “$x+b$” par “$k$”, les parenthèses sont importantes :

$$k*(x+b)$$

Mais vraiment, au pire, gardez juste la règle “$k(x+b)$” en tête et appliquez là au besoin. Par exemple, si je vous propose une fonction $P_{rout}(x)$ qui fait un superbe prout mathématique, vous pourrez la transformer en $P_{rout}(k(x+b))$, et donc l’écraser et la décaler sous le nez du voisin.

On applique

Donc, je prends $tanh(x)$ et je lui ajoute mes valeurs $k$ et $b$ pour faire les transformations que je veux :

$$S(x) = tanh(k.(x+b))$$

C’est tout… J’ai pas tortillé 2 ans, j’ai juste appliqué la formule magique.

Avec $k$ et $b$ des valeurs que je vais choisir pour avoir la forme que je veux. $k$ modifie la pente, et $b$ le décalage à droite et à gauche.

Je sais, donc, changer la “force” de la courbe (sa pente), et je sais la déplacer… mais dans le mauvais sens crénondedjiou.

Et oui, si $b$ vaut, par exemple, $0,5$ alors la courbe se déplace à gauche. Grrrrrr. Pas content.

On va donc soustraire au lieu d’additionner, ce sera plus naturel :

$$S(x) = tanh(k.(x-b))$$

Voilà !

Bon, en animant $k$ et $b$ (merci à Desmos, ce site est génial), on peut voir comment agissent les valeurs sur la courbe (la droite en bleu c’est une représentation de la pente qui est modifiée par “k”, et le point “b” c’est pour vous indiquer le décalage) :

Posez vous deux secondes, je vous résume ça.

On n’a pas fait un truc de fou, je vous assure. Au pire acceptez simplement le principe :

j’ai pris une fonction qui a la tête d’un “S” parce que c’est ce que je veux
j’ai fait en sorte de pouvoir faire glisser la courbe à gauche ou à droite en ajoutant une valeur “b”
j’ai fait en sorte de pouvoir l’écraser, simplement en multipliant la valeur “x” par une valeur que j’appelle “k”
c’est assez simple : on multiplie pour accélérer, on ajoute pour avoir de l’élan

Clairement, on est pas mal là. Sauf qu’on voit un petit souci. Oh, rien de bien méchant…

Là, on a juste trouvé comment changer la pente et la position de la courbe. Mais on est toujours pas dans le carré vert, c’est-à-dire qu’on ne sait pas encore utiliser seulement des valeurs entre 0 et 1, et retourner des valeurs qui doivent passer par 0 et 1 en y.

Ce que je vous dis, clairement, c’est que la courbe en $x=1$ ne donne pas 1. Et en 0, on a des valeurs négatives (la courbe passe à gauche, et est en dessous de 0) alors qu’on doit retourner 0.

Il va falloir utiliser une opération connue en informatique : la normalisation

Normalisation de la courbe

Une normalisation, c’est une opération qui vise à transformer des valeurs dans un intervalle donné entre deux autres valeurs choisies.

En français, notre fonction balance des valeurs entre -1 et 1, on veut qu’elle se place entre 0 et 1.

Sachant que nous allons lui envoyer, en entrée, que des valeurs entre 0 et 1, parce qu’une image ça marche comme ça et puis c’est tout, on n’a pas à s’occuper de ce qui est en dehors de cet intervalle.

Alors, je ne vais pas passer par 42 chemins, une normalisation ça se calcule comme ça :

$$\frac{x - m_{inimum}}{m_{aximum}-m_{inimum}}$$

Et nous, comme on tape entre 0 et 1, on va prendre les valeurs $S(0)$ et $S(1)$ pour le minimum et le maximum.

Donc, prenez votre respiration :

$$\frac{S(x) - S(0)}{S(1) - S(0)}$$

Et ça, c’est notre courbe en S pour changer la lumière et les ombres d’une image. On pourra paramétrer la force avec $k$ et corriger la dose d’ombres et de lumière avec $b$.

Voilà, on y est. En modifiant $k$ et $b$ on arrive à avoir à peu près tous les types de réglages que l’on veut pour faire adapter l’image et passer à la suite.

Je veux juste qu’on soit bien clairs entre nous. La fonction qu’on a créée, elle a deux valeurs qui nous servent de réglage. $k$ et $b$. Alors que $x$ sera la valeur de chaque pixel de l’image, en réalité chaque couleur de chaque pixel de l’image. De mon côté, j’utilise cette fonction en Python, mais en vérité, vous pouvez la “coder” avec Blender (avec les nœuds), l’utiliser dans Excel ou OnlyOffice, avec autre chose que $tanh$.

Le “overlay”

Ce sera moins compliqué, on va juste appliquer la formule pour faire ce qu’on appelle un “Overlay”. En gros, ce que fait cette opération, surtout utilisée pour le traitement d’image, c’est de prendre deux images : une “base” et une “couche supérieure”. Là où la base est sombre, la couche supérieure doit devenir plus sombre, et là où la base est claire, la couche supérieure doit l’être encore plus.

C’est une opération qui vise, donc, à utiliser une image comme référence d’ombres et lumières pour régler la seconde (la sortie).

La formule est décrite dans la page Wikipedia https://en.wikipedia.org/wiki/Blend_modes#Overlay et elle utilise une condition.

On prend $a$ et $b$, avec $a$ étant la base, et $b$ la couche supérieure.

Si $a$ est inférieur à 0,5, alors on fait “$2 *a* b$”",
sinon on doit faire $1-2(1-a)(1-b)$

En écriture plus “matheuse” on écrit :

$$ \begin{align} O_{verlay}(a,b) = \left\{ \begin{array}{cl} 2ab & \text{si } a < 0,5 \\ 1-2(1-a)(1-b) & \text{si } a\ge0,5 \end{array} \right. \end{align} $$

Il faut juste savoir une chose ici, $a$ et $b$, ce sont les valeurs qu’on va prendre dans la tronche, les couleurs de chaque pixel, les une après les autres. Mais en Python, avec numpy, on ne se prend pas la tête. On code les opérations comme si c’était une seule valeur, alors qu’en réalité, on reçoit l’image en entier (un tableau, de valeurs à plein de dimensions) - c’est lui qui se débrouille. On est de sacrés fainéants, mais c’est pour ça qu’on aime Python.

Ce ne sont que des multiplications, des additions et des soustractions. Je vous assure, prenez le temps de lire, c’est relativement simple..

On passe à Python

Je ne vous donne pas le code complet du “nœud” de ComfyUI que je développe, parce qu’il y a tout un pan de qui sert à la présentation dans l’interface, la gestion des entrées etc.

Avant de lire, sachez que je vais utiliser numpy, puisqu’il simplifie grandement les algorithmes à développer. En gros, au lieu de faire le calcul moi-même, pixel par pixel, couleur par couleur, il va le faire pour moi… Numpy gère les matrices sans qu’on ait à se battre avec les boucles.

La fonction de base, c’est le calcul $tanh(k.(x-b))$ :

import numpy as np

def T(x:np.ndarray, k: float, b: float) -> np.ndarray:
  return np.tanh(k*(x-b))

# en mode dégueux on ne donnerait pas les "tupes" attendus
def T(x, k, b):
  return np.tanh(k*(x-b))

# ça marche aussi, mais c'est infâme à utiliser dans les éditeurs de code... pensez à
# indiquer les types attendus, ça aide grandement

“x”, ici, c’est l’image sous formel de tableau de valeurs. Quand je vous dis que c’est simple avec numpy…

Alors, oui, je me balade les valeurs “k” et “b” partout, parce que je ne veux pas les mettre en “valeur globale”. C’est une habitude quand on développe, mais sachez que vous auriez pu faire :

# avant de créer la fonction
k=3
b=0.5

# et en gros:
def T(x):
  return np.tanh(k*(x-b))

# c'est simple à lire, mais encore une fois c'est pas pro ça

Bon, pour la normalisation, on a plein de manière de faire, mais le calcul “manuel” est plus clair :

def Tnorm(x:np.ndarray, k:float = 3.5, b:float = .5) -> np.ndarray:
  return ( T(x, k, b) - T(0, k, b) ) / (T(1, k, b) - T(0, k, b))

On a notre effet… ou presque.

Alors, encore une fois, je vous passe les détails, mais en fait, il va manquer deux trois trucs pour que ça marche.

il faut savoir ouvrir une image, notamment en utilisant le package PIL (Pillow)
en réalité, on doit désaturer (réduire les couleurs, en gros) l’image avant de la passer dans la courbe en “S”
on doit avoir un facteur pour régler à quel point on prend l’une ou l’autre image dans le “overlay”

Bref, pour vous aider à comprendre, j’ai créé un notebook, cliquez sur ce bouton pour voir le code et le résultat :

Et le résultat final comparé à l’article de référence que j’ai utilisé :

Merci à Tristan Kneschke pour son excellent article traitant de cet effet photo pour le logiciel “DaVinci Resolve”. Son travail m’a servi de référence pour Blender et pour le code que j’ai produit.

Son article est ici : https://www.premiumbeat.com/blog/color-grading-bleach-bypass-look-in-davinci-resolve/

Et donc, avec ComfyUI ?

Et bien j’ai créé un nœud qui utilise le code que je vous présente dans le notebook. Y’a pas mal de code pour la gestion des “tenseurs” (et oui, faut pas déconner non plus, tout n’est pas si simple). Mais il marche pas mal du tout !

Le projet est en cours de “push”, sur ma page github - patience… je dois nettoyer le code, documenter, tout ça…

Ce n’est pas grand-chose, mais ça le fait.

Et ça marche, évidemment, avec les images générée par l’IA…

Le truc étonnant, c’est cette récupération d’ombre en fond d’image, invisible dans l’image générée. Cet effet est très étonnant.

Les maths, c’est cool, vraiment

Il se peut que vous n’ayez vraiment pas capté ce que j’ai raconté. J’en suis désolé et non ça ne fait pas de vous un idiot ou une personne en dessous des autres. Certaines personnes calent sur les maths, d’autres, c’est sur la psychologie, et d’autres sur la mécanique.

Ce que j’ai tenté de vous montrer, c’est qu’il n’est pas nécessaire d’avoir un bagage de malade pour faire des trucs en math. Croyez-le ou non, je n’ai utilisé ici que des multiplications et des additions. Inutile de comprendre ce qu’est une tangente hyperbolique, ou de savoir pourquoi la formule de normalisation est comme ça. Si vous avez juste une idée de la forme d’une fonction, ou de ce qu’elle peut donner comme résultat, alors vous pouvez les utiliser comme des outils.

Je ne sais pas comment fonctionne mon réseau de flotte dans la maison, pourtant je sais me servir d’un robinet. Et bah en math, on peut faire pareil. On peut utiliser une fonction sinus ou une normalisation pour sortir un résultat sans pour autant avoir toute la théorie qui mène à leur création.

Dans mon métier, je dois manipuler des fonctions Sigmoïde, tanh, des normalisations bizarres et des vecteurs à 1000 dimensions. Je vous assure que, dans le quotidien, je ne les utilise que pour sortir des résultats, je ne les étudie pas et je ne pourrais d’ailleurs pas toutes les expliquer. Je sais à quoi ça sert et comment les manipuler.

Il ne faut, au final, que deux choses : observer et trouver une astuce. C’est ce qu’on a fait dans cet article.

Cela ne m’a pas empêché, finalement, de me replonger dans la théorie par la suite, mais je vous assure que ce n’est pas une obligation.

Pour finir, il est évident que cet article s’adresse à ceux qui, potentiellement, ont envie d’apprendre à développer en Python des outils pour traiter le son et l’image, ou pour les gens qui utilisent des outils qui permettent de faire des opérations pour traiter des images (Blender, DaVinci Resolve, Gimp, Photoshop, etc.). Dans les faits, bien souvent, l’outil vous propose un bouton pour réaliser l’effet. Mais si vous voulez aller plus loin, voire créer votre propre effet à vous, et bah taper dans les maths, ce n’est pas déconnant.

L'aberration Des Mails Non Chiffrés

Sun, 10 Nov 2024 14:34:11 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vendredi soir, le médecin nous appelle pour un résultat d’analyse qui nécessite une prise de médicament le lendemain. Il est 19 h 40, le médecin est vraiment sympa de prendre du temps pour nous, et nous envoie l’ordonnance par mail. Loin de moi l’idée de lui casser du sucre sur le dos, bien au contraire, car il nous dit au téléphone “je déteste faire ça hors messagerie sécurisée, mais là, c’est assez urgent du coup je vous l’envoie sur votre mail directement”.

Soyons clairs, on a accepté sans broncher, et cela ne nous a pas dérangé plus que ça. C’est après coup que j’ai réfléchi à cette situation aberrante.

Précision importante : cet article n’est pas une critique de ce qu’a fait le médecin. Encore une fois, il l’a fait avec notre accord et nous sommes conscients de ce que nous avons fait. Ma réflexion est générale, cela va au-delà d’un mail d’un médecin. J’ai déjà eu cette réflexion pour des échanges avec des clients, des amis, etc. En clair, je trouve cela ubuesque que nous ayons laissé tomber le chiffrement de nos mails. Vraiment, c’est une aberration.

Laissez-moi vous expliquer ce qui était, il y a plus de 20 ans, assez commun, et qui a disparu de nos habitudes.

Avant

Oui, avant, les “webmail” existaient déjà.

Un WebMail, c’est un site web sur lequel vous pouvez lire et envoyer des mails. Or, le web était plus “pauvre” et les navigateurs moins puissants. Du coup, on utilisait des logiciels spécifiques pour récupérer nos mails.

Si, si… souvenez-vous… Outlook, Thunderbird, Evolution, etc. ces noms vous parlent ? Si oui, vous avez plus de 35 ans.

Ces logiciels, on les configurait pour se connecter à un serveur mail, et on récupérait nos mails. C’était simple (ça demandait un peu de configuration, mais c’était simple). Mais surtout, ça offrait des fonctionnalités plus élaborées que ce que proposaient les WebMail.

Et notamment, le chiffrement par pair de clef, avec GPG.

Je ne me souviens plus vraiment comment j’en était venu à activer ça alors que je n’étais absolument pas informaticien, mais c’était une évidence que je voulais, parfois, envoyer des messages sans que personne d’autres que le destinataire ne puisse les lire.

Et quand j’ai vu “confidentialité” dans les options de Thunderbird, j’ai cliqué dessus. Voilà.

Alors, clairement, je n’avais pas compris tout le fonctionnement, mais j’avais compris la base : si je chiffre pour un destinataire, alors si quelqu’un au milieu essai de lire le message, il ne pourra pas.

C’est simple, c’est posé, c’est compréhensible.

Chiffrement par paire de clefs

Alors, si vous voulez avoir la base de la base, même si vous n’êtes pas obligés de tout comprendre, voilà comment ça se passe :

Au début :

vous configurez une “paire de clefs” : une clef publique et une clef privée, elles sont liée entre elles,
vous donnez votre clef publique à vos contacts, voire au monde entier, c’est fait pour ça,

Et ensuite :

les gens vous envoient des messages chiffrés avec votre clef publique,
vous déchiffrez les messages avec votre clef privée,
et c’est “automatique” : vous n’avez rien à faire, c’est transparent pour vous si vous utiliser un client mail qui supporte GPG (genre Thunderbird)

Et inversement, pour envoyer un message chiffré, vous prenez la clef publique de votre destinataire, vous chiffrez le message avec cette clef, et vous envoyez le message.

Et c’est en fait automatique. Vraiment vous n’avez pas à chercher comment faire. Vous allez voir ma capture d’écran plus loin c’est vraiment simple.

Thunderbird, le client mail

Thunderbird rendait cette opération super simple. Vous cliquiez sur un bouton pour générer une paire de clefs, et puis voilà.

Quand vous enoyez un message à un contact qui n’a pas encore votre clef publique, et bien Thunderbird l’injecte dans le mail pour vous. Le destinataire n’a plus qu’à cliquer sur un bouton pour l’ajouter à sa liste de clefs publiques. Et à partir de là, vous pouvez lui envoyer des messages chiffrés.

Et c’est encore le cas aujourd’hui !

Ce que je vous raconte existe depuis des années, et ça n’a jamais disparu.

On se foutait de savoir si le mail était chez Hotmail, Gmail, Yahoo, ou chez le fournisseur de mail de Bob. On savait que le message était chiffré, et que seul Bob pouvait le lire.

Ouais, mais ça ne plaisait pas à Google, Microsoft, Yahoo, etc…

La suite après la pub

Et oui parce que, si le message est illisible par tout le monde à part Bob, comment Google peut lire le message pour vous proposer de la pub ciblée ?

Et comment il peut vous dire “hého, je sais que t’as rendez-vous chez le proctologue, je te propose une promo sur les suppositoires” ? Comment il peut faire ça s’il ne peut pas lire le message ?

Donc, Gmail a tout simplement refusé de supporter le chiffrement par paire de clefs sur le WebMail… Simple, basique.

Et comme la grande majorité des gens utilisent le WebMail, et bien personne n’a accès à un petit bouton pour “chiffrer” le message.

Sauf si vous avez un plugin, mais c’est une autre histoire.

Et alors, pour mon médecin ?

Eh bien, c’est là que c’est fou. Mon médecin doit certainement payer un truc pour chiffrer des messages et nous permettre d’y accéder - c’est potentiellement compliqué à gérer.

Si le chiffrement GPG était resté une norme, il n’aurait rien eu à faire. Il aurait chiffré le message pour moi et moi seul, et je l’aurais déchiffré avec ma clef privée.

Thunderbird retient les clefs publiques des contacts, donc il chiffre automatiquement avec la bonne clef.

Le tout est absolument transparent pour l’utilisateur hein ! Pas la peine d’être ingénieur.

Juste pour que vous voyez le résultat

Je me suis envoyé un mail chiffré à moi-même.

Et sur Gmail, c’est impossible à lire !

Et si je tente d’ouvrir le fichier “encrypted.asc”, j’obtiens ça :

Ce fichier, Thunderbird sait l’utiliser comme un grand, il prend ma clef privée et le déchiffre. Je n’ai rien à faire moi-même, c’est automatique.

Ce que je veux dire, c’est que sur Thunderbird, je vois mon message comme n’importe quel autre message !

Vous remarquez, en haut à droite, l’icône “OpenGPG” qui indique que le message est sûr et bien chiffré.

Et les autres ?

C’est vrai, on ne passe pas son temps à envoyer des secrets à nos contacts. N’est-ce pas ?

En fait… si. En soit, tout doit être un secret.

Si vous vous posez deux secondes sur la question, vous allez vous rendre compte que tous les messages que vous envoyez sont des secrets.

D’abords, au niveau professionnel. Combien de mails recevez-vous avec des informations sensibles ? Je ne parle pas nécessairement de mots de passes, mais des données qui parlent de l’entreprise, d’un projet dont on n’aimerait pas qu’une boite d’informatique nous pique les idées. Et c’est là que ça fait peur, c’est que beaucoup de nos clients utilisent Office 365, avec un Outlook en ligne, avec Microsoft qui peut analyser le contenu des messages.

Encore une fois, la faute à qui ? Quand une entreprise comme Microsoft vous promet monts et merveilles avec leurs outils, et un Copilot qui lit tout ce qui se passe, on ne peut pas s’étonner que les gens utilisent ces outils. Et donc, on ne chiffre rien. Et Microsoft est content.

Et puis, il y a les mails personnels. Combien de fois avez-vous envoyé des photos de vos enfants, de votre famille, que Google se délecte pour (on ne sait pas hein) entrainer son IA, analyser le contenu pour afficher de la pub, etc. Et si ces données fuitaient ? Si, comme beaucoup trop de gens, vos mots de passes étaient faibles ? Et bien vous mettez en danger vos photos, et les photos qu’on vous envoie.

Et ce n’est pas que pour les mails

Comme je le disais, GPG est utilisé pour chiffrer des fichiers, des messages, des connexions, etc. C’est un outil génial qui est toujours dans les outils des informaticiens, mais qui a été abandonné par le grand public.

C’est bête, c’est dommage.

GPG, avec une simple ligne de commande, ou avec des outils à la souris, c’est un truc vraiment intelligent et efficace. Pour vous donner une idée des utilisations que j’en ai:

J’ai fourni ma clef à un client pour qu’il chiffre un mot de passe à me donner pour me connecter à une base de données
signature des logiciels que je publie afin d’assurer que ce que les gens téléchargent ne peuvent provenir que de moi (si le test de signature échoue, c’est que le fichier a été modifié par quelqu’un d’autre)
chiffrement de fichiers sensibles que je stocke sur le cloud (oui, je stocke des trucs sur le cloud, mais chiffrés)
chiffrement de mails, bien entendu
etc.

Conclusion

Installez un client mail, utilisez le chiffrement en créant une paire de clefs (franchement, suivez juste le guide dans la configuration de Thunderbird, c’est simple), et envoyez vos mails chiffrés.

Si tout le monde arrêtait d’utiliser des WebMail, et utilisait des clients mail qui supportent le chiffrement, on réglerait un nombre incalculable de problèmes.

Fini les messageries sécurisées pour chaque service, difficile à lire, à utiliser sur le net, et à maintenir. On pourrait simplement envoyer un mail à la CAF, la CPAM, la banque, etc.
fini d’avoir des pubs au milieu des messages, et de se demander pourquoi Google affiche des pubs à propos d’un cadeau dont on parle en famille par mail pour un anniversaire,
fini de se poser la question “comment je t’envoie le mot de passe ?”
fini de se demander si le message provient bien de la personne indiquée, genre si j’ai la signature GPG de mon banquier, personne ne peut se faire passer pour lui,
etc.

GPG est libre, très utilisé dans le monde informatique (par exemple, on signe nos travaux Git, s’en sert pour valider des dépôts de logiciels, etc.), et très simple à utiliser.

GPG, ça sert à chiffrer et à signer. Je ne vais pas tout expliquer dans cet article déjà un peu trop long, mais vous pouvez :

envoyer un message en clair, mais assurer que c’est vous et personne d’autre qui a bien écrit cela
envoyer un message chiffré, que seul le destinataire pourra libre
ou ne rien faire, et envoyer un message en clair

C’est inclut par défaut sur Linux, c’est intégré à Thunderbird pour Windows, Linux, Mac, mobile, et ça marche du feu de dieu.

Non, vous n’avez pas besoin d’être informaticien pour chiffrer vos mails, installez Thunderbird et aller dans les paramètres de votre compte, dans “confidentialité”, et cliquez sur “Gérer les clefs”. POINT !

Il vous suffit d’installer Thunderbird, de cliquer sur un bouton pour générer une paire de clefs, et c’est tout bon sang…

Et il existe bien entendu d’autres clients mail que Thunderbird. C’est juste que c’est, à ma connaissance, le seul qui ait une intégration aussi simple de GPG, qui répond à 99% des besoins et qui soit largement documenté.

J'ai créé une IA qui analyse un débat politique à la télévision

Thu, 27 Jun 2024 15:18:18 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Et cerise confite sur le gâteau au chocolat noir, je vais tout faire avec des outils open-source.

C’est important, c’est très important… Nous allons voter dimanche 30 juin pour les législatives. Il y a trois grands groupes politiques qui sont très présents et il se trouve qu’un débat a eu lieu, et qu’on retrouve le replay sur TF1, où plusieurs sujets ont été abordés.

Ce que je voulais savoir, par cette approche, c’est comment, à de partir d’une donnée très compliquée à analyser, à savoir une vidéo (disons plutôt le son de la vidéo), nous pourrions proposer un outil qui analyse et synthétise le contenu. L’idée étant de pouvoir extraire des propos, les vérifier, résumer, ou même simplifier ce qui est dit.

Vous pourrez adapter les questions à votre guise, et même poser des questions plus complexes. Mais il va falloir passer de la vidéo à quelque chose de compréhensible par une machine.

Pour cela, il y a quelques étapes à suivre. Je vais donc tenter de vous expliquer, pas à pas, comment j’ai procédé. Je vais vous expliquer des concepts en les vulgarisant autant que je peux. Car si l’on se penche un peu plus dans les détails cela peut paraitre abstrait, imbitable, et cela peut même décourager.

J’espère que je vais réussir à vous expliquer tout ça de manière simple et claire. Même si certains concepts ne sont clairement pas évidents, j’ai à cœur de vous démontrer que c’est finalement assez accessible. Et si les blocs de code vous rebutent, je vous invite à ne vous pencher que sur les concepts.

Bref, j’espère que je vais être utile.

Mais avant tout, je dois impérativement vous mettre en garde

Ce que je vous propose ici est avant tout une approche didactique à des fins de recherches et de tests.

En aucun cas une intelligence artificielle ne doit vous orienter votre vote.

Les débats politiques sont complexes et ont des enjeux propres à chacun. Vous avez aussi votre propre sensibilité aux sujets abordés.

Cette approche peut générer des données biaisées, erronées ou opposées aux convictions des candidats. Je vous répèterai souvent qu’il faut vérifier les réponses et les données. Malgré tout le soin que j’ai apporté à ces tests, il est évident que je ne peux pas garantir l’exactitude des réponses qui sont générées.

Les étapes

Il va falloir passer par plusieurs étapes. Ce travail prend du temps. Si vous voulez reproduire ce que je vous propose, il faudra s’armer de patience, certainement corriger les données, faire plusieurs tests (notamment changer de modèle, adapter les méthodes de réponses, lire de la documentation…).

Les étapes sont donc les suivantes :

Récupération de l’audio du débat et édition du fichier pour supprimer ce qui n’est pas nécessaire (la pub…)
Transcription automatisée de l’audio en texte, qui se déroule en deux étapes :
- segmenter par phrase et par locuteur (en gros, “qui dit quoi” et quand ?),
- transcrire chaque phrase en texte (traduire le son en texte)
enregistrer les textes en vecteurs dans une base d’indexation vectorielle (je vais vous expliquer le concept)
poser des questions à un LLM (je vais vous expliquer…), en sortir des analyses, et des idées pour aller encore plus loin

Pour y arriver, on aura besoin de pas mal d’outils.

Je vais passer outre le téléchargement de l’audio/vidéo pour une raison simple : on est à la limite de l’égalité, car le contenu est potentiellement sous droits d’auteurs. Je me refuse à donner des moyens d’effectuer des téléchargements illégalement depuis des sites de chaines de télévision. Pour autant, croyez-moi, c’est une étape très simple à réaliser. Un coup de Google et vous allez trouver des outils pour cela (genre, cherchez “video downloader”, voilà, j’en ai trop dit).

Par contre, pour la suite, aucun souci. Tout va passer par des outils IA :

pyannote.audio pour le découpage des segments de l’audio, afin d’avoir une série de phrases, et de savoir qui parle et quand
pydub pour la manipulation de l’audio
whisper pour la transcription de l’audio en texte
llama-index pour toute la partie que l’on appelle “RAG” (Retrieval Augmented Generation), en d’autres termes pour la recherche d’informations dans un corpus de texte (pas de panique, je vais vous expliquer)

On utilisera un modèle pour que l’IA réponde à nos questions plus naturellement. J’apprécie beaucoup le modèle Qwen2, qui est bien entrainé pour répondre en français. Localement, avec LLamaCPP, c’est viable. Mais je n’ai pas des foudres de guerre et donc je vais passer par l’API de HuggingFace pour gagner du temps.

Il faudra utiliser, bien entendu, le modèle au format GGUF que vous trouverez ici Qwen2-7B-Instruct-GGUF. Les modèles dans ce format sont “quantizés” de différentes manières. Si j’en crois mes tests, c’est le modèle q4_k_m qui est le plus probant. Mais vous pouvez tester les autres…

Par chance, llama-index propose un package pour utiliser ce service.

Si vous préférez OpenAI ou avoir un modèle local, voyez ma note en bas de l’article.

Cette API est gratuite pour un usage modéré, mais personnellement, j’ai un accès “pro” pour 9 €/mois qui repousse la limite d’utilisation. Par contre, dans tous les cas, pour utiliser l’API ou récupérer des modèles, il vous faudra vous enregistrer (gratuitement) sur le site et générer une clef d’API.

Je vous laisse suivre les étapes expliquées sur la page de Hugging Face. Je vous conseille d’ailleurs d’installer le client en ligne de commande comme indiqué ici pour enregistrer le “token” sur votre poste et ne pas avoir à le mettre dans votre code source. La commande huggingface-cli login vous demandera la clef d’API et cela sera plus simple pour la suite.

Vous pouvez aussi adapter tout ce que je vous explique ici pour utiliser les accès à OpenAPI (avec GPT donc), ou même charger un modèle localement selon plusieurs méthodes.

Allez lire la documentation du site de llama-index qui vous donnera les explications nécessaires pour comprendre comment ça fonctionne.

Prérequis et préparation

Normalement, tout devrait à peu près fonctionner sur un notebook (comme Google Colab, Jupyter, Kaggle…) - pour ma part, j’utilise des scripts Python directement sur mon poste. Cela me permet de mieux contrôler les étapes et d’éviter des écrasements de variables.

Il vous faut absolument Python sur le poste, de préférence sur Linux, et avoir un GPU ayant, a minima, 8 Go de VRAM. Malheureusement, pour la partie “transcription”, les modèles ne supportent que des GPU NVIDIA. Vous pouvez passer par votre CPU, mais vous allez sentir passer le temps¹.

Transcription de l’audio

On part du principe que vous avez récupéré l’audio de l’émission. Vous devez le transformer au format .wav, car les autres formats semblent poser un souci. N’oubliez pas de virer les publicités pour ne pas avoir des voix inutiles à classifier. Un outil comme Audacity peut vous aider à éditer l’audio.

Il est temps de se lancer.

Créez un environnement virtuel, installez les dépendances :

# on va travailler dans un répertoire dédié
mkdir -p Projects/ML/Débat
cd Projects/ML/Débat

python -m venv venv
source venv/bin/activate
pip install pyannote.audio pydub whisper-openai

Le code segmentazie.py suivant va créer un fichier audio.rttm qui contiendra les segments de l’audio, avec le locuteur. C’est une étape très importante, elle va nous permettre de savoir qui parle et quand.

Avant toutes choses, notez que j’ai supprimé les publicités du fichier audio pour éviter d’avoir à identifier un nombre conséquent de voix.

import numpy
import torch
from pyannote.audio import Pipeline
from pyannote.audio.pipelines.utils.hook import ProgressHook

# numpy.NAN is not defined, so we define it here
# I fixed this in a PR: https://github.com/pyannote/pyannote-audio/pull/1732
setattr(numpy, "NAN", numpy.nan)

INPUT_FILE = "input.wav"

pipeline_model = "pyannote/speaker-diarization-3.1"

# check if cuda is available
device: torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

pipeline = Pipeline.from_pretrained(pipeline_model).to(device)

# apply the pipeline on the input file
with ProgressHook() as hook:
    diarization = pipeline(file=INPUT_FILE, hook=hook)

# dump the diarization output to disk using RTTM format
with open("audio.rttm", "w", encoding="utf-8") as rttm:
    diarization.write_rttm(rttm)

Le fichier audio.rttm est un fichier texte qui contient ce genre de lignes :

SPEAKER input_truncated 1 0.115 10.598 <NA> <NA> SPEAKER_01 <NA> <NA>
SPEAKER input_truncated 1 10.713 1.316 <NA> <NA> SPEAKER_04 <NA> <NA>
SPEAKER input_truncated 1 12.029 3.493 <NA> <NA> SPEAKER_01 <NA> <NA>
SPEAKER input_truncated 1 21.293 12.521 <NA> <NA> SPEAKER_01 <NA> <NA>
SPEAKER input_truncated 1 34.135 20.672 <NA> <NA> SPEAKER_04 <NA> <NA>
SPEAKER input_truncated 1 55.094 15.711 <NA> <NA> SPEAKER_01 <NA> <NA>
SPEAKER input_truncated 1 71.311 12.572 <NA> <NA> SPEAKER_04 <NA> <NA>
SPEAKER input_truncated 1 83.782 19.862 <NA> <NA> SPEAKER_01 <NA> <NA>
SPEAKER input_truncated 1 103.660 12.690 <NA> <NA> SPEAKER_04 <NA> <NA>
SPEAKER input_truncated 1 117.093 13.601 <NA> <NA> SPEAKER_02 <NA> <NA>

On ne va pas détailler, mais il faut retenir que (en partant de la colonne 0) :

La colonne 3 est le début du segment
La colonne 4 est la durée du segment
La colonne 7 est le “locuteur” - évidemment que c’est un identifiant “anonyme” car le script ne connait pas les voix, il sait juste que c’est une personne différente qui parle.

Pour ma part, j’ai écouté quelques segments en me basant sur les temps de début et j’ai pu trouver que (dans mon cas) :

SPEAKER_01 est Anne-Claire Coudray
SPEAKER_04 est Gilles Bouleau
SPEAKER_02 est Manuel Bompard
SPEAKER_05 est Gabriel Attal
SPEAKER_08 est Jordan Bardella

Les autres segements sont généralement les moments où les candidats parlaient en même temps. Je les omets volontairement pour la suite.

Transcription de l’audio en textes

Maintenant que je sais qui parle et quand, je vais pouvoir transcrire les phrases en texte. On va utiliser whisper, un modèle open-source de OpenAI, très bien entrainé et franchement très bon.

J’ai tenté d’utiliser le modèle “de base” (base) mais les résultats étaient assez mauvais. Le modèle medium a été plus adapté. J’aurais adoré tester avec un modèle plus large, et par conséquent plus précis, mais ma machine a un peu de mal à tout gérer.

Ce que je vais faire, ici, c’est de créer des fichiers texte dans un répertoire par candidat. Cela permettra d’indexer les propose plus facilement par la suite.

Voilà donc le script transcription.py :

import os

import torch
import shutil
import whisper
from pydub import AudioSegment

INPUT_FILE = "input.wav"

# model to use
model_type = "medium"  # tiny, base, small, medium, large

# open the audio file
audio = AudioSegment.from_file(INPUT_FILE, format="wav")
# open the diarization file
dz = open("audio.rttm", "r").read().splitlines()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# load the model
model = whisper.load_model(model_type, device=device)

# only the candidates
speakers = {
    "SPEAKER_02": "Manuel Bompard",
    "SPEAKER_05": "Gabriel Attal",
    "SPEAKER_08": "Jordan Bardella",
}

# delete and recreate transcriptions/xxx
shutil.rmtree("transcriptions", ignore_errors=True)
for speaker in speakers.values():
    os.makedirs("transcriptions/" + speaker, exist_ok=True)

current = ""
for line in dz:
    line = line.split()

    # get the speaker and the segment
    speaker = line[7]
    if speaker not in speakers:
        # not a candidate
        continue

    # get the real name of the speaker
    speaker_name = speakers.get(speaker)

    # get the start and the duration and convert to milliseconds
    start = float(line[3]) * 1000
    duration = float(line[4]) * 1000

    # get the segement
    audio_slice = audio[start : (start + duration)]

    # one channel, 16kHz
    audio_slice = audio_slice.set_channels(1).set_frame_rate(16000)

    if audio_slice.raw_data is None:
        continue

    # transcribe with raw data (converted)
    text = whisper.transcribe(
      model,
      audio=np.frombuffer(audio_slice.raw_data, dtype=np.int16).astype(np.float32)/32768.0,
      language="fr",
    )

    # print (optional)
    if speaker != current:
      # new speaker...
      print(f"--- {speaker_name} ---")

    print(text["text"])

    # append the text to the file in the speaker directory
    with open(f"transcriptions/{speaker_name}/propos.txt", "a", encoding="utf-8") as f:
        f.write(text["text"] + "\n")

    current = speaker

Cela m’a généré 3 fichiers (dans le répertoire “transcriptions”) :

Manuel Bompard/propos.txt
Gabriel Attal/propos.txt
Jordan Bardella/propos.txt

J’aurais pu, bien entendu, aller plus loin, en ajoutant des contextes de question des journalistes, des réponses, voire structurer les données. Mais je n’ai pas un temps infini².

Attention whisper se trompe de temps en temps, et parfois pyannote attribue des propos à la mauvaise personne. Donc, clairement tout ce qui va suivre doit être pris avec des pincettes. Partez du principe qu’il faut normalement tout vérifier et corriger les données. Or, je n’ai pas le temps, et là je vous propose uniquement une explication dans un contexte d’actualité. Mon IA finale n’est pas précise, elle demanderait des heures de travail pour être plus pertinente et moins dans l’erreur. J’espère avoir été clair : attention à ce que vous allez lire !

Les LLM

Avant d’aller plus loin, un petit rappel sur ce que sont les “LLM” (Large Language Models).

Ce sont des modèles, c’est-à-dire des gros fichiers qui représentent des calculs à faire (des milliers, voir des millions ou des milliards de paramètres) qui sont adaptés pour “traiter et générer du texte”. On parle de “modèles de langage”.

Vous avez forcément entendu parler de ChatGPT, Gemini, Claude, Mistral… ce sont des outils qui utilisent ces modèles pour vous donner des réponses qui semblent cohérentes et naturelles.

Ils ont, par contre, un énorme défaut !

Ils sont “entrainés” à un instant T, sur des données qui sont “statiques”. Cela veut dire que, si vous leur posez une question sur un sujet dont elle n’a pas connaissance, ce qui est très vrai en ce qui concerne l’actualité, eh bien, il peut avoir trois réactions possibles :

dire qu’il ne sait pas… ce qui est très rare
donner une réponse qui n’est pas à jour
raconter n’importe quoi, on dit qu’il hallucine

Par exemple, si je demande à ChatGPT (en 2024) la liste des “femmes premières ministres” que nous avons eu en France…

Et oui… son entrainement date de 2021, il n’est donc pas au courant…

En ce qui concerne les cas d’hallucination, par exemple, je lui ai demandé de me donner les trois premiers ministres “femmes” qu’on a eu en France. Selon d’où vient le vent, il me sort trois noms. Alors qu’en 2024, nous n’avons eu que deux femmes premières ministres (E. Cresson et E. Borne).

Pour la blague, il m’a cité “Ségolène Royal” dans la liste. Il a clairement halluciné la réponse 😉.

Mais pourquoi il “hallucine” ? Il est bête ou quoi ? Il ment ouvertement ?

Parce que le modèle cherche à donner une réponse coute que coute. Il va potentiellement commencer une phrase dont la suite va être fausse. Qu’à cela ne tienne, il va continuer pour être cohérent.

Hors, la cohérence n’est pas forcément vraie.

Comprenez bien que son but n’est pas de donner une vérité, mais de “fournir une réponse”. Il ne cherche pas l’information, il génère du texte qui semble bon. Si l’information est biaisée, ou si elle parait ouverte, il va inventer sans s’en rendre compte. Il faudrait qu’il ait vu une information viable pour donner une réponse viable.

Alors pourquoi on ne les entraine pas tous les jours ? En continu ?

Parce que c’est long. Entrainer un modèle GPT prend des semaines, voire des mois ! Et ça coûte cher. Très cher. Il faut des machines très puissantes, qui avalent de l’électricité comme Gérard enquille les litres de rouge. Vraiment, c’est catastrophique.

Et ça, c’est l’erreur que beaucoup font aujourd’hui : penser qu’un modèle LLM est une “source de vérité”. Un modèle LLM ne sert par à donner de l’information, il sert à donner une réponse “naturelle”. La question qu’on lui pose oriente la réponse. Si la question est mal posée, la réponse sera fausse.

Arrêtez d’utiliser ChatGPT comme si c’était un moteur de recherche !

C’est pour cela qu’on utilise de plus en plus la méthode “RAG”, dont on va parler plus tard, qui consiste à donner de l’information à jour, contextualisée, au modèle.

Vectorisation de termes

Cette phase est la plus “compliqué”. Même si, clairement, llama-index est absolument génial et va vous mâcher tout le travail, il faut prendre le temps de comprendre comment ça fonctionne.

Si vous n’avez jamais entendu parler de “vectorisation de texte”, que l’on appelle aussi embeding, je vous fais un topo rapide.

En français, et en anglais aussi, on utilise un terme pour définir “comment comprendre un mot”, et c’est assez fou que ce terme soit exactement la définition dont on a besoin. On dit qu’un mot à un “sens”. Vous ne vous rendez pas compte à quel point dire cela est juste. D’ailleurs, on parle de direction quand on évoque “où veut aller le discours”, et on dit clairement “je ne vois pas où tu veux en venir”.

Car, en réalité, un “sens” indique une direction.

Alors prenons le mot “sens” au pied de la lettre. Imaginons que l’on dessine une flèche pour définir un mot.

Donc, deux mots “proches” iront à peu près dans la même direction, tandis qu’un mot opposé ira dans le sens inverse.

Et vous savez quoi ? Un sens, une flèche, en géométrie, on appelle ça un vecteur. On peut le définir mathématiquement. Un vecteur, en mathématique, c’est une direction et une longueur. On peut définir la longueur du vecteur à partir des coordonnées.

Chose encore plus dingue, si on se débrouille bien, une addition de vecteurs peut donner un autre vecteur. Ce vecteur résultant aura aussi un sens. Cela veut dire que, si on trouve une méthode pour savoir la direction de chaque mot, alors :

on peut additionner les vecteurs de chaque mot d’une phrase, et avoir le sens de la phrase
des vecteurs proches auront des sens proches

Cela veut dire que la “sémantique” est mathématiquement représentable. C’est ce que l’on appelle la “vectorisation de texte”.

Ici, pour vulgariser, j’ai utilisé des flèches sur un plan. Donc en deux dimensions (2D). On peut imaginer qu’un vecteur soit défini par trois dimensions (3D)…

Par exemple, “Chat” et “Chien” sont proches, mais “Serpent” l’est moins. Si les axes ont une signification propre au modèle (par exemple s’il approche les concepts de “mammifère”, “animal”, “domestique”, etc.), alors on peut imaginer ce genre de vecteur en trois dimensions :

Sauf que mathématiquement, on n’a aucune limite. Les modèles utilisés pour la sémantique gèrent des vecteurs en 128, 256, 512, 1024 dimensions… Le cerveau humain ne peut pas imaginer ce genre de flèche, de vecteur. Mais on peut le représenter mathématiquement. Cela donne énormément d’informations sur le sens d’un mot.

Ainsi, un mot comme “chat” peut être représenté comme ceci:

[-0.255, 1.25, 6.32, -0.23, 1.2, 6.3, ...]

Comment on choisit ces valeurs ?

Eh bien ce n’est pas à nous, humains derrière le clavier, de décider. On utilise des algorithmes qui vont trouver tout seul les valeurs qui rapprochent ou éloignent les concepts. Ce sont des “régressions statistiques” qui vont trouver ces données, et c’est bien assez compliqué pour que je vous dise “ayez confiance, ça marche”.

Nous, de toutes manières, on ne va pas se prendre la tête, on va utiliser des modèles déjà entrainés qui savent donner un vecteur à chaque mot.

Par contre, c’est bien beau de savoir vectoriser des mots, mais ça sert à quoi au juste ?

Le but, c’est d’être capable, à terme, de pouvoir trouver des parties d’un document qui “semble parler d’un sujet en particulier”. Cela veut dire que, si je cherche des documents qui parlent de “chien”, je vais chercher les vecteurs qui se rapprochent le plus du vecteur “chien”. Et je vais certainement tomber sur des documents qui parlent de “canidés”, de “toutous”, de “cabots”, etc. Parce que les vecteurs qui représentent ces mots sont proches de celui de “chien”. On dit que leur “distance vectorielle est proche”.

La méthode la plus simple est donc de découper mon texte en petits morceaux (en phrases, ou en sections de texte), et d’enregistrer chaque morceau et ses vecteurs dans une base de données adaptée.

Cela veut dire que, si j’ai une “question” à poser, je peux la transformer en un vecteur et chercher dans la base tous les bouts de texte qui ont un sens proche. Alors une fois de plus, on a des outils pour ça, on ne va pas faire de maths bien énervés nous-même. Reposons-nous sur le travail fait par des gens qui nous ont facilité la tâche.

Maintenant, comprenez l’intérêt dans notre exemple. On va pouvoir faire ce genre de choses :

chercher les propos de chaque candidat dans une base pour un sujet donné, une question, etc.
construire une question à donner à un modèle de génération de texte pour avoir une réponse “naturelle”

C’est ce que l’on appelle, le RAG (Retrieval Augmented Generation).

Je réponds à une question qu’on m’a posé dernièrement :

Mais pourquoi passer par des vecteurs tout compliqués alors que j’ai un moteur de base de données qui sait faire de la recherche “full text” (recherche de mots) ?

Eh bien parce que le but n’est pas de trouver des textes qui contiennent des “mots clefs” trouvés dans la question. Le but est de trouver des bouts de textes qui ont un sens proche de la question. Cela veut dire que, si je pose une question “Trouves moi un truc à me mettre sur la tête”, je ne veux pas trouver les textes qui parlent de “porter” et “tête”. Je veux qu’il me trouve des textes qui parlent de bonnets, de chapeaux ou de couronnes. Même si je n’ai pas utilisé ces mots. Seule la sémantique, le sens, compte. Et la vectorisation de texte est la seule technique qui permet de faire ça efficacement.

En fait, on pourrait se passer de la vectorisation, mais les résultats seraient moins précis. On aurait des résultats parasites, des réponses ambivalentes.

Ah, une précision tout de même, on pourrait utiliser Elastic Search ou TypeSense qui propose déjà une vectorisation des termes indexés. Mais, à mon sens, c’est utile si vous avez besoin de la base pour d’autres choses. Nous, ici, on va faire du “one shot”, du test ponctuels, donc on va passer par une base en mémoire, adaptée à la recherche sémantique pour ce cas de figure.

Et donc, t’as parlé de RAG, c’est quoi ?

Eh bien, c’est une “technique” qui consiste à utiliser un moteur de recherche pour extraire des informations à partir d’une question, puis de compiler une question avec ce contexte qu’on va poser à un modèle LLM. Et par conséquent d’avoir une réponse “naturelle” et cohérente basée sur des informations à jour dans un contexte bien déterminé.

En gros, on oriente la réponse que donne une IA en lui donnant des informations.

C’est, en fait, assez “simple” conceptuellement parlant.

La question posée par un utilisateur est utilisée deux fois :

pour trouver les bouts de texte dans la base, afin d’avoir un “contexte” d’informations
pour demander à l’IA de répondre à la question en prenant en compte le contexte qu’on lui injecte

Cela a pour effet d’éviter les “hallucinations” des modèles, car on leur donne des informations à jour, contextualisées.

Le LLM en bout de chaine, il sert à deux choses finalement :

arriver à analyser pour résumer la réponse de manière cohérente
donner une réponse “naturelle” à l’utilisateur

Comme un “LLM” est un modèle “génératif”, et qu’on “retrouve” des informations qu’on injecte à notre question, vous comprenez que RAG (Retrieval Augmented Generation) veut bien dire “Génération Augmentée par la Recherche”. Eh ouais 😄

Dans les faits, on peut pousser le concept très loin. Par exemple en envoyant la réponse une seconde fois dans le moteur avec d’autres informations issue d’une autre recherche basée sur la réponse. On peut ainsi affiner la réponse (“méthode Refine”).

llama-index propose d’ailleurs plusieurs techniques de recherche, et de génération de résultat. On peut par exemple faire de la recherche en mode “refine”, “compact” ou “summarize”, et avoir des arbres de réponses pour connaitre le document sur lequel il trouve les réponses, etc.

Pour l’heure, on fait simple. Mais vous pouvez vous amuser un peu si vous voulez.

Je vous invite à lire leur documentation, vous verrez que c’est très complet. Mais vraiment très complet.

Implémentation du RAG

Nous allons créer un second environnement virtuel parce que LLamaIndex utilise une version de numpy incompatible avec celle que nous utilisons pour pyannote.audio.

Nous installons chromadb pour indexer les documents, on va l’utiliser en mode in memory, car nous n’avons pas beaucoup de documents à indéxer, ce sera donc rapide et nous n’aurons pas à stocker tout ça sur le disque.

On pourrait utiliser le système d’indexation par défaut, intégré à llama-index. Cependant, chromadb est plus adapté et mieux optimisé pour les recherches sémantiques.

Il nous faudra aussi quelques sous-paquets pour accéder à des modèles LLM. Dans mon cas, je vais utiliser l’API d’inférence de HuggingFace (parce que c’est rapide, simple et efficace). Mais si vous désirez utiliser un modèle local, vous pouvez changer un peu le code et utiliser llama-index-llms-llamacpp pour charger un modèle au format GGUF par exemple.

# quittez l'environnement virtuel précédent
deactivate

# créez un nouvel environnement virtuel
python -m venv venv-llama
source venv-llama/bin/activate

# installez les dépendances
pip install chromadb
pip install llama-index llama-index-embeddings-huggingface llama-index-llms-huggingface llama-index-vector-stores-chroma

Le code suivant est à peu près clair.

Nous créons une base chroma en mémoire
Pour chaque candidat, je crée une collection séparée (comme ça je peux trouver les réponses pour un candidat)
Ensuite, je boucle sur les candidats :
- J’indexe les propos.
- Je stocke les vecteurs dans la collection du candidat.
- Je garde le moteur de requête pour pouvoir poser des questions.

Il me reste enfin à avoir une base de questions. Pour chaque question à poser, je la pose à chaque candidat.

Lisez les commentaires dans le code, c’est important si vous voulez comprendre ce que je fais, et comment l’adapter à vos besoins.

from llama_index.llms.huggingface import HuggingFaceInferenceAPI
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core import (
    SimpleDirectoryReader,
    StorageContext,
    VectorStoreIndex,
    PromptTemplate,
)
import chromadb

# une base ChromaDB épheémère, en mémoire
chroma_client = chromadb.EphemeralClient()

# Une lsite de candidats avec leur collection associée. Bien entendu,
# j'aurais pu automatisé en listant les répertoires, mais pour vous clarifier
# le code... je fais comme ça
collections: dict[str, dict] = {
    "Jordan Bardella": {
        "chroma": chroma_client.create_collection("bardella"),
        "query": None,
    },
    "Manuel Bompard": {
        "chroma": chroma_client.create_collection("bompard"),
        "query": None,
    },
    "Gabriel Attal": {
        "chroma": chroma_client.create_collection("attal"),
        "query": None,
    },
}

# le prompt "de base" pour contextualiser la manière dont me répondra le LLM.
# Je force un peu la main pour avoir des réponses en français et contextualisées sur
# le domaine politique.
system_prompt = " ".join(
    [
        "Tu est un électeur qui cherche des réponses à des question sur les candidats à l'élection legislative.",
        "Tu réponds en français.",
    ]
)

# LLM à utiliser. J'utilise ici l'API de HuggingFace, mais vous pouvez
# passer par OpenAI, ou charger un modèle avec LLamaCPP. La doc est assez
# fournie
# model = "mistralai/Mistral-7B-Instruct-v0.3" # peu précis et contradictoire
model = "HuggingFaceH4/zephyr-7b-alpha" # le meilleur durant mes tests
# model = "HuggingFaceH4/zephyr-7b-beta" # me donne souvent des textes vides...
llm = HuggingFaceInferenceAPI(
    model_name=model,
    system_prompt=system_prompt,
)
# Voir la note dans l'article, plus bas, pour OpenAI ou LLamaCPP

# le moteur de vectorisation de texte. J'utilise ici un modèle léger, largement suffisant
# pour ce genre de tâche (il tournera en local, donc il va être téléchargé)
embeddings = HuggingFaceEmbedding(model_name="BAAI/bge-base-en-v1.5")

# les templates pour le LLM. Parce que je veux des réponses en francais, je dois
# adaper les templates. Si vous voulez bosser en anglais, c'est inutile. llama-index
# a déjà des templates utilisés par défaut.
text_qa_template_str = (
    "Le contexte de l'information est le suivant :"
    "\n---------------------\n{context_str}\n---------------------\n"
    "En utilisant à la fois ces informations de contexte et tes propres connaissances, "
    "réponds à la question suivante : {query_str}\n"
    "Si le contexte n'est pas utile, tu peux également répondre à la question par toi-même.\n"
)
text_qa_template = PromptTemplate(text_qa_template_str)

# seulement utile si on veut changer le mode de réponse en mode "refine"
refine_template_str = (
    "La question originale est la suivante : {query_str}\nNous avons fourni une"
    " réponse existante : {existing_answer}\nNous avons la possibilité d'affiner"
    " la réponse existante (uniquement si nécessaire) avec un peu plus de contexte"
    " ci-dessous.\n------------\n{context_msg}\n------------\nEn utilisant à la fois"
    " le nouveau contexte et tes propres connaissances, mets à jour ou répètes la réponse"
    " existante.\n"
)
refine_template = PromptTemplate(refine_template_str)

# C'est parti. Puor chaque candidat, on va indexer les propos qui se trouvent dans le répertoire
# qui porte le nom du candidat.
for candidate, col in collections.items():
    path = f"transcriptions/{candidate}" # répertoire qui contient les propos du candidat
    storage = StorageContext.from_defaults(
        vector_store=ChromaVectorStore(col["chroma"]), # collection du candidat
    )
    # on lit les documents (les propos dans le fichier texte)
    documents = SimpleDirectoryReader(path).load_data(show_progress=True)
    # on indexe les documents (vectorisation et enregistrement dans la base)
    vector_store = VectorStoreIndex.from_documents(
        documents=documents,
        storage_context=storage,
        llm=llm,
        embed_model=embeddings,
        show_progress=True,
    )
    # on crée un moteur de recherche sémanitque qui répondra avec le LLM et en utilisant
    # le ou les templates de questions
    query_engine = vector_store.as_query_engine(
        llm=llm,
        embed_model=embeddings,
        text_qa_template=text_qa_template,
        refine_template=refine_template,
    )
    col["query"] = query_engine # on garde ce moteur pour poser des questions

# donc là on a "collections" qui contient, pour chaque candidat, un moteur de "requête"
# qui va nous permettre de poser des questions et d'avoir des réponses contextualisées

# les questions à poser
questions = [
    "Que propose le candidat pour lutter contre le chômage ?",
    "Que propose le candidat pour augmenter le pouvoir d'achat ?",
    "Que propose le candidat pour lutter contre le réchauffement climatique, l'environnement, les énergies fossiles et renouvelables ?",
    "Que propose le candidat pour améliorer le système de santé, les déserts médicaux, l'accès aux soins ?",
    "Que propose le candidat pour améliorer le système éducatif, scolaire, écoles ?",
]

# et c'est parti... on pose les questions
for question in questions:
    print(f"=== Question: {question} ===")
    for candidate, col in collections.items(): #pour chaque candidiat on pose la question
        print(f"=> Candidat: {candidate}")
        response = col["query"].query(question)
        print(response)
        print()

En exécutant ce script, nous avons des réponses clarifiées, propres, contextualisées et plus condensées.

Voici un extrait de la sortie dans le terminal, attention, je vous rappelle que l’IA peut se tromper, mal interpréter, voir halluciner une réponse. Ne prenez pas ces réponses pour argent comptant, ne les utilisez pas pour prendre votre décision dimanche 30 juin. Ceci est un exemple, rien d’autre !

Avec le modèle MisralAI/Mistral-7B-Instruct-v0.3, voici un exemple de sortie (que je trouve moyen) :

=== Question: Que propose le candidat pour lutter contre le réchauffement climatique, l'environnement, les énergies fossiles et renouvelables ? ===

=> Candidat: Jordan Bardella
Le candidat propose de mettre en place un moratoire sur la construction de tout nouveau chantier éolien, car il estime
que 25% du temps, les énergies éoliennes tournent à vide et que l'énergie ne se stocke pas, ce qui oblige à brader l'énergie.
Il souhaite également refaire de la France un paradis énergétique en défendant le nucléaire, qui permet à la France d'avoir
une énergie pas chère, décarbonée et bonne pour les factures et pour les entreprises. Il souhaite également déverrouiller
les contraintes qui pèsent sur la croissance pour les entreprises, réindustrialiser, relocaliser et simplifier l'économie pour
créer les conditions d'une diminution de l'empreinte carbone de la France sur la planète et de celle de l'Union européenne.
Il estime également que la gestion stratégique de l'eau pose des enjeux très concrets pour les agriculteurs.

=> Candidat: Manuel Bompard
Le candidat Manuel Bompard propose de faire des investissements publics massifs pour la transition écologique, notamment
dans la rénovation thermique des logements. Il considère que la construction de nouveaux réacteurs nucléaires ne peut
pas être une solution à l'urgence climatique, car les efforts de réduction des émissions de gaz à effet de serre qu'il
faut faire doivent être faits dans un temps qui ne permet pas la construction de ces réacteurs nucléaires.

=> Candidat: Gabriel Attal
Le candidat propose de continuer à investir pour décarboner notre industrie, mais pas via la décroissance comme le propose monsieur Bonpard.
Il a engagé un plan pour relancer le nucléaire avec 14 nouveaux réacteurs et les chantiers ont déjà démarré.
En 2035, on aura des nouveaux réacteurs qui pourront entrer.
Il a également promis de continuer à investir dans les énergies renouvelables, mais il a souligné que si on veut baisser
nos émissions de CO2, si on veut être vraiment indépendant en matière d'énergie, il faut continuer à installer des éoliennes.
Il a également souligné que les éoliennes nouvelles qui sont installées chaque année, c'est l'équivalent d'un réacteur nucléaire supplémentaire.

En utilisant, cette fois, le modèle HuggingFaceH4/zephyr-7b-alpha, voici un autre exemple de sortie, que je trouve plus pertinent et cohérent :

=== Question: Que propose le candidat pour lutter contre le réchauffement climatique, l'environnement, les énergies fossiles et renouvelables ? ===

=> Candidat: Jordan Bardella
Le candidat propose de lutter contre le réchauffement climatique en faisant de la France un pays de producteurs
et en relocalisant les industries. Il souhaite refaire de la France un paradis énergétique en soutenant
le nucléaire, qui est un atout incontesté pour la France et l'Union européenne.
Il pense que les énergies renouvelables doivent être sécurisées, mais il souhaite également arrêter les éoliennes
et mettre en place un moratoire sur la construction de nouveaux chantiers éoliennes en raison de leur faible efficacité
énergétique. Il est opposé à l'importation de véhicules électriques trop chers et à leur coût de réparation trop élevé
, qui rendraient les véhicules électriques inaccessibles pour les classes populaires et moyennes. Il souhaite
donc simplifier l'économie et déverrouiller les contraintes qui pèsent sur la croissance pour les entreprises.

=> Candidat: Manuel Bompard
Le candidat Manuel Bompard propose de faire des dépenses significatives, très importantes, de plusieurs dizaines de milliards
d'euros pour la transition écologique, parce que c'est le défi du siècle, et que ce défi du siècle, on ne pourra y répondre
que par des investissements publics massifs.
Il considère que face à l'urgence climatique que nous avons devant nous, c'est une très mauvaise décision de faire des coupes budgétaires
 sur le budget de la transition écologique et en particulier sur la rénovation thermique des logements. Il estime que
pour lutter contre le réchauffement climatique, il faut réduire massivement les émissions de gaz à effet de serre d'ici à 2030,
d'ici à 2035, d'ici à 2040. Il estime que présenter la construction de nouveaux réacteurs nucléaires comme une solution à
l'urgence climatique est tout simplement faux et inexact.

=> Candidat: Gabriel Attal
Le candidat propose de continuer à investir pour décarboner notre industrie et non pas via la décroissance comme le
propose le candidat de l'autre parti. Il soutient la construction de 14 nouveaux réacteurs nucléaire
s et les chantiers ont déjà démarré. Il a également promulgué une loi de fermeture centrale nucléaire, mais il affirme
que les premières centrales nucléaires seront en place en 2035. Il soulève la question de savoir
comment les Français pourront répondre à la demande croissante d'électricité si les éoliennes sont arrêtées alors que les
nouveaux réacteurs nucléaires ne seront pas en place avant 2035. Il affirme que les éoliennes
nouvelles qui sont installées chaque année, c'est l'équivalent d'un réacteur nucléaire supplémentaire. Les parcs actuels
arrivent à échéance dans combien de temps ?

En fonction du modèle, nous avons des divergences de résultats. Pour autant, le sens reste à peu près le même et les informations extraites sont assez cohérentes à ce que j’ai pu entendre en direct.

Mais je le répète : je n’ai pas nettoyé les données d’extraction audio, et il est possible d’ailleurs que certains propos ne soient pas attribués à la bonne personne.

Il faudrait aussi que j’adapte les prompts pour les rendre plus précis, plus ouverts, ou au contraire plus strict sur la réponse attendue.

Mais, est-ce que cela est pertinent ?

Alors… si je pars “en connaissance de cause”, en sachant qu’il manque certainement des informations, que la transcription demande des corrections, etc. Oui, c’est pertinent. Oui cela a bien résumé les propos, et oui, je trouve à peu près ce que je cherche dans le débat qui a duré plus d’une heure et demie.

Aussi, je retrouve à peu près les mêmes informations que j’ai pu entendre. Clairement, avec peu de moyens et de temps, j’ai déjà un résultat qui est assez satisfaisant.

Oui, cela est utile, oui, on peut s’en servir. Mais il est impératif de prendre du recul et de vérifier les propos extraits par l’IA. Car clairement, elle se trompe de temps en temps.

La règle est claire : doutez de l’IA. Elle est comme un pote à qui vous parlez, elle sort un avis, basé sur ses compétences d’analyse, mais elle a des biais, et en plus vos données sont potentiellement cassées.

Note à propos de OpenAI ou LLAmaCPP

Si vous ne voulez pas utiliser l’API de HuggingFace, vous pouvez utiliser OpenAI ou LLamaCPP.

OpenAI, installez le paquet llama-index-llms-openai et utilisez le modèle OpenAI/gpt-3.5-turbo. Remplacez la variable llm par :

llm = OpenAI(
    system_prompt=system_prompt,
)

LLamaCPP, vous devez installer, en premier lieu, le package LamaCPP-python en précisant le “backend” que vous voulez.

Pour ma part, j’en ai marre d’utiliser CUDA, donc je passe par Vulkan :

CMAKE_ARGS="-DLLAMA_VULKAN=on" pip install llama-cpp-python

Puis, installez le paquet lla-index-llms-llamacpp et utilisez le modèle GGUF. Remplacez la variable llm par :

llm = LLamaCPP(
    model_url="ici l'url d'un modèle GGUF",
    system_prompt=system_prompt,
    # model_kwargs={"n_gpu_layers": 28}, # si vous avez un GPU avec peu de mémoire
    # model_kwargs={"n_gpu_layers": -1}, # si vous voulez tout charger dans le GPU
)

L’intérêt de LLamaCPP, c’est que vous pouvez charger des modèles GGUF qui débordent de la VRAM sur la RAM du système et de répartir le travail en partie sur le CPU. On appelle cela du “offloading”. C’est très utile si vous avez un GPU trop léger. Par contre, c’est plus lent. Pour une RTX 3070 avec 12 Go de VRAM, je suis obligé de réduire le nombre de couches (28 sur les 31 de Qwen2) à charger dans la carte. Cela demande donc au CPU de gérer 2 couches. Ça reste utilisable, mais on entend les ventilateurs tourner…

Par exemple, pour un modèle Qwen2-7B-Instruct-GGUF, j’utilise https://huggingface.co/Qwen/Qwen2-7B-Instruct-GGUF/resolve/main/qwen2-7b-instruct-q4_k_m.gguf

Le compte “The Block” propose un grand nombre de modèles GGUF, vous pouvez les tester : https://huggingface.co/TheBloke, par exemple les modèles Llama2 en 7B se trouvent ici : https://huggingface.co/TheBloke/Llama-2-7B-GGUF/tree/main

Encore plus loin

Je ne vous colle pas le code ici, car l’article devient long. Mais j’ai ajouté pas mal de traitements supplémentaires à mon script :

pour chaque réponse, je fais demande à l’IA de me sortir une requête que je pourrais donner à un moteur de recherche,
cette requête, je l’envoie à Google (ou autre) pour trouver des pages d’information,
ces pages, je les indexe
ensuite, je lance une recherche sémantique sur ces pages pour avoir des informations,
je demande au LLM de me dire si le candidat a dit vrai ou faux, en partie ou totalement

Eh bien, sans surprise, les trois candidats ont beaucoup (mais alors, beaucoup hein) raconté de choses ambigües, ont forcé le trait ou menti. Un candidat a même excellé dans les contre-vérités et l’imprécision (en répondant “en dehors de la question”).

J’ai aussi réussi, tant bien que mal, à analyser la “teneur des propos”, et deux candidats sont perçus comme “agressifs”, un est souvent sur la défensive, et un autre est souvent “dans le flou”.

Alors, encore une fois, tout sort de ce que l’IA “semble comprendre”. Et c’est pour cela que je ne vous montre pas ces résultats. Ils pourraient être mal interprétés, et utilisés à mauvais escient. Mais sachez que, franchement, j’ai trouvé l’analyse assez proche de mon ressenti.

Pour information, elle m’a même démontré que j’avais tort sur un sujet. J’ai vérifié son propos, j’ai revu le passage du débat en question et cherché sur le net… et bon sang ! Elle avait raison.

Je me dis que, avec un peu de travail (de temps, d’argent…) ce genre de travaux pourraient aider les analystes, et à terme aider des gens à faire leur choix. Mais pour cela, il faudrait fiabiliser et rendre plus factuel les réponses. Et malheureusement, c’est à ce jour une tâche trop lourde pour le temps que j’ai à disposition.

Conclusion

Je n’ai pas passé beaucoup de temps à coder tout ça. J’ai dû passer, en gros, 2 heures de mon temps, le soir, au lieu de regarder un film. Donc, évidemment que le résultat n’est pas parfait, loin de là. Cependant, cela montre à quel point nous avons sous la main des outils d’une puissance incroyable.

C’est avant tout un test, un amusement. Impossible à ce jour, avec le matériel que j’ai à disposition et surtout le manque de temps que je peux consacrer à ces travaux, de faire un travail plus abouti.

J’ai déjà travaillé sur d’autres implémentations RAG avant cela, et ce fut souvent plus précis, plus pertinent. Pour cet exemple, le résultat est moins fiable à cause de nombre de transformations à effectuer sur les données qui conduisent forcément à un paquet d’erreurs. Il faudrait relire, corriger, adapter…

Mais une chose est certaine : la transcription automatique avec pyannote et whisper combinée, afin de détecter l’interlocuteur et ses propos fonctionne plutôt bien. whisper-openai est clairement un bel outil qui fonctionne vite et bien. llama-index est un outil qui permet de faire de la recherche sémantique plus simplement, et simplifie le requêtage des modèles LLM.

ChromaDB et llama-index se marient bien. D’ailleurs, ayant aussi testé le RAG avec des PDF, en utilisant les plugins intégrés à llama-index, je vous assure que cela donne de très bons résultats.

Le RAG, c’est clairement l’avenir de l’IA dans beaucoup de domaines.

Tout ce que je vous ai montré utilise des outils opensource. Merci encore à la communauté.

Il serait temps que les librairies de Machine Learning suivent un peu le besoin et passent à OpenCL ou Vulkan. Pour l’heure, seul LLamaCPP propose de changer de backend facilement. ↩︎
j’ai un bébé, un travail, pas mal de fatigue. ↩︎

Apt, Dnf, Utilisons PackageKit

Mon, 15 Apr 2024 23:19:03 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si vous vous prenez la tête à toujours proposer des commandes apt, dnf, zypper, pacman ou emerge dans vos articles, vos scripts, Makefile ou autres, on va discuter de PackageKit.

Je suis le premier à faire ce genre de truc :

je fais un article, je veux que les gens puissent installer un outil, un logiciel, blablabla,
je suis sur Fedora, donc je connais le package à installer avec dnf,
et je me dis “ha zut, il y a des gens sur Ubuntu, Debian, Arch Linux, openSUSE, Gentoo, etc.”,
donc je me dis que, par respect, je vais leur proposer une ligne de commande pour “la plupart des distributions”

Et, à la fin, soit je me trompe de nom de package, soit le package a différentes variantes, soit j’oublie une distribution. Et en plus, je me démarre un conteneur (avec Podman) pour vérifier.

Idem quand je veux créer un script d’installation pour des utilisateurs finaux, ou un Makefile pour un truc général… je dois détecter la distribution, et proposer des commandes différentes.

Et pourtant, je le sais hein, je le sais que PackageKit existe, et que c’est fait pour ça.

Et j’oublie de l’utiliser. Donc, je vais vous en parler, et vous expliquer pourquoi je vais commencer à l’utiliser plus fréquemment. Je vais aussi vous dire quand ne pas l’utiliser.

D’abord, c’est quoi ça ?

PackageKit est un système de gestion de paquets qui abstrait les détails des gestionnaires de paquets. Il permet de proposer une interface commune pour installer, mettre à jour, supprimer des paquets, et ce, quelle que soit la distribution Linux utilisée.

Oui, c’est “universel” (enfin, presque).

En fait, “Gnome Software”, “Discover”, “Apper”, etc. utilisent PackageKit pour gérer les paquets. Il y a que les vieux barbus dans mon genre, ou les vieilles barbues (ouais, inclusion, tout ça) qui utilisent encore les commandes apt, dnf, zypper, pacman ou emerge directement.

Bon, attendez… on va se calmer.

Certes, PackageKit est un outil pratique, qui installe proprement les packages, et qui n’entre pas en conflit avec votre gestionnaire de paquet habituel (parce qu’il l’utilise). Le truc, c’est que c’est un outil “haut niveau”, qui ne permet pas de faire des choses spécifiques à une distribution.

C’est un outil, comment dire, “bureautique” ? Si vous devez faire un truc plus technique, avec des options particulières ou adapté à une distribution spécifique, vous devrez utiliser les commandes spécifiques à la distribution. Donc, ne pas utiliser PackageKit mais apt, dnf, zypper, pacman ou emerge.

Par contre, si vous êtes un rédacteur d’article, un développeur d’application qui demande d’ajouter des packages ou un éditeur qui est parfaitement au courant que son outil est dans les dépôts : PackageKit. Sérieux, faites un effort, il faut juste remplacer le mot “apt” par “pkcon”.

Parce que, m*@!#* à la fin ! J’en ai plus que marre de voir des gens n’écrire des commandes que pour Ubuntu/Debian et se foutre royalement des autres distributions. Je suis utilisateur de Fedora et je fais l’effort de toujours proposer des commandes apt et dnf - c’est le minimum syndical.

Mais même en faisant cet effort, je l’avoue, j’oublie Arch Linux, openSUSE, Gentoo, etc. Et je ne parle même pas des distributions plus exotiques.

Va falloir que ça devienne un réflexe.

Donc : PackageKit et la commande pkcon !

En mode graphique ?

Eh bien si vous avez un environnement de bureau, vous avez sûrement un gestionnaire de paquets qui utilise PackageKit. Par exemple, sous Fedora, vous avez “Gnome Software”. Sous Ubuntu, vous avez “Discover”. Sous openSUSE, vous avez “Apper”.

Tous utilisent déjà (en partie ou totalement) PackageKit pour gérer les paquets.

Ce que j’essaie de vous faire comprendre, c’est que si vous avez utilisé un gestionnaire de paquets graphique, vous avez déjà utilisé PackageKit.

Mais ce qui est cool, c’est que vous pouvez l’utiliser en ligne de commande, et ça, peu de gens le font.

PackageKit en ligne de commande

Linux, ça s’utilise graphiquement et c’est bien. Mais je ne connais pas un utilisateur qui, après peu de temps, n’ouvre pas un terminal pour utiliser son ordinateur plus “rapidement”.

La ligne de commande principale, c’est “pkcon”. Suivi d’une “commande” :

pkcon install <package> pour installer un paquet
pkcon remove <package> pour supprimer un paquet
pkcon search <package> pour rechercher un paquet
pkcon info <package> pour obtenir des informations sur un paquet
et d’autres…

Ce qui est cool, c’est qu’Ubuntu, Fedora, openSUSE, Arch Linux, etc. ont tous PackageKit d’installé par défaut. La commande : pkcon

Je veux installer, par exemple, “Firefox”. Je vais donc utiliser la commande pkcon install firefox :

pkcon install firefox

Résolution                   [=========================]         
Chargement du cache           [=========================]         
Test des changements          [=========================]         
Terminé                      [                         ] (0%)  
Les paquets suivants doivent être installés :
 firefox-124.0.2-2.fc39.x86_64	Mozilla Firefox Web browser
 firefox-langpacks-124.0.2-2.fc39.x86_64	Firefox langpacks
 mozilla-openh264-2.4.0-2.fc39.x86_64	H.264 codec support for Mozilla browsers
Continuer avec ces changements ? [N/y] y

                             [=========================]         
Installation                  [=========================]         
Requête                      [=========================]         
Téléchargement des paquets  [=========================]         
Test des changements          [=========================]         
Installation des paquets      [=========================]         
Terminé                      [=========================]

Vous avez remarqué ? Pas besoin de sudo pour installer un paquet. PackageKit va demander les droits administrateurs si nécessaire. C’est tellement plus pratique…

Par exemple, j’ai demandé une réparation (inutile sur mon système, mais pour vous montrer…), j’ai donc tapé pkcon repair et le système m’a demandé les droits administrateurs :

Intéressant, car il me dit ce qu’il va faire, en l’occurrence, réparer les paquets cassés. Je peux donc annuler ou accepter avec mon mot de passe. Voilà, ça, c’est bien !

Et si je veux supprimer “Firefox”, je vais utiliser la commande pkcon remove firefox :

pkcon remove firefox

Mais PackageKit c’est aussi l’outil qui sait mettre à jour votre système.

pkcon get-updates

Obtention des mises à jour   [=========================]         
Attente dans la file          [=========================]         
Démarrage                    [=========================]         
Terminé                      [=========================]         
Disponible  	act-cli-0.2.61-1.fc39.x86_64 (copr:copr.fedorainfracloud.org:rubemlrm:act-cli)	Run your github workflows locally
Amélioration	alsa-sof-firmware-2024.03-2.fc39.noarch (updates)           	Firmware and topology files for Sound Open Firmware project
Bug fix     	amd-gpu-firmware-20240410-1.fc39.noarch (updates)           	Firmware for AMD GPUs
Bug fix     	amd-ucode-firmware-20240410-1.fc39.noarch (updates)         	Microcode updates for AMD CPUs
Normale     	annobin-docs-12.46-1.fc39.noarch (updates)                  	Documentation and shell scripts for use with annobin
Normale     	annobin-plugin-gcc-12.46-1.fc39.x86_64 (updates)            	annobin gcc plugin
Bug fix     	atheros-firmware-20240410-1.fc39.noarch (updates)           	Firmware for Qualcomm Atheros WiFi/Bluetooth adapters
Amélioration	b43-fwcutter-019-36.fc39.x86_64 (updates)                   	Firmware extraction tool for Broadcom wireless driver
Bug fix     	bluez-5.73-3.fc39.x86_64 (updates)                          	Bluetooth utilities
Bug fix     	bluez-cups-5.73-3.fc39.x86_64 (updates)                     	CUPS printer backend for Bluetooth printers
Bug fix     	bluez-libs-5.73-3.fc39.i686 (updates)                       	Libraries for use in Bluetooth applications
Bug fix     	bluez-libs-5.73-3.fc39.x86_64 (updates)                     	Libraries for use in Bluetooth applications
Bug fix     	bluez-obexd-5.73-3.fc39.x86_64 (updates)                    	Object Exchange daemon for sharing content
#...
#...

Et par conséquent, la commande pkcon update va mettre à jour les paquets. Voilà, simple, efficace, et “universel”.

Je vous invite à lire la documentation pour plus d’informations.

Mais ça marche comment ?

PackageKit utilise des “backends” pour communiquer avec les gestionnaires de paquets. Un “daemon” nommé packagekitd tourne en tâche de fond le temps nécessaire à la recherche et à l’installation et des “backends” sont utilisés pour communiquer avec les gestionnaires de paquets.

Par exemple, le backend dnf pour Fedora, le backend apt pour Debian, le backend zypp pour openSUSE, etc.

Pour les développeurs, sachez que vous pouvez communiquer avec PackageKit via D-Bus, et que vous pouvez utiliser des bindings pour Python, C, Go, etc.

C’est donc un système très modulaire, et qui permet de gérer les paquets de manière uniforme quelle que soit la distribution Linux utilisée.

Mais, le revers de la médaille, c’est justement que cela utiliser D-Bus, donc que ce n’est pas viable pour, par exemple, des conteneurs ou des images OCI (Docker, Podman…). C’est un outil “haut niveau” pour des utilisateurs finaux.

Par exemple, dans un conteneur, voilà ce qu’il se passe :

$ pkcon install firefox
Failed to contact PackageKit: Could not connect: No such file or directory

Vraiment, je vais vous le répéter, pkcon, c’est pour vos postes de travail, pas pour vos serveurs ou vos conteneurs.

Mais, soyons honnêtes, vous, moi, on est des utilisateurs finaux, non ? Qu’on soit développeur, administrateur système, gamer, utilisateur bureautique, on est des utilisateurs finaux.

Donc, personnellement, je commence à prendre l’habitude d’utiliser pkcon dans mes scripts d’installation si, et seulement si, on parle de script pour des utilisateurs finaux.

Mais du coup, on remplace tout par `pkcon` ?

Alors non.

Déjà, comme je vous l’ai dit, cela ne marche pas sur des conteneurs (et tant mieux hein, on ne va pas démarrer un D-Bus pour installer des packages !).

Ensuite, PackageKit n’a pas toutes les options des gestionnaires de paquets.

C’est, pour le moment, une commande pratique et un backend pour des outils graphiques. C’est donc très sympa pour généraliser l’installation d’outils si vous visez plusieurs utilisateurs sur plusieurs distributions. Voire pour FreeBSD. C’est aussi super bien si vous créer un outil de gestion d’installation, vous vous connectez au D-Bus et vous installez le nécessaire.

Donc, amis développeurs qui créent des “wizzard” d’installation, il serait temps d’arrêter de faire des apt dans un processus - ça fait péter un câble aux utilisateurs de Fedora, ArchLinux, openSUSE, etc.

Cependant, les gestionnaires de paquets propres aux distributions ont bien plus d’options, des sources de packages parfois spécifiques et des fonctionnalités qui ne sont pas disponibles via PackageKit. Donc, si vous avez besoin de fonctionnalités spécifiques, ou si vous avez besoin de gérer des paquets spécifiques à une distribution, vous devrez utiliser les commandes spécifiques à la distribution.

Vraiment, PackageKit c’est pour simplifier et généraliser, pas pour remplacer.

Au final

Bien que ce soit un outil pour simplifier l’installation et qui n’a pas la finesse du “vrai” gestionnaire de paquet utilisé en direct, je commence à pousser son utilisation dans mes Makefile, scripts d’installation, articles, etc.

Pour deux raisons :

je n’aime pas utiliser sudo dans un Makefile, je préfère l’interface proposée par PackageKit qui explique à l’utilisateur ce qu’il va se passer
je veux me soulager de la charge de devoir proposer des commandes pour chaque distribution Linux
je pense que c’est potentiellement plus adapté si la cible est un utilisateur final, même dans un terminal

On devrait toujours avoir le réflexe de parler de pkcon avant de parler de parler des outils spécifiques à une distribution. J’ai un avis vraiment à contre-courant de beaucoup de spécialistes, et je l’assume complètement. Je sais, et je l’ai dit juste avant, que dnf ou apt (pour ne citer qu’eux) sont des bien meilleurs outils d’installation. Je le répète donc, une fois de plus, PackageKit c’est pour simplifier et généraliser. Je le propose(rai) dans mes articles pour éviter de discriminer les utilisateurs de distributions Linux. Et je vous invite à en faire autant.

Mais, il est évident que, quotidiennement, j’utilise dnf sur mes postes Fedora, et que apt, apk, etc. sur les autres distributions que j’utilise essentiellement dans des conteneurs ou sur les serveurs au travail (ouais, pas moyen de faire plier les admins systèmes, ils veulent du Debian 😦).

Mason, comment installer facilement des LSP, des linters, des formatteurs... sur NeoVim

Fri, 12 Apr 2024 06:13:53 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

NeoVim, le Vim du futur, sait parfaitement gérer des LSP (Language Server Protocol), des linters, des formateurs, des snippets, etc. Avec CoC, on est à deux doigts d’avoir un VSCode en mode terminal. Mais installer un LSP (Language Server Protocol), demandait de faire deux ou trois choses manuellement pour chaque langage. C’était sans compter sur “Mason”.

Mason est un utilitaire simple et proprement pensé, avec un registre de langages bien fourni, qui permet d’installer facilement des LSP, des linters, des formateurs, des snippets, etc. pour NeoVim.

Je vous l’avoue, j’ai eu un peu de mal à comprendre comment on l’initialise, d’où ce billet. Mais dans les faits, c’est super simple.

Installation

Il faut installer le plugin dans NeoVim. Personnellement, j’utilise vim-plug. C’est simple et efficace, ça s’installe en deux temps trois mouvements. Et je n’ai qu’à ajouter une ligne dans mon fichier de configuration pour que le plugin soit pris en compte.

Plug 'williamboman/mason.nvim'

On doit alors taper :PlugInstall pour installer le plugin.

Ensuite, il faut initialiser Mason. Pour cela, il faut ajouter une ligne dans votre fichier de configuration, plus bas, en fin de configuration si vous le voulez.

lua require('mason').setup()

C’est cette ligne qui n’est pas dans la documentation (je suis étonné, et j’ai ouvert cette issue pour le signaler).

À partir de là, le chemin d’installation des LSP et autres outils est ~/.local/share/nvim/mason/bin/ au sein de NeoVim.

Ce qui a plusieurs avantages :

D’abord, cela ne va pas polluer votre “PATH” dans les terminaux. Par exemple quand je tape “helm” en ligne de commande, je ne veux pas voir helm_ls apparaître dans la completion
D’autre part, cela ne pollue pas le système. Les LSP sont dans un répertoire personnel, facile à dégager, géré par Mason et c’est tout.
Et le fait que le PATH soit “local à neovim” fait que vous n’avez pas à spécifier le chemin complet des exécutables dans vos configurations.

En bref, c’est déjà bien pensé.

Installer un LSP

Reste à installer un LSP. Prenons par exemple un LSP pour helm.

Ouvrez NeoVim et tapez :MasonInstall helm-ls

Va alors s’ouvrir cette fenêtre (fermez en pressant la touche “Echap”) :

Et voilà, c’est tout. Mason va télécharger le LSP, l’installer dans le répertoire ~/.local/share/nvim/mason/bin/.

Pour que NeoVim sache ce qu’est un fichier helm (on parle du “type de fichier”, parce que c’est un fichier YAML mais avec des balises de template, et que NeoVim ne peut pas le comprendre tout seul), il faut ajouter un plugin (et on n’oublie pas de taper :PlugInstall pour l’installer) :

Plug 'towolf/vim-helm'

Vous pouvez ensuite définir comment l’utiliser. Moi, j’utilise le plugin “Coc” pour des milliers de raisons. Et une des raisons est que je peux utiliser des LSP sans me prendre la tête. Il suffit de taper :CocConfig et d’ajouter une ligne dans le fichier de configuration de CoC.

{
  "languageserver": {
    "helm": {
      "command": "helm_ls",
      "args": ["serve"],
      "filetypes": ["helm"],
      "rootPatterns": ["Chart.yaml"],
    }
  }
}

Et voilà, vous avez un LSP pour helm. Il va vous engueuler quand vous faites des erreurs, vous donner des suggestions, autocompléter les valeurs en prenant en compte le fichier de “Values”, etc.

Conclusion

De mon point de vue, NeoVim est quasi parfait avec une configuration simple :

Nerdtree pour la navigation https://github.com/preservim/nerdtree ainsi que quelques “plugins” pour avoir les icônes, la couleur, l’état “Git”…
CoC pour les plugins et les LSP https://github.com/neoclide/coc.nvim
Mason pour installer les LSP https://github.com/williamboman/mason.nvim

J’ai quelques autres plugins, pour la correction grammaticale (ce qui ne m’empêche pas d’en laisser passer, je suis vraiment pas rigoureux sur ce point), pour les snippets, j’ai aussi Copilot (parce que bon sang, c’est pratique), etc. Vraiment, NeoVim permet d’avoir un IDE complet.

Avec quelques astuces voilà à quoi ressemble mon NeoVim, dans mon terminal :

Je pense qu’un jour, je ferai un billet sur ma configuration NeoVim, voir une vidéo…

BleachBit en mode Automatique

Fri, 05 Apr 2024 23:26:52 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

BleachBit est un outil fantastique pour nettoyer votre système. Mais, bien que l’interface graphique soit très bien pensée, j’avais envie d’automatiser le processus. Et comme on est sous Linux, évidemment, ça se fait super facilement.

Je vous préviens d’avance, c’est un article assez simple, rien de techniquement innovant. Mais je vois tellement de gens faire les choses un peu n’importe comment, que je me suis dit que ça valait le coup de l’écrire. Aucune animosité de ma part, enfin… si… mais c’est bon enfant. Ne le prenez pas mal 😄

Cet article est un prétexte pour vous parler de systemd, et notamment les timers, en mode “utilisateur” (donc, sans sudo, sans taper dans le système, sans prendre des risques de tout péter). Mais je veux aussi mettre en lumière BleachBit, un outil que j’utilise depuis des années et qui m’a toujours rendu de fiers services. Le fait de pouvoir nettoyer son système aussi efficacement, et de pouvoir automatiser le processus, ça m’a paru une bonne idée de vous montrer “ze way to do it” (en mode “je fais ça bien”).

Non parce que je suis généralement en tain de grogner devant mon écran en lisant certains articles, rédigés par des gorets qui adorent claquer du sudo partout. Alors que non, on ne fait pas ça. On est des gens bien, on ne touche pas au système quand il ne faut pas, on ne le casse pas, on ne le corrompt pas. Arrêtez de faire ça. Sudo, c’est pour les opérations qui nécessitent des droits d’administration. Point barre.

Installer un paquet: OUI

Ajouter un timer pour un truc perso sur mon “home”: NON

Sérieux, arrêtez de faire ça. C’est pas bien.

Parlons de BleachBit, que j’utilise depuis des années.

J’ai très souvent des problèmes de place sur mon disque dur. J’ai beau avoir 500 Go sur le laptop et utiliser des disques distants pour stocker mes données, je me retrouve souvent à court d’espace. C’est moins le cas sur mon poste “desktop” qui, lui, à 2To de stockage. Mais voilà, j’utilise mon laptop, je télécharge des modèles d’IA, je teste, je code, je fais un peu de Blender… En quelques jours, voire quelques semaines si je me calme, j’atteins 80% d’occupation du disque et ça m’énerve. Et BleachBit me règle ça en quelques secondes.

BleachBit est développé en Python et vous trouverez la page officielle ici. Et les sources se trouvent sur leur GitHub ici. Cet outil est une vraie pépite, et je vous encourage à le tester.

Installation

Bon, pour commencer, il faut installer BleachBit. C’est un logiciel libre, et vous pouvez le trouver dans les dépôts de votre distribution. Par exemple, pour Ubuntu, ça se fait avec la commande suivante :

sudo apt install bleachbit

Mais comme vous êtes des gens bien, vous utilisez Fedora n’est-ce pas ? Dans ce cas, vous pouvez installer BleachBit avec la commande suivante :

sudo dnf install bleachbit

Voilà, passons à la suite…

Premier nettoyage

On va le faire avec l’interface graphique pour commencer. Il y a une raison pour cela : quand vous modifiez les options de nettoyage, BleachBit enregistre ces options dans un fichier de configuration. Vous le trouverez dans ~/.config/bleachbit/bleachbit.ini.

Pourquoi je fais ça ? Eh bien en fait on pourrait très bien se passer de cette étape. Il faudrait alors utiliser la ligne de commande pour lancer le nettoyage avec un tas de “cleaners” dont il faut connaitre non seulement le nom, mais aussi ce que ça fait. Et franchement j’avais la flème.

L’UI vous donne plein d’information sur chaque “cleaner”. Alors je vous propose de sélectionner :

pour tous les navigateurs que vous avez installés (firefox, chromium, brave, etc.), de virer le cache, et optimiser les bases de données
dans la section “système”, vider le cache et les fichier temporaires. Aussi, de supprimer les “fichier corrompus” et la corbeille.
et ensuite de faire le nécessaire pour les applications que vous utilisez. Lisez bien ce que ça fait (histoire de ne pas perdre un truc important, comme les mots de passe de votre navigateur par exemple).
Dans analyse approfondie, j’ai personnellement coché la suppression des fichier de sauvegarde et les fichiers temporaires.

Bien entendu, ce sont mes choix, à vous de voir ce que vous voulez nettoyer. Faites juste attention à ne pas supprimer des trucs importants, j’insiste.

Aussi, dans les paramètres, j’ai ajouté des répertoires que je veux vraiment ne pas nettoyer. Par exemple, j’ai ajouté “~/.cache/oh-my-posh/” (pour ne pas perdre la configuration de mon terminal qui stocke les thèmes dedans)¹.

Bon, normalement, vous pouvez “prévisualiser” le nettoyage pour voir ce qui va être supprimé. Si vous êtes sûr de vous, vous pouvez lancer le nettoyage.

La première fois, j’ai récupéré près de 120Go d’espace disque. C’est pas mal… allez ne faisons pas les blasés, c’est énorme !

Automatisation

Fermez BleachBit et regardez le fichier ~/.config/bleachbit/bleachbit.ini. Vous y trouverez toutes les options que vous avez sélectionnées.

Chez moi, par exemple, j’ai ceci :

# ... des trucs et puis:

[list/shred_drives]
0 = /home/metal3d/.cache
1 = /tmp

[preserve_languages]
en = True
fr = True

[tree]
brave.cache = True
brave = True
firefox.cache = True
firefox = True
google_chrome.cache = True
google_chrome = True
journald.clean = True
journald = True
system.cache = True
system = True
system.trash = True
thunderbird.cache = True
thunderbird = True
vlc.mru = True
vlc = True
brave.vacuum = True
firefox.vacuum = True
google_chrome.vacuum = True
thunderbird.vacuum = True
system.desktop_entry = True
system.tmp = True
deepscan.backup = True
deepscan = True
deepscan.tmp = True

[whitelist/paths]
0_type = folder
0_path = /home/metal3d/.cache/oh-my-posh/themes

Et c’est pratique, parce que la ligne de commande suivante va reproduire votre nettoyage :

# pour nettoyer
bleachbit --preset -c

# pour prévisualiser ce que ça va faire... c'est bien de le faire avant
bleachbit --preset -p

On peut donc demander de lancer cette commande tous les lundis matin à 3 h du mat’ (et au pire, si le PC est éteint, ça se passera au démarrage de votre ordinateur, voir la documentation de l’option “Persistent”).

Alors, non, on ne va pas utiliser le vieux “crontab”². Non vraiment je l’adore, c’est un vieux copain, mais systemctl est tellement plus adapté. Moi, je ne fais pas partie des détracteurs qui ont menacé de mort l’auteur de systemd. J’espère d’ailleurs que ces crétins aient eu ce qu’ils méritaient³. Bref, je m’égare.

Le “souci” c’est que, quand on ne le sait pas (mais moi je sais, nananère), systemd est “de base” un daemon⁴ qui tourne via l’utilisateur “root”. Donc si vous allez claquer des fichiers avec sudo dans /etc/systemd/system/, vous devriez tout de suite arrêter ce que vous faites. C’est aussi grave que ceux qui vous disent de faire un sudo pip install (sérieux, arrêtez de faire ça).

Sauf que systemd est bien pensé, et ouais. Vous avez aussi un espace utilistateur pour y assigner vos services, timers, mounts et sockets. C’est dans ~/.config/systemd/user/ que ça se passe. Mais j’ai tendance à oublier ce dossier.

L’astuce, c’est de s’en foutre. On va utiliser une ligne de commande pour éditer les deux fichiers nécessaires.

La première commande :

systemctl --user edit --force --full bleachbit.service

Bim, un éditeur s’ouvre, et vous collez le contenu suivant :

[Unit]
Description=Clean disk space with BleachBit

[Service]
Type=oneshot
ExecStart=/usr/bin/bleachbit --preset --clean

[Install]
WantedBy=default.target

Sauvez le fichier, et voilà. Le service existe. Maintenant, on va créer un “timer” pour lancer ce service tous les lundis matin à 3 h.

systemctl --user edit --force --full bleachbit.timer

Et encore un éditeur qui s’ouvre !

[Unit]
Description=Clean the disk space each monday at 3:00 AM

[Timer]
OnCalendar=Mon *-*-* 03:00:00 Europe/Paris
Persistent=true

[Install]
WantedBy=timers.target

Le fonctionnement de systemd est d’avoir un timer qui porte le même nom que le service. C’est pour ça que je vous ai demandé de créer un service bleachbit.service et un timer bleachbit.timer. Dans les faits, un “timer”, execute un “service” à un temps donné.

Bon et bien allez hop, on les active et voilà !

systemctl --user enable --now bleachbit.service
systemctl --user enable --now bleachbit.timer

C’est tout, ça va marcher. Et si vous voulez vérifier que tout est bien configuré, vous pouvez lancer la commande suivante :

# voir l'état des timers
systemctl --user list-timers

# voir les logs du timer
journalctl --user -u bleachbit.timer
journalctl --user -u bleachbit.service

Et vous pouvez lancer le nettoyage manuellement si vous le voulez:

systemctl --user start bleachbit.service

Bref, c’est vraiment propre, intégré dans votre environnement, c’est centralisé (logs avec journalctl, activation avec systemctl)… Ce n’est plus du bricolage avec des scripts qui en foutent partout. Propre. Zen.

Conclusion

BleachBit c’est le pied, et systemd c’est le pied. Alors les deux ensemble, bah, c’est les deux pieds. C’est Jean-Claude Van Damme qui me l’a dit.

En soit ce n’est pas grave que je perde ce cache, car je peux le reconfigurer avec une ligne de commande. Mais ça m’évite de le faire tous les lundis matin… ↩︎
Crontab était supposé être remplacé par systemd, mais il est toujours là. Je pense que les admins système sont attachés à leurs habitudes, et je n’ai rien à redire sur le fait que crontab fonctionne comme attendu. C’est pratique, c’est un standard, et c’est bien. Mais systemd a des avantages et je pense qu’il faut savoir laisser partir crontab dans le paradis des outils qui ont droit à une mort digne et paisible. ↩︎
Voir ici, des débiles ont trouvé pertinent de collecter des BitCoins pour engager un tueur à gage… On parle d’un outil informatique, et les gens sont prêts à tuer pour ça. Je ne sais même pas comment je peux commenter ça. ↩︎
Tiens, tu le savais que “daemon” veut dire “Disk And Execution MONitor” ? ↩︎

Comment J'ai Généré Un Dataset Avec L'IA

Tue, 12 Mar 2024 22:29:03 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

J’avais besoin d’un dataset de produits en JSON, en français, et pas moyen de trouver un truc bien sur le net (gratuitement). Alors je me suis lancé dans une folie : demander à une IA de le faire pour moi. Et localement !

EDIT: allez voir le second article, j’ai découvert “LLama.cpp” et son backend Python, je vous conseille vivement de lire mon test.

Si vous être trop pressé, allez en bas de l’article pour trouver le lien du code source. Lisez les commentaires en début de script et débrouillez-vous. Utilisez LM Studio pour lancer une API local avec un modèle Mistral 7b hein !

Non parce que bon… Payer une API OpenAI ou Mistral pour un test perso, ça m’énerve un peu. Il fallait bien que trouve une solution.

e me dis, donc, que ChatGPT 3.5, gratos, va me faire un truc pas mal. Et effectivement en lui demandant ce genre de contenu, il fait le job. Mais voilà :

D’abord, il répond gentiment avant de me foutre un bloc Markdown. Il faudrait que je clique sur le bouton “copier”, puis aller coller ça dans un fichier. Pour 1000 produits, ça va être long…
Et on est un peu limité par la taille de sortie
Et puis ce n’est pas évident pour lui de garder le contexte. Il a tendance à oublier les règles de base qu’on lui a donné (parce que l’historique est limité)
Et puis j’ai envie de m’amuser un peu.

Donc, LM Studio…

LM Studio ?

LM Studio est une interface assez bien pensée qui vous permet de jouer avec des modèles LLM (Large Language Model) sur votre PC personnel. Sans trop d’effort, et de manière très intelligente (en utilisant des modèles reformatés, et en jouant avec votre matos).

Grosse déception, ce n’est pas un logiciel open source. J’en demande beaucoup, mais j’aurai tellement préféré. Pour une fois, je fais l’impasse sur mes principes et j’accepte leur licence.

Alors, j’ai tendance à leur faire confiance. Ils garantissent ne pas récupérer de données personnelles, tout ce que vous faites reste privé, je me demande quand même comment ils gagnent leur vie…

Attention, vous devez avoir une machine récente. Que votre CPU supporte AVX2, et franchement il vous faut un GPU si vous ne voulez pas prendre des rides en attendant une réponse d’un modèle.

Bon, j’ai un laptop avec une RTX 3060, donc je pense pouvoir charger une partie du modèle dans la VRAM. Je sais que Mistral ne passe pas entièrement mais “LM Studio” utilise une méthode avec “llama cpp” qui peut scinder le modèle dans la RAM. Donc je serai en hybride “CPU/GPU” mais ça fera l’affaire.

En fait je pourrais très bien utiliser les ctransfomers de HuggingFace, me battre pour trouver la configuration à donner au modèle et blablabla. Mais je veux faire un truc rapidement là, LM Studio est pas mal fichu, donc je me dis que pour tester…

Donc hop. On lance LM Studio, on récupère un modèle pas trop lourd, genre “mistral-7b-instruct-v0.2.Q6_K.gguf” et je me lance.

On lance un “chat” sur ce modèle, on tente des paramétrages…

Le bot répond, c’est cool, ça marche sur ma machine… Il répond en anglais, mais les produits sont en français. On va passer ce détail et se dire “bon ça ira”.

Mais je me retrouve finalement dans la même situation qu’avec n’importe quel “Chat” que l’on trouve en ligne (HuggingChat, ChatGPT, Gemini, …) - On est sur une “interface utilisateur”, pas un truc pour générer des fichiers.

Ou pas ! Parce qu’il y avait un onglet que je n’avais pas vu !!!

Bon sang, mais quelle idée de mettre une icône aussi foireuse !

Il suffit de lancer le serveur et nous voilà avec une API compatible OpenAI. Entendez par là que vous pouvez utiliser le package “openai” en Python (ou utiliser curl, mais on n’est pas des sauvages).

Donc, on se lance dans un délire !

Et si…

Et si, comme ça, mode bourrin, à 22 heure, devant la télé, le gamin qui dort… je me lançais dans un script qui appelle l’API locale, et que je traitais les réponses pour enregistrer les données dans des fichiers.

T’as sommeil ? Non…

Je sais que je vais me confronter à pas mal d’embuches. Parce que je suis habitué avec le temps. J’en ai testé des modèles, j’en ai bouffé des craquages à façonner mes requêtes pour avoir un prompt qui passe bien. Et je ne vous dis pas le nombre de fois où j’ai fait planter la machine en chargeant un peu trop fortement l’historique de conversation dans la VRAM.

Donc, je sais à quoi m’en tenir, et je sais très bien, avant même de commencer, que je vais devoir :

ruser avec l’historique de conversation
devoir traiter les résultats
ne pas y aller trop fort, demander 10-20 produits par requête, sinon ça va foirer (non mais j’ai testé avec 100, ça fait n’importe quoi)

Allez, je me lance !

Rappel de ce que je veux faire

Le but est d’avoir un ou plusieurs fichier JSON qui contiennent des produits. Je veux m’en servir pour alimenter une base de données de test. J’ai juste besoin de ces champs:

name : qui est un nom de produit
description : qui décrit le produit
tags : qui est une liste de tag
categories : pareil, une liste de catégories, moins verbeuse,
price : nombre à virgule, un prix…

Je me fiche un peu de la cohérence et que les produits n’existent pas. J’ai besoin de données, c’est tout.

Et je les veux en français ! C’est tout le problème qui fait que je n’ai rien trouvé de viable sur le net.

Passons à Python

Bon, j’adore pipenv, donc :

mkdir -p ~/Projects/ML/product-generator
cd ~/Projects/ML/product-generator
pipenv install openai

Pour bien comprendre comment ça se passe, il faut faire un petit test.

from openai import OpenAI

API_URL="http://127.0.0.1:1234/v1" # LM Studio API
API_KEY="not-needed"

client = OpenAI(base_url=API_URL, api_key=API_KEY)

history = [
    {
        "role": "system",
        "content": "Ici, une description claire pour donner une condition à l'IA",
    },
    {
        "role": "user",
        "content": "Là, une question à poser"
    }
]

response = client.chat.completions.create(
    model=MODEL_NAME,  # this field is currently unused if you use LM Studio
    messages=history,  # pyright: ignore
    temperature=0.7,
    stream=False,
)

# on affiche le résultat
print(response)

# en fait c'est plutôt
print(response.choices[0].message.content)

Là, on a une prémisse de ce qu’il faut faire. Reste donc à bien formater le “prompt” et comprendre le rôle de l’historique.

Le rôle de l’historique et le problème de “taille”

Mais de quel historique il parle ?

On parle de l’historique de conversation. En fait, les modèles conversationnels font des réponses “one shot”, entendez par là qu’il ne gardent pas en mémoire ce que vous lui avez dit, et ce qu’il vous a répondu. Il faut lui rappeler tout ça à chaque fois que vous relancez un prompt. C’est un historique de conversation.

Rappelez-vous qu’un modèle n’est pas un logiciel, pas un service. Il est figé.

En général, les LLM ont deux modes. Il y a des modèles de “completion” (qui continuent un début de phrase), et des modèle “instructions” qui, eux, peuvent prendre en compte des contextes.

La liste history est donc un tableau qui représente la conversation avec le “bot”. C’est un “contexte” pour qu’il continue la conversation.

Et un contexte, c’est en général une liste de prompts. Ces prompts ont pour la plupart 3 rôles différents :

“system” pour donner un contexte initial (on lui donne en début de conversation et une seule fois),
“user” qui correspond à vos messages,
et “assistant” qui sont les réponses données par le modèle.

On doit bien les mettre dans l’ordre (contexte initial, puis questions et réponses dans l’ordre chronologique) afin d’avoir une logique.

Donc, si vous voulez créer une conversation, à chaque fois il faudra prendre la réponse du modèle, l’ajouter dans cette liste, ajouter une nouvelle phrase ou question venant de vous, et rappeler l’API.

Vous voyez le souci… si je veux générer des centaines de produits au format JSON, avec des descriptions, ça va être problématique…

Ça veut dire qu’à un moment donné, mon historique va être énorme. Et ma machine ne va pas supporter que je donne au modèle plusieurs miliers de lignes de texte générées.

Si je dois renvoyer les réponses au modèle pour qu’il évite les doublons, et qu’il “continue” à générer des produits au fur et à mesure :

je vais taper dans la limite que supporte une requête HTTP
je vais saturer la RAM / VRAM, qui doit déjà charger les 4 Go de modèle (avec 20 couches, pour avoir un peu de place)

Donc, il va falloir ruser… C’est tout le travail du “prompt engineering”. Notez que ce domaine est très mal compris par beaucoup de corps de métiers en informatique. Beaucoup pense que c’est juste “taper des prompts malins”, mais en réalité, quand on commence à pousser un peu dans le domaine, c’est une tâche qui peut s’avérer très complexe. Et dans notre cas, ça ne l’est pas tellement, pourtant il m’a fallu faire pas mal de tests pour que ça soit bon. Donc, je défends les “prompt engineer” pour ma part.

La ruse de sioux

Je me suis dit :

“Attend mais… on s’en fout de lui fournir les JSON, ou même la conversation. Parce que le contexte, je peux le contrôler moi même.

On va juste lui donner la liste de noms des produits qu’il a générés”.

Et oui, on va être clair et lui dire qu’on a déjà “ces produits”, c’est tout ! Et comme c’est une IA, que le “I” veut dire “Intelligence”, il ne devrait pas être trop débile.

Le bon prompt

Donc, en mode “chatbot” dans LM Studio, j’ai testé quelques prompts + contextes initiaux pour trouver la bonne formule, pour générer du JSON pas trop mauvais.

Dans “system”, je dois être très explicite. Je dois lui dire qu’il est un expert en développement, qu’il est francophone et ne répond qu’en français. Qu’il est capable de générer du JSON valide, et blablabla
dans ma question, je dois lui donner beaucoup de détails, et notamment le schéma JSON que je veux qu’il respecte. Le nombre de produits à générer (à partir de 20 il gueule un peu en disant qu’il va déborder, donc on se limite à 10 pour le moment)

Notons que le markdown est accepté, ce qui donne encore un peu plus de sens à nos prompts.

Donc, voilà ce que j’ai fait dans mon script :


SCHEMA = """
```json
[
    {
        "name": "string",
        "description": "string",
        "price": 0.0,
        "categories": ["string"]
    }, {...}
}
```
"""

NUM_PRODUCTS_PER_REQUEST = 5  # The number of products you want to generate
INIT_HISTORY = [
    # the system role is used to set the language and the role of the model. We exxplicitly
    # tell that the model must respond in French - change the message to your target language
    {
        "role": "system",
        "content": (
            "Tu es un développeur français et ne répond qu'en français. "
            "Tu peux proposer des solutions à des problèmes de programmation "
            "et générer du contenu technique."
        ),
    },
    # here we ask the model to generate a list of products in JSON format
    # with the given schema
    {
        "role": "user",
        "content": (
            "J'ai besoin que tu me génères, en JSON,  une liste de "
            f"{NUM_PRODUCTS_PER_REQUEST} produits avec name, "
            "description, price et categories. Le nom doit être pertinent et unique, "
            "la description claire, et de 2 à 5 catégories. "
            "Le contenu doit être en français. "
            "Retourne un tableau d'objets JSON. "
            "Le schema doit être conforme à : " + SCHEMA
        ),
    },
]

Ces variables me servent de configuration. Ce n’est pas super joli, mais ça a le mérite de rester en haut de mon script.

Reste un sérieux souci… le JSON n’est pas forcément donné directement, il est souvent imbriqué dans du Markdown parce que le modèle est fait pour répondre avec de la mise en page.

Un modèle trop humain ?

Ou disons plutôt “trop orienté sur l’imitation d’un humain”.

Le modèle Mistral 7b est vraiment bien foutu, pour faire un chatbot. Il est franchement intéressant pour discuter. Mais moi je veux me servir du modèle pour générer de la donnée. Je n’ai pas envie de discuter avec lui.

On doit éliminer les phrases de gentillesse. Parce que voilà, il va vous répondre, de temps en temps, un truc du genre :


Voilà 5 nouveaux produits, j'espère que cette réponse vous convien !
```json
        le contenu json ici
```

N'hésitez pas à me demander plus de trucs...

Mais parfois, il répond avec du JSON, directement, sans même un bonjour…

On a donc besoin de tenter de charger la réponse “telle quelle”, si ça plante on passe un une extraction Markdown. Je n’ai pas mieux pour le moment :


def extract_json_from_markdown(content):
    """ Extract the JSON content from the response inside a markdown block """ ""
    # The response is a string, there is a json inside "```" and "```", we extract it
    # it is possible that the model starts the json with a newline, so we need to remove it
    json_start = content.find("```") + 3
    json_end = content.rfind("```")
    json_content = content[json_start:json_end]
    if json_content.startswith("json"):
        json_content = json_content[4:]
    try:
        loaded = json.loads(json_content)
    except Exception:  # pyright: ignore pylint: disable=broad-except
        logging.info("JSON content not found as Markdown")
        return None
    return loaded


def extract_json_from_content(content):
    """Extract the JSON content from the response"""

    # if the response is not warp in brackets, add them
    content = content.strip()
    if not content.startswith("["):
        content = f"[{content}]"

    try:
        json_content = json.loads(content)
    except Exception:  # pyright: ignore pylint: disable=broad-except
        logging.info("JSON content not found as full response")
        return None
    return json_content


def extract_json_content(content):
    """Extract the JSON content from the response"""

    content = content.strip()
    loaded = extract_json_from_content(content)
    if loaded is None:
        loaded = extract_json_from_markdown(content)

    if loaded is None:
        logging.error("Error parsing JSON content, no content")
        return None

    # save known products name
    KNOWN_PRODUCTS.extend([product["name"] for product in loaded])

    return loaded

Vous remarquez que je stocke le nom des produits généré pour les redonner à manger au modèle afin de ne pas avoir de doublons.

On fait en sorte de “continuer”

Je vous passe les détails, vous verrez le code final dans le lien en bas de l’article, mais je sauve les JSON dans des fichiers numérotés. Et je me débrouille pour les charger au démarrage du script si besoin.

Passons ce détail, maintenant je veux gérer l’historique proprement. En résumé :

si je suis sur la première itération, je demande ma liste de produit
ensuite, si je “continue” la génération pour avoir d’autres produits, et bien je veux ajouter l’information qui donne la liste des produits que j’ai déjà

Donc, on se garde une variable “KNOWN_PRODUCTS” dans une globale bien dégueulasse, et on se génère une liste à la Markdown. Parce que le modèle comprend la “mise en forme”. Comme ça je peux lui dire que ne ne veut pas les produits que j’ai déjà stocké.

APPEND_PROMPT = """
J'ai déjà ces produits :
"""

KNOWN_PRODUCTS = []

def list_of_products():
    """Generate a list of products in markdown format"""
    return APPEND_PROMPT.strip() + "\n".join([f"- {p}" for p in KNOWN_PRODUCTS])

Et je ponds une fonction pour générer le prompt dans le cas initial et le cas “continue” :

def create_completion(continuation=False):
    """Create a completion using the conversation history"""

    # force a copy of the history
    history = list(INIT_HISTORY)

    # add the continuation prompt
    if continuation:
        history.append(
            {
                "role": "user",
                "content": list_of_products(),
            }
        )

    logging.info("History: %s", history)

    return CLIENT.chat.completions.create(
        model=MODEL_NAME,  # this field is currently unused if you use LM Studio
        messages=history,  # pyright: ignore
        temperature=0.7,
        stream=False,
    )

Cela va ajouter “j’ai déjà ces produits :” avec la liste des noms de produits déjà générés si je passe “True” en argument.

Un exemple de résultat ?

Allez… je vous montre un bout de fichier que me génère mon script (ne paniquez pas, je vous donne le lien du code en bas de l’article):

[
  {
    "name": "Samsung Galaxy S21 Ultra - Nouvelle G\u00e9n\u00e9ration",
    "description": "Smartphone avec \u00e9cran OLED dynamic AMOLED 2X, processeur Exynos 2100 ou Snapdragon 888 et une batterie de 5000mAh.",
    "price": 1299.99,
    "categories": [
      "Smartphones",
      "Electronique"
    ]
  },
  {
    "name": "Apple iPad Pro 12,9 pouces (5e g\u00e9n\u00e9ration)",
    "description": "Tablette tactile dot\u00e9e d'un \u00e9cran Liquid Retina XDR avec M1 Chip et une batterie de 30.42 w-h.",
    "price": 1119.0,
    "categories": [
      "Tablettes",
      "Electronique"
    ]
  },
  {
    "name": "Canon EOS R5 - Hybride RF Mount",
    "description": "Appareil photo reflex num\u00e9rique \u00e0 plein format avec capteur CMOS de 45 Mpx et autofocus Dual Pixel.",
    "price": 3899.0,
    "categories": [
      "Appareils photos",
      "\u00c9lectronique"
    ]
  },
  {
    "name": "Logitech MX Master 3 - Souris sans fil wireless",
    "description": "Souris haut de gamme avec une ergonomie adapt\u00e9e \u00e0 la main, des boutons programmables et une batterie interne rechargeable.",
    "price": 99.99,
    "categories": [
      "Souris informatique",
      "\u00c9lectronique"
    ]
  },
  {
    "name": "Dell XPS 15 - 9510",
    "description": "Ordinateur de bureau portatif \u00e9quip\u00e9 d'un \u00e9cran OLED 15.6 inches, un processeur Intel Core i7 et une batterie de 86 Wh.",
    "price": 2349.0,
    "categories": [
      "Ordinateurs portatifs",
      "\u00c9lectronique"
    ]
  }
]

Et j’en ai généré 1500, scindés en pleins de fichiers.

Ça a pris un peu de temps, soyons honnête. Ma machine est limitée (c’est un portable hein, donc les RTX sont bien bridée), et mon vieux coucou ne comprend pas les instructions AVX2 (donc, j’ai 24 Go de RAM, une RTX 3070, un corei7, mais je ne peux pas l’utiliser avec Mistral avec LM Studio…)

Mais clairement, Python ici est fabuleux. Ce script n’est pas un truc de prod, c’est un gadget qui me génère de la data. J’ai codé ce machin en 20 minutes environ.

Le code final

Bien entendu, je n’ai pas tout décrit dans cet article. Le code complet est dans un “gist” :

https://gist.github.com/metal3d/448da715534baf686c1fffc685483296

Le script génère des fichiers, sans écraser les anciens. Il sait relire les données déjà générées pour continuer la génération de JSON.

Ce n’est pas du grand art, je le sais. C’est codé à l’arrache, et ça mérite potentiellement de créer un vrai projet. Voir une interface graphique, etc.

Mais là, pour l’heure, j’ai bien tous mes fichiers générés.

Vous pouvez adapter le script, et notamment le prompt, pour changer la langue, forcer un domaine de produits, etc.

Amusez-vous !

Podman et Nvidia, ou comment avoir accès à son GPU dans un conteneur

Thu, 09 Nov 2023 21:15:02 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Partager sa carte graphique avec un conteneur est très intéressant. Cela évite d’une part d’avoir à installer localement toute une batterie de packages et de librairie (surtout pour CUDA qui est une plaie), de rendre jetable un test, de partager une application utilisant le Machine-Learning simplement, etc.

Bref, c’est utile et ça soulage.

Mais ce n’est pas évident à activer. La conteneurisation sert à isoler l’application du système, et là on veut absolument lui partager un périphérique. Et pas n’importe lequel, pas une imprimante USB ou une caméra… non… là on parle d’une carte graphique. Heureusement, les derniers efforts de Nvidia à proposer de la documentation et leur ouverture de certaines parties de leur travail permet de s’en sortir avec un peu plus de confort.

TL;DR

Pour les pressés, voici les étapes rapides :

# installer le dépot de nvidia container toolkit
curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo | \
  sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repo
# puis les outils
sudo dnf install nvidia-container-toolkit

# et on commence par créer le fichier de configuration
sudo nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yaml

# on corrige les soucis SELinux
nvidia-container-cli -k list | sudo restorecon -v -f -
sudo restorecon -Rv /dev

Si vous voulez utiliser Podman en “rootless”, il faut modifier avec sudo, le fichier /etc/nvidia-container-runtime/config.toml, on trouve les deux lignes qui nous intéresse :

[nvidia-container-cli]
#no-cgroups = false
no-cgroups = true

[nvidia-container-runtime]
#debug = "/var/log/nvidia-container-runtime.log"
debug = "~/.local/nvidia-container-runtime.log"

Et on peut tester, il faut bien ajouter --device nvidia.com/gpu=all et --security-opt=label=disable.

podman run --rm \
    --device nvidia.com/gpu=all \
    --security-opt=label=disable \
    ubuntu nvidia-smi -L

# ça doit vous donner un truc de ce genre:
GPU 0: NVIDIA GeForce RTX 3070 (UUID: GPU-f7187582-1105-9022-2d77-ac16ed3b10ca)

Voilà, c’est tout…

En détail…

Bon, on va expliquer pas à pas ce qu’il faut faire.

Installer les outils de Nvidia

Nvidia propose des outils assez bien foutus pour permettre à Docker et Podman (mais aussi à Kubernetes, etc…) de partager votre carte graphique avec des conteneurs OCI. Le fait est que depuis quelque temps, et ce grâce à l’explosion des travaux en Machine-Learning, Nvidia est aux avant-postes. Du coup, ils ont mis les bouchées doubles, ont ouvert une partie de leur code, et ils se sont mis à documenter correctement tout leur boxon.

Pour le coup, on peut souligner les efforts et leur dire merci.

Bref, la documentation est assez complète et les outils assez “simples” à utiliser.

Je suis sur Fedora, donc je ne vais pas tortiller pendant des heures avec Ubuntu. L’installation commence par ajouter le dépôt officiel pour Fedora:

curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo | \
  sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repo

Ce dépôt vous propose quelques outils, mais c’est nvidia-ctk et nvidia-container-cli qui nous intéressent. Et ces outils se trouvent dans le package nvidia-container-toolkit :

sudo dnf install nvidia-container-toolkit

À partir de là, on est paré pour la suite.

Configurer pour Podman

La doc est assez claire, mais elle va vous vous guider, ensuite, vers une autre page pour Podman.

Nvidia vous demande d’utiliser plutôt “CDI” (Container Devide Interface) pour configurer l’accès à votre périphérique. Et cette page vous demande de faire deux trois bricoles.

La première commande va générer un fichier yaml qui liste les “devices” et les “hooks” à effectuer quand le conteneur va demander l’accès à ces périphériques. Le faire à la main aurait été une plaie, là, c’est simple :

# enlevez --output=... pour voir ce qu'il va générer
sudo nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yaml

Après cela, vous pouvez contrôler la liste des périphériques qu’il a configuré :

nvidia-ctk cdi list
# il doit vous sortir un truc du genre
# nvidia.com/gpu=all
# nvidia.com/gpu=0

Ces lignes, ce sont les options à --device qu’on pourra donner à Podman. Vous allez voir ça juste après.

Si cette étape s’est bien passé, on va corriger les attributs SELinux au cas où… (en réalité je pense que ce n’est pas nécessaire, mais dans le doute…)

nvidia-container-cli -k list | sudo restorecon -v -f -
sudo restorecon -Rv /dev

Il reste un dernier point, et pas des moindres, c’est de corriger la manière dont on va permettre à Podman d’écrire des logs et d’utiliser les cgroups et ce, seulement si vous voulez utiliser le mode “rootless” de Podman.

C’est tout de même l’un des points forts de Podman, dont on ne s’en privera pas. Je vous conseille donc de le faire !

Ouvrez, avec les droits d’admin (donc sudo vim ou sudo nano) le fichier /etc/nvidia-container-runtime/config.toml pour toucher deux lignes:

La première dans le groupe nvidia-container-cli pour lui dire de se passer des cgroups (ouais bah… bon…)
L’autre dans le groupe nvidia-container-runtime pour lui changer le chemin des logs car, de base, il va taper dans /var/log et vous, en tant qu’utilisateur, vous ne pourrez pas le faire.

Donc en gros, trouvez les lignes (normalement commentées), copiez-les en dessous et changez la valeur. Surtout, gardez les autres lignes telles quelles :

[nvidia-container-cli]
#no-cgroups = false
no-cgroups = true

[nvidia-container-runtime]
#debug = "/var/log/nvidia-container-runtime.log"
debug = "~/.local/nvidia-container-runtime.log"

Pour référence, voici mon fichier à moi :


#accept-nvidia-visible-devices-as-volume-mounts = false
#accept-nvidia-visible-devices-envvar-when-unprivileged = true
disable-require = false
supported-driver-capabilities = "compat32,compute,display,graphics,ngx,utility,video"
#swarm-resource = "DOCKER_RESOURCE_GPU"

[nvidia-container-cli]
#debug = "/var/log/nvidia-container-toolkit.log"
environment = []
#ldcache = "/etc/ld.so.cache"
ldconfig = "@/sbin/ldconfig"
load-kmods = true
#no-cgroups = false
no-cgroups = true
#path = "/usr/bin/nvidia-container-cli"
#root = "/run/nvidia/driver"
#user = "root:video"

[nvidia-container-runtime]
#debug = "/var/log/nvidia-container-runtime.log"
debug = "~/.local/nvidia-container-runtime.log"
log-level = "info"
mode = "auto"
runtimes = ["docker-runc", "runc"]

[nvidia-container-runtime.modes]

[nvidia-container-runtime.modes.cdi]
annotation-prefixes = ["cdi.k8s.io/"]
default-kind = "nvidia.com/gpu"
spec-dirs = ["/etc/cdi", "/var/run/cdi"]

[nvidia-container-runtime.modes.csv]
mount-spec-path = "/etc/nvidia-container-runtime/host-files-for-container.d"

[nvidia-container-runtime-hook]
path = "nvidia-container-runtime-hook"
skip-mode-detection = false

[nvidia-ctk]
path = "nvidia-ctk"

Attention, quand vous mettez à jour vos packages, ce fichier est écrasé. Ou pas… en fait il y aura un fichier config.toml.rpmsave dans lequel il y aura vos anciennes modifications. Mais je vous conseille d’utiliser le fichier mis à jour, qui généralement à des modifications importantes, et de simplement remettre d’aplomb les lignes qu’on a changées.

Voilà… on a fini. Reste à tester :

podman run --rm \
    --device nvidia.com/gpu=all \
    --security-opt=label=disable \
    ubuntu nvidia-smi -L

# doit vous donner la même ligne que `nvidia-smi` en local
# pour ma part :
GPU 0: NVIDIA GeForce RTX 3060 Laptop GPU (UUID: GPU-21c9319b-4c2d-84db-f028-cd065f9d9e8f)

Important

Vous allez certainement tester des outils qui ne parlent que de Docker, alors que ça marche très bien avec Podman. La seule chose à penser c’est de ne pas utiliser le paramètre --gpus (qui ne marche pas sur Podman et je ne sais pas pourquoi), mais d’utiliser --device nvidia.com/gpu=all (ou l’index de carte à la place de all, par exemple nvidia.com/gpu=0) et de forcer la non-labellisation avec --security-opt=label=diable.

Sans cela, vous allez vous prendre des erreurs dans la poire sans rien comprendre.

Pour ma part j’ai ajouté un alias dans mon environnement :

alias podman-gpu="podman run --device nvidia.com/gpu=all --security-opt=label=disable"

Et c’est beaucoup plus simple 😄

Conclusion

Ce n’est pas évident, je vous l’accorde. Mais ce n’est pas insurmontable en réalité. La seule chose à bien penser est de refaire la modification du fichier toml pour les cgroups et le chemin des logs quand les packages sont mis à jour.

C’est d’ailleurs dommage que nous ne pouvions pas utiliser un fichier d’override (c’est peut-être possible, si c’est le cas je modifierai l’article), mais bon… ça me prend moins d’une minute à faire tout ça.

L’intérêt est de pouvoir lancer des inférences, des entrainements, des outils utilisant le GPU sans installer tout ça localement. C’est aussi intéressant de pouvoir tester plusieurs versions de CUDA sans les installer à l’arrache.

Podman est devenu mon seul et unique runtime de conteneur depuis des mois, du moins sur mon poste Linux (car je suis forcé d’utiliser un poste Windows dans mon nouveau Job).

Références

Bien Configurer Son Terminal Bash

Wed, 07 Jun 2023 09:44:46 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

C’est bien plus agréable de travailler avec un terminal qui en jette et qui soit simple à configurer. Alors voilà comment je m’y prends.

Les anciens qui utilisent Windows n’arrivent pas à nous comprendre, nous, Linuxiens et/ou Unixiens (parce que Mac OSX n’est pas en reste). On adore le terminal de commande. Quand on est un débutant, on a l’impression d’être un hacker, et quand on a de l’expérience, on fait à peu près tout et n’importe quoi dessus. On s’abstrait d’énormément d’actions rébarbatives, on automatise des trucs, on se fait nos outils en Bash, etc. En bref, le terminal de commande est incroyable.

Le terminal date des années 60, rendez-vous compte. Une fenêtre généralement noire avec du texte en blanc et voilà, on peut contrôler une machine. Pas besoin de souris (mais en fait on peut), pas besoin d’interface à 200 onglets dans 80 menus… tout est là. On tape une commande et on a ce qu’il faut.

Sauf que voilà, un terminal avec “bash” de base, ça donne pas envie à un novice.

Heureusement, Bash (mais aussi Zsh, fish etc.) permet de faire plein de choses pour rendre cette interface un peu plus sexy !

Le souci, c’est que l’on trouve pas mal de mauvaises pratiques sur internet en ce qui concerne la configuration. Donc, on va y aller proprement, de manière à ne pas gâcher le plaisirs.

Faisons les choses dans l’ordre.

On commence par avoir une configuration de base claire

Normalement, vous devriez avoir un fichier .bashrc à la racine de votre répertoire utilisateur.

Pour la suite, je vais utiliser le symbole “~” qui est interprété par “bash” comme étant votre répertoire utilisateur. Ainsi, ~/.bashrc est le fichier .bashrc dans votre “HOME”.

Dans ce fichier, si vous n’avez rien fait, voilà ce qu’il doit y avoir:

# .bashrc

# Source global definitions
if [ -f /etc/bashrc ]; then
	. /etc/bashrc
fi

# User specific environment
if ! [[ "$PATH" =~ "$HOME/.local/bin:$HOME/bin:" ]]
then
    PATH="$HOME/.local/bin:$HOME/bin:$PATH"
fi
export PATH

# Uncomment the following line if you don't like systemctl's auto-paging feature:
# export SYSTEMD_PAGER=

# User specific aliases and functions
if [ -d ~/.bashrc.d ]; then
	for rc in ~/.bashrc.d/*; do
		if [ -f "$rc" ]; then
			. "$rc"
		fi
	done
fi

unset rc

Si ce n’est pas le cas:

Vous êtes sur Ubuntu, et ils ne sont pas du tout un modèle de vertue
Vous avez fait une bêtise
Vous n’utilisez pas bash…

Dans tous les cas, il serait idéal que ce fichier soit tel quel et de ne rien ajouter dans ce fichier. Car en effet, il est largement suffisant, regardez bien.

Et oui, la partie “User specific aliases and functions” est LA bonne pratique.

Vous l’aurez compris, on peut désormais ajouter des fichier dans un répertoire pour activer, modifier, changer la configuration de notre shell. Cool !

Créez le répertoire ~/.bashrc.d dans lequel on va créer des scripts de configuration.

Et si vous voyez un ami, collègue, membre de la famille, qui n’a pas fait ça, il vous est permis de prendre des airs suffisants et de dire de manière condescendante qu’ils font les choses comme des débutants.

mkdir -p ~/.bashrc.d

On active la “completion”

La completion est un confort d’utilisation sans précédent. La touche “tabulation” (celle qui est à gauche du clavier, représentée par deux flèches qui vont dans les deux sens) va “compléter” la commande ou les options. C’est optionnel, mais je ne connais personne d’humain qui ne l’utilise pas.

Donc, on va installer le paquet qui active la “complétion” bash.

# Fedora, Red Hat, etc...
sudo dnf install bash-completion

# Ubuntu, Debian...
sudo apt install bash-completion

Et maintenant, on est prêt pour l’aventure.

On crée le répertoire local !

Ça me rend assez dingue cette histoire. Je vois encore des gens utiliser les répertoires systèmes pour installer des outils “personnels”.

Freedesktop recommande depuis des lustres d’utiliser un répertoire dans le HOME utilisteur pour les outils que vous installez hors package de distribution. En l’occurence, on va installer des trucs qui ne sont pas “officiels” (mais pas risqué), et il est inadmissible de voir encore des outils qui demande accès à /usr ou /usr/local.

Le répertoire dont nous avons besoin est ~/.local, dans lequel seront créé des répertoire “bin”, “share”, “cache”…

Donc:

mkdir -p ~/.local/bin
source ~/.bashrc

Et désormais, le répertoire local “bin” est dans notre “PATH”, cela veut dire que si vous installez une commande “foo” dans ce répertoire, alors la commande “foo” existera (sans demander de taper tout le chemin).

Franchement, en 2023, ça me scie les nerfs…

On se crée des alias

Les alias sont des command qui permettent d’avoir des “raccourcis”. Par exemple, la commande “ls -l” pourrait avoir un alias “ll”.

Alors, voici mes aliases, à vous d’en ajouter si vous le désirez. Ce fichier est placé en ~/.bashrc.d/aliases-and-path.sh

# J'utilise nvim, mais vous pouvez mettre
# gedit, nano, ce que vous voulez
export EDITOR=nvim

# aliases
alias ll='ls -l'
alias la='ls -A'
alias l='ls -CF'
alias k=kubectl
alias h=helm
alias see="highlight -n -O ansi --force=text"

# append go bin to path
export PATH="$HOME/.local/share/go/bin:$PATH"

Notez:

see est un alias à “highlight”, il colore le fichier en sortie sur le terminal (c’est pratique pour voir du code source)
kubernetes et helm sont des outils que j’utilise, supprimez ces alias si vous n’en avez pas besoin
pareil pour “go”, je préfère placer les binaires à un endroit spécifique, et j’ajoute ce répertoire à $PATH, mais si vous n’en avez pas besoin, vous pouvez supprimer la ligne.

Pour le moment, si vous rechargez votre shell (source ~/.bashrc) alors les alias doivent fonctionner. Tapez la commande l, ll, ou la pour vérifier.

Oh My Posh

C’est optionnel, mais j’adore avoir un “prompt” plus moderne.

Oh-My-Posh est un outil qui va décorer et ajouter des fonctionnalités à votre shell (ça marche avec pas mal de shell). On l’installe assez facilement:

curl -s https://ohmyposh.dev/install.sh | bash -s -- -d ~/.local/bin

Maintenant, créez un fichier ~/.bashrc.d/oh-my-posh.sh et ajoutez:

eval "$(~/.local/bin/oh-my-posh init bash --config ~/.cache/oh-my-posh/themes/bubblesline.omp.json)"

# an alias to update
alias update-oh-my-posh="curl -s https://ohmyposh.dev/install.sh | bash -s"

Parfois, il y aura une notification dans votre terminal pour vous dire qu’une nouvelle version de oh-my-posh est disponible. Dans ce cas, tapez la commande (l’alias) update-oh-my-posh et le tour est joué.

On va rendre le terminal un poil plus ergonomique

D’abord, cette fameuse “completion”, elle marche bien mais elle pose des contraintes. Elle est sensible à la casse (ça veut dire qu’elle prend en compte les majuscules et minuscules), et elle a tendance à faire défiler le terminal pour rien. Par exemple:

Dans l’image ci-dessus, je presse la touche “tabulation” pour essayer de compléter le chemin, mais comme il existe un paquet de fhciers… il me propose toutes les possibilités dans la sortie.

On peut faire mieux !

On commence par créer un fichier ~/.inputrc dans lequel on ajoute:

set completion-ignore-case on
set show-all-if-ambiguous on
set show-all-if-unmodified on
set visible-stats on
TAB: menu-complete

Là il faut vraiment fermer votre terminal et le rouvrir. Maintenant:

Ça évite énormément de lignes inutiles en sortie.

Ble.sh

Ble.sh est un outil qui va fortement modifier l’interaction dans votre shell.

Il rend le mode “menu” plus convivial, en permettant de sélectionner avec les touches de direction le fichier ou l’option que vous voulez (en completion)
Il fait de la coloration syntaxique avec contrôle, donc les mots clef “for, while, if…” sont colorés, ainsi que les commandes
Si la commande ou le contrôle n’existe pas, il le surligne
Il permet l’édition multiligne, par exemple en tapant une boucle
Et plein d’autres choses…

C’est un peu gadget, mais j’adore.

On commence par installer l’outil. Mais on va le faire “à ma manière”.

git clone --recursive --depth 1 --shallow-submodules https://github.com/akinomyoga/ble.sh.git
make -C ble.sh install PREFIX=~/.local
rm -rf ble.sh

Et on crée le fichier ~/.bashrc.d/ble.sh qui contient:

# initialize ble.sh
source ~/.local/share/blesh/ble.sh

Idem que pour oh-my-posh, vous pouvez mettre à jour avec la comamnde ble update.

Reste que les couleurs de base sont, non mais n’ayons pas peur de le dire, affreuses. Alors personnellement j’ai reconfiguré quelques variables.

Voici mon fichier ~/.blerc:

ble-face command_function=fg=205
ble-face command_directory=fg=004,underline
ble-face filename_directory=fg=004
ble-face filename_directory_sticky=fg=103
ble-face auto_complete=fg=15,bg=000
ble-face region_insert=fg=252,bg=000
ble-face syntax_function_name=fg=105,bold
ble-face varname_export=fg=135,bold
ble-face filename_other=
bleopt complete_auto_complete=

Cela correspond mieux à mes préférences. Vous pouvez utiliser la commande ble-face pour voir toutes les variables et les modifier ensuite dans votre ~/.blerc personnel. Franchement c’est pas le truc le plus rigolo que j’ai fait dans ma vie. C’est un peu ostère comme syntaxe, et ça demande des tests. Mais bon, on ne le fait pas tous les jours.

Voilà le résultat:

Les raccourcis qui vont bien

Bash permet pas mal de raccourcis dont certains me paraissent indispensables.

Voici ceux que j’utilise très souvent:

Ctrl+c: très connu mais sait-on jamai… cela “stoppe” la commande en cours
Ctrl+r ou Ctrl-Maj-r: permet de retrouver une commande qu’on a tapé
Ctrl+x Ctrl+e: édite la ligne en cours dans un éditeur de texte (celui configuré dans la variable EDITOR). Astuce, gardez la touche Ctrl enfoncé et pressez successivement x puis e
Ctrl+l: nettoie le terminal, “clear”
Alt+b et Alt+f: reculer ou avancer d’un “mot” dans la commande (f=forwar, b=backward)
Alt+d: supprime le mot sous le curseur

Un autre raccourcis que j’utilise énormément est Ctrl+z, il met en “tâche de fond” la commande en cours. Pour revenir à cette tache, il suffit de taper fg. Mais à quoi ça sert me direz vous ?

Et bien, j’utilise “neovim” (un vim amélioré), et parfois j’ai envie de taper une commande sans avoir à ouvrir un nouveau terminal. Du coup, je presse Ctrl+z dans vim, ça le met en tâche de fond. Je peux alors taper des commandes, puis taper fg et je reviens à vim.

Mais la ligne de commande c’est aussi lié à un terminal

Bash est un shell, un outil qui interprète et utilise des commandes. Cela passe par un télétype, ou un émulateur de terminal. Dans 99% des cas, c’est un émulateur que vous allez utiliser.

Par exemple, gnome-terminal, terminator ou xterm.

Pour ma part, j’ai choisi un autre terminal. Certes, un peu plus lourd en mémoire mais qui a des options qui, à mon sens, sont primordiales quand on travaille énormément sur le terminal.

Mon choix se porte, à ce jour, sur Kitty-Terminal

Pour plusieurs raisons, mais celles que je mets en avant sont:

permet de splitter le terminal (comme le fait terminator) et de changer les raccourcis
permet l’utilisation de polices avec ligatures (comme Fira Code, ou Jetbrain Mono Nerd Font)
permet d’afficher des images dans le terminal (notamment avec ranger, un navigateur de fichier terminal)
de scripter des comportements en python (par exemple j’ai un bout de code qui me permet de “zoomer” sur une partie de mon terminal quand il est splitté)

Kitty est dans les paquets de Fedora, et je vous invite à le tester, à le configurer et de ne pas hésiter à aller lire la documentation.

Depuis les dernières versions, kitten est déjà présent, donc kitten icat fonctionne bien. Mais vous pouvez ajouter cet alias dans ~/.bashrc.d/kitty.sh:

# see image in terminal
alias icat=`kitten icat`

Et ça fait son effet:

Que dire de plus…

Il existe tellement de possibilités de configuration de terminal, et de votre shell, qu’un simple article ne suffit bien évidemment pas.

Je vous conseille d’installer et configurer ranger qui est un superbe navigateur de fichiers terminal. Associé à kitty c’est un outil fabuleux. Il ne faut pas hésiter à aller chercher un peu comment changer les thèmes. Que ce soit sur Kitty ou ranger.

Aussi, au lieu de top ou htop, testez l’expérience bpytop qui est, une fois encore, une preuve que le terminal est loin d’être un machin austère.

Et en ce qui concerne les outils de développements, rien ne vaut Coc dans vim/neovim. Avec quelques plugins, votre éditeur devient un IDE proche de ce qu’on voit sur VSCode.

Je pense en faire un article complet un jour.

Bref, éclatez vous !

Comment récupérer une version ou un tag git efficace dans un Makefile

Mon, 06 Dec 2021 09:26:15 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

J’adore “versionner” mes paquets ou un executable avec le tag git ou la version “sha” du dépôt en cours, alors comment on peut rendre ça vraiment automatique ?

Ce billet sera court, c’est juste une astuce que j’ai dans un coin qui va vous permettre de faire une opération qui est généralement bien lourde à gérer. Cette petite technique, elle marche dans un Makefile, mais libre à vous de l’adapter pour d’autres systèmes de build.

Je vous expose le problème. Imaginons que je décide que mon Makefile doive faire un tarball de mon application. Et bien entendu je veux avoir la version dans le nom. En général on fait comme ça:

# ! non ne faites PAS ça
VERSION=1.1.O

exemple:
    tar caf  foo-$(VERSION).tgz ./src

Et vous allez bien entendu vouloir utiliser un outil CI/CD pour lancer la commande qui va déposer le paquet quelque part. Bravo, c’est pas idiot, mais il y a un hic. Et un sérieux hic en fait: vous allez forcément oublier de changer la variable VERSION dans le Makefile.

Non mais… je vous connais… et puis je fais pareil…

Alors vous allez me dire:

oui mais moi mon CI/CD il va créer le tag, puis passer la version en argument etc…

Oui… pourquoi pas, et puis c’est vrai que tout le monde utilise un outil CI/CD 🙄, et puis il va falloir aussi penser à “puller” le dépôt sur votre poste, sans compter que parfois “ça foire” sur l’outil CI/CD… Allons allons 😌

Il existe une façon de faire bien plus effcicace, un poil plus simple (si si) et surtout qui est sûre et contrôlable. J’entends par ces termes que vous allez simplement taguer (ou pas) votre version, et le Makefile trouvera tout seul l’état, et donc la version, de votre dépôt.

L’idée est simple:

si j’ai un tag et que mon dépôt est bien à ce tag précisément alors je veux que la version soit égale à ce tag
sinon je veux le nom de la branche + le “SHA” du commit actuel.

Trois commandes suffisent:

git branch --show-current pour avoir le nom de la branche en cours, dans le cas où le dépôt n’est pas positionné sur un tag
git log --pretty="%h" va donner l’empreinte courte du commit en cours
git describe --exact-match --tags SHA (avec SHA qui est le résultat de la commande du dessus), va me donner le tag si et seulement si le SHA correspond au commit du tag. Sinon il ne retourne rien.

Et donc, dans votre Makefile, faites juste ça:

CUR_SHA=$(shell git log -n1 --pretty='%h')
CUR_BRANCH=$(shell git branch --show-current)
VERSION=$(shell git describe --exact-match --tags $(CUR_SHA) 2>/dev/null || echo $(CUR_BRANCH)-$(CUR_SHA))

exemple:
    tar caf foo-$(VERSION).tgz ./src

Donc:

si je viens de taguer, et que je n’ai rien touché, VERSION contient le nom du tag
sinon, VERSION vaut “nom-de-la-branche-SHA” (par exemple master-34ge12f)

Un exemple avec Go, pour builder avec la version du binaire en variable:

CUR_SHA=$(shell git log -n1 --pretty='%h')
CUR_BRANCH=$(shell git branch --show-current)
VERSION=$(shell git describe --exact-match --tags $(CUR_SHA) 2>/dev/null || echo $(CUR_BRANCH)-$(CUR_SHA))

build:
    go build -ldflags="-X 'main.Version=$(VERSION)'" .

Voilà, c’est tout bête mais je voulais vous le partager 😗

Créer une application Web TypeScript / JS en un rien de temps

Mon, 01 Nov 2021 15:45:52 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

TypeScript c’est le pied, mais pas “from scratch”. On aime ce que propose Vue, Angular ou encore React en mode “dev” (live reload, HMR, etc…) - alors comment on fait sans framework ? Et bien parlons de “Parcel” qui vient de sortir en version 2 et qui déchire de la licorne (et on parlera aussi de Vite ou SnowPack).

Vous avez déjà codé une application “from scratch” en TypeScript et sans outil particulier ? Si oui, vous connaissez certainement le souci dont je vais vous parler: TypeScript ne remplace pas les “imports” - du coup, votre serveur Web ne trouve pas les ressources. Il faut faire la manipulation d’ajout d’extension. Ça c’est donc le premier souci.

Et puis, soyons honnête, presser F5 pour rafraîchir la page à chaque modification, c’est pas compliqué mais c’est pas confortable.

Allons-y franchement, j’ai envie d’un truc qui ne me pose pas de question, qui me serve ma page pendant que je développe, qui compile correctement le TypeScript, le SCSS, qui me donne quelques possibilités pour les images etc… et ne me prenne pas la tête - ça doit rouler tout seul.

J’ai déjà assez à faire avec mes bugs, pas envie de passer des heures à configurer la construction et/ou l’environnement de développement.

Et c’est pour ça que, pour le moment, je ne pense pas à WebPack. Il est très puissant et configurable, mais moi j’ai pas besoin de ça. Franchement, chapeau bas à ceux et celles qui arrivent à configurer WebPack du premier coup.

Et quid des dépendances à ajouter à package.json pour faire du SCSS, à devoir gérer les versions, et potentiellement devoir adapter les “scripts” pour que tout soit compilé correctement pour avoir une version en développement et en production.

Bref, c’est souvent pour cela que je passe directement par Vue ou Angular, pour m’éviter de devoir me coltiner ces tracas.

Mais j’aime bien coder “from scratch”, parce que je dois juste coder une librairie standard, parce que je veux tester un truc rapidement, bref j’ai pas tout le temps besoin d’avoir un framework complet.

Autre truc, pour une petite application, j’ai des fragments de HTML que je veux utiliser dynamiquement, donc j’ai envie de les importer (à la manière de React, même si je déteste ce Framework) et de les placer dans le DOM. Et ce sans passer par fetch(), juste import "blabla.html".

Et dernier point non négligeable, j’ai envie d’utiliser “Bootstrap”, ou “Bulma” - mais à chaque fois je me demande comment je vais faire pour avoir le droit de toucher à des variables, compiler correctement le bouzin et l’intégrer dans le projet.

Tout ça, tout ce dont je vous parle, c’est ni plus ni moins qu’un besoin de simplification: ne pas utiliser de framework, juste coder, éliminer les dépendances.

Et bien depuis quelques années, une famille d’outil est arrivé pour ça: les Front Build Tools.

Ce que proposent ces outils:

un serveur de développement, qui se recharge tout seul lors des modifications, et recharge la page lors de l’injection de module (HMR, Hot Module Replacement)
construction de l’application quelque soit la ou les technologies choisies (TypeScript, SCSS, JS, CSS, Less…)
transforme les ressources non code en ressources de code (une image, une page HTML, une feuille de style, vous pouvez l’importer et la gérer)

Il en existe tellement, ViteJS, SnowPack ou encore, celui qui m’intéresse le plus et dont on va parler: Parcel

Je vous expliquerai pourquoi j’utilise Parcel et non pas Vite ou SnowPack. Mais vous verrez que ce choix n’est pas figé, et que vous aurez tout à fait raison d’utiliser les autres.

Mais d’abord, commençons par regarder Parcel.

Bon alors Parcel…

Voilà en gros ce que je fais pour commencer à travailler:

# je crée un répertoire de travail
mkdir -p ~/Projects/test-parcel
cd !$

# je crée le projet, avec yarn, mais vous pourriez utiliser npm
yarn init -y

# on installe Parcel en dépendance de développement
yarn add -D parcel

# je remplace dans `package.json` la ligne 
# "main": "index.js"
# par:
# "source": "src/index.html"
sed -i 's,"main": "index.js","source": "src/index.html",' package.json

# je créée la page
mkdir src
echo '<p>Yop</p>' > src/index.html

# et je lane le service de dev
yarn parcel

Voilà, allez à la page http://localhost:1234 et vous avez votre page qui tourne.

La moindre modification de vos sources va rafraîchir la vue. Déjà ça c’est bon !

Et donc, pour le TypeScript ? Facile… Ajoutez un fichier src/main.ts par exemple, et tapez:

class Foo (){
    constructor(private name: string) {}

    hello() {
        console.log(this.name);
    }
}

const f = new Foo("Youpi ?");
f.hello();

et dans index.html:

<script type="module" src="main.ts"></script>

Et voilà, c’est tout… Parcel va utiliser un transpiler pour vous, tout va bien. La page est rafraîchie et dans la console (du navigateur) vous devriez voir apparaître un “Youpi ?”.

Pas une ligne de configuration, rien, que dalle. Ça marche et c’est tout ce qu’on voulait.

Non mais en vrai, on configure un truc ou deux non ?

Oui alors… Parcel n’est pas parfait. Il balance tout dans un répertoire nommé “dist” et je trouve ça pas super pertinent. Parce qu’en plus il ne nettoie pas sa chambre ce bougre. Donc on va améliorer un peu en touchant package.json, voici ce que je fais par habitude:

"scripts" : {
    "predev": "rm -rf .tmp",
    "dev" : "parcel --dist-dir .tmp",
    "prebuild": "rm -rf dist",
    "build": "parcel build"
}

Voilà, comme ça je tape juste yarn dev ou yarn build et tout est propre.

Et pour le SCSS ?

Parcel n’est pas qu’un bundler ou un serveur de dev. Comme ses confrères il a quelques tours dans sa manche.

Partons d’un exemple simple, j’ai envie d’utiliser “Bootstrap”, parce que… je l’ai décidé. Tout va aller très vite:

D’abord j’ajoute bootstrap en dépendance de développement:

yarn add -D bootstrap

Et là vous avez deux solutions:

soit vous codez salement comme dans React
soit vous décidez de faire les choses plus proprement

Donc, pour les gorets, dans main.ts:

import '../node_modules/bootstrap/scss/bootstrap.scss'

Et sinon pour les vrais professionnels, vous créez un fichier styles.scss:

@import '../node_modules/bootstrap/scss/bootstrap.scss'
/* Et là vous pouvez mettre vos adaptations, changements de couleurs etc... */

et vous ajoutez cela dans index.html:

<link rel="stylesheet" href="styles.scss" />

Dans les deux cas, il va se passer un truc “étrange”, mais tellement génial.

Parcel va, tout seul, ajouter une “devDependencies” dans package.json - un plugin qui va compiler le SCSS et le placer où il faut.

Sans redémarrer le service, sans rien faire de spécial, ça va marcher.

Et bien entendu, en TypeScrip, vous pouvez utiliser “bootstrap” pour injecter des alertes, des “toast”, etc. D’ailleurs, Bootstrap propose une petite page de documentation pour utiliser Parcel et je vous conseille bien entendu d’aller la lire !

“Et tu parlais d’import de ressources ?”

C’est un truc qui marche aussi dans les autres build tools, mais chez Parcel j’aime beaucoup comment on s’en sert.

Faire un fichier config.yaml:

mode: prod
title: "[DEV] Exemple de code"

et importer ça comme ça dans du TypeScript:

import config from "config.yaml";

if (config.mode == "prod") {
    // et faire des choses ici
}

En gros, les ressources qui ne sont pas des fichier JS/TS sont quand mêmes utilisables.

Quand j’ai besoin de faire des fragments de code HTML, j’avoue que l’import est plus tordu. Prenons un exemple, dans mon index.html je vais faire ça:

<div id="app"></div>

Et j’ajoute un fichier content.html:

<p>Et voilà le contenu !</p>

Dans le main.ts voilà ce que je peux faire:

// comme je veux le texte, je demande un import "bundle-text"
import  content from "bundle-text:./content.html";

document.querySelector("#app").innerHTML = content

Tout est expliqué dans la page qui parle de bundle inline.

Il faut utiliser ça avec parcimonie, n’est-ce pas chers amis fans de React…

Et quand on foire ?

Pas de panique, que ce soit dans la console ou le navigateur, l’erreur apparaît et vous aide beaucoup à corriger.

Mais vraiment, pour Typescript, ajoutez des dépendances

Parcel s’occupe de construire et empaqueter, mais il ne paramètre pas votre IDE. C’est pourquoi j’ajoute quand même deux dépendances:

yarn add -D eslint@^7 typescript

# et je génère les fichiers de conf
yarn tsc --init
yarn eslint --init

Aux questions de eslint je fais en sorte de prendre en compte TypeScript, je “réponds aux question de style” pour forcer les “double-quote” et les point-virgules, et supprime finalement la partie “indent” du fichier .eslintrc.json - parce que finalement, 2 espaces c’est pas si mal¹

En utilisant “NeoVim” + “Coc” (https://github.com/neoclide/coc.nvim) j’ai de quoi coder, avec des imports automatiques, des correction automatiques, documentation et autocompletion, le tout dans le terminal².

Bref, zero-conf oui, mais faut pas non plus faire la feignasse tout le long, avoir de quoi bosser proprement ça demande un peu de paramétrage, soyons sérieux.

Alors donc, pourquoi pas Vite ou SnowPack ?

“Vite” et “SnowPack” sont excellents. Je ne vais pas dire le contraire et je pousse les gens à regarder les trois outils.

“Vite” est d’ailleurs bien plus populaire. Pour des raisons certainement très défendables.

Alors, calmez vous les fans de Vite et SnowPack, je ne dis pas qu’ils sont moins bons - attendez de lire ce qui suit.

SnowPack ne correspond pas à mon besoin, il demande une structure et je dois passer par une phase “d’init” (yarn snowpack init, changer le “root” etc…) - il est certes puissant et très performant mais je cherche avant tout, justement, à me passer de la configuration. SnowPack a un autre objectif et dans le cas que je présente ici, ce n’est pas le plus adapté.

“Vite” était à deux doigts de me convenir, mais… il ne prend pas la base de code par défaut en passant par package.json, et du coup les “imports” de ressources typescript, ainsi que SCSS ou autres, ne sont pas “logiques” à mes yeux. Le souci est que “Vite” prend la base de code à la racine du projet, et que vous devez donc forcer le chemin au démarrage du serveur web. Et bon bha c’est pas aussi facile et rapide à utiliser au final.

Alors que dire ? qu’il ne faut pas les utiliser ? Certainement pas ! - ils sont au moins aussi bon que Parcel, mais ils sont adaptés à d’autres situations.

Pour être exact, j’utilise aussi “Vite” ou “SnowPack”, mais dans des conditions différentes. Par exemple j’adore les templates de “Vite” pour VueJS. Vous ne devez en aucun cas ignorer les autres outils.

Bref, Parcel n’est peut-être pas ce dont vous avez besoin et vous auriez tout à fait raison de passer par un autre outil zero-conf.

Parcel est, à mon sens, parfait pour le prototypage et le “build simplifié” - il est pratique pour sa qualité de HMR et sa gestion super intelligente des imports de ressources. Mais il a ses défaut (plus lent, plus lourd, difficile de sortir de l’obscurification, etc…) - je n’abandonne donc pas ses confrères (je n’utilise pas le mot “concurrent”, car ils ne le sont clairement pas), j’utilise juste le bon outil pour le bon besoin.

allez-y, trollez sur les indentations ! ↩︎
allez-y, trollez sur vim ! ↩︎

Kind - Kubernetes local, sans Docker ? avec Podman !

Tue, 16 Feb 2021 13:45:53 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Kind (Kubernetes in Docker) avec Podman au lieu de Docker, avec un utilisateur “normal” - disons, en évitant au maximum de passer par “sudo”

Soyons clairs, je n’ai rien contre Docker. Mais Docker, c’est “une méthode parmis d’autres” pour créer des conteneurs. Et force est de constater que depuis quelques temps je me détourne de cette manière de faire pour diverses raisons.

L’une d’entre elles est le fait qu’il en bave avec les nouvelles gestions de hiérarchie unifiée cgroup… Depuis Fedora 33, nous sommes forcés de dégrader le fonctionnement en injectant un paramètre à la ligne de démarrage du noyau Linux. Et ça, çe me gène.

Il existe d’autres “runners”, comme “CRI-O”, “runc”… et bien que nous avons une mouture de Docker maison nommée “moby-engine” sur Fedora, je me range de plus en plus du côté de podman. J’adore le principe.

Pas de service qui tourne en fond
Gestion des images locales à l’utilisateur (dans ~/.local/share/containers)
Donc… pas de groupe à gérer (avec Docker il faut être dans le groupe docker)
podman-compose très compatible à docker-compose

C’est propre.

Et, bien entendu, c’est compatible avec Docker - les pulls d’images fonctionnent, les conteneurs ont la même tête et les commandes de démarrage sont très proches.

La seule vraie grosse différence, et elle fait un peu mal, c’est que vos conteneurs n’auront plus d’IP à proprement parler (si vous les démarrez en tant qu’uitilisateur “normal”). Aussi, ils sont injectés dans des Pods, tout comme sur Kubernetes - et donc on se familarise plus vite à cette notion. L’avantage est que les conteneurs au sein d’un même pod communiquent avec l’adresse “localhost”, mais ça surprend un peu de ne pas pouvoir utiliser un vieux dnsmasq de derrière les bottes de foins pour taper sur le conteneur. Rien de bien méchant mais ça peut être une contrainte.

OK donc, je passe à Podman, et je suis content. Mais je bosse beaucoup sur Kubernetes… et donc j’ai besoin de tester localement mes déploiements.

Kind ?

Si vous ne connaissez pas kind, je vous invite à aller voir la page de documentation. Si vous n’avez pas “Go”, pas de panique, passez par la page Github pour prendre le binaire.

Ce binaire, placez le dans un répertoire accessible dans $PATH. J’utilise personnellement ~/.local/bin, mais je sais que certaines distributions (Ubu…) ont du mal avec les standards, donc débrouillez vous car dans l’article, je vais utiliser la commande “kind” en partant du principe qu’elle est accessible sans donner le chemin.

Bref, en gros, Kind propose de démarrer un cluster Kubernetes en quelques secondes, sans VM, via… Docker…

Ouais… Docker… Kind veut Docker, ou du moins il “préfère”.

Pas de panique, Kind supporte podman de manière “expérimentale”. Alors bref, je me dis “bon, dégageons Docker et on y va”. (Oui j’ai vraiment supprimé le paquet “moby-engine” et/ou “docker” de mon poste)

Et là, le drame:

$ kind create cluster
enabling experimental podman provider
Creating cluster "kind" ...
podman provider does not work properly in rootless mode

Arrgghhhh oui, zut… Kind veut créer un CNI du coup, et il a aucun droit car je ne suis pas “root”. La raison est simple, Kind a besoin d’une IP pour le ou les conteneurs qu’il va créer pour simuler les “masters/nodes”, et donc il faut que Podman puisse créer la ressource CNI (ou utiliser celle qui existe pour les conteneurs non “rootless”).

Et bien pas de panique ! On va passer un peu outre en utilisant jute un peu “sudo” mais vraiment qu’un peu.

D’abord, on démarre le cluster

Bon, on va pas y couper, il faut passer par “sudo” pour démarrer le cluster, ça c’est pas sorcier et “tant pis”:

sudo /home/metal3d/.local/share/go/bin/kind create cluster
enabling experimental podman provider
Creating cluster "kind" ...
 ✓ Ensuring node image (kindest/node:v1.20.2) 🖼
 ✓ Preparing nodes 📦
 ✓ Writing configuration 📜
 ✓ Starting control-plane 🕹️
 ✓ Installing CNI 🔌
 ✓ Installing StorageClass 💾
Set kubectl context to "kind-kind"
You can now use your cluster with:

kubectl cluster-info --context kind-kind

Have a question, bug, or feature request? Let us know! https://kind.sigs.k8s.io/#community 🙂

Alors, pour ma part, je force l’utilisation du chemin complet pour atteindre le binaire “kind”, parce que j’ai installé depuis les sources avec “go install”, mais si vous avez posé le binaire dans un PATH accessible par tout le monde, pas de souci, mettez juste sudo kind create cluster.

Bon, jusque là tout vas bien, kind a démarré et il est accessible… par root… !?

# ne marche pas
kubectl get nodes

# marche bien...
sudo kubectl get nodes

Hors de question de taper “sudo” pour toutes les commandes !

On fait quoi ? On se met un bon vieux Eric Bibb en repensant au bon vieux temps où on se disait “non mais, pas grave je vais bosser en root directement”…

NON !

On évite sudo ?

Et bien c’est simple, là, la seule chose qui fait que seul “root” ait accès au cluster ce n’est pas parce que le “pod” a été démarré par “root”, non non non, c’est que la configuration d’accès (le “kubeconfig”) a été écrite sur /root, on va juste la récupérer !

sudo cp /root/.kube/config ~/.kube/kind-config
sudo chown $(id -u):$(id -g) ~/.kube/kind-config

# Si vous savez ce que vous faites:
# ln -sf ~/.kube/kind-config ~/.kube/config
# Sinon, utilisez la variable `KUBECONFIG` pour la placer sur ce fichier:
# export KUBECONFIG=~/.kube/kind-config
# et pensez-y... tout le temps !

OK, on y est, testons:

$ kubectl cluster-info
Kubernetes control plane is running at https://127.0.0.1:40113
KubeDNS is running at https://127.0.0.1:40113/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

Et voilà… C’était simple 😇

Soyons précis, désormais on a accès au cluster local parce que le “Kubeconfig” est généré pour ce cluster. Mais si vous le supprimez et que vous le recrééz, il faudra récupérer la configuration /root/.kube/config pour la placer dans votre HOME. Car cette configuration contient le certificat nécessaire pour s’authentifier sur le cluster. Compris ?

On va un peu plus loin ?

Cette partie fonctionne avec Kind démarré avec Docker ou Podman donc pas de différence hormis le fait que la récupération de l’IP du noeud se fait “sans sudo” avec Docker.

Perso, j’aime pouvoir accéder à mes tests sans passer par un “port-forward” ou un NodePort. Donc, vous devez le savoir, la technique est d’utiliser un ingress-conroller et de créer des ingress.

Le souci, bha… on a pas de nom de domaine local. Sauf que, des gens bien intentionnés vous permettent d’utiliser un domaine particulier qui est très pratique. Je vous en cite 3 mais je suis persuadé qu’il en existe d’autres:

xip.io
nip.io
sslip.io

Tous ces domaines sont très pratiques, il vous permettent de placer une IP dans le nom de domaine ainsi qu’un sous-domaine. Par exemple:

domaine	résolution
10.2.3.4.xip.io	10.2.3.4
app.10.2.3.4.xip.io	10.2.3.4
mon.app.10.2.3.4.xip.io	10.2.3.4

Bon vous avez compris… on met ce qu’on veut en IP dans le domaine, et ça répond avec cette IP. Pratique !

Ouais sauf que… Free et SFR ont une facheuse tendance à foutre la merde avec les DNS, et j’ai donc pas mal de collègues qui en bavent. En gros, avec Free et SFR vous avez une chance sur dix que ça passe. Et même en forçant les DNS c’est le boxon (SFR filtre le port 53 il parait). Donc, si vous êtes chez ces FAI, vous allez potentiellement en baver un peu.

Bon, on installe un “ingress-controller”, par exemple l’excellent “ingress-nginx” que je trouve au poil:

# On ajoute le dépot qui va bien
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# on installe ça dans un namespace nommé "infra" (valeur modifiable)
NS="_change_infra"
helm install ingress-controller ingress-nginx/ingress-nginx \
    --set controller.hostNetwork=true \
    --namespace=$NS --create-namespace

Et après quelques secondes l’ingress-controller est présent, reste à avoir l’IP du noeud prinicpal (ou d’un des noeuds worker si vous avez démarré plusieurs workers, donc faites un choix):

sudo podman inspect kind-control-plane -f '{{.NetworkSettings.Networks.kind.IPAddress}}'

L’ip qui apparait, vous la notez et vous la gardez dans un coin.

À partir de maintenant, quand vous paramétrez un ingress, vous donner en hostname “ce-que-vous-voulez.ip-trouvée.xip.io”, et c’est gagné.

Par exemple, pour tester, on va se déployer un petit serveur nginx:

# Récupération de l'ip si vous ne l'avez pas encore
KIND_IP=$(sudo podman inspect kind-control-plane \
    -f '{{.NetworkSettings.Networks.kind.IPAddress}}')

# ajout du dépot de bitnami (bon sang que je les aime)
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update

# le sous-domaine voulu, préfix de xip
DOMAIN="_change_example"

# Namespace pour tester
NS="_change_testapp"

# on installe nginx en indiquant une adresse
helm install _change_mon-application bitnami/nginx \
    --namespace=$NS --create-namespace \
    --set ingress.enabled=true \
    --set ingress.hostname="$DOMAIN.$KIND_IP.xip.io"

echo "Visitez http://$DOMAIN.$KIND_IP.xip.io"

L’adresse apparait donc à la fin, et vous devriez pouvoir visiter la page web indiquée. Si tout va bien, après quelques secondes/minutes d’installation selon la vitesse de votre machine, vous devriez avoir une belle page de “Welcome” de la part de nginx. C’est tout bon !

Alors, podman ?

Honnêtement, podman est un bonheur. Aujourd’hui je construis mes images avec, j’utilise “podman-compose” et je n’ai ressenti que très peu de vraies grosses différences hormis le fait que je n’ai pas d’IP direct. Mais… Je me suis surtout rendu compte que je n’ai pas tant besoin que ça d’un IP de conteneur. Mais je ne dis pas non plus que c’est inutile, disnons que j’ai appris à m’en passer.

Kind version 0.10.x fonctionne vraiment bien avec podman. Je n’ai à ce jour aucun souci. Maintenant, clairement, au travail j’utilise toujours docker pour des raisons évidentes de possibles manques de compatibilité avec mes coéquipiers. Cela-dit, je pourrais m’en passer… J’expérimente en ce moment.

Podman ne permet pas pour le moment d’avoir des IP en mode “rootless” (c’est-à-dire si vous démarrez des conteneurs avec votre utilisateur, sans sudo), c’est donc pour cela qu’il faut passer par “sudo” pour démarrer le cluster local. Mais en déportant la configuration de kubectl sur votre répertoire personnel, vous n’aurez pas de souci.

Donc, en somme, I 💙 Podman et Kind.

Python, Jouez Avec Les Annotations de Classes

Sun, 24 Jan 2021 11:30:51 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Et si on se servait des annotations pour faire autre chose que du simple “type checking” dans les IDE ? Par exemple, si on rendait la sérialisation JSON ou la création d’un système de modèle pour BDD plus élégant ?

Les annotations, on s’en sert de plus en plus en Python, ça aide la compréhension du code, et les IDE adorent ça pour vous proposer de l’autocompletion efficacement. Mais je trouve qu’on ne se sert pas assez des annotations pour “tout le reste” - et notamment pour rendre la configuration de classe bien plus pratique. Je vais d’abord vous expliquer rapidement l’état des lieux, puis je vais vous montrer comment on peut utiliser les annotations pour “configurer une classe”. Cela peut rendre vos projets bien plus jolis à lire, à modifier, et surtout à contrôler.

Ce que vous faisiez avant…

Imaginons que nous devions gérer un ensemble d’objets très hétérogène, c’est souvent le cas qu’on veut travailler avec des objets à stocker en base de données. Par exemple,

un “User” a un nom, un prénom, un email, une date de naissance… Il faut contrôler que les types sont bons, mais aussi ne pas exporter les propriétés inutiles.
Mais vous aurez aussi un autre type d’objet. Par exemple un “Projet” a un nom, une description, mais surtout un responsable qui est de type “User” (ou autre) , etc…

Du coup vous allez composer les objets avec d’autres objets. C’est normal, c’est logique, mais ça pose un souci. Parce que quand vous voulez exporter ça en JSON:

TypeError: Object of type Project is not JSON serializable

Arrrrrggggg ouais…(suivi de pleurs, Dust in the wind à fond, etc…)

Après quelques minutes à trouver pourquoi il vous insulte de la sorte, alors que vous êtes gentil hein, on vous propose dans des documentations de faire des méthodes de sérialisation, et de boucler les propriétés pour ne sortir que ce dont vous avez besoin. Et puis vous ajoutez des propriétés, et vous recommencez à devoir manipuler les méthodes et ainsi de suite. En gros, chaque classe dérive de “JsonMachin” et vous devez surcharger la méthode “to_json()” pour dire quelles propriétés vous voulez exporter.

Ça marche hein, on est d’accord, mais c’est fastidieux à la longue.

Le souci est que lorsqu’un objet est composé d’autres objets, cela devient le berzingue pour sortir un truc propre. Vos classes commencent à devoir gérer des propriétés publiques que vous voulez, ou non, exporter, transformer, et ça commence à vous énerver. Et je vous comprends, moi ça m’énerve aussi.

Regardons ce que font les autres…

SQLAlchemy propose une idée très plaisante pour sérialiser les données à mettre en base, c’est d’utiliser des variables statiques. Par exemple dans la classe “User” :

class User(Model):
    name = StringValue(32)
    lastname = StringValue(32)
    # ...

C’est pas idiot car cela rend identifiables les propriétés avec des types qu’on connait bien. Il suffit de vérifier si les champs sont des dérivés de la classe “Column” (avec la fonction isinstance(obj, type)).

Cette méthode est super intéressante mais elle a des désagréments pour notre cas:

la classe a un objet statique instancié, ça a un côut en mémoire (pas grand chose mais il est là)
pour bien être certain que la propriété de l’objet est un champs à traiter, il faut absolument avoir un type qui hérite d’une classe identifiable comme telle, par exemple “Field” ou “Column” - au final on va quand même le faire, mais pour l’heure imaginons que nous voulions nous en passer
et donc, il faut penser à tout… tous les types !
et c’est pas ce qu’on veut, on veut sérialiser en JSON des trucs simples à taper bon sang. Des chaines de caractères, des nombres, et potentiellement des objet “sérialisables” de temps en temps
et quid des objets déjà tout prêts qu’on veut rendre sérialisables après coup ? Par exemple dans projet déjà bien conséquent

Je ne suis pas en train de dire que SQLAlchemy fait mal les choses, non non. Je dis juste que dans des cas “simples”, et dans un cas “custom”, on a pas forcément l’envie de se prendre la tête définir des types spécifiques. Là pour la sérialisation JSON, c’est bien trop compliqué !

C’est quoi la solution pour un cas plus simple ?

Les annotations !

Dans les faits vous avez peut-être déjà vu des annotations dans des déclarations de fonctions.

def truc(vara: int, varb: str):
    pass

Dans l’exemple du dessus, les annotations sont les “: quelquechose”. Contrairement à ce que beaucoup pense, ce n’est pas du typage, car Python se fout complètement de l’annotation. Par contre les IDE, ils s’en servent pas mal pour vous proposer l’autocompletion adéquate. Ça sert aussi à ne pas se tromper dans les arguments, et de ne pas avoir à les nommer pour faire comprendre quel type est attendu. Mais fonctionnellement, c’est pas utile à Python.

Une annotation, c’est un genre d’attribut mais il ne fait rien… mais alors rien ! À part “taguer” des propriétés

Par contre, chose que beaucoup en savent pas (moi je sais, nanaère), c’est que les annotations peuvent être retrouvées au sein du code. C’est donc super intéressant car vous pouvez jouer avec pour vérifier vous même les types. Et vous savez quoi ? Ça marche aussi avec des attributs de classe !

L’idée c’est que l’annotation c’est un genre de “tag”, qui ne peut contenir qu’une chose: un type (ou un tuple de types). Et vraiment rien d’autre… Il sert de “description” d’un attribut. Il n’assigne pas de valeur.

Vous sentez venir le coup ?

Une annotation, comme quand on le fait pour les arguments d’une fonction, ça s’écrit “nom: type”. Attention, pas de signe “égal”, c’est bien “deux points”.

class User(JSONizer):
    firstname: str
    lastname: str
    email: str

Sérieusement, vous trouvez pas ça joli ? C’est net, c’est efficace, c’est carrément compréhensible.

Mon objet hérite de JSONizer, une classe que je vais développer. Cette classe va pouvoir traiter les annotations et faire ce que je veux: Nous aurons accès à self.__annotations__ qui est un dictionnaire (dict). On peut donc le parcourir, avoir la valeur et les clefs - ça va pas être bien compliqué.

Ici je vais m’en servir pour:

vérifier que ce que m’envoi l’utilisateur dans la construction de l’objet existe dans les annotations (par exemple hein, on est pas obligé)
vérifier que le type déclaré correspond au type de la valeur que je reçois en constriction (encore une fois, pas obligé, c’est pour vous montrer)

C’est un exemple hein, on peut s’en servir pour autre chose… vous verrez après…

Pour faire ceci, ma classe mère JSONizer contient:

un constructeur, pas obligatoire mais intéressant, il va enregistrer les propriétés envoyées en argument (mais on pourrait très bien, en plus, utiliser __setattribute__ , en complément ou pas)
une méthode save() qui me retourne le JSON (mais elle pourrait très bien enregistrer en base de données),
et une méthode todict() qui va me permettre de faire un peu d’introspection et sortir un dictionnaire ne contenant que les attributs qui correspondent à une annotation. Bien entendu ça pourrait très bien être fait dans la méthode save() mais j’aime bien factoriser les trucs.

Voilà le code:

class JSONizer:
    def __init__(self, **kwargs):
        # kwargs => on prend toutes les valeurs à la bourrin
        # évidemment vous pourrez améliorer la classe hein
        # Dans votre cas, ce sera peut-être pas utile

        # Pour chaque argument nommé reçu, on va faire quelques
        # tests et les injecter dans la classe en tant que **proriété**
        for name, val in kwargs.items():

            # Par exemple l'argument doit être dans les annotations
            # On peut s'en passer, là c'est pour vous
            # montrer comment on peut "forcer la déclaration", si pas
            # d'annotation => je refuse l'attribut
            if name not in self.__annotations__:
                raise Exception(f"Undeclared attribute {name}")

            # et/ou  on vérifie que le type est bon
            if isinstance(val, self.__annotations__[name]):
                wanted = self.__annotations__[name]
                raise Exception(f"Bad type for {name}, want {wanted}")

            # tout est bon, on assigne l'attribut à l'objet
            setattr(self, name, val)

    def todict(self):
        """ Transforme en dictionnaire """

        # C'est là que c'est intéressant, je peux par exemple ne prendre
        # dans mon dictionnaire, que les valeurs qui ont une annotations
        data = {k: getattr(self, k) for k in self.__annotations__}
        for k, v in data.items():
            # et si l'attribut a "todict", on l'appelle
            if hasattr(v, "todict"):
                data[k] = v.todict()

        return data

    def save(self):
        """ là c'est un exemple hein """
        return json.dumps(self.todict(), indent=4)

Vous pouvez tenter de faire ceci:

u = User(name="Sarah", lastname="Connor", email="terminator@skynet")

# et là ça passe
print(u.save())

# affiche:
# {
#     "name": "Sarah",
#     "lastname": "Connor",
#     "email": "terminator@skynet"
#
# }

Maintenant faisons notre classe “Project” qui contient un “User”:

class Project(JSONizer)
    name: str
    owner: User # là

Comme l’attribut “owner” est de type “User” et que “User” hérite de “JSONizer”, on trouvera la méthode “todict()” . Et comme la fonction de cet objet enfant va aussi vérifier ses propres enfants, tous les objets vont être transformés.

Parfois le développement parait magique…

Et par conséquent:

u = User(name="Patrice", lastname="Ferlet", email="me@foo")
print("L'utilisateur:", u.save())

p = Project(name="Website", owner=u)
print("Le projet:", p.save())

Ce qui nous produit:

L'utilisateur: {
    "name": "Patrice",
    "lastname": "Ferlet",
    "email": "me@foo"
}
Le projet: {
    "name": "Website",
    "owner": {
        "name": "Patrice",
        "lastname": "Ferlet",
        "email": "me@foo"
    }
}

On voit bien que l’objet “User” est dans l’objet “Project”.

Bien entendu vous faites comme vous le voulez, par exemple au lieu de coller l’objet vous pourriez prendre l’ID qui vient de la base de donnée de cet objet, ou faire une transformation qui vous amuse. Rien n’est interdit (si, mais bon vous me comprenez).

Changeons donc la méthode “todict()” pour illustrer mon propos, par exemple je ne vais garder que le champs “name"de l’utilisateur dans le Projet :

    def todict(self):
        """ Transforme en dictionnaire """
        data = {k: getattr(self, k) for k in self.__annotations__}
        for k, v in data.items():
            if hasattr(v, "name"):
                data[k] = v.name

        return data

Et on aura donc en sortie:

L'utilisateur: {
    "name": "John",
    "lastname": "Ferlet",
    "email": "me@foo"
}
Le projet: {
    "name": "Website",
    "owner": "John"
}

On a toujours le risque d’écraser une propriété parente, je ne le nie pas. Mais…

ma classe “JSONizer” ne va pas garder beaucoup de propriétés, elle est faite pour “transporter” des données, le risque est minime en soit

je vais de toutes manière préfixer mes propriétés par un double underscore pour les rendre privées

On va aller un peu plus loin

Bon maintenant vous vous dites que c’est cool, mais vous aimeriez mettre d’autres annotations. Mieux encore, vous aimeriez décider quelle propriété mettre dans l’export, et ignorer les autres.

Et bien c’est pas compliqué, on va commencer par fair un type (une classe) qui va nous permettre d’identifier que l’attribut annoté est une propriété à exporter en JSON.

class JSONProp:
    pass

Reste à changer l’implémentation de la classe JSONizer, on va maintenant accepter toutes les annotations de tous les types, on ne contrôle pas le contenu. Par contre, la méthode todict() va filtrer les propriétés annotées en tant “JSONProp” - vous allez voir la souplesse du bousin.

Dans vos développements, bien entendu, le constructeur qui prend en paramètre les valeurs à assigner peut être supprimé. Je l’ai mis ici pour réduire la taille des exemples et ne pas assigner les valeurs ligne par ligne.

class JSONizer:
    def __init__(self, **kwargs):
        # cette fois j'accepte tout
        for name, val in kwargs.items():
            # on accepte tout, pas de contrôle de type
            setattr(self, name, val)

    def todict(self):
        annotations = self.__annotations__

        # et là je filtre
        data = {
            key: getattr(self, key)
            for key, kind in annotations.items()
            if kind is JSONProp
        }
        for k, v in data.items():
            if hasattr(v, "todict"):
                data[k] = v.todict()

        return data

    def save(self):
        return json.dumps(self.todict(), indent=4)

Et je vais maintenant faire en sorte que seules les propriétés “name” et “lastname” de la classe “User” soient dans mon export JSON :

class User(JSONizer):
    name: JSONProp
    lastname: JSONProp
    email: str # Cette propriétés sera ignorée
               # On pourrait d'ailleur la virer tiens...

Maintenant, u.save() ne me retournera pas l’email. C’est une annotation “autre” dont je me fous royalement.

Heu OK, mais pour avoir plusieurs types dans une annotation ?

Et ouais, ce qui serait cool maintenant, c’est que l’annotation puisse contenir une liste de types, comme ça je peux dire que le champs “name” est une chaîne et en plus que c’est une propriété à exporter:

class User(JSONizer):
    name: (str, JSONProp)
    lastname: JSONProp # là on se fout du type
    email: str # et ça c'est pas exporté

Et bien il suffit de changer la méthode todict et remplacer le filtrage par :

data = {
    key: getattr(self, key) # on prend l'attribut
    for key, kind in annotations.items() # dans les annotations
    if kind is JSONProp or (isinstance(kind, tuple) and JSONProp in kind)
    # ↑ si le type est un JSONProp, ou que c'est un tuple et que JSONProp s'y trouve
}

Voilà, pas plus compliqué…

Et là, un truc intéressant, c’est que vous pouvez faire du type checking. Vous pouvez donc faire hériter vos classes de JSONizer qui gère les JSONProp + hériter d’une autre classe qui va vérifier les types que vous injectez. Ça peut aller très très loin !

Ça t’as vraiment servi ?

Oui. J’ai un projet qui utilise une base de données que j’adore vraiment, RethinkDB. Cette base orientée document ne prend en charge que des types “natifs” aux langages que vous utilisez (chaines, entiers, flottants, dates…) - cela réduit fortement les contrôles à effectuer. Du coup j’ai créé mon propre système de modèle.

J’avais commencé à utilisé la méthode de SQLAlchemy, mais quand j’ai repensé mon implémentation, et que j’ai utilisé les annotations, tout est devenu plus élégant. Dans mon cas en tout cas.

Un objet injectable en base (donc qui hérite de “Model”) ressemble à ça:

class User(Model):
    username: (str, Unique, NonNull)
    email: (str, Unique, NonNull)
    password: (str, NonNull)
    verified: bool

    def login(self, username, password):
        """ Needed method to log in user """
        found = self.filter({
            "username": username,
            "password": SHA(password),
        })
        if len(found) > 0:
            # return the found user
            return User(**found)

        # not found user
        return False

J’ai créé quelques classes dérivées du genre “Unique” qui demande un contrôle de l’existence en base de tel ou tel attribut d’un objet, et la classe de base ajoute des champs qui me plaisent comme “createdAt, updatedAt, deletedAt” dans sa méthode “save()”. Méthode qui en plus sait faire un insert ou update en fonction de la valeur de l’ID de l’objet… Bref un truc fun et très facile à maintenir.

Il aurait été possible, bien entendu, d’utiliser des propriétés statiques comme je vous le dis plus haut. Mais les annotations me permettent de réduire le code de contrôle des champs et de ne pas avoir à tout typer. Bref c’est très adapté à ma façon de coder. Je préfère taper (str, NonNull, Unique) que StringValue(null=False, unique=True) par exemple, je trouve les annotations plus “jolies”.

Ce qui est cool

Ce qui est cool, c’est que la classe “JSONizer” et la classe “JSONProp” sont juste deux types à utiliser sans se prendre la tête. Tous vos objets déjà existants vont pouvoir utiliser les annotations pour définir ce que vous voulez sortir en JSON, sans ajouter de méthode. Vous avez juste à annoter vos objets pour définir ce qui doit être exporté, et comment. Je vous rappelle que la méthode “save()” peut être nommée comme vous le souhaitez, et que rien ne vous interdit de transformer les valeurs de l’objet.

Alors attention, ce que je vous mets dans l’article c’est un exemple, à vous de faire un truc plus propre, plus adapté, avec les contrôles qui vous chantent.

T’es sûr de toi ?

Les annotations servent déjà au “type checking” dans certains IDE (y compris vim quand on sait faire 😜), il est donc assez naturel de les utiliser pour faire tu type checking par introspection sur les annotations.

Évidemment, la méthode qu’utilise SQLAlchemy est très puissante. Les propriétés statiques permettent de ne pas avoir un type mais un objet qui contient de la configuration de champs (par exemple, donner une longueur maximale de chaîne, dire si un champs est unique, etc…) - En soit, les annotations sont surtout un outils pratique, peu coûteux en mémoire et facile à appréhender.

J’aime beaucoup le fait de pouvoir, par exemple, générer du JSON en définissant quelles propriétés sortir, sans avoir l’erreur XXX is not JSON Serializable. Et comme je vous le disais, c’est aussi intéressant pour faire un système custom de modèle de base de données.

Par contre, je ne dis pas qu’il faille les utiliser pour tout et n’importe quoi. Les annotations sont utiles pour du type checking et, à la limite, du filtrage, elle ne peuvent contenir que des “types” ou “tuple de types”, pas des instances. Sinon, passez par des propriétés statiques !

PS: quand tout sera bien testé, je pense vous proposer en open source mon package “RDBModel” pour Python 😇

Voilà !

De Flask À Quart - pourquoi pas, surtout pour les Websockets

Mon, 21 Dec 2020 11:12:01 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Flask est certainement l’un des frameworks les plus connus dans le monde de Python, mais connaissez-vous Quart, compatible Flask, qui gère l’asychronisme ? Vous allez voir à quel point c’est bénéfique, notamment pour la gestion des WebSockets.

Flask a été pour moi l’une des plus grosses révélations quand je suis passé de PHP à Python, il y a déjà fort longtemps. C’est un framework facile à apprendre, à comprendre, léger, souple, qui permet d’écrire des API REST ou un site avec un rendu “server side”. Il intègre Jinja2 et vous avez un paquet de “plugins” pour gérer l’authentification, les CORS, et j’en passe. Bref, Flask, c’est le pied total. Jusqu’au moment où vous avez envie de faire des trucs “en parallèle”, par exemple gérer des ServerEvents ou des Websockets.

Oui, on peut le faire avec Flask, je ne dis pas le contraire. Mais Python propose depuis quelque temps une écriture native pour faire de l’asynchrone (des coroutines), je vous en ai parlé et je vous invite à vraiment vous pencher sur la question.

Et c’est là que je tombe sur Quart.

Oh non, encore un framework !

Ouais mais non. Je suis, moi aussi, peu enthousiaste à devoir passer d’un framework à l’autre. D’autant que la syntaxe de Flask est idéale pour moi. Mais justement, Quart utilise quasiment la même syntaxe. Je dis “quasiment” parce que finalement, la seule chose qui change c’est le fait de déclarer nos fonctions (nos routes) en coroutine.

Je vous fais un résumé simple.

# Avec Flask
from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Hello"

# Avec Quart
from quart import Quart

app = Quart(__name__)

@app.route("/")
async def index():
    return "Hello"

Voilà, à part le nom du framework et un “async” qui traine, rien de bien nouveau.

Alors, me direz-vous, ça change quoi ?

Et bien, de part sa nature asynchrone, Quart va vous soulager grandement pour gérer des tâches qui peuvent tourner en tâche de fond, comme pour les ServerSide Events, ou les websockets.

Les websockets

Flask, de base, nativement, ne peut pas gérer des websockets. Il vous faut un package supplémentaire (e.g. SocketIO).

Quart inclue un module de websocket, et il est… Comment dire… Très naturel à utiliser.

Alors, soyons précis, je le trouve idéal car il me permet de gérer la logique moi-même, chose que beaucoup n’aime pas. Je le comprends. J’ai un plaisirs fou à coder les logiques de base, alors que d’autres aiment utiliser les implémentations clef-en-main. C’est une question de goût et d’habitude.

Donc, à mon sens, la logique de Quart est plus adaptée à ma manière de travailler. Bref, comment ça marche ?

De la même manière que l’objet “request” dans Flask et Quart, il existe un objet websocket qui utilise le contexte. De ce fait, quart.websocket sera utilisé au sein d’une route pour:

reçevoir des messages avec websocket.receive() (asynchrone)
envoyer des messages avec websocket.send(data) (asynchrone)

Comme je vous le disais, il faut gérer la logique de base. En général, vous voulez envoyer des données à tout moment à vos clients connectés.

L’exemple donné dans la page de documentation dédiée au sujet est assez basique, et ne reflète pas forcément le besoin que vous aurez. Pour ma part, l’envoi et la réception d’info sont décorrélés. Donc, je fais comme ça :

je crée une route de connexion, par exemple sur “/ws”
je crée une asyncio.Queue qui servira au serveur à envoyer des données à la connexion
je crée deux coroutines qui vont gére la réception et l’envoi

Vous allez voir c’est pas si compliqué :

import asyncio
import json
from datetime import datetime

from quart import Quart, copy_current_websocket_context, websocket

app = Quart(__name__)


async def manage(data, queue):
    # Ici, je gère les message reçus depuis le client.
    # Si le client m'envoie une clef "hello" je lui répond
    # par un "hello"
    # Pour envoyer au client, j'écris simplement dans une Queue.
    if data.get('hello'):
        await queue.put({"response": "Hello %s!" % data['hello']})
    else:
        await queue.put({"response": "What ?"})


async def ping(queue):
    # Là c'est un exemple de fonction qui peut tourner en tâche de fond
    # pour envoyer des données, de manière asynchrone, au client.
    while True:
        await asyncio.sleep(5)
        await queue.put({"response": "ping %s" % datetime.now()})


@app.websocket('/ws')
async def ws():

    # Queue qui permet aux coroutines d'envoyer des data
    # au client.
    queue = asyncio.Queue()

    @copy_current_websocket_context
    async def recv():
        # Ici, on va attendre indéfiniment que le client
        # envoie des données. Quand on en a, on la traite
        # avec la fonction "manage".
        while True:
            message = await websocket.receive()
            await manage(json.loads(message), queue)

    @copy_current_websocket_context
    async def send():
        # Ici, on attend que des données entrent dans la queue,
        # quand on nous envoie des infos, on les envoie au client.
        while True:
            data = await queue.get()
            await websocket.send(json.dumps(data))

    # ici, je crée mes tâches concurrentes
    producer = asyncio.ensure_future(send())
    consumer = asyncio.ensure_future(recv())
    pinger = asyncio.ensure_future(ping(queue))

    # là, je vais attendre qu'un coroutine se viande, si c'est le cas
    # c'est que le client a coupé la connexion (ou l'a perdu)
    try:
        await asyncio.gather(producer, consumer, pinger)
    finally:
        producer.cancel()
        consumer.cancel()
        pinger.cancel()

Pour les deux coroutines qui utilisent le websocket, je dois utiliser copy_current_websocket_context pour ne pas perdre le contexte, c’est un “souci” commun dans ce genre d’application, mais ce décorateur fait ce qu’il faut pour ne pas avoir à trop se prendre la tête.

Si jamais vous voulez sortir les fonctions de la fonction mère, vous pouvez, mais dans la création de tâche, vous devrez utiliser le décorateur en tant que fonction, par exemple:

producer = asyncio.ensure_future(
    copy_current_websocket_context(producer)()
)

Et si vous avez un argument à passer, genre la queue, faut passer par functools.partial:

send_func = functools.partial(send, queue)
producer = asyncio.ensure_future(
    copy_current_websocket_context(send_func)()
)

Mais en règle générale, je préfère créer une toute petite fonction de dispatch, comme dans l’exemple que je vous ai donné.

Revenons au code de l’exemple ci-dessus, et voyez la fonction “ping” qui peut tourner en arrière-plann et qui envoie un message toutes les 5 secondes.

Le plus important reste les deux coroutines recv et send qui gèrent, en concurrence, l’envoi et la réception de données. La asyncio.Queue est très importante, mais aussi très pratique. Inutile de balader un objet de connexion de websocket, on va simplement stocker les messages dans une file d’attente qui part vers le client.

Coté JS, c’est pas compliqué :

let w = new WebSocket('ws://127.0.0.1:5000/ws');
w.onmessage = data => {
    console.log(data.data)
}
w.send(JSON.stringify({
    "hello": "John"
}))

Si vous avez besoin d’un “broadcast”, c’est-à-diree une fonction qui envoie à tous les clients, l’idée est de faire ceci :


# en haut, en globale
QUEUES = set()


# dans la fonction "ws()" qui gère la websocket:
queue = asyncio.Queue()
QUEUES.add(queue)

# et dans le finally en fin de fonciton, quand la connexion est perdue,
# on vire la queue de la liste:
    try:
        await asyncio.gather(producer, consumer, pinger)
    finally:
        producer.cancel()
        consumer.cancel()
        pinger.cancel()
        QUEUES.remove(queue)

Et donc, imaginons une fonction de broadcast :

async def broadcast(message):
    for qeue in QUEUES:
        try:
            await queue.put(json.dumps(message))
        except:
            pass

Voilà, tous les clients vont avoir le message.

Je passe à Quart ou je reste sur Flask ?

Ça dépend. Flask est éprouvé, bénéficie d’une large communauté, et il a des plugins d’une puissance extrême. C’est facile à gérer, surtout quand on pas l’habitude (ou l’envie) de bosser avec des tâches asynchrones.

Cela-dit, Quart est très proche de Flask (c’est un fork hein), et les développeurs n’entrent pas en conflit avec ceux de Flask, au contraire ils collaborent étroitement. Quart commence à se faire entendre, et il vous permet d’exploiter la puissance des coroutines Python. Côté Websocket et ServerSide events, c’est à mon avis la meilleure approche à avoir. Pas de thread à gérer, et vous avez la maitrise de la logique métier.

Je retrouve avec Quart ce que j’adore avec Go et les websocket en coroutines. C’est donc clairement un avis personnel lié à mes goûts.

Alors, à mon avis, la meilleure chose à faire de votre côté est de tester. Si vous n’aimez pas, restez sur Flask et les packages adéquats. Si vous aimez les coroutines et le fait de ne pas avoir à gérer des packages externes, peut-être allez-vous aimer Quart 🤓.

Je Pars De Twitter, Et Je Rejoins Mastodon

Wed, 04 Nov 2020 13:34:24 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

C’est décidé, je quitte Twitter et je rejoins Mastodon. Je vous explique…

Trop long de tout lire ? Je suis désormais ici, https://techlover.eu/@metal3d, et mes messages partent sur Twitter, mais je ne répondrai plus sur Twitter. Si vous voulez créer un compte Mastodon, cherchez une communauté qui vous intéresse (vous pourrez vous abonner à n’importe quel compte de n’importe quelle instance) ou alors demandez moi un code d’invitation sur mon instance.

Si vous voulez comprendre ce qu’est Mastodon, lisez la suite.

D’abord, pourquoi je quitte Twitter ?

Je me suis inscrit sur Twitter en 2009. J’aimais beaucoup l’accès à des “infos rapides”, l’humour de certains messages, le fait de trouver des nouveautés, l’échange d’idées.

Mais, un peu comme tout, Twitter avait déjà quelques travers.

D’abord une limite dans le nombre de caractères pour un message qui était un poil ridicule (140 caractères au début, puis 250 aujourd’hui, et ça reste trop léger pour moi) qui était intimement liée au nombre de caractères limite des… SMS… Aussi, une modération quasi inexistante. Et petit à petit, l’oiseau a fait son nid (poudoum pchit), et des gens de tous bords sont arrivés pour y déverser des idées sombres, des informations tronquées ou falsifiées, des théories du complot vaseuses, et l’échange est devenu bien plus aggresif.

J’ai tenu bon, nettoyé ma timeline (le fil d’actualité si vous voulez), placé des filtres sur certains mots clef, et j’ai blacklisté à peu près 120 personnes en 11 ans.

Et là, depuis quelques mois, c’est carrément une souffrance pour moi. Des proches ou des connaissances de longues dates, des gens qui parlaient avant tout des sujets que j’apprécie (tech, 3D, ML, mais aussi films, science…) ont commencé à devenir très très très virulents et militants. Contre le gouvernement, contre la science, contre les médecins, contre tout… Et je passe outre la missandrie et la machisme (que je place dans le même panier).

Marre… vraiment j’en ai marre. Marre de voir des ministres étrangers traiter un prédident de fils de chienne, marre qu’une discussion soit systématiquement marquée comme du mansplaining, marre des VeloTaffeurs dans le dénis, marre des chasseurs qui veulent passer pour des héros, marre…

La modération de ces plateformes, trop larges, est une catastrophe. Que ce soit Youtube, Twitter, Facebook… Une seule entité avec des millions, voir milliards d’individus à modérer, c’est comme si vous n’aviez qu’une seule caméra de suveillance pour veiller sur l’entrée, les stocks, la porte de derrière, dans le brouillard et avec des coupures de courant.

D’où le fait de tenter l’expérience d’un système plus adapté à l’internet actuel, la décentralisation qui permet d’avoir une modération efficace car la population est groupée par instance (je vais vous expliquer, c’est super simple)

Du coup, il me fallait trouver un autre réseau social, un endroit moins occupé, clair, avec un peu plus de caractères pour m’exprimer et répondre, mais surtout de la modération. Je ne veux pas de censure¹, mais je veux une plateforme où des gens réactifs peuvent clairement désaturer le service et diriger les sujets en fonction de mes choix. Et j’ai opté pour Mastodon.

Donc, je pars sur Mastodon

Et je rejoins 4 millions d’utilisateurs, c’est moins que les 330 millions de Twitter, certes, mais quantité vs. qualité, tout ça…

Le principe est quasi identique à Twitter dans la forme (affichage, utilisation, règlement), mais avec des points qui sont chers à mon coeur:

opensource (Licence libre - AGPL-3.0)
pas de publicité
modération selon l’instance (on va en reparler après)
500 caractères (sérieux… 250 caractères chez Twitter c’est infâme)
des communautés définies
le contenu flouté si “sensible”
ne pas être enchaîné à une plateforme, à des admins incompétents, ou à une politique de service qui ne me correspond pas - si je veux changer de communauté, je peux partir et ne pas perdre mes abonnés.
et par conséquent, ne pas être obligé de maintenir mon instance si j’en ai marre - si j’en ai marre, je démanage mon compte sur une autre instance sans perdre mes abonnements/abonnés

Mastodon répond à ça: c’est décentralisé (je vais vous expliquer), ce qui permet donc à tout le monde d’avoir son propre serveur ou de s’inscrire sur un serveur existant (perso, j’ai créé mon instance https://techlover.eu) tout en ayant accès à ceux qui sont inscrits ailleurs. C’est tout simplement génial.

Pour info, comme énormément d’outils libres et/ou opensource, c’est un européen qui l’a créé (un allemand) nommé Eugen Rochko. Entre Linux, Python, PHP, et j’en passe… ça en fait des projets du vieux continent qui sont dans la place hein !

Alors la décentralisation cékoidonc ?

Twitter, c’est une seule place, un seul endroit, pour s’incrire et échanger. Donc le réseau, et les comptes, appartiennent à une seule entité: Twitter (qui exploite en plus vos profiles à des fins commerciales). Vous n’avez pas le choix: tout le monde parle de tout, c’est un bordel infâme, on vous colle des pubs, on vous insulte sans réaction de la part des modérateurs.

Mastodon (mais d’autres services existent dans le même genre) ça change pas mal.

Vous pouvez vous y inscrire depuis plusieurs endroits différents, par exemple sur https://mamot.fr qui est l’instance de la quadrature du net, mais aussi https://mastodon.top ou https://mastodon.iriseden.eu/ qui est hébergé par OVH. Et quelque soit l’endroit où vous vous inscrivez vous aurez accès aux autres instances et aux comptes qui s’y trouvent, donc vous pouvez vous abonner à un compte, le masquer, échanger avec tout le monde, etc… Le principe n’est pas de vous isoler sur une instance, mais d’avoir des contenus proposés plus en adéquation avec votre envie, tout en ayant accès aux autres communautés

Si Alice est chez mamot.fr, et Bob sur techlover.eu, ils peuvent s’abonner entre eux, échanger, discuter… c’est le principe de la décentralisation.

Sinon, faites comme moi (si vous êtes à l’aise avec la technologie), créez votre propre instance avec votre propre règlement.

Oui, cela veut dire que Mastodon appartient aux utilisateurs et non pas à une entreprise

Petite différence avec Twitter, sur une instance Mastodon, il y a deux listes:

une liste “locale” de messages, qui présente le contenu de ce serveur
une liste “globale” de messages qui provient des autre serveurs, fédérés

Cette liste de messages, c’est une liste de “pouets” (toot en anglais), l’équivalent d’une liste de “tweet”. C’est rigolo comme terme 🤡

Vous pouvez visiter librement les fils des gens, et vous abonner à l’un deux (comme sur Twitter donc). Je ne vais pas détailler trop longtemps, mais dans les faits les serveurs s’envoient les listes entre eux.

Dans le fonctionnement, en tant qu’utilisateur, on est très proche de Twitter. Vous pouvez “poueter” (au lieu de “twitter”), vous pouvez retransmettre, vous pouvez répondre, parler en privé, balancer des vidéos, des images, des liens… C’est pareil, mais en plus joli, avec plus de caractères pour vous exprimer et c’est bien plus adapté à l’échange.

Vous avez aussi le droit de déménager votre compte, donc de partir de mamot pour aller sur votre propre serveur par exemple. Et vous ne perdrez ni vos abonnés, ni vos abonnements.

Attention, une instance peut potentiellement ne rien afficher (un temps) en “globale”, tout simplement par ce que la fédération n’est pas activée, qu’elle refuse certaines instances, ou simplement qu’elle est jeune et que les messages ne sont pas encore là. C’est un défaut/avantage de Mastodon: pour que la fédération fonctionne, il faut que des gens se connectent entre-eux d’instance en instance, et par conséquent une instance jeune n’a RIEN en globale… C’est frustrant pendant un temps. Mais d’un autre côté, vous n’êtes pas noyé par des flux qui ne vous intéressent pas du tout, parce que l’instance ne liste que des contenus proches de votre préférence/communauté.

Ça vous évite aussi une polution de messages bien nazes puisque généralement votre communauté (instance) colle à vos préférences.

On parle de suite de la complication

Alors, je ne vais pas non plus vous vanter la puissance de Mastodon tout en vous cachant les points plus compliqués, parce qu’il y en a.

D’abord, pour le commun des mortels, l’idée de s’inscrire sur une communauté ou instance, c’est pas une notion évidente. Car quand vous arrivez, par exemple, sur mamot.fr, vous voyez des contenus qui ne sont pas forcément les mêmes que sur l’instance techlover. La raison est simplement que chaque instance ne fédère une autre instance que lorsque qu’un membre s’abonne à un compte de l’instance en question. Et ça, c’est pas évident du tout.

Mon instance, Techlover, est récente, je n’ai pas de membres autres que mon compte. Donc, pour que le fil “global” se remplisse, il faut que je trouve des comptes à suivre sur d’autres instances.

Si vous vous inscrivez sur une instance plus ancienne ou connue, vous n’aurez pas ce souci.

Et donc, si une personne non informée de cette spécificité ne le sait pas, elle ne trouvera aucun contenu intéressant sur mon instance. Il va devoir aller sur d’autres instance par lui-même, chercher des contenus, et suivre un compte qui lui plait. Et seulement à ce moment, mon instance va essayer de férerer l’instance cible.

Donc, un débutant, je ne lui recommande pas de monter sa propre instance ou de s’inscrire sur une instance avec peu d’utilisateurs, mais d’aller sur une instance proche de son envie et avec beaucoup d’inscrits (puis de déménager son compte si il le souhaite)

Mais sur une instance très utilisée, aucun souci - c’est relativement facile.

Autre complication, le “déménagement de compte”, qui marche plutôt bien, mais on perd les anciens “toots” qu’on a publié… Il sont bien entendu toujours consultables sur l’ancienne instance, mais je trouve ça dommage. J’avais publié des trucs sur mamot.fr, ils ne sont pas consultables sur mon instance 😞

Et le dernier truc, qui suit du coup les points précédents, c’est que voilà… faut trouver des comptes pour s’y abonner. Si vous êtes sur une grosse instance avec plein d’inscrits, c’est très simple. Le principe de fédération va vous permettre d’avoir énormément de toots et de comptes dans le fil global. Mais si, comme moi, vous montez votre propre instance, avec très peu de comptes (genre 1 dans mon cas…) alors il va falloir vous ballader un peu sur des instances connues pour trouver votre bonheur. Et comme vous n’avez pas accès à un moeur de recherche sans être inscrit… ça peut devenir une quête de longue haleine.

Je vous conseille, donc, si vous êtes un débutant, d’aller vous inscrire sur une instance réputée, large, et qui correspond à vos attentes. Vous pouvez en trouver ici: https://joinmastodon.org/communities

Et ne créez une instance que si vous êtes technicien, prêts à fouiller et relativement patient.

Me trouver ?

Pour voir mon profile: https://techlover.eu/@metal3d

En quelques jours, j’ai déjà trouvé des gens intéressants, des gens qui sont aussi sur Twitter et que je suivais. Il y a des “bots” qui retransmettent des tweets de quelques comptes. Bref, je vais rester là bas un moment. Alors… oui, il y a aussi des gens qui partagent des trucs avec lesquels je ne suis pas d’accord, de la virulence envers les politiques, etc… mais c’est beaucoup plus facile de s’en échapper, d’ignorer et/ou à signaler à la modération. Et comme maitenant j’ai mon instance à moi, je sais que je vais vraiment pouvoir me couper de ces discussions débiles sur les vaccins qui tuent des gens, la 5G pour nous contrôler, Raoult notre sauveur…

Ha, aussi, je viens de découvrir https://crossposter.masto.donte.com.br qui permet de faire du “cross post”, donc quand je “prout” sur Mastodon, ça balance un tweet aussi. Et vous pouvez bien entendu faire l’inverse. C’est paramétrable.

C’est assez sympathique de ne pas perdre trop de communication. Seul “hic”, on ne récupère pas les réponses de Twitter dans Mastodon (mais ce serait un beau bordel si c’était possible). Donc l’idée est de répéter ou d’épingler un tweet sur Twitter pour dire au gens “je suis plus là, mais sur Mastodon, voici l’adresse de mon profile”.

Bref, si vous me trouvez sur Twitter, c’est ce qui va apparaitre.

Niveau applications mobiles et bureau ?

Il existe bien entendu des applications mobiles, j’ai choisi Tusky sur Android, mais je vous laisse voir le lien précédent pour trouver celui qui vous convient le mieux. Et côté bureau, une simple “SSB” (ou PWA) me suffit, mais il existe Whalebird que je trouve très intéressant.

Mais je ne me voile pas la face

Il y a des comptes que j’aime énormément sur Twitter, comme Scilabus, E-Penser, Defakator, et j’en passe - je ne les trouve pas sur Mastodon. C’est triste mais je vais perdre leurs actualités, et potentiellement des échanges sympas. Mais Twitter les noit dans un flot nauséabond de débilités sans nom. Viendront-ils un jour sur une instance Mastodon ? J’en sais rien, je le souhaite mais je comprends aussi que leurs abonnés sont sur des réseaux sociaux plus massivement utilisés.

J’ai vu que Defakator et E-Penser ont des bots qui renvoient les tweets sur Mastodon, mais celui de E-Penser semble mort, et celui de Defakator est à 0 abonnés… Étrange…

Je sais aussi que très peu de gens vont me suivre. J’avais une petite audience sur Twitter, je vais donc avoir moins d’interactions avec eux. C’est triste pour moi.

Oui mais, bon sang, ce n’est pas une fin en soit. Cette volonté de popularité ne m’interesse pas. Oui j’aime avoir des gens qui discutent avec moi et qui s’abonnent (ça veut dire que je suis, pour ces gens, une source potentiellement intéressante, et je peux pas nier que c’est gratifiant), mais mon but c’est surtout d’avoir une vraie qualité d’échange.

Je préfère avoir 10 abonnés avec qui on discute clairement, que 500.000 avec qui l’échange est une joute verbale sans fin.

(bon ok, avoir 500.000 abonnés avec qui on parle sans souci, ce serait encore mieux, mais là c’est de l’utopie totale)

Pour les techniciens

Juste un point, pour ceux qui en ont envie, puisque Mastodon est opensource et libre d’accès, vous avez tout à fait le droit de démarrer votre propre instance, avec vos propres règles, vos modifications, etc. J’ai testé l’installation avec le “helm chart” proposé dans les sources, et ça marche très bien sur Kubernetes. Mais vous pouvez démarrer votre instance “brute” ou avec Docker.

Il est possible de “fermer” votre instance à toute fédération entrante ou sortante, donc de faire un réseau social interne, ou limité à certains.

Il est donc tout à fait possible d’avoir un réseau social d’entreprise, fermé au monde - et bien entendu, un réseau social pour votre club de cracheur de noyau de cerise, etc.. Vous choisissez si oui ou non on peut s’y inscire librement, par invitation… Vous êtes LIBRE.

J’ai monté mon instance avec un helm chart proposé par le projet Mastodon, je l’héberge sur Kapsule (de scaleway) et cela demande 3 noeuds (donc c’est pas léger hein)

Mais si vous avez un serveur sous la main qui tient le choc, que ce soit dans votre entreprise ou pour votre association, votre groupe de potes, ou ce que vous voulez, c’est très simple à mettre en place. Je vous conseille quand même Kubernetes qui permet d’avoir de la haute dispo sans trop forcer, et de pouvoir scaler votre instance.

Petite note importante, le gros intérêt d’avoir son instance, c’est que vous pouvez bannir un compte, ou une instance entière, pour votre communauté. Cela supprimera purement et simplement le lien de férédation entre vous et l’instance ou le compte incirminé. Certains parlent de censure, je le répète:

Ne confondez pas censure et modération

Techlover ?

Je voulais m’éviter les messages militants, mamot.fr en a un peu trop à mon goût. Je ne trouvais pas spécialement d’instance qui collait à mes envies, alors j’ai créé mon instance https://techlover.eu

J’ai bloqué l’inscription, mais vous pouvez demander une invitation, à condition de lire les conditions d’inscription (éviter le militantisme, les messages agressifs contre la politique ou la religion, sans pour autant les interdire, je demande à ce que cette instance soit cool) mais aussi d’accepter que cette instance est un test (pour le moment). Je ne sais même pas si la procédure de demande d’invitation fonctionne correctement (j’ai pas tout testé). Pour le moment cette instance est donc limitée à moi, et potentiellement quelques élus.

Mais vous pouvez me suivre depuis les autres instances (je n’arrête pas de vous dire que vous pouvez vous inscrire n’importe où et suivre les autres comptes d’autres instances), donc mon compte est là https://techlover.eu/@metal3d

Je vais potentiellement me faire un second compte pour mes travaux “créatifs” (Blender en grosse parite), mais le compte @metal3d est le compte principal (et administrateur de la plateforme).

Je ne vais pas supprimer mon compte Twitter

Honnêtement, je suis parfaitement conscient que Twitter est largement plus utilisé que Mastodon, et que ça va durer des années. Me couper de Twitter et donc de potentiels abonnés est une chose que je veux éviter. Alors comment je vais faire ?

Pour l’heure, je laisse le “bot” pousser mes messages de Mastodon vers Twitter, et je vais régulièrement pousser un message pour dire que je ne répond plus là bas. Et je vais aussi changer mon profile Twitter pour inciter les gens à venir sur Mastodon au lieu de me suivre sur Twitter.

Pour finir

Désolé à ceux qui interragissaient avec moi de manière plaisante sur Twitter, mais ce raz-le-bol m’a poussé vers la sortie. Créez vous un compte quelque part et installez Tusky ou Whalebird pour garder le contact. Ça ne vous coute rien, c’est bien plus sécure que Twitter ou Facebook.

Je ne peux que vous inciter à faire grandir le réseau Mastodon. Si votre seule raison de rester sur Twitter est d’avoir une grosse audience, je le comprends. Mais si vous voulez des échanges avec des communautés plus adaptées, plus proches de votre domaine, ou de vos passions, alors je ne vois aucune raison de ne pas vous créer un compte.

Je vous rappelle que le réseau fédéré Mastodon permet de vraiment supprimer votre compte, de démanager votre compte, de choisir ce que vous verrez, de pouvoir interragir avec la modération des instances, et que tout ça est opensource.

Merci à vous de m’avoir lu, merci à mes followers Twitter de comprendre mon choix.

Ressources

La censure c’est très différent de la modération. La modération exclut un domaine, alors que la censure interdit une opinion. ↩︎

Firefox SSB ou PWA - C'est quoi et comment on s'en sert ?

Thu, 22 Oct 2020 12:25:32 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Chrome propose de transformer une page web en application depuis des lustres, mais Firefox permet aussi de faire à peu près pareil. C’est pas si compliqué… Vous pouvez le faire ! (et pas besoin d’être développeur)

Bon, cet article est aujourd’hui désuet car Firefox abandonne le support SSB, ce qui a pour conséquences:

de me mettre très en colère, je ne vois pas comment Firefox peut luter contre Google Chrome (et ses dériviés) si il abandonne des features qui sont supportées par tous les concurrents
de me faire abandonner purement et simplement ce navigateur qui fait tout pour m’empêcher d’utiliser le Web comme je l’entends

Donc, cet article est toujours bon pour les informations pratiques, mais pas pour la méthode qui va tout simplement disparaitre. Donc pour ma part, et tant pis pour les détracteurs, je vous recommande “Brave”, qui est une très bonne mouture dérivée de Chromium (donc la forme open source et libre de Chrome, avec le moteur Blink), qui permet la création de SSB/PWA en deux cliques.

Firefox n’est pas pour moi…

Rien compris, explique !

Un site web à la base, c’est en gros des pages liées entre elles avec des “liens”, voilà… mais les technologies WEB ont évolué à une vitesse folle. Aujourd’hui, une page peut jouer des sons, des vidéos, des animations en 3D, interagir avec des serveurs sans quiter la page (chatroom, interactions…), vous pouvez même éditer des documents, des tableurs, faire du travail photo, sur une “page web”. On est donc en train de parler d’application bien plus que de site web.

Mais alors elle est où la différence entre, par exemple, votre Excel et Google Sheet (tableur de Google) ? Et bien simplement que pour Excel, vous avez “installé” un logiciel, alors que pour Google Sheet, vous devez visiter un site web qui fourni, dans le navigateur une interface qui est l’application de tableur.

OK ? Bon maintenant, imaginons que je vous donne une application que vous installez sur votre PC, mais qui affiche Google Sheet sans que vous ayez à ouvrir la page internet ?

C’est ce que l’on appelle une PWA (Progressive Web Application), et plus généralement un SSB (Specific Site Browser). Dans les faits, ça existe depuis des années, et on a même des outils pour générer des applications “web installables” (par exemple Electon). Bon bref…

Chrome a une option pas si connue que ça, elle permet de transformer n’importe quel site web en une application de bureau. En cochant bien la case “ouvrir dans une fenêtre séparée”, Chrome vous crée un racourcis sur le bureau pour ouvrir le site comme une vaie application. Par exemple avec une page wikipedia:

Et voilà, vous avez une icone “wikipedia” sur le bureau (ou dans votre menu “Activités”), cool… Imaginez maintenant que vous fassiez cela avec Gmail, Youtube, etc… plus besoin d’ouvir Chrome et d’aller chercher la page, vous avez maintenant une application de Bureau.

Et c’est un peu à cause de cela que je suis parti de Firefox il y a quelques temps. Je n’avais pas ce confort avec Firefox, alors qu’avec Brave, Chromium ou encore Google Chrome, c’était si simple…

Sauf que depuis quelques temps, le vent commence à tourner et je retrouve enfin le panda roux.

Alors, ce qu’on va faire, c’est que je vous montre comment ça fonctionne, et ensuite à vous de créer en quelques secondes des applications Netflix, Gmail, Facebook, ce que vous voulez, et ce sans être développeur !

Bon, donc avec Firefox…

C’est un poil plus compliqué, mais au final c’est complètement jouable. Cette option est expérimentale, donc ça ne marchera pas parfaitement, on en parle après.

Cela faite même assez (trop) longtemps que cette option existe, et que ce “mode” n’est pas finalisé (près de 4 ans).

Il faut passer par une activation de ce mode. Ouvrez Firefox et dans la barre d’adresse vous tapez: about:config - et vous “acceptez les risques”. Tapez simplement “ssb” dans la barre de recherche, et vous allez voir ceci:

L’idée est de faire en sorte que ce paramètre soit à “true”, donc cliquez sur l’icone à droite pour changer la valeur. Voilà, c’est fait.

Maintenant, allez sur un site, n’importe lequel… et dans le menu de votre navigateur vous devriez trouver une option “Use this site in App mode”:

Et voilà, l’application existe… sur Firfox. Oui parce que voilà, il crée pas d’icone sur le bureau (pas encore), et je sais que c’est casse pied. Cela-dit, vous allez trouver l’application dans le menu:

OK… Donc là c’est fait, j’ai mon application.

Mais je veux l’avoir dans mon menu de bureau, je ne veux pas avoir à démarrer Firefox pour démarrer mon application en second lieu. Alors je fais comment ?

La solution, c’est de faire tout soit-même.

Via une ligne de commande, et donc pouvoir créer une icone de bureau

Je ne parle que de Linux ici, désolé pour les Windows et autre OSX, mais j’ai pas ça sous la main…

Dans un terminal, on va commencer par tester si ça marche. Prenons l’exemple d’une application web pour aller sur netflix par exemple.

firefox --ssb https://netflix.com

L’exemple est un peu foireux parce que vous allez devoir vous authentifier sur une autre fenêtre, donc le faire, puis fermer votre application et relancer la commande. Après ce sera bon, il aura votre cookie d’authentification.

Mais bon, voilà ce que j’ai de mon coté:

Donc… On a une commande qui permet de démarrer un site en mode “SSB”, bha cool, on va juste créer un fichier desktop !

Dans un editeur de texte, tapez ceci:

#!/usr/bin/env xdg-open
[Desktop Entry]
Version=1.0
Name=Netflix
Comment=Films et séries sur Netflix
Exec=/usr/bin/firefox --ssb  https://netflix.com
Icon=netflix
Terminal=false
Type=Application
StartupNotify=true

Vous l’enregistrez dans $HOME/.local/share/applications/firefox-netflix.desktop. Allez chercher une icone pour Netflix, et placez la dans $HOME/.local/share/icons/netflix.png (ou .svg, au choix).

Et voilà…

Et bien entendu, on peut mettre cette icone sur le bureau (si vous avec encore des icones de bureau…) ou dans la barre d’accès rapide.

Donc pas trop mal hein. C’est simplement ce dont j’avais besoin, malgré les actions à faire pour y arriver, je suis vraiment content d’avoir enfin un début de solution qui me permette de revenir à Firefox. Et donc, de me passer de Brave, Chrome, Chromium ou encore (oh mon dieu…) de Edge (oui oui… sur Linux…) Allez voir la page de Korben qui utilise à merveille l’ironie de cette abération: https://korben.info/microsoft-edge-linux.html

Oui mais…

Il y a des soucis… pas énormes mais suffisants pour que vous restiez un peu pantois devant votre ordinateur.

D’abord, certains sites comme Gmail me font des blagues. Impossible de visiter un lien qui apparait dans un mail. Je n’ai pas d’explications… donc bha…“copier/coller du lien” 👍
Les extensions ne marchent pas… donc si vous avez un bloqueur de pub, ou une extension comme “youtube enhance” bha vous l’aurez pas (je cherche encore comment outrepasser ce souci)
Attention, le comportement de l’application est de “s’ouvrir quoiqu’il arrive”, même si elle est déjà ouverte dans une autre fenêtre (je me suis retrouvé avec 5 fenêtres ouvertes pour la même application), pensez-y
Le mode “vidéo incrustée” du lecteur intégré est bien bugué…
Si le site ne vous propose pas un bouton “plein écran”, la touche “F11” ne fait rien… c’est pourtant un truc que je voulais
Les PWA de Chrome et dérivés ont une jolie décoration de titre de fenêtre, malheureusement ce n’est pas le cas avec Firefox SSB, mais je suis certain que ça va évoluer
L’icone de votre app, dans les tâches, c’est toujours celle de Firefox… pareil j’attends avec impatience que ce soit corrigé

Bref, ça ne rend pas les SSB inutilisables, mais il faut accepter que certains détails ne sont pas encore là.

Et vous pouvez aller loin

J’ai une bonne dizaine d’applications de ce genre, Gmail, Youtube, Netflix, Mastodon, ou encore Twitter (que je vais quitter, mais j’en parlerai dans un autre post). Sous linux j’ai juste à utiliser un petite patron de fichier desktop que j’ai sous la main, je trouve une icone et voilà. En 2 minutes j’ai une PWA (ou bon ok SSB App) qui fonctionne avec Firefox.

Je voulais vraiment revenir à Firefox, non pas que je hais Google (loin de là) mais Firefox est tellement plus respectueux de ses utilisateurs et il marche tellement bien, j’étais triste de m’en passer depuis tant de temps. Avec les SSB, je comble le manque.

A terme, soyons clair, les SSB seront bien mieux supportés et bien entendu nous n’aurons plus à faire des manipulations de ce genre pour avoir une entrée sur le bureau. Pour l’heure, ça fonctionne pas trop mal.

PS: bon du coup, je vous incite à utiliser Brave dans mon appel aux dons… vais devoir reformuler.

Démystifier Python Async

Tue, 04 Aug 2020 10:58:43 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

C’est pas si évident qu’avec JS ou Go, mais c’est vraiment puissant et utile, et c’est pas si compliqué.

Python propose l’asynchronisme natif depuis la version 3.4. C’est à dire depuis 2013… et pourtant, malgré l’intérêt et la puissance de ce paradigme, on remarque que peu de développeurs Python s’en servent. Et je vais être honête, je en m’en suis pas beaucoup servi. Le fait est que Go propose un système de “goroutine¹” qui abstrait énormément de contraintes alors que Python, malgré toute l’affection que j’ai pour ce langage, demande un peu plus de réflexion pour la gestion des tâches asynchrones.

La plupart des langages propose de quoi faire des tâches asynchrones, Javascript propose les “Promises”, Go propose ses “goroutines”, et j’en passe. Et tout le monde en est content. Si les développeurs Python utilise encore trop peu les coroutines c’est que quelque chose ne va pas, n’est-ce pas ?

Je vous partage ma théorie: c’est tout simplement mal expliqué.

Clairement, il y a quelques années, j’ai trouvé la documentation de asyncio austère, c’était obscure, ça donnait pas envie. Mais par la force des choses, j’ai insisté et j’ai très vite compris que c’était très puissant, utile, et au final absolument pas compliqué.

J’aurai aimé, à cette époque, qu’on me montre asyncio avec des exemples plus bruts - voilà donc ici comment j’aurais aimé qu’on me présente les choses.

TL;DR

Pour faire court:

import asyncio

async MachinTruc():
    # faire plein de chose
    # mais il faut avoir un appel
    # à await, au moins une fois
    await asyncio.sleep(0)


# conseil: avoir une fonction principale, asynchrone
async main():
    # démarre une coroutine
    await MachinTruc()

    # ou alors
    t = MachinTruc()
    await t

    # ou alors démarrer créer une tache
    # elle démarre "quasi immédiatement"
    task = asyncio.create_task(MachinTruc())

    # et l'attendre plus tard
    await task

    # ou alors attendre une liste de taches
    await asyncio.wait(liste_de_taches)

    # ou, pour avoir les résultats
    resultats = await asyncio.gather(liste_de_taches)


if __name__ == "__main__":
    # on crée une boucle d'évènements
    asyncio.run(main())

    # ou avec python < 3.7
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

C’est tout ce qu’il faut savoir: await attend une coroutine ou une tache et permet à d’autres coroutines d’avoir une chance d’exécuter des trucs.

Maintenant, voilà le détail.

D’abord c’est quoi l’asynchronisme ? C’est un thread ?

Cette partie est utile seulement si vous n’avez jamais entendu parler de coroutine, d’asynchronisme, ni de “Promise”.

Ne tournons pas en rond: NON (enfin pas exactement, et zut on commence à s’embrouiller), une coroutine n’est pas un Thread.

Les tâches asynchrones permettent de faire comme si vous aviez des threads, sans pour autant avoir des tâche en parallèle. L’idée c’est que vos tâches sachent attendre pour laisser la place à d’autres tâches. Il faut “ordonnancer” ces tâches.

Cela impose quelques règles, dont une qui va vous poser un gros souci, mais qu’on saura résoudre par la suite: il ne faut pas qu’une tâche soit bloquante (et si c’est le cas, pas de panique je vais vous donner des solutions)

“Bloquer” ça veut dire prendre le CPU pour soi et ne pas permettre à quelqu’un d’autre de l’utiliser. C’est là où les Threads sont très différents dans le fonctionnement. Eux vont savoir gérer une tâche bloquant le CPU. Mais pour cela, les Thread utilisent une “commutation de contexte” (context switch) qui demande à l’OS de deplacer régulièrement un processus pour qu’un coeur de CPU puisse gérer toutes les tâches.

Les Threads ont donc moins de contraintes pour le développeur, mais si vous en avez des miliers à gérer, cela peut être très brutal en terme de resources.

Bref, les coroutines, asynchrones, sont éxécutées dans un seul “process”, et vont simplement se partager du temps.

Dans énormément de cas, vous aurez l’impression de faire du parallélisme, gagner en temps, et en plus éviter de défoncer votre CPU et la RAM. Mais dans les faits, c’est surtout que vous allez faire en sorte qu’une tâche “pas prête” saura attendre en laissant la main à d’autres tâches de faire leur cuisine.

Les coroutine, et l’asynchronisme, vous les avez certainement utilisé dans d’autres langages. Par exemple les “promesses” en Javascript, ou les “goroutines” dans Go. Notez toutefois que Go a un avantage certain, c’est qu’il sait démarrer un Thread si votre tâche est bloquante…

`await` - on en parle de suite

Je préfère commencer par un truc qui est généralement expliqué après coup. Ne sautez pas cette section - même si vous avez une idée de ce à quoi ça sert, parce que bien souvent c’est cette notion qui fait défaut et qui empêche son utilisation.

Python propose plusieurs types qui permettent l’asynchronisme, ces types sont dit “Awaitable” (qu’on peut attendre) c’est-à-dire qu’ils peuvent entrer dans un gestionnaire d’évènements (on en parle après), et qu’on doit les attendre. Le mot clef await est justement fait pour ça, mais pas seulement.

D’une part, oui, l’idée est de pouvoir attendre qu’une fonction réponde, mais en quoi ce serait différent d’appeler une fonction non asynchrone? Et bien c’est là qu’on zappe un principe très important de ce que fait ce fameux await.

await permet aussi, et surtout, de dire à Python qu’on peut aller voir si une autre coroutine en attente peut continuer de travailler.

En d’autres termes, c’est quand Python rencontre le mot clef “await” qu’il va donner une chance à une autre coroutine de continuer son travail. En soit, await c’est le checkpoint, l’étape.

Mais c’est quoi une coroutine ?

Créons une function qui prend du temps à répondre. Dans cette fonction, nous simulons un traitement long en utilisant asyncio.sleep(). Nous ne pouvons pas utiliser time.sleep() parce que, comme je vous l’ai dit auparavent, il faut appeler await pour que Python puisse laisser les autres coroutines s’exécuter periodiquement.

import asyncio
import random
import time  # on s'en servira après

# async => la fonction est une coroutine
async def bigWork(i):
    print('Big work %d starts' % i)
    delay = random.uniform(0, 1.5)
    # surtout n'utilisez pas time.sleep()
    # pour rappel, il faut avoir un appel à await pour que
    # la coroutine bigWork puisse laisser une chance aux autres
    # de tourner
    await asyncio.sleep(delay)
    print('Big work %d ends after %.2f seconds' % (i, delay))

Cette fonction est déclarée “asynchrone” via le mot clef async, cela veut dire qu’elle pourra être ordonnancé, c’est une “coroutine”.

Voyons ce qu’il se passe si on appelle la fonction bigWork() (ici, dans iPython):

>>> bigWork(1)
<coroutine object bigWork at 0x7f1814622440>

Ha… ça n’a rien lancé ! Mais à la place, j’ai reçu une “coroutine”, un objet.

C’est la première chose à retenir: une fonction asynchrone, on ne l’appelle pas à l’arrache, on doit l’ordonnancer ou l’attendre…

Le souci, c’est que si je veux l’attendre, il faut que j’appelle la fonction avec await et ça doit être fait dans une coroutine:

  File "/tmp/a.py", line 11
    await bigWork(1)
    ^
SyntaxError: 'await' outside function

Alors je sais ce qui commence à vous prendre la tête (et c’est tout à fait normal): si je dois attendre une coroutine au sein d’une coroutine, qu’il faut attendre aussi, on tourne en rond là.

La réponse est moins évidente qu’en JS ou en Go, Python demande une “boucle d’évènements” qu’on appelle aussi un “ordonnancement”.

Un ordonnancement, c’est un gestionnaire de tâches qui va faire tourner des “trucs” et les orchestrer. Quand une tâche peut attendre, on passe à une autre, et quand l’autre a fini, on regarde si une autre peut répondre et ainsi de suite. Et si vous avez suivi, c’est quand on rencontrera le mot await que l’ordonnancement passera d’une routine à l’autre.

Cet ordonnancement est très simple à démarrer, asyncio.run prend en argument une coroutine, et il attend qu’elle soit finie. Si d’autres coroutines sont démarrées par cette coroutine, il attendra aussi. Il va gérer toutes les coroutines au sein d’un processus.

# si vous travaillez avec Python >= 3.7
asyncio.run(bigWork(1))

# sinon...
loop = asyncio.get_event_loop()
loop.run_until_complete(bigWork(1))

Tout ce que dit cette (ou ces) ligne(s) c’est: “Donne moi un gestionnaire de coroutine, et démarre bigWork(1)”.

Là, pour le moment, on a rien fait de très intéressant. On démarre une coroutine et on l’attend, ça ne change pas grand chose à démarrer une fonction non-asynchrone, pire c’est même plus compliqué à coder.

Il est temps d’aller plus loin

Allons de l’avant, et passons à ce qui nous intéresse: avoir plein de coroutines en “parallèle” (oui, en concurrence…). Nous allons crére une fonction générale qui va lancer plein de tâches, et cette fonction sera donc celle qui sera attendu par la boucle d’évènements. Ce sera plus simple pour la suite.

async def main():
    # on va lancer 5 coroutines
    for i in range(5):
        await bigWork(i)

# et ici je chronomètre l'ensemble
start = time.time()
asyncio.run(main())  # on démarre ici
end = time.time() - start
print('Total time: %.2f' % end)

Encore une fois (je vous tease un peu hein), pas trop d’intérêt mais vous voyez que je peux lancer plein de tâches les unes après les autres, et quand tout est terminé alors mon script s’arrête:

$ python /tmp/a.py
Big work 0 starts
Big work 0 ends after 0.57 seconds
Big work 1 starts
Big work 1 ends after 0.42 seconds
Big work 2 starts
Big work 2 ends after 0.22 seconds
Big work 3 starts
Big work 3 ends after 0.34 seconds
Big work 4 starts
Big work 4 ends after 0.46 seconds
Total time: 2.05

Mais, on est d’accord, le temps total correspond plus ou moins à la somme des temps des coroutine. Elles ont démarré dans l’ordre et aucune coroutine ne démarre avant que l’autre ait terminé.

Faisons une pause deux secondes avant de continuer. Dans l’ensemble, si vous aviez d’autres coroutines dans votre code, alors votre script est très bien écrit. Chaque itération de la boucle for fait un await et permet donc à une autre coroutine de tourner. Mais, dans notre exemple, nous voulons faire tourner nos coroutines bigWork en concurrence. Donc, effectivement, à partir de maintenant, on va chercher à étudier des fonctions qui permettent d’aller plus loin, mais dans vos développements vous pouvez déjà estimer que ce bout de code est viable.

Reprenons, nous voulons maintenant faire en sorte que toues les coroutines bigWork tournent en concurrence.

Rappelez vous maintenant ce qu’il s’est passé quand on a appelé bigWork() sans utliser await. Vous vous souvenez que la fonction n’est pas appelée mais que nous avions une “coroutine” en retour. Et bien cherchons à les stocker puis à les attendre en même temps, et ce avec une des méthodes proposées par le module asyncio, par exemple wait():

async def main():
    tasks = []
    for i in range(5):
        tasks.append(bigWork(i))

    # on attend que la liste
    # de coroutines soit terminée
    await asyncio.wait(tasks)

Et maintenant, tout se passe comme on le veut:

$ python /tmp/a.py
Big work 1 starts
Big work 2 starts
Big work 3 starts
Big work 0 starts
Big work 4 starts
Big work 1 ends after 0.20 seconds
Big work 3 ends after 0.30 seconds
Big work 0 ends after 1.08 seconds
Big work 2 ends after 1.32 seconds
Big work 4 ends after 1.46 seconds
Total time: 1.47

Le temps total a pris à peine plus de temps que la tâche la plus longue. Et là c’est ce qu’on attendait !

Remarquez aussi que les tâches n’ont pas été démarrées dans l’ordre, ça peut paraitre étonnant mais c’est aussi un effet de l’asynchronisme, les tâches sont ordonnancées de manière non déterministe (on ne peut pas prévoir).

Task et Coroutine

Parlons maintenant d’un piège, celui de vouloir créer des coroutines et de les attendre via await sans passer pas asyncio.wait:

async def main():
    tasks = []
    for i in range(5):
        tasks.append(bigWork(i))

    for t in tasks:
        await t

C’est une erreur logique, mais si vous lancez votre script, vous allez vous retrouver dans le même état que lorsque vous faisiez await biWork(i).

Mais pourquoi ? Comment fait asyncio.wait() pour s’en sortir ?

C’est à ce moment qu’il faut parler des Task…

Un coroutine est un objet qui représente une fonction asynchrone, mais pour qu’elle soit exécutée il faut l’encapsuler dans une tâche (Task). Sauf que Python le fait pour vous, de manière transparente, quand vous utilisez await (si la coroutine n’est pas encapsulée). Quant à asyncio.wait(), ainsi que d’autres fonctions de ce module, il va aussi le faire pur vous.

Alors comment faire ça manuellement ? Comment démarrer une coroutine tout de suite, et les attendre après coup ?

async def main():
    tasks = []
    for i in range(5):
        # je découpe tout pour vous montrer les étapes
        coroutine = bigWork(i)
        task = asyncio.create_task(coroutine)
        tasks.append(task)

    for t in tasks:
        await t

Le principe est donc d’avoir une coroutine, et de l’encapsuler avec create_task, cela à pour effet de démarrer tout de suite la tâche. Le mot clef await voit bien que vous avez non plus une coroutine mais une tâche (qui est Awaitable) et va juste attendre qu’elle soit terminée.

Effectivement, on aura plutôt tendance à faire asyncio.create_task(bigWork(i)) mais je vous ai découpé les opérations pour que ce soit bien clair.

Bon, si vous lancez votre script, on revient à ce que fait asyncio.wait(). Les tâches sont ordonnancées, tout va bien.

Et quand ça bloque ?

Nous y voilà… Le souci est que vous ne maitrisez pas forcément tout le code, vous allez utiliser des packages externes, ou des anciens développements, et bien souvent cet historique de travail ne contient pas de code asynchrone. Alors, on s’en sort comment… ?

Prenons notre code bigWork et rendons le synchrone:

en supprimant async
en remplacant asyncio.sleep par time.sleep

# synchrone...
def bigWork(i):
    print('Big work %d starts' % i)
    delay = random.uniform(0, 1.5)
    time.sleep(delay)  # là ça va bloquer
    print('Big work %d ends after %.2f seconds' % (i, delay))

Impossible d’utiliser “await” car la fonction n’est pas déclarée aysnchrone, et en plus time.sleep n’est pas awaitable donc elle va bloquer le processus.

Heureusement, asyncio va nous permettre de nous en sortir malgré tout. L’idée est d’utiliser a boucle d’évènements et de lui demander de gérer des Thread (oui… des threads) qu’on saura attendre.

Il y a plusieurs manière de faire, la première est de demander à la boucle d’évèenements de prendre en charge un Thread:

# on récupère la boucle
loop = asyncio.get_event_loop()

# None => on voit ça après, mais disons
# que là, on ne lui donne pas, donc il se débrouille...
loop.run_in_exector(None, function)

function correspond à la fonction à ajouter à l’exécution, par exemple bigWork, donc sans argument… Sauf que voilà, nous avons un argument à donner. Pour se sortir de l’impasse, on va utiliser un partial qui vient du module functools:

# un partial est une fonction
# partielle, on lui fourni les arguments
# en liste...
coroutine = functools.partial(bigWork, i)
# et au final:
loop.run_in_exector(None, coroutine)

run_in_exector retourne une task, et on va pouvoir l’atendre de la même manière qu’avant:

async def main():
    tasks = []
    loop = asyncio.get_event_loop()
    for i in range(5):
        coroutine = functools.partial(bigWork, i)
        task = loop.run_in_executor(None, coroutine)
        tasks.append(task)

    await asyncio.wait(tasks)

Ce qui va nous donner:

$ python a.py
Big work 0 starts
Big work 1 starts
Big work 2 starts
Big work 3 starts
Big work 4 starts
Big work 1 ends after 0.35 seconds
Big work 4 ends after 0.56 seconds
Big work 2 ends after 0.70 seconds
Big work 0 ends after 1.16 seconds
Big work 3 ends after 1.23 seconds
Total time: 1.23

Magnifique, ça fonctionne (c’était prévu…)

Cela veut dire que si vous avez des fonctions non asynchrones, il est possible d’utiliser la boucle d’évènements pour exécuter des Threads.

Une autre manière de faire est d’utiliser un pool, encore une fois via asyncio pour utiliser la boucle d’évènements. Le package natif concurrent.futures propose un système de Pool de Thread ou de Process. Voici comment faire:

async def main():
    tasks = []
    loop = asyncio.get_event_loop()
    with futures.ThreadPoolExecutor() as pool:
        for i in range(5):
            coroutine = functools.partial(bigWork, i)
            # et cette fois, on lui donne l'exécutor,
            # donc pas None, mais le pool
            t = loop.run_in_executor(pool, coroutine)
            tasks.append(t)

    await asyncio.wait(tasks)

Gros intérêt, on peut limiter le nombre de Threads (ou de Process en utilisant ProcessPoolExecutor) via l’argument max_workers. C’est une excellente manière de ne pas surcharger vos CPU avec des miliers de Threads à switcher.

On résume

Donc, pour faire simple:

Une fonction asynchrone doit être déclarée avec le mot cle async
Elle doit attendre un truc, même un await asyncio.sleep(0) suffit, mais il faut attendre avec await, sinon ça bloque les autres coroutines
Vous devez faire passer une fonction à asyncio.run() pour gérer une boucles d’évènements
Vous pouvez ordonnancer des fonctions non asynchrones, via des Thread ou Process, en utilisant un executor

Notez aussi que:

asyncio.wait est annulable, alors que asyncio.gather vous retourne une liste de résultats des fonctions asynchrones
asyncio.create_task(coroutine) envoloppe une coroutine pour avoir une tâche, une tâche démarre au plus tôt, alors qu’une coroutine doit être attendu pour démarrer.

Conclusion

Certes, Python demande un peu plus de boulot qu’avec Go ou JS pour démarrer une coroutine, surtout avec des fonctions bloquantes (que Go sait tellement bien gérer), mais après quelques heures vous allez avoir beaucoup moins de mal à gérer des coroutines.

Notez que le module asyncio propose des équivalents à pas mal de fonctions que vous utlisiez, par exemple:

asyncio.sleep au lieu de time.sleep
asyncio.create_subprocess_exec au lieu de suprocesss.Process
asyncio.Queue au lieu de queue.Queue
et j’en passe.

Allez voir la page de documentation asyncio qui est une ressource de connaissances exemplaire, et prenez le temps de bien lire la page d’api qui est assez claire.

L’avantage de asyncio est de limiter l’utilisation de Queue, des context switch CPU, et de gérer des tâches en concurrence alors que le parallélisme est souvent inutile. Vous allez limiter la charge OS en ayant un seul processus tout en ayant une gestion de tâches concurrente qui va accélerer les traitements. À terme, les Threads seront votre solution de recours, et non pas la solution initiale.

L’idée n’étant pas de dénigrer les Threads et les sous-processus, mais de les utiliser que dans le cas où ils sont vraiment utiles.

En espérant que mon article vous ait servit.

non je n’ai pas fait une faute de frappe, c’est bien avec un “g”, les goroutines sont des coroutines spécifiques à Go. ↩︎

Une UI cross-plateform, en Go, embarquée, ça existe

Sun, 28 Jun 2020 21:18:58 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Ce qui manquait à Golang c’était une librairie graphique pour faire des interfaces, mais sans dépendance, et qui marche partout, même en app Mobile - et bien Fyne c’est ça !

J’ai attaqué Go depuis quasiment le début de sa sortie (Merci Nicolas d’avoir insisté pour que je jette un oeil), ce langage m’a convaincu en quelques heures. J’adore ce langage pour sa philosophie, son fonctionnement, son principe clair et qui ne force pas la POO à foison. En Go, tout est logique, on vous pousse à coder et non à chercher comment coder.

Mais depuis le début, j’ai senti un manque, un vrai manque. Vous l’avez capté, à cause du titre, c’est la possibilité de coder des interfaces graphiques.

Alors oui, bien entendu, on peut utiiser GTK ou Qt, oui.

Mais un des principes de Go (qui peut déplaire, je le conçois) c’est que vous vous abstrayez des dépandances. J’entends par là que la compilation est (par défaut) statique, et que vous évitez dans 99% des cas d’avoir à installer des librairies externes à Go. Or, par exemple avec GTK, vous devez avoir les librairies Gtk-Dev pour compiler votre application et le client doit avoir la bonne version de GTK pour faire tourner le binaire. On est donc loin du compilé statique natif.

Autre chose, en GTK, il est difficile d’exploiter la puissance des goroutines - on est obligé de travailler avec des états de la Glib qui permettent de mettre en parallèle des traitements. Bref, ça fonctionne très bien mais ça n’est pas “Golang ready”.

Et puis, pour ajouter une cerise sur le gâteau déjà bien empilé, j’aimerai faire une application qui fonctionne partout, y compris sur du mobile.

Bref, j’avais entendu parler de “nuklear” mais la complexité du code me laissait de marbre.

Et je suis tombé par hasard sur la pépite, le graal, enfin bref le truc qui répond à mon besoin et potentiellement le votre. Ce petit bijou s’appelle Fyne.

Miiiiiissssss Fyne¹ !

Fyne est une librairie qui fait partie d’un projet plus grand: conquérir le monde…

Enfin pas exactement, hein. En gros il y a deux projets:

un projet de gestionnaire de bureau qui se nomme fynedesk
La librairie graphique qui permet de créer des applications (avec tout plein de widgets) qu’on appelle “Fyne”
- La page de présentation est ici
- le projet Github est ici

Le premier point, on ne va pas en parler ici - par contre la librairie graphique, elle, c’est du lourd.

Ils sont partis de zéro, pour que la définition des objets graphiques puissent répondre aux différents drivers que l’on peut utiliser. Ces drivers permettent d’afficher les objets de la même manière que vous soyez sur Linux, Windows, Mac, iOS ou Android.

Vous avez bien lu, on parle de Desktop et de Mobile. Vous allez voir, il suffit de compiler l’application pour la bonne cible et sans trop s’arracher la perruque.

Votre application contiendra, si vous le souhaitez, un gestionnaire de préférences, encore une fois sans vous soucier de l’emplacement des données puisque cela est toujours différent selon l’OS que vous ciblez.

Et le petit truc qui donne encore plus de saveur à ce projet, c’est que les développeurs ont inclu ce qu’il faut pour créer votre application en TDD² et ce sans avoir à utiliser un serveur graphique. Vous trouverez une bon didacticiel dans cette vidéo:

Je ne vais pas en parler dans cet article, par contre je vous conseille de l’utiliser dans vos développements, parce que lorsque votre application commence à prendre un peu de poids, tout devient plus simple à corriger. Et le TDD est à mon avis l’une des méthodologies les plus intéressantes dans notre métier - on code un test qui décrit ce qu’on veut faire, et on fait en sorte que le test passe en codant la fonctionnalité.

Bon bref, voyons comment ça fonctionne.

Premier test, à l’arrache

On va se créer un petit projet, dans /tmp/test-fyne et utiliser aussi le gestionnaire de dépendances intégré à Go (il était temps qu’il y en ait):

# on crée le répertoire de demo
mkdir -p /tmp/test-fyne
cd /tmp/test-fyne
# on initialise notre gestion de dépendances
go mod init demo
# on installe Fyne
go get fyne.io/fyne

Et on commence par développer notre première application graphique, simplement:

package main

import (
    "fyne.io/fyne"
	"fyne.io/fyne/app"
)

func main(){
    // l'objet d'application
    application := app.New()

    // on se crée une fenêtre
    win := application.NewWindow("Hello")
    // comme on a pas de contenu... je vous conseille de mettre ça
    win.Resize(fyne.NewSize(400, 300)) 

    // on lance l'app
    // cette fonction est un alias à win.Show() et application.Run()
    win.ShowAndRun()
}

Alors, ne me dites pas que c’est compliqué. Testez l’application en lançant go run main.go et vous allez voir:

Notre première application

Bon, mettons nous tout de suite d’accord: le design est léger, pas forcément joli, voir “old-school”. Mais l’idée n’est pas de remplacer GTK, Qt, ou tout autre librairie graphique adaptée à votre environnement. Là, on parle de faire une application rapidement, cross-platform, et facile à déployer “partout”. Donc, on va s’y faire (et rien ne dit que les thèmes ne soient pas, plus tard, encore plus jolis).

Maintenant, on va ajouter des trucs dans cette fenêtre, un label (un texte…) et un bouton qui a pour action de fermer l’application - notez que j’ai supprimé le Resize et ajouté l’utilisation d’une boite verticale (VBox). Aussi, il faut ajouter fyne.io/fyne/widget dans les imports pour avoir accès à ces gadgets graphiques (c’est à peu près la traducition du mot widget).

package main

import (
	"fyne.io/fyne/app"
	"fyne.io/fyne/widget"
)

func main() {
	application := app.New()

	win := application.NewWindow("Hello")

	label := widget.NewLabel("Et un bouton, un")
	button := widget.NewButton("Click me", func() {
		application.Quit()
	})

	// une boite verticale pour les gouverner
	// et la fenêtre les lier
	box := widget.NewVBox(label, button)

	win.SetContent(box)
	win.ShowAndRun()
}

Et là, simplement:

Un bouton, un label, dans une boîte

Il y a à peu près tout ce dont on a besoin. Le package “widget” contient des boutons, labels, entrées de texte, etc. Dans “canvas” vous trouverez des conteneurs d’image, de dessins - mais vous avez aussi un package pour des boites de dialogue, de notifications, de thèmes… Donc à peu près tout ce dont on a besoin pour faire une application graphique complète

Bref, il faut fouiller un peu dans la documentation³ mais c’est vraiment pas très complexe.

Bon, vous avez aussi certainement remarqué l’abscence d’icône dans votre barre des tâches. Alors l’idée c’est d’éviter à tout prix d’avoir un fichier externe. On va donc installer la commande “fyne” pour transformer une image en resource (en code):

# installons la commande fyne
go get fyne.io/fyne/cmd/fyne

# allez chercher une icone, et créons la ressource en Go
fyne bundle face-monkey.png > icon.go

Vous pouvez regarder dans le fichier icon.go qui contient une variable nommée resourceFaceMonkeyPng, elle correspond à votre icône.

Il faut ajouter une petite ligne de code pour gérer ça:

// après la création de l'application:
application.SetIcon(resourceFaceMonkeyPng)

Dans ma barre des tâches, c’est bon j’ai l’icône:

L'icône dans la barre de taches, c'est OK

Et donc, le binaire contient l’icône, inutile de gérer des chemins etc… Effectivement c’est un peu réberbatif de devoir convertir vos icônes, mais en soit c’est une source d’énervement en moins pour livrer votre programme à quelqu’un.

Alors oui, coupons court à toutes discussions, le binaire de sortie est très lourd !

Le binaire va contenir les ressources et la librairie graphique, on table donc à minima sur du 17Mo pour une fenêtre. Mais après, clairement, quand l’interface sera plus fournie avec des évènements à gérer etc., le binaire ne va pas tant grossir. Et puis il faut faire un choix entre se battre avec des dépendances (et y arriver, je ne dis pas le contraire hein) ou faire un soft qui n’impose finalement qu’une contrainte de poids. À vous de voir.

Une petite subtilité: le redimensionnement

Rien n’est jamais parfait, et je me suis très vitre confronté à un petit souci qui m’a pris un peu de temps à résoudre. Heureusement, les auteurs sont à l’écoute et m’ont répondu sur GitHub.

Étant donné le travail fourni pour que les applications passent aussi bien sur Mac que Linux ou Windows, et sur les mobiles, la gestion du placement et des espaces d’éléments graphiques est parfois un peu complexe à comprendre. Prenons un exemple simple. Je veux afficher:

un label
un texte plus gros scrollable (par exemple une information de licence)
un bouton pour passer à la suite

Le tout dans une boite verticale. Naturellement je vais faire ceci

label := widget.NewLabel("Information de license")

// on fait un gros texte qu'on place dans un conteneur
// qui permet le défilement
license := widget.NewLabel(licenseText)
scrollable := widget.NewVScrollContainer(license)

button := widget.NewButton("Click me", func() {
	application.Quit()
})

// on place tout à la verticale
box := widget.NewVBox(label, scrollable, button)

Sauf que voilà… tout l’espace de la fenêtre n’est pas utilisé.

Tentez le coup, vous allez voir. La fenêtre se cale à la taille “définie” et si vous redimensionnez la fenêtre, tous les éléments restent en haut de la fenêtre. Or, on veut que notre texte s’étire sur la hauteur.

Quand on vient du monde GTK ou Qt, on se dit qu’il suffit de donner une indication à tel ou tel widget pour qu’il s’étire. Mais ce n’est pas le cas avec Fyne. Il va falloir connaitre un peu ce que sont les Layouts et jouer avec.

Avec un peu de lecture de doc, on comprend très vite comment faire. La solution ici est d’utiliser un Layout nommé BorderLayout qui se trouve dans le package à inclure fyne.io/fyne/layout. Et ce Layout doit servir à dimensionner un “conteneur” avec fyne.NewContainerWithLayout() (package fyne.io/fyne).

En soit, les VBox et HBox, par exemple, sont des Layout prédéfinis.

On peut d’ailleurs coder notre propres Layout.

Ce que fait ce BorderLayout, c’est de placer les éléments en “haut”, “bas”, “gauche” et “droite” de la fenêtre. Mais on peut omettre des éléments.

Ce qu’on va faire est:

poser notre label en “haut” (top)
poser le bouton en “bas” (bottom)
rien à doite et à gauche
et placer notre “scrolable” entre le haut et le bas

Si vous avez plusieurs éléments à mettre en haut et bas, alors vous devez les faire entrer dans des box (Vbox, Hbox ou autres conteneurs) et ce seront ces “box” qui devront être placées en “top” et “bottom”.

label := widget.NewLabel("Information de license")
license := widget.NewLabel(licenseText)
scrollable := widget.NewVScrollContainer(license)
button := widget.NewButton("Click me", func() {
	application.Quit()
})

// on definit un "conteneur" et on lui donne les éléments qui servent à calculer
// l'espaement et le placement - ici, on veut le label en haut et le bouton en bas
// mais rien à droite et à gauche
container := layout.NewBorderLayout(label, button, nil, nil)
// et notre boite utilisera ce conteneur, on a plus qu'à lui donner la
// liste des éléments (l'ordre n'importe pas ici)
box := fyne.NewContainerWithLayout(container, label, scrollable, button)

win.SetContent(box)

Fyne va alors utiliser le layout pour placer les éléments que vous lui avez donné, et au bon endroit, il place le scrollable là où il peut (au milieu) et le redimensionnement de la fenêtre va alors étirer l’élément.

La fenêtre peut être redimensionnée

Sans cela, vous devriez donner une taille fixe ou vous contenter d’une application qui ne redimensionne pas le contenu. C’est donc un point à savoir, et il faut vraiment prendre en compte ce comportement.

Compiler / packager votre application (desktop, mobile)

Vous pouver proposer le binaire tel quel, mais votre “client” va devoir lancer la commande dans un terminal. Et un terminal, ça fait peur.

En général, sous Linux, on doit proposer un fichier “.desktop” qui décrit l’application, son icône de lancement, son emplaement… Sous Mac il faut packager un “.dmg” et sous windows il faut embarquer l’image dans le binaire en “.exe”…

Et quand il faut fournir une application mobile, par exemple pour Android, là c’est un package .apk qu’il faut construire.

Du boulot donc et pas des moindres.

Du coup, une nouvelle fois, les auteurs de Fyne ont fait un excellent boulot - la commande fyne propose une sous-commande nommée “package”. On sent que les auteurs de la librairie ont eut les mêmes problèmes que la plupart d’entre nous pour faire des applications.

Les commandes sont les suivantes:

fyne package -os linux -icon myapp.png
fyne package -os darwin -icon myapp.png
fyne package -os windows -icon myapp.png

Pour Linux, un tarball est généré, contenant le fichier “.desktop” et une structure de répertoire à installer sur la machine cible.
Pour Mac (darwin), c’est un dmg tout ce qu’il y a de plus commun, qui est généré.
Et pour Windows, un executable avec l’icône embarquée.

Encore une fois, Fyne soulage vraiment les procédures en automatisant les tâches qui fâchent.

Et pour finir, vous pouvez générer les applications mobiles:

fyne package -os android -appID com.example.ma-demo -icon mobileIcon.png
fyne package -os ios - appID com.example.ma-demo -icon mobileIcon.png

Il vous faudra bien entendu choisir un appID unique, et avoir le nécessaire pour compiler vers la plateforme cible (adb pour Android, Xcode pour iOS) - mais encore une fois, c’est clair, net et ça soulage les nerfs.

Allez voir la page de documentation qui explique toute la procédure. Vous aurez toutes les informations nécessaires.

J’ai testé sur Android, ça fonctionne vraiment bien.

Le mot de la fin

Je suis vraiment impressionné par le boulot qui a été fourni, que ce soit en tant que compatibilité cross-platform, mais aussi en terme de simplicité et d’outillage. Fyne me permet de créer des applications clientes rapidement et sans que j’ai à me soucier de savoir si les machines cibles ont ou non les librairies graphiques. Cette notion “d’embarquer” les ressources (graphique et librairies dans un binaire) est exactement ce dont j’avais besoin.

Fyne est en cours d’écriture pour une nouvelle mouture, encore plus poussée, qui va proposer du data-binding et des animations. J’ai hâte de voir ça 🤯 - pour l’heure, je vous laisse jeter un oeil sur cette petite perle.

N’hésitez pas à partager vos remarques, vos tests et un grand merci à vous pour la lecture 😘

Avouez que vous connaissez la référence 😁 Une nounou d’enfer ↩︎
Test Driven Development, ou développement dirigé par des tests ↩︎
C’est le lot de notre métier, il faut lire la documentation ↩︎

Passer De Pip À Pipenv

Sat, 20 Jun 2020 10:04:24 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

La commande “pip” couplée à des virtualenv, c’est un peu le b.a.-ba en Python. Mais “pipenv” va vous rendre la vie encore plus facile.

Cela fait des années que je code en Python, depuis environ 2003 pour être exact. Je suis passé par pas mal de techniques pour éviter d’écrire mes dépendances dans le système, et il faut bien avouer que les Virtualenv ont beaucoup aidé l’adoption de Python. Ça, et l’avènement du Machine Learning dans lequel Python fait de plus en plus d’adpetes. Avant toute chose, je vais insister sur un truc qui m’énerve très souvent…

Arrêtez de faire des “sudo pip install truc” !!!

Cette commande installe les paquets (packages et modules) sur votre système, donc :

si un paquet de votre distribution (deb, rpm, etc…), contient cette dépendance, il va vous l’exploser
si vous avez deux projets / applications Python qui ont la même dépendance, mais pas avec la même version, vous allez en avoir une des deux qui va se vautrer
et puis mince à la fin, c’est quoi cette idée de faire des installations dans le système ?

Alors oui, on peut ajouter l’option --user qui va installer les packages et binaires dans votre HOME, c’est bien… Mais cela doit rester anecdotique, pour des outils dont le paquet n’existe pas sur votre distribution, ou si vous savez ce que vous faites. Dans tous les cas, pour développer en Python, on passe par un environnement virtuel.

Je vais donc vous faire un rappel, puis on parlera de Pipenv

Avant, on faisait des virtualenv et on utilisait “pip”

Avant de parler de Pipenv, je pense qu’il est important de voir comment la plupart des projets sont démarrés en Python avec pip et les virtualenv.

La méthode super standard aujourd’hui, qui marche très bien, c’est de créer un environnement virtuel.

mkdir -p ~/Projects/monsite1
cd ~/Projects/monsite1

python -m venv virtualenv

# et on doit activer cet environnement avant de bosser
# ... à chaque fois...
source vitrualenv/bin/activate

À partir de là, toutes les commandes pip install vont installer les packages et dépendances dans le répertoire virtualenv (vous pouvez le nommer autrement si ça vous chante) - c’est pratique, et quand on a l’habitude c’est quasiment un reflex.

Intéressant aussi, on peut taper cette commande pour générer un fichier de dépendances pour que vos collaborateurs puissent avoir la même version que vous :

pip freeze > requirements.txt

# vos collaborateurs vont ensuite faire:
pip install -r requirements.txt

C’est cool, mais ça a quelques inconvénients:

d’abord, il faut penser à créer le virtualenv sur les postes de vos collègues de projet
ensuite, le “freeze” colle les paquets + dépendances
et en plus de cela, si vous avez des packages / outils seulement pour le développement, et bien ils sont dans ce fichier…
et puis si on travaille avec git, il faut penser à “ignorer” le virtualenv (ou le placer en dehors du projet)

Donc, oui, ça marche bien, mais ça demande un peu de manipulation pour séparer ces fameuses dépendances de “dev”.

À côté de cela, on voit Node utiliser un “package.json” via npm, qui sait d’ailleurs très bien séparer les dépendances de dev et de run - ou encore “composer” pour PHP qui fait à peu près bien ce travail…

Sous Python, on se sentait un peu démunis, en dessous du lot, un peu peiné d’avoir un langage tellement cool mais avec une gestion de package limitée…

Et puis arrive le prince Pipenv !

Pipenv, mon ami mon frère

Depuis quelques mois, je teste “pipenv” - et je peux vous dire que j’ai du mal à comprendre pourquoi si peu de Pythonistes ne l’utilisent. Et surtout, pourquoi il n’est pas plus connu !? Car là, on a un outil propre, qui fait exactement ce dont on a toujours besoin en dev Python, qui reprend les concepts utiles de “npm”, “glide”, ou “composer”… Bref, un truc qui sert professionnellement !

Cette commande est dans la plupart des dépôts de distribution, donc dnf install pipenv, ou apt install pipenv fonctionnera. Dans “alpine”, pas le choix, on passera par “pip” pour l’installer avec pip install pipenv (c’est logique d’utiliser pip ici). OSX n’est pas en reste… Avec brew ça passe aussi.

Pipenv ne va pas vous éloigner de “pip”, en fait il est même simplement un genre de “superset” de cet outil. Vous allez voir, c’est vraiment le panard.

Créons un projet de site:

mkdir -p ~/Projects/monsite1
cd ~/Projects/monsite1

pipenv install

Et c’est tout.

Voilà… Croyez-le ou non, c’est déjà prêt. Il vient de faire le nécessaire;

création d’un virtualenv

préparation d’install de dépendances

Vous allez trouver deux fichiers, Pipfile et Pipfile.lock, l’un contient les dépendances, et le second va contenir les informations de version de tout ce que vous allez installer.

Déjà, il faut bien comprendre que le fichier “Pipfile” remplace (en quelque sorte) le fichier “requirements.txt”. Donc, quand un collaborateur va récupérer votre dépôt, il fera aussi un appel à la commande “pipenv install”, et cela installera les dépendances de projet.

On est clairment dans la même situation qu’avec package.json pour NPM, ou composer.json pour composer… Mais en Python !

Allons y, installons “Flask”:

pipenv install flask

Quoi ? Comme ça ? Sans activer de virtualenv ?

Et oui mes amis, le virtualenv a été créé par l’outil et il l’utilise tout seul. Mais il est où ce virtualenv ?

$ pipenv --venv
/home/metal3d/.local/share/virtualenvs/monsite2-EXci-bmn

Il le trouve comme un grand.

Pour que cet environment soit actif vous avez plusieurs solutions. La plus simple est d’utiliser la commande pipenv run [command] avec, bien entendu, la commande que vous voulez. Par exemple, pour lancer flask:

pipenv run flask run -h 0.0.0.0

Sinon, vous pouvez lancer un shell:

pipenv shell

Cette commande active le virtualenv. Alors important !!! évitez d’utiliser la commande deactivate et pressez plutôt CTRL+D pour désactiver le shell. Si vous vous plantez, c’est pas très grave : redémarrez votre terminal si vous avez des soucis.

Mais c’est pas fini !

Installons un outils de test unitaire, par exemple…“pytest”. On est d’accord que cet outil ne doit être installé que pour le développement ? En production, on en veut pas. Et bien, tout comme avec “npm”:

pipenv install pytest --dev

Et voilà, une dépendance installée pour les développeurs. Ce qui veut dire que :

# n'installe que les packages de run
pipenv install 

# install SANS METTRE À JOUR le fichier .lock
# (pour installer en prod)
pipenv sync

# pour avoir les outils de dev
pipenv install --dev

# et si on veut tout, en une fois :
pipenv install --all

Et attendez… C’est pas fini…

Vous voulez générer les fichiers de requirements, parce que votre environment de déploiement gère “pip”. Et bien, pas de souci, “pipenv” sait le créer en évitant les paquets de développements :

pipenv lock -r > requirements.txt

Et si vous voulez générer des requirements séparés :

pipenv lock -r --dev > requirements-all.txt
pipenv lock -r --dev-only > requirements-dev.txt

Le site propose une jolie animation:

Exemple de séquence Pipenv - source https://pipenv.pypa.io/en/latest/

Les petits trucs en plus

Un truc que j’apprécie énormément, c’est le fait de pouvoir utiliser un fichier .env. Très pratique avec Flask pour mettre “FLASK_DEBUG=1” par exemple. Et bien entendu, ces variables sont chargées en tant que variable d’environnement (le nom aurait dû vous orienter) :

$ echo "FOO=bar" > .env
$ pipenv run python -c "import os; print(os.environ['FOO'])"
Loading .env environment variables…
bar

Si vous voulez avoir l’arbre de dépendance, c’est aussi très pratique à lire :

$ pipenv graph
MarkupSafe==1.1.1
pytest==5.4.3
  - attrs [required: >=17.4.0, installed: ?]
  - more-itertools [required: >=4.0.0, installed: 8.4.0]
  - packaging [required: Any, installed: 20.1]
  - pluggy [required: >=0.12,<1.0, installed: 0.13.1]
  - py [required: >=1.5.0, installed: 1.8.2]
  - wcwidth [required: Any, installed: 0.2.3]

Pour parfaire le tout, pipenv propose de la completion, dans votre ~/.bashrc, ajoutez :

source <(pipenv --completion)

Et le tour est joué.

Et il y a bien d’autres options, comme “check” qui vérifie les requirements “PEP 508”. La documentation est simple mais efficace. La page PIpenv Advance Usage est une mine d’informations.

Et vous pouvez même tester en ligne l’outil sans rien installer chez vous 🎉

En bref

En gros, je ne me sers plus vraiment de “pip”. Pipenv a pris le relais. Mon process est clairement plus souple. J’ouvre vim avec la commande pipenv run vim pour avoir le contexte de virtualenv dans l’éditeur.

Notez que VSCode, vscodium¹, Pycharms, etc… savent utiliser pipenv.

Je génère tout de même les fichiers de requirements pour installations plus anciennes, et/ou pour le déploiement (car “pip” est plus répandu sur les plateformes de déploiement), mais je les génère plus proprement avec “pipenv” qui évite les packages de dev.

Pipenv ne change pas radicalement votre workflow, il vous évite simplement certains init, des commandes superflues, et une gestion de dépendances manuelle. En soit, les deux seules commandes utiles pour démarrer sont :

pipenv install ... [--dev] pour créer, installer le projet, en séparant ou non les paquets de dev
pipenv run <command> pour lancer une commande avec l’environnement virtuel activé

Eventuellement, ponctuellement, pipenv uninstall, pipenv lock -r…

En gros, pipenv est un bel équivalent de “npm” mais pour Python. Je vous conseille vraiment de tester. N’hésitez pas à commenter, partager l’article et discuter avec moi de ces sujets 👍

vscodium est un build de VSCode qui n’envoit pas de données à Microsoft ↩︎

Vue et React avec Typescript pour s'approcher de Angular

Sun, 14 Jun 2020 09:04:07 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Voici comment j’ai retrouvé un de l’intérêt à React, un vrai plaisirs de coder avec Vue - mais aussi pourquoi je continue à militer pour Angular.

Depuis que ES6 (javascript moderne), développer en JS est devenu encore plus adapté aux projets d’envergure. Aujourd’hui, nos navigateurs sont de véritable socles à applications, un site devient une application à part entière qui est interactive et permet de tourner coté client. Depuis des années, les frameworks se sont succédé pour finalement voir au moins 3 frameworks se dégager:

Angular¹ qui n’est plus un framework JS comme l’était AngularJS, proposé par Google
React² (ou ReactJS) par Facebook
VueJS³ qui est développé par un ancien développeur de Angular

Angular se détâche des deux autres car, il est pensé pour développer une application en Typescript, et ne permet pas (du moins pas facilement) de s’intégrer dans une page existante. La philosophie de Angular est de pousser le développement dans le sens de la qualité et d’exploiter les concepts de développement en Typescript, avec des concepts d’injection de dépendance, décorateurs, et une structure très précise. Il est purement MVC⁴ ce qui est donc bien plus “logique” à utiliser pour un développeur qui vient d’un autre univers (Java, PHP, Python…)

VueJS propose deux mode de développement. Soit en pure JS pour s’intégrer dans une page, ou alors une écriture en “vue file”, qui est en soit une manière de séparer la vue et le controle mais de rester dans le même fichier. Mais ce que je lui reproche c’est le fait de demander de proposer des propriétés spécifiques pour définir les méthodes. Et d’ailleurs, un composant est un objet à retouner et non une classe.

ReactJS est, tout comme VueJS, une librairie qui permet de créer une application ou de s’intgrérer à une page existante. Cela dit, il a une approche un peu spéciale en utilisant JSX et, par conséquent, mélange le HTML au JS. Ce choix divise beaucoup, et je ne suis pas un fan de cette écriture. Cela-dit, j’ai du mal à l’apprécier tel quel. Il manque de standards, d’homogénéité, et ce mélange de code HTML dans le JS ne m’apporte rien, voir me fait perdre en qualité. Mais il faut l’admettre, ReactJS marche très bien.

Bref, React et VueJS sont d’excellents outils, mais je préfère largement Angular pour sa rigueur et son assurance.

Je me suis surtout rendu compte d’une chose importante, c’est que je pense que ce qui me plait énormément avec Angular, au delà de la structure du projet, c’est Typescript. Beaucoup rejettent ce langage qui est pourtant une amélioration compatible de Javascript (vraiment, en fait vous codez en JS mais avec des extensions de langage) - et que c’est un point majeur pour assurer le fonctionnement d’un projet. Le typechecking, les “generics” (je suis pourtant pas un adorateur de cette écriture), etc… je trouve cela rassurant. Angular utilise ce langage à la perfection, et pour cause, il est nativement prévu pour ce langage. La différence se trouve dans le choix par défaut.

Et donc, ReactJS et VueJS ont choisi JSX et JS comme approche native.

oui… mais…

Mais vous le savez certainement, il est possible d’utiliser TypeScript avec React et VueJS. Autaut vous dire que cela change fortement mon point de vue - l’écriture de composant est tout à coup bien plus adaptée, surtout si vous travaillez en équipe. J’ai donc tenté l’expérience sur quelques projets. Et je me suis fait violence pour démarrer un projet en React + TSX (TypeScript à la JSX) pour vraiment creuser sur le fonctionnement et faire preuve d’honnêteté quant à mon analyse.

Et bha… c’est pas mal du tout ! VueJS et React s’en sortent même très bien, et cela m’a apporté bien plus de plaisirs à coder et surtout bien moins de stress pour gérer les erreurs.

Alors comment ça se passe ?

Vue + TS

Depuis que npx⁵ est sorti, c’est bien plus simple de démarrer un projet sans trop se prendre la tête. Le client “vue” propose des options qu’il faut regarder. L’idée est de passer par le choix “manuel”:

npx -p @vue/cli vue create my-ts-application

Il faut passer par le menu “Manually select features” et sélectionner (avec la touche espace) les options suivante:

Babel
Typescript
Router (je le recommande)
CSS preprocessor (vous choisirez celui qui vous plait)
Linter / Formatter (encore une fois c’est conseillé)
Unit Testing (optionnel mais on aime faire de la qualité n’est-ce pas ?)

Ensuite, je vous coneseille fortement de laisser les choix par défaut (“Use class-style component syntax”, “Babel along Typescript”…), sauf l’option ESLint que je trouve plus adapté avec “Prettier”.

Donc, le résultat:

? Please pick a preset: Manually select features
? Check the features needed for your project: Babel, TS, Router, CSS Pre-processors, Linter
? Use class-style component syntax? Yes
? Use Babel alongside TypeScript (required for modern mode, auto-detected polyfills, transpiling JSX)? Yes
? Use history mode for router? (Requires proper server setup for index fallback in production) Yes
? Pick a CSS pre-processor (PostCSS, Autoprefixer and CSS Modules are supported by default): Sass/SCSS (with node-sass)
? Pick a linter / formatter config: Prettier
? Pick additional lint features: Lint on save
? Where do you prefer placing config for Babel, ESLint, etc.? In dedicated config files

Alors, ça change quoi ?

Et bien voilà à quoi ressemble une Vue:

import { Component, Prop, Vue } from "vue-property-decorator";

@Component
export default class HelloWorld extends Vue {
  @Prop() private msg!: string;

  onButtonClick() {
    this.msg = "Clicked !"
  }
}

On a enfin une vraie classe exportée, les méthodes, data, etc sont enfin des éléments de la classe et non des propriétés à écrire dans une propriété spécifique. Les décorateurs @Component et @Prop proposent de configurer notre classe de manière claire. Tout change ! Et bon sang que c’est plus pratique pour coder.

@Prop est clairment l’équivalent de @Input de Angular - on retrouve vite ses petits.

⚠ Juste un point important - n’oubliez pas que la balise “script” doit avoir l’attribut lang="ts", c’est à dire: <script lang="ts">... ⚠

En ce qui concerne la reconnaissance de syntaxe dans VSCode (ou VSCodium si vous préférez une version plus respectueuse de votre vie privée), passez par le plugin “Vutter” va vous donner satisfaction. Il reconnait très bien le code TypeScript.

React + TSX

Je ne suis pas un fan de React (loin de là) - je le trouve peu rigoureux (on peut écrire un composant avec une fonction ou une classe, le routing se fait dans la vue, et la vue se trouve dans le code… bof…). Mais je dois être honnête, il est pratique et simple. Je comprend l’engouement qu’ont les développeurs Web pour cette techno.

Mais il faut que je le reconnaisse aussi, avoir utilisé React avec TypeScript m’a donné bien plus de plaisirs.

Comment on fait ?

npx create-react-app my-ts-react --template typescript

Bon… Déception, l’application générée ne propose pas un composant exemple. Mais en soit c’est assez simple de trouver la manière de faire. Voici un petit exemple:

import React, { Component } from 'react';

export default class Foo extends Component {
    render() {
        return <div>Mon Composant !</div>
    }
}

Vous allez me dire “ok… super… c’est juste plus lourd que d’écrire une classe JS ou une fonction… super ton idée”, mais non !

Tout d’abord, la gestion d’état (statefull) est plus simple et surtout plus claire en utilisant l’écriture génériques. Idem pour les propriétés qui peuvent être des interfaces à part entière:


// Des propriétés du composant
// comprennez par là: attribut de la balise
interface Profile {
    name: string,
    age: number
}

// Une interface pour les états
interface Activated {
    isActive: boolean
}

// on utilise cet état et les propriétés dans notre classe
export default class Foo extends Component<Profile, Activated> {

    state: Activated {
        isActive: false
    }

    activate = () => {
        this.setState({
            isActive: !this.state.isActive
        })
    }

    render() {
        return <div>
            <p>{this.props.name} - {this.props.age} ans - {this.state.isActivate}}</p>
            <p><button onClick={this.activate}>(De)Activate</button></p>
        </div>
    }

}

On a donc enfin du type checking, des classes bien plus claires et faciles à adapter, une logique d’écriture de projet plus adaptée à un environnement plus large. On réduit drastiquement le nombre d’erreurs.

Bon, par contre, la perte de contexte dans la vue est toujours actuelle… donc les “handlers” doivent être déclarés en “arrow fuction” (source d’erreur…)

Bref, j’ai clairement redécouvert React en passant par TypeScript.

Du coup, je quitte Angular ?

Et bien… non. 😁 - du moins, sur les gros projets, je reste sur le fait que Angular est plus adapté. Mais pour des applications plus légère, ou dans le cas où Angular peut faire peur, je pense pouvoir proposer React avec TSX. Quant à Vue, je le propose généralement si Angular est refusé, et j’essai de faire passer l’idée d’utiliser TS. Vous l’avez compris, React est mon 3ieme choix. Mais dites-vous que quelques semaines auparavent je refusais simplement de le proposer. J’ai simplement pris conscience que c’est la structure projet d’une applicaiton React qui me gène (je parle de structure de code, pas de la structure logicielle car, avec de la rigueur, on peut structurer une applicaiton proprement avec n’importe quel techno)

Angular est, de base, prévu pour développer en Typsescript. Il propose l’injection de dépendance et le routage par défaut. Ses templates sont bien séparés du controlleur, et je trouve que la gestion des requêtes HTTP (incluses nativement) est beaucoup plus adaptée que celle de React et VueJS (non native, pas standard).

J’apprécie aussi énormément le langage de template de Angular - celle de Vue me va, alors que je trouve React bien en dessous en terme d’écriture. Par exemple, faire une boucle d’affichage dans React n’est pas générique, il y a plein de façons de faire, et (je sais que cet argument ne vous ira pas) ce n’est pas du tout commun par rapport à Jinja / Twig ou à ce qu’on peut trouver ailleurs. J’attends que React propose une vraie amélioration de ce coté.

De plus, Angular a un ecosystème que j’adore, par exemple ng-bootstrap… Je sais qu’il existe des équivalents chez React et VueJS, mais l’intégration est selon moi bien mieux pensée dans l’univers Angular.

Vue me parait aussi plus simple que React, y compris avec TypeScript. Pas besoin de mettre des arrow functions pour éviter de perdre le contexte avec les handlers, et il ne demande pas l’utilisation de “generics” pour ajouter une propriété de composant. Idem pour la gestion d’état qui est plus lourde chez React. Clairement, Vue utilise Typescript de manière plus optimale que React, mais encore une fois Angular est un cran au dessus à ce niveau.

Je ne rejette pas React. Je n’ai juste pas la même philosophie d’écriture de projet que celle proposée par ce framework. Cela étant dit, si je dois démarrer un projet React à l’avenir, je vais militer pour que TypeScript soit utilisé dans le projet. Même si il n’expoite pas toute la puissance du TypeScript, la qualité d’un projet augemente fortement par rapport à ce que je vois en JSX.

Donc, bilan, je suis très attaché au code, et pour ma part le langage importe énormément pour la productivité. React gagne à utiliser ce langage. C’est bien entendu ma vision, mon avis, ma façon de voir les choses. Vous avez tout à fait le droit, et certainement raison, de ressentir les choses autrement, d’avoir d’autres objectifs et une philosophie différente de la mienne. C’est aussi ça la force de notre métier, chers amis.

Vous l’aurez donc compris, mon choix reste sur Angular, puis VueJS, et enfin React. Et surtout que je préfère largement utiliser Typescript. Et je finis sur le positif, React me plait avec Typescript, il peut, potentiellement, être un de mes choix dans des futurs projets à condition d’utiliser TSX.

https://angular.io/ ↩︎
https://reactjs.org/ ↩︎
https://vuejs.org/ ↩︎
Model Vue Controller ↩︎
Voir Introducing npx and npm package runner ↩︎

Que vaut Kapsule, le Kubernetes autogéré de Scaleway ?

Tue, 07 Apr 2020 05:15:15 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Après 3 ans de bons et loyaux services, mon cluster Kubernetes a lâché. Il a fallu que je trouve une solution pour remettre mon blog ,gitea, et autres services sur pattes sans y passer des heures. J’ai essayé Kapsule, le Kubernetes autogéré de Scaleway - voilà ce que j’en pense.

EDIT 22/04/2020: Si vous avez déjà lu cet article, j’ai corrigé une partie de ce que je disais sur le LoadBalancer, voir plus bas.

EDIT 14/05/2020: Scaleway a pris en compte le manque de documentation à propos du LoadBalancer et je les en remercie. Voir plus bas, je vous donne le lien vers la documentation.

Scaleway est un service “cloud”, fournisseur européen d’infrastructure aussi connu sous le nom de Online SAS. Fondée par Xavier Niel, c’est une filiale du groupe Iliad. Vous savez, Free… tout ça…

Scaleway est un IaaS (Infrastructure as a Service), un peu comme Amazon AWS mais avec des prix nettement inférieurs. Soyons honnêtes, il y a encore 4 ou 5 ans, l’offre était plutôt limitée. Peu de machines proposées, et rien de bien fou coté stockage à part des disques à monter sur celles-ci.

Par contre, l’idée était intelligente. J’ai beau avoir un vrai souci avec Free pour ses offres aussi cassées que son réseau, là on parle d’un service de location de serveurs pour pas cher, avec des options de préinstallation bien fichues et qui fonctionnaient (à peu près) bien.

Pour chaque machine que vous créez, vous avez le choix de la distribution à installer, ou carrément de demander une installation d’un service prêt à l’emploi. En clair, vous pouvez tout aussi bien demander une Fedora, une Debian ou une CentOS que d’avoir une instance avec Gitlab, OpenVPN ou Redmine. En quelques clics, tout est réglé.

Et soyons clairs, c’est vraiment pas cher du tout. Les machines virtuelles 2CPU 2Go de RAM à 2.99€ je trouve que c’est vraiment à la porté de tous.

Scaleway a beaucoup évolué pour proposer, depuis quelques temps, d’autres services tels qu’un service d’Object Storage de type S3, un Load Balancer, un Postgres à la demande, des machines GPU (pour le machine learning), et dernièrement Kapsule qui propose la gestion d’un cluster Kubernetes autogéré.

Et je vais être honnête, une fois de plus je ne suis pas fana de X.Niel, ni de Free, mais Scaleway a vraiment fait un effort de qualité pour un prix toujours aussi bas - sans pour autant être le fameux “AWS du pauvre” comme je l’ai entendu. Non, là vraiment, c’est pas mal du tout.

Alors pour mon cluster pété, les solutions proposées étaient donc:

soit de passer à des nouvelles machines (et donc de me retaper une installation de Kubernetes)
soit de passer à Kapsule - ce fameux nouveau service Kubernetes autogéré de Scaleway.

Kapsule

Le principe est super simple, au lieu de vous taper l’installation de Kubernetes manuellement (avec Rancher, Kubespray, ou ce que vous voulez), vous n’avez ici qu’à demander la création du cluster. Après quelques minutes (en fait moins d’une minute dans mon cas) le cluster est prêt à l’emploi.

Le prix de base est vraiment pas cher, pour un “node” DEV 1M (3cpu, 4Go RAM) vous en aurez pour 7,99€/mois.

Une option très intéressante est que vous pouvez activer l’auto scaling avec une limite maximum de Nodes. Le tout dans des Pools de machines dimensionnées selon vos besoins. On en parle après.

Par exemple, dans mon cas, j’ai demandé à avoir maximum 3 machines en cas de besoin. Bien entendu, ces machines sont facturées à l’heure (0.016€/h) jusqu’à une limite de 2€99, et seulement si elles sont démarrées.

Notez que, à cela, vous allez certainement ajouter quelques euros si vous avez besoin de stockage, car Kapsule propose de base un “StorageClass” qui permet de créer des disques SSD réseaux. Donc en gros, si vous démarrez une base de donnée sur votre cluster, il faudra stocker les données sur un “Persitent volume”, et donc passer un par un “Claim” - le prix des stockages n’est pas douloureux (environ €0.08/GB/mois).

La présentation de l’offre est ici : Kapsule

Pour résumé, Kapsule associé quelques services Scaleway, ça peut se représenter ainsi:

Maintenant, faisons le point sur ce que je trouve vraiment bien, et ce que je trouve un peu moins cool…

Création d’un cluster

L’interface de création est vraiment bien fichue.

Une des choses que j’apprécie particulièrement chez Scaleway, c’est le fait de voir le prix que vous allez payer en bas de la page de création - c’est d’ailleurs ce qui m’agace chez AWS qui ne permet pas de calculer clairement le coût d’une création de machine ou de cluster. Scaleway ne se fout pas de nous, en plus de proposer un service pas cher, il indique clairement les informations de prix (remarquez, c’est peut-être lié…)

Autres options, vous pouvez demander à avoir accès au Dashboard et d’installer un Ingress Controller de type NGinx ou HAProxy. Pas besoin du Dashboard pour ma part, mais j’ai opté pour Nginx afin de ne pas avoir à le faire moi-même.

Finalement, vous avez :

les masters gérés par Scaleway
des nodes dans au moins un “Pool” (on en parle après)
un fichier pour kubectl
au choix, un dashboard et/ou un ingress-controller

Kapsule est donc un soulagement pour la création du cluster. C’est rapide, pas cher, et je vais enfin m’abstraire de pas mal de tâches de gestions.

Le principe de Pool

Kapsule propose un système de Pool de machines qui est assez clair et pas mal pensé.

Un Pool est en fait un groupe de machines (node) à attacher à votre cluster Kubernetes. Chaque Pool défini le type de machine que vous voulez (DEV 1 M, GPU, Bare Metal…) auquel vous pouvez définir l’auto scaling ou non. Ces nodes seront labellisés correctement ce qui va vous permettre d’utiliser des “nodeAffinity” lors des déploiements de service.

Et ça c’est une sacrée bonne idée.

Pour ma part j’ai estimé qu’une seule machine dans un seul Pool me suffit, mais que je peux potentiellement monter en charge. J’ai donc réglé ce Pool pour avoir maximum 3 machines qui seront démarrées automatiquement si le besoin apparait. Pas de surprise au niveau du prix, je sais que mon cluster me coûtera 7.99€/mois minimum, ou 23.97€/mois si le Pool grossi. Pas plus !

Si vous avez quelques sites à démarrer avec plusieurs services gourmands, il vous suffit de créer un pool avec des machines légères (DEV 1 M par exemple), et un autre plus costaud avec des machines robustes pour faire tourner des BDD, un Elastic Search ou je ne sais quel glouton de CPU/RAM que vous voulez démarrer. Les Pools peuvent être créés ou supprimés à tout moment. Ce qui est en soit une excellente manière d’éviter de vous ruiner alors que votre besoin en CPU s’est tout à coup réduit pour des mois.

Petite chose que je viens de remarqué, on me propose des mises à jour à faire facilement:

Il suffit de cliquer sur le lien “upgrade” et de choisir de faire la mise à jour vers la version proposée.

Bref, la gestion de Pool est vraiment agréable, facile à gérer, et économique.

Le StorageClass

Il est difficile d’utiliser un cluster Kubernetes sans avoir du stockage persistant.

Pour ceux qui ne connaissent pas le principe, une petite piqûre de rappel:

Un conteneur est dit “stateless”, cela veut dire qu’il est sensé pouvoir être détruit sans garder un état. Du coup, toutes les données stockées au sein du conteneur disparaissent avec le conteneur quand il est éteint. Cela est vrai pour Docker, Podman, mais aussi Kubernetes. Vous pensez que c’est une mauvaise chose ? NON, c’est voulu !

Le but est que vous puissiez perdre une machine du cluster et voir votre conteneur démarrer sur une autre machine viable. Il ne faut pas que les données soient stockées sur l’hôte.

Alors comment on fait ?

La réponse est d’avoir des volumes de stockage qui sont montés sur le conteneur. On appelle cela un volume persistant.

Or, si vous voulez servir une base de données (e.g. MariaDB, Mongo, SQLite…), la vieille méthode est de créer ce volume, puis de le définir dans le déploiment pour indiquer où le monter. C’est pas marrant…

Bonne nouvelle ! Kubernetes propose un système de “réclamation”, appelé “Persistent Volume Claim”.

En gros, au lieu de créer un volume, vous créez une “demande de volume”. À charge d’un système de génération de volume de vous créer l’espace demandé et de vous fournir le volume que Kubernetes va monter pour vous. Pas de prise de tête. C’est super pratique…

Mais ?

… mais y’a un hic.

Tout n’est jamais aussi simple 😤

Comme le volume doit être monté sur n’importe quel conteneur de n’importe quelle machine, il faut que ce système de stockage soit “réseau”. On en connait quelques’uns:

Ceph,
Gluster,
NFS,
et bien d’autres…

Et par conséquent, il faut une API qui sache prendre en charge la demande de création. Bref…

Pour ajouter une couche de stress supplémentaire, certains types de volumes ne peuvent pas se monter sur plusieurs conteneurs en même temps. Cela veut dire que quand vous allez scaler un service, le volume ne pourra se monter que sur un seul hôte. Par exemple, GlusterFS n’a aucun souci à se monter sur plusieurs conteneurs positionnés sur plusieurs machines, aucun souci (à part la lenteur d’écriture), NFS pareil, mais Ceph RBD, lui, ne veut pas.

Il y a donc plusieurs modes:

ReadWriteOnce ⇒ veut dire que le mode de montage est sur un seul hôte à la fois, et pas plus
ReadWriteMany ⇒ peut être monté sur autant d’hôte en parallèle

OK, reveneons à Scaleway.

Scaleway propose des disques BSSD (donc en réseau), et a préconfiguré ce fameux StorageClass, ouf ! 🎉🕺🎊

Les BSSD, ce sont ces fameux volumes proposés depuis des lustres qui sont ici simplement créés et montés dans les Pods que vous allez démarrer. Ils sont plutôt rapides en écriture, et ne coûtent vraiment pas cher. Et par défaut, votre cluster aura ce “StorageClass” préparamétré - vous n’avez rien à faire de plus, c’est là, clef-en-main je vous dis. C’est la fête hein ! hein… non ?

Heu en fait y’a encore un hic… 😒

Seulement voilà, ces disques sont ReadWriteOnce…

Alors, on se calme hein, c’est fréquent. Parce que les services de stockage distribués sont rarement capables de proposer du ReadWriteMany en garantissant une bonne vitesse d’écriture.

Généralement les services de stockage rapides ne gèrent que le mode ReadWriteOnce. Cela n’est pas une grosse contrainte en soi. C’est un choix basé sur ce qui existe déjà et aussi pour éviter que vous pétiez un câble lors de l’écriture.

Pour la petite histoire, j’adore Gluster qui sait faire du ReadWriteMany, mais sitôt que j’ai eu besoin d’écrire des donnnées rapidement, j’ai déchanté. Et dans les faits, je n’avais pas tant besoin de monter du ReadWriteMany.

Si vraiment vous voulez avoir un service de stockage ReadWriteMany, il faudra l’installer par vous-même sur votre cluster, ou sur des instances séparées. Scaleway propose ce qu’il vous faut pour 99% des besoins, c’est déjà très bien ! Coté AWS vous pouvez utiliser un EFS (Elastic File Système) mais souvenez vous que c’est du NFS, donc lent… Sinon c’est du EBS qui est un équivalent de ce que propose Scaleway. Donc voilà… (Voir la liste ici)

Notez que c’est un sujet récurrent dans le monde de Kubernetes, et je préfère désormais ruser lorsque j’ai besoin d’avoir plusieurs Pods en parallèle qui doivent utiliser un espace de stockage commun. Par exemple, si je veux scaler un site qui dessert des fichiers statiques, ils se trouve sur un S3 - et si le framework ne le gère pas, je me débrouille pour faire tourner un truc léger, genre NFS, pour monter un volume dans le Pod. Il exite d’autres techniques, comme par exemple ajouter un sidecar qui fait la synchro des volumes, ou Mongo qui sait stocker des fichier en GridFS, et j’en passe…

Ce n’est pas vraiment une spécificité de Scaleway. Le principe est donc de s’adapter. Utiliser Kubernetes demande tout de même un peu de boulot.

Bref, la côté positif, c’est que Scaleway propose un StorageClass qui fonctionne très bien. Les volumes sont créés à la demande et monté en BSSD. Et quand vous supprimez l’application, le volume est recyclé. Si votre cluster à plus d’un node en marche, et que le Pod décide de passer d’un node à l’autre, le volume est très vite remonté dans sur l’hôte cible. Et pour ma part, je me passe plutôt facilement du ReadWriteMany.

La gestion du cluster

Là on entre dans la partie un peu moins agréable.

Si vous connaissez bien Kubernetes, vous n’aurez potentiellement pas trop de soucis de ce côté. Pour ma part, kubectl et helm me suffisent à faire ce que je veux. Je n’ai pas besoin de plus.

Mais si vous êtes à la recherche d’une solution interfacée pour permettre à des équipes de Dev de déployer des projets, il va falloir installer quelque chose. Par exemple, un Rancher sur une instance dédiée.

Et pour le coup, vous risquez une petite déception, car puisque vous n’avez pas accès aux nodes en SSH, il en pourra pas tourner sur une de ces machines. Et puisque vous n’avez pas non plus accès aux “masters”, Rancher va vous claquer des gros blocs rouges bien terrifiants sur la page de gestion puisqu’il n’arrivera pas à accéder à toutes les ressources.

Alors ce n’est pas si grave en soi… C’est même normal et pas bloquant du tout.

Ce n’est pas grave car votre but est justement de ne pas avoir à gérer ces parties. Le monitoring est proposé par Scaleway, vous pourrez donc utiliser Rancher normalement pour tout le reste (installation de services, gestion des droits utilisateurs, monitoring des conteneurs, etc.)

Finalement, le souci n’est pas vraiment Scaleway, mais Rancher qui ne propose pas (à ce que je sache) de désactiver ces erreurs de monitoring. Toujours est-il qu’il vous faudra une machine de plus pour ça. Donc ajoutez à la balance de 3 à 8€.

Sécurité et Load Balancer

Cette partie est un peu plus problématique. Rien de très grave, mais cela peut entrer en conflit avec vos besoins.

D’abords, les nodes ont forcément une IP publique. Impossible de mettre ces machines derrière un bastion. Ce qui est gênant c’est que cela implique que vos machines peuvent avoir un “NodePort” ouvert par un service qui sera accessible.

Alors, en soit c’est pratique et ce n’est pas si grave, cela permet d’utiliser facilement nginx-controller et faire pointer vos domaines sur un de vos Nodes. Mais aussi d’utiliser des NodePort pour des services non HTTP. Par exemple avec Gitea pour accéder au protocole git en SSH et non en HTTPS, je peux binder sur un NodePort.

C’est plus compliqué avec un bastion devant avec une configuration de Load Balancer à régler au poil (ce qui est possible avec le LB de Scaleway, on en parle tout de suite). Effectivement, ici, pas besoin de se battre puisque les nodes sont accessibles.

Ça vous gène niveau sécurité ? Je peux le comprendre mais dans les faits ce n’est pas si “open bar” que ça en à l’air. Les nodes n’acceptent pas de shell SSH, ils sont gérés par Scaleway.

Là où ça pêche, c’est si vous ne maitrisez pas Kubernetes et que, pour des raisons pratiques, vous décidiez d’ouvrir des NodePort sur des services sensibles. C’est de votre responsabilité !. Il est évident que vous devez faire un peu de travail pour que vos services tournent proprement. Donc, si vous avez une base de données qui tourne sur votre cluster, il serait complètement fou d’ouvrir son port d’accès en NodePort, il faut bien entendu utiliser un type ClusterIP

Reste la question des accès HTTP(s) puisque vous avez certainement demandé d’avoir un Ingress Controller (NGinx ou Traefik). Je me suis posé la question un moment, et je deais être un peu fatigué ce jour là parce que, quand on connait Kubernetes, la réponse tombe sour le sens…

Scaleway propose un service de LoadBalancer haute dispo, et au sein de votre cluster il y a déjà un controller qui repère les “Services” qui ont un type “LoadBalancer”. Si vous en créez un, alors un LoadBalancer va être créé coté Scaleway avec une IP fixe. Du coup, si vous faite tomber un node et qui redémarre, ou si vous ajoutez des nodes, le loadbalancer sera reconfiguré pour faire son travail.

Si vous voulez que votre IngressController puisse être utilisé par un LoadBalancer, il suffit de lui ajouter un “Service” de type “LoadBalancer” (non vraiment je ne comprends pas pourquoi je n’y ai pas pensé…).

Changement au 14/05/2020 Scaleway à donné une très bonne page pour expliquer comment activer un load-balancer wildcard.

J’ai signalé un manque d’informations sur ce sujet, et j’en avais parlé avec ScaleWay sur leur Slack et Twitter. Par chance, chez Scaleway, les DevOps et admins sont très sympas et prennent le temps de répondre de manière détaillée. Vraiment, merci à eux. J’ai donc eu la réponse, mais j’ai surtout eut la surprise d’avoir cette réponse sur mon Twitter:

Là pour le coup, je tire mon chapeau. Il ne manquait vraiment que cette page. Donc, la voici, elle contient ce dont vous avez besoin:

Using a load balancer to expose your Kubernetes Kapsule ingress controller service

En résumé, pour Nginx-ingress, il suffit de pousser cette configuration sur votre cluster une fois pour toute:

apiVersion: v1
kind: Service
metadata:
  name: nginx-ingress
  namespace: kube-system
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
spec:
  type: LoadBalancer
  ports:
    - port: 80
      name: http
      targetPort: 80
    - port: 443
      name: https
      targetPort: 443
  selector:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

En appliquant ce fichier, on a bien une IP pour notre ingress-controller:

nginx-ingress   LoadBalancer   10.45.150.14    51.XX.XX.XX   80:31468/TCP,443:30454/TCP   10s

Le tour est joué, cette IP peut maintenant être assigné dans les DNS, on la perdra pas, et le LB va faire le boulot comme demandé.

Ce serait bien cool que Scaleway documente cela, car mon article est resté plusieurs jours avec une mauvaise info… Mais je ne vais pas faire le lourdingue, les équipe de Scalexay répondent rapidement et avec des vraies bonne infos.

Donc, on résume:

Le LoadBalancer est utilisable, fiable, fait le boulot, c’est automatique et ça coute pas si cher.

Je vais conclure (© J.C. Duss)

Kapsule est un très bon service de création et de gestion de cluster Kubernetes. Il est économique, prêt à l’emploi, et facile à manipuler. Il est parfait pour les freelances qui veulent déployer des démos de site, ou pour des petites entreprises qui veulent héberger leurs services dans un PaaS.

Tout est là, y compris la création de volume.

Les plus grosses entreprises pourront l’utiliser notamment pour l’hébergement de démo et/ou pour l’intégration continue, mais cela demande un petit effort supplémentaire pour intégrer des outils de gestion PaaS tels que Rancher (afin d’avoir une gestion de droits par utilisateurs).

Les pools élastiques sont clairement efficaces et économiques. C’est beaucoup moins compliqué et moins cher que chez AWS.

En ce qui concerne l’hébergement de services pour les grosses entreprises avec de gros besoins, je ne vais pas trop m’avancer. Cela-dit, je gère déjà des clusters pour des grosses structures et je dois bien avouer que Kapsule peut répondre à certains clients d’envergure. Si mon avis vous intéresse, je place Kapsule au dessus de la solution EKS de Amazon, que ce soit en terme d’interface, de prix, d’aide et de tenu de route. C’est bien entendu mon avis personnel.

Le fait de pouvoir gérer des pools de machines adaptées à la puissance nécessaire, et de pouvoir les couper à tout moment permet de faire de sacrées économies.

Kapsule peut donc clairement être utilisé par une entreprise de grande envergure, tout comme un particuier, un freelance ou une petite entreprise. C’est selon moi la meilleure offre du marché de par son prix, sa souplesse et sa simplicité.

Scaleway propose un S3 et un registre docker privé qui, couplés à Kapsule, permettent en tout cas de faire 99% du travail attendu en ce qui concerne un hébergement PaaS Kubernetes. Le fait que les machines soient monitorées et que Kubernetes soit géré par une équipe dédiée en prestation est un vrai plus. Le prix du stockage d’image est de 0.025€ mais je trouve que le prix de la bande passante inter-région un peu élevé. 0.03€ par push/pull ça peut devenir vite angoissant. Par contre, en intra-région, c’est grauit. J’ai mis en place un Drone qui construir les images et les pousse sur le registre. Donc de ce coté, je ne paye rien car les pulls effectués par mes noeud Kubernetes se trouve sur la même région (Paris) que le registre.

Je ne vois plus qu’un seul bémol: l’absence de possibilité d’utiliser un bastion. Si cela est votre besoin, vous devriez plutôt passer par Scaleway Datacenter qui propose aussi une gestion de Kubernetes mais bien plus adaptée à la production niveau “entreprise”.

Bref, si vous avez envie de tester un hébergement Kuberenetes pour pas cher, et qui fonctionne bien, Kapsule est une bonne solution alternative à AWS EKS. Et en plus, c’est Européen ! (et largement géré par une boite Française).

Le don de calcul pour rémunérer un blog

Sun, 13 Oct 2019 03:58:36 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Au lieu de vous imposer de la pub, je vous propose de faire un “don de calcul”. Pourquoi ? Comment ? je vous explique !

De hein ? Quoi ? 👀

Ce blog a failli être abandonné un certain nombre de fois. J’en ai perdu la foi, j’ai même quasiment arrêté d’écrire. Mais j’y reviens.

J’étais très productif à une certaine époque, mais à force de vouloir proposer des tests, des techniques, et notamment avec la monté de la technologie de conteneurs, j’ai changé de système d’hébergement un certain nombre de fois. Même si je le voulais, en passant ce blog sur un hébergeur gratuit, j’aurais besoin de serveurs pour tester mes travaux. En l’occurence, vous le comprennez, ce blog me coute de l’argent.

Je propose pas mal à la communauté:

des images Docker
Je développe et je fournis aussi quelques outils
je partage mon expérience ici quand j’en ai le temps

Tout ça en version opensource ou creative commons, en fonction de ce que je fournis. Je ne suis pas un grand héro de l’ère informatique, mais j’apporte ma petite brique comme des milions le font. Je n’en tire pas de mérite (c’est important que vous ne pensiez pas que je pense “mériter” quoique ce soit)

Seulement, ça me coûte. Je persévère à utiliser des serveurs parce que je suis passionné par mon métier et que j’aime partager, mais ça me coûte vraiment en terme de finance.

Pour palier à cela, j’avais positionné un bloc de pub AdSense - non pas que je sois un grand fana du tracking d’utilisateur, mais soyons honnêtes leur intégration est facile, et çame rapportait de quoi rembourser une petite partie de mes frais.

Et un jour… AdBlock est arrivé… 😡

AdBlock n’est pas arrivé là par hasard. Puisque la pub peut rapporter un peu de sous, certains n’ont pas hésité à en abuser fortement. En plaçant énormément de pubs, et en faisant un gros de travail de recherche de traffic, il était possible pour certains site de se faire beaucoup d’argent. Mais au détriment des lecteurs:

ralentissment de chargement (avec énormément de données à faire transiter, la planète ne nous dit pas merci)
la gestion de la vie privée, et bien… on s’en fiche
un confort de lecture du contenu “réel” dégradé (sur mobile, certains sites sont tout bonnement inutilisables)

Bref, AdBlock a permi de virer toutes ses pubs. Mais… Le souci est qu’il bloque “par défaut”. Ceux qui par contre tentaient, comme je le faisais, de ne pas trop gêner le lecteur tout en essayant de ganger quelques sous pour le travail fourni, se sont retrouvé avec une perte de gain énorme. Pour ma part, la chute a été de plus de 90%.

Des solutions ? oui oui…

Alors il a fallu fournir encore plus de travail pour arriver à retrouver un peu de gain.

Première tentative, détecter l’utilisation de bloqueur de pub et :

soit demander gentiment au lecteur de couper son bloqueur
soit interdire la lecture si AdBlock est activé

Pour l’option 1, 50% des lecteurs ne le coupent pas. Sympa les mecs… En plus cela demande un travail assez lourd, car il existe des “bloqueurs de détecteurs de bloqueurs”, du coup ça devient une guerre sans fin pour tenter de détecter un détecteur de détecteur de bloqueur de pub… Bref, pas marrant.

Option 2, je me suis pris des mails d’insultes…

OK, donc, autre tentative, demander un don.

Personne ne donne. Vraiment personne. Et je vais être honnête, moi non plus je ne donne jamais d’argent à des auteurs de blogs, même si la qualité est vraiment au rendez-vous. Parce qu’en général, je vais sur un blog après une recherche ponctuelle, je trouve l’info, et je me casse.

Flattr, PayPal, etc… rien, que dalle, pas un don.

Du coup, j’ai envie de tester un truc.

Le don de calcul - pourquoi pas ?

Le don de calcul existe depuis des années. Bien avant la cryptomonnaie, on avait déjà les projets Seti@Home ou notre PS3 qui calculait, pendant la veille, des constructions de molécules pour la recherche.

C’est un truc pas idiot en soit. Et je me suis dit que, comme la vaste majorité des lecteurs de mon blog sont des techos, on peut peut-être trouver un terrain d’entente.

Aujourd’hui, la cryptomonnaie s’est bien installée dans notre univers, et elle a un petit avantage, elle permet de rémunerer le minage. Je ne vais pas trop entrer dans le détail, mais le minage de cryptomonnaie demande à un ordinateur de “prouver” qu’il a travaillé pour valider des transactions. Et cela, on peut le faire sur n’importe quelle machine (ou presque)

Pour le Bitcoin, c’est mort. Ça rapporte rien à moins d’avoir un ASIC et beaucoup de chance, ou une ferme de calcul.

Par contre… Le Minero, ça passe. CPU ou GPU, resistant aux ASIC, ouais ça peut le faire.

Alors voilà, je me suis dit:

Et pourquoi pas demander à mes lecteurs de miner un peu “à mon compte”

En gros, ça ne vous coûte rien (enfin si, un peu d’électricité), vous lancez un mineur local ou web, en disant que votre preuve de travail me revient.

OK, mais comment ?

Deux solutions:

Vous pouvez utiliser mon conteneur Xmrig qui, par défaut, est paramétrer pour miner pour moi (mais vous pouvez le paramétrer pour votre compte hein)

docker run --rm -it metal3d/xmrig

Ici, vous allez utiliser un “proxy” qui tourne sur mes serveurs, qui table sur MoneroOcean - ça mine des Alcoins. Ci-après, voilà à quoi ça ressemble quand on lance le conteneur.

Vous utilisez le minage “web”, qui est sur la colonne à gauche de mon site (oui, AdBlock le cache… toujours sympa hein… 😤) Ici, c’est un Minero.cc qui est utilisé, ça rapporte peu, mais c’est plus facile pour vous si vous n’avez pas Docker.

Faites tourner ça au moins quelques minutes, heures, jours… Le minage, ça rapporte peu…

Le conteneur Docker est paramétré pour utiliser les CPU en mode “idle”, donc seulement quand ils ne sont pas utilisés pour autre chose. De plus, il n’utilise que la moitié des CPU disponibles. Vous pouvez régler le nombre de CPU utilisés en ajoutant une variable:

# par exmple, avec seulement 2 CPUs
docker run --rm -it -e THREADS=2 metal3d/xmrig

T’y crois vraiment ?

Je n’en sais rien. C’est un test. Je veux vérifier:

si ça vous intéresse
si ça rapporte un peu

Pour le moment je tente le coup…

À partir d’aujourd’hui, il y aura donc un message sur chaque billet, après introduction, qui vous demandera de faire ce minage le temps de la lecture. Si vous avez Docker, vous n’aurez donc pas à couper AdBlock. Si vous le désirez, vous pouvez utiliser le minage Web (sur votre navigateur), mais il faut couper AdBlock 😒.

Je ne deviendrai pas riche, l’argent gagné devrait à peine rembourser 15% du coup de mes serveurs. Et encore…

Dans tous les cas, à tous ceux qui acceptent de miner un peu pour moi, un grand merci 🧡 !

Requête d'API REST en bash avec http et jq

Sun, 05 May 2019 14:49:15 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Nous sommes dans l’ère des API REST, le Web se tourne vers ce mode depuis des années, et ce n’est pas pour nous déplaire - car effectivement, détacher la data du “front” est une bonne idée. Et clairement cela permet aussi de devenir “client” de l’API depuis n’importe quel technologie capable de faire des appels HTTP.

J’adore travailler avec un terminal, je pense que ceux qui me cotoient le savent. Et j’adore automatiser des tâches, telles que récupérer des outils non packagés sans avoir à aller sur une page web, télécharger, déplacer le binaire, etc.

Ici, je vais vous montrer comment je me débrouille pour rendre automatique une récupération de nouvelle version d’un outil que j’utilise avec Scaleway, à savoir l’outil “scw” qui me permet de manipuler les serveurs à distance (un peu comme l’outil aws-cli pour Amazon).

Je vais utiliser httpie, jq, et wget en utilisant l’API github. Vous allez vite comprendre l’intérêt.

Avant automatisation

D’abord, il faut comprendre comment ça se passe. Pour récupérer l’outil “scw”, je dois aller sur la page https://github.com/scaleway/scaleway-cli/releases, chercher la dernière (taguée “latest”), puis trouver la version “linux-amd64” qui correspond à mon environnement.

Clique droit sur l’url… et je finis par coller l’url dans un terminal pour faire:

wget <url collée> -O ~/.local/bin/scw
chmod +x ~/.local/bin/scw

Ça parait assez simple, mais ça me demande pas mal de manipulations. Or, github propose une API ouverte. Alors ne nous en privons pas.

Travailer avec l’API

Un petit tour sur la documentation de github pour me rendre compte que je peux avoir la liste des “releases” de scw rapidement, et sans effort avoir la “dernière release” - comprennez bien “latest”.

L’URL est donc, dans mon cas: https://api.github.com/repos/scaleway/scaleway-cli/releases/latest

Le retourn est un JSON qui me présente des “assets”, quelques infos utiles, et des URL de téléchargement. Bref, un “asset” est un objet que je peux télécharger, ici ce sont les binaires pour toutes les plateformes. Or, moi, je veux la version Linux amd64.

Il est temps de parler de httpie et jq.

HTTPIe ?

J’utilise souvent “curl”, il est pratique et complet, mais depuis quelques années j’aime beaucoup “httpie” qui est selon moi plus adapté pour jouer avec des APIs. En soit, ça ne change pas grand chose, mais dans les faits il propose une “sortie” propre, colorée, et qui met en forme le JSON, le XML etc.

Vous pouvez bien entendu ne pas utiliser httpie, mais sa facilité pourrait vous convaincre.

Notez bien que “httpie” est le nom du logiciel, mais la commande à utiliser est “http”.

jq ?

JQ, pour Json Query, est un outil en ligne de commande qui permet de traiter (depuis STDIN, donc via des “pipes”) du contenu JSON, de faire des sélections, de la manipulation…

JQ peut paraitre un peu complexe dans sa syntaxe, mais il évite de passer par des commandes grep/awk qui engendrent souvent des erreurs de sélection. JQ est bien plus fiable.

Allons-y…

Traitement du JSON

Pour aller plus vite, je vais juste enregistrer l’url dans une variable pour éviter de la répéter dans les exemples ci-dessous.

$ export URL="https://api.github.com/repos/scaleway/scaleway-cli/releases/latest"

En utilisant l’adresse https://api.github.com/repos/scaleway/scaleway-cli/releases/latest, on remarque une entrée “racine” nommé “assets”:

 $ http $URL
 ...
 ...
 {
    "assets": [
    ...

Donc, clairement, nous avons là un taleau d’assets. Nous devons donc descendre dans cette entrée pour avoir les assests.

JQ vous propose la syntaxe “.assets[]” qui va sortir tous les assets, un par un, mais “hors tableau”, donc en supprimant les crochets. Le résultat n’est plus un JSON valide, mais une série de JSON. En soit ça change presque rien, mais pour le traitement final, ça aura son effet. Mais allons-y pas à pas.

Testons:

http $URL | jq '.assets[]'

Très bien… Nous avons les assets. On peut récupérer les noms, par exemple:

$ http $URL | jq '.assets[].name'
"scw-darwin-amd64"
"scw-darwin-i386"
"scw-freebsd-amd64"
"scw-freebsd-arm"
"scw-freebsd-i386"
"scw-linux-amd64"
"scw-linux-arm"
"scw-linux-arm64"
"scw-linux-i386"
"scw-netbsd-amd64"
"scw-netbsd-arm"
"scw-netbsd-i386"
"scw-windows-amd64.exe"
"scw-windows-i386.exe"
"scw_1.19_amd64.deb"
"scw_1.19_arm.deb"
"scw_1.19_arm64.deb"
"scw_1.19_i386.deb"

Bien, et pour les url:

$ http $URL | jq '.assets[].browser_download_url'
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-darwin-amd64"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-darwin-i386"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-freebsd-amd64"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-freebsd-arm"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-freebsd-i386"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-linux-amd64"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-linux-arm"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-linux-arm64"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-linux-i386"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-netbsd-amd64"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-netbsd-arm"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-netbsd-i386"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-windows-amd64.exe"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-windows-i386.exe"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw_1.19_amd64.deb"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw_1.19_arm.deb"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw_1.19_arm64.deb"
"https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw_1.19_i386.deb"

Il faut maintenant ne récupérer que l’adresse de téléchargment de la version “scw-linux-amd64”, et c’est là que ça se complique un peu. Rien d’insurmontable, mais il faut connaitre ce que propose JQ en terme de filtrage.

Ici, nous voulons utiliser l’asset dont le nom (name) est “scw-linux-amd64”. Pour cela, on va utiliser un “pipe jq” avec la fonction “select” (Voir la documentation)

$ http $URL | jq '.assets[] | select(.name=="scw-linux-amd64")'
{
  "url": "https://api.github.com/repos/scaleway/scaleway-cli/releases/assets/11793235",
  "id": 11793235,
  "node_id": "MDEyOlJlbGVhc2VBc3NldDExNzkzMjM1",
  "name": "scw-linux-amd64",
  "label": null,
  "uploader": {
    "login": "jerome-quere",
    "id": 526046,
    "node_id": "MDQ6VXNlcjUyNjA0Ng==",
    "avatar_url": "https://avatars0.githubusercontent.com/u/526046?v=4",
    "gravatar_id": "",
    "url": "https://api.github.com/users/jerome-quere",
    "html_url": "https://github.com/jerome-quere",
    "followers_url": "https://api.github.com/users/jerome-quere/followers",
    "following_url": "https://api.github.com/users/jerome-quere/following{/other_user}",
    "gists_url": "https://api.github.com/users/jerome-quere/gists{/gist_id}",
    "starred_url": "https://api.github.com/users/jerome-quere/starred{/owner}{/repo}",
    "subscriptions_url": "https://api.github.com/users/jerome-quere/subscriptions",
    "organizations_url": "https://api.github.com/users/jerome-quere/orgs",
    "repos_url": "https://api.github.com/users/jerome-quere/repos",
    "events_url": "https://api.github.com/users/jerome-quere/events{/privacy}",
    "received_events_url": "https://api.github.com/users/jerome-quere/received_events",
    "type": "User",
    "site_admin": false
  },
  "content_type": "application/octet-stream",
  "state": "uploaded",
  "size": 11409167,
  "download_count": 80,
  "created_at": "2019-03-29T13:24:02Z",
  "updated_at": "2019-03-29T13:24:06Z",
  "browser_download_url": "https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-linux-amd64"
}

Il ne reste plus qu’à récupérer la propriété “browser_download_url” qui est l’url de téléchargement. Un dernier point, nous utilisons l’option “-r” pour avoir une sortie brute (raw) afin d’éviter que JQ ne mette en forme l’url avec des guillemets.

$ http $URL | jq -r '.assets[] | select(.name=="scw-linux-amd64").browser_download_url'
https://github.com/scaleway/scaleway-cli/releases/download/v1.19/scw-linux-amd64

Voilà, nous avons l’url de téléchargement de la dernière version de scw, reste à faire un petit script de mise à jour (version simplifiée):

# simple function to get latest release from a repository
get_release() {
	REPO=$1
	NAME=$2
	URL="https://api.github.com/repos/${REPO}/releases/latest"
	http $URL | jq -r '.assets[] | select(.name=="'$NAME'").browser_download_url'
}

# update scaleway cli
update_scw() {
	REPO="/scaleway/scaleway-cli"
	NAME=scw-linux-amd64

	URL=$(get_release "$REPO" "$NAME")
	wget "$URL" -O ~/.local/bin/scw
}


case $1 in
    scw) update_scw ;
    *) echo "Unknown $1 command to update";;
esac

Et je peux ensuite créer des fonctions pour chaque clients que je récupère sur github, en ne spécifiant le dépôt, et le nom du binaire, en paramètre de “get_release”

Et voilà, de temps en temps je tape la commande: update-cli scw (ou autre, j’en ai quelques-uns dans ma liste), et plus besoin d’aller sur la page github, de faire des manipulations, etc.

Conclusion

La ligne de commande n’est pas privée de l’intérêt des API REST. Avec httpie ou curl, jq, et l’ensemble des outils ancêstraux comme awk, grep, sed… quelques lignes de commande suffisent à avoir un client bash capable d’utiliser les API.

Il est évident que pour des API plus complexes, un langage de programmation plus adapté (Python, Go, NodeJS…) va proposer des options plus avancées, mais jq est assez complet pour faire des manipulations json remarquables.

Fedora, de Docker à Moby

Sun, 07 Apr 2019 00:51:17 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si vous êtes utilisateur de Docker sur Fedora 29, vous avez certainement installé le paquet “docker” des dépôts officiels, ou “docker-ce” des dépôts Docker. Sauf que les paquets diffèrent drastiquement en terme de version. Alors on va parler de Moby.

TL;DR

Pour résumer, à ceux qui n’ont pas envie de lire tout le billet, la version sans marque de Docker-CE existe dans les dépôts officiels de Fedora sous le nom “moby-engine”. Pour l’installer:

sudo systemctl stop docker
sudo dnf remove docker docker-ce
# si vous avez installé les dépôts Docker, vous pouvez les supprimer
# dans le répertoire /etc/yum.repos.d/
# puis:
sudo dnf install moby-engine
sudo systemctl start docker

Et vous voilà avec une version de docker à jour, gérée par la communauté Fedora.

Moby ?

Quand on parle de Docker, on ne sait pas vraiment de quoi on parle… Parlons-nous du client, des conteneurs, du services, de ses commandes pour démarrer et gérer des conteneurs? On en oublie que Docker est un produit assez large, géré par une entreprise du même nom, qui propose une version “CE” (Community Edition) et une version “Entreprise” (EE).

Sur Fedora, on retrouve une paquet un peu ancien, nommé “docker”, mais à quoi fait-il référence ?

Le fait est que certaines distributions tiennent à garder une certaine cohérence en tereme de licence et de respect de la philosophie “libre”. Donc la préférence va généralement se porter sur la version la plus “libre” et la moins soumise à des droits pouvant porter préjudice aux projets “vraiment libres”. Mais alors que peut-il se passer avec Docker ?

Et bien sur Fedora, ça pose un léger problème. Docker-CE est “brandé” (terme angliciste qui veut dire, en gros, que nous parlons d’une marque, et non d’une technologie). En soit ce n’est pas si grave, mais dans les fats il existe depuis 2017 une séparation de projet. En effet, il y a “Moby”, et “Docker” – bien que liés, il y a une différence en terme de “marque”.

Bon, OK, et du coup c’est quoi Moby ?

Moby a été lancé à l’initiative de Docker en 2017, c’est un projet de “kit” permettant de construire une solution de conteneurisation standardisée sur laquelle Docker lui-même repose.

Solomon Hykes, le créateur et gérant du projet Docker en parle dans un de ses tweets:

The @moby Project in a nutshell: inside and outside. pic.twitter.com/K8Rn9YYtVs
— Solomon Hykes (@solomonstre) April 22, 2017

On ne va pas en faire des caisses, disons simplement que Moby est la base du projet, et que Docker est un produit constuit à base de Moby. Si je devais vous expliquer tout ce qu’impliquent Docker, Moby, et les “sous-projets” que sont “runC”, CRI etc… on y passerait des pages entières, et vous ne serez pas plus avancés.

Revenons à Fedora et les paquets “docker”

Depuis des mois, voir des années, j’utilise le paquet “docker” fourni dans les dépôts Fedora. Et comme mon collègue, Daniel, me l’a fait remarqué, ce paquet semble bloqué à la version 1.13 – alors que la version “docker-ce” proposé par Docker est en version 1.18 depuis… des mois.

Donc, j’ai deux choix:

utiliser un paquet officiel Fedora
utiliser un paquet officiel Docker

Dans le premier cas, j’évite l’installation d’un dépôt tiers, mais (vous allez comprendre juste après) je me retrouve avec une version très en retard de Docker. Et dans le second cas, je suis à jour, mais j’ai moins confiance. C’est un dépôt tiers qui n’est pas géré par la communauté – mais j’ai une version à jour. Bref, le choix est rude. Sauf que…

En parlant sur IRC avec Kwizart (décidément il est une source d’infos importante pour moi), j’apprend qu’un paquet nommé “moby-engine” existe sur les dépôts, alors que le paquet “docker” est en cours d’abandon. Et ce paquet, vous l’avez compris, part du projet Moby (capt’ain Obious merci), et propose une version à jour.

L’idée est qu’en partant de Moby, on évite de nommer le paquet avec le nom de la marque, mais on peut tout de même utiliser le mot “docker” pour les commandes et le service. Ça semble bon.

Et donc, j’ai testé.

On essaye

Allez, ça coûte rien d’essayer, de toutes manières mes conteneurs sont “jetables” (c’est le but des conteneurs je vous le rappelle) et je peux parfaitement revenir à un état antérieur grâce à “dnf history”.

On vire docker, point barre:

sudo systemctl stop docker
sudo dnf remove docker docker-ce

Voilà, c’est fait. Reste à installer “Moby-engine”:

sudo dnf install moby-engine

Et là, pas de panique, ce paquet propose les mêmes outils et commandes docker – donc vous allez retrouver le service “docker” (et “dockerd”) et la commande du même nom.

sudo systemctl start docker
docker version
Client:
 Version:           18.06.0-dev
 API version:       1.38
 Go version:        go1.11.5
 Git commit:        0ffa825
 Built:             Mon Feb 11 14:47:59 2019
 OS/Arch:           linux/amd64
 Experimental:      false

Server:
 Engine:
  Version:          dev
  API version:      1.38 (minimum version 1.12)
  Go version:       go1.11.5
  Git commit:       0ffa825
  Built:            Mon Feb 11 14:47:26 2019
  OS/Arch:          linux/amd64
  Experimental:     false

Et oui, la version colle bien à “docker-ce”, mais je n’ai pas eu besoin des dépôts Docker, tout est bien dans les dépôts officiels de Fedora.

Et voilà une raison de plus qui me fait préférer Fedora aux autres distributions: j’évite de prendre des dépôts externes et je reste en confiance.

Pour information, mes anciens conteneurs fonctionnent toujours, mes images sont encore là, rien n’a vraiment bougé à part le fait que je suis mainenant en train d’utiliser une version récente de Docker.

Un souci ?

Il se peut que vous ayez un souci, honnêtement rien n’est jamais parfait, et sur un de mes postes j’ai eu un tout petit problème à régler.

Dans mon cas, je mets à jour Fedora sur un poste depuis la version 25 je crois, et sans réinstallation. Depuis cette date, j’ai beaucoup manipulé les installations de Docker et j’avais utilisé “devicemapper” des années auparavent. Puis je suis passé à Overlay2, sans jamais avoir supprimé le répertoire de volumes et conteneurs. Pour la version 1.13 de Docker, il n’y avait pas de souci, mais là… En passant à Moby-Engine, j’ai eu une erreur.

En regardant les logs (via journalctl), j’ai vu qu’il n’aimait pas le fait d’avoir plusieurs possibilités de pilotes de volumes d’écritures. Il m’a suffit de supprimer le répertoire /var/lib/docker/devicemapper pour que ça passe.

Si vous avez des soucis, je serai heureux que vous commentiez et j’ajouterai les solutions dans ce billet.

Pour conlure

Je n’ai rien contre l’entreprise Docker, bien au contraire je respecte le travail de fait et leur ouverture à un produit qui est, aujourd’hui, majeur. Je ne cherchais pas à m’écarter de l’entreprise mais je voulais vraiment avoir un paquet récent de Docker depuis les dépôts Fedora. Je comprends que le nom du paquet puisse limiter sa reconnaissance (et c’est pour cela que j’en parle dans ce billet) – mais si vous êtes utilisateur de Fedora, je vous conseille de passer à “moby-engine”. Cela ne vous changera rien en soit, ce sera bien Docker-CE, vous aurez les mêmes outils, etc. Mais sans utiliser un dépôt tiers, et surtout en restant à jour.

Le projet Moby est une initiative qui me plait énormément. J’applaudie Docker d’en être l’initiateur et de respecter l’ouverture d’esprit propre à la philosophie du libre.

Pour en savoir plus sur Moby:

Cuda et Tensorflow sur Fedora 29

Sat, 06 Apr 2019 15:33:25 +0200

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

L’un des points sensibles quand on veut travailler en machine learning avec TensorFlow, c’est l’installation et la gestion de version de CUDA - voici la marche à suivre que j’utilise depuis quelques temps et qui me permet de faire les choses bien.

J’utilise Fedora 29, et il fait bien l’avouer, l’installation de CUDA et des libs CuDNN sont franchement pas géniales si on se réfère à la documentation Nvidia. La récupération de la bonne version CUDA et le fait de devoir s’inscrire pour récuperer un tarball pour la librarie CuDNN est pas l’idée que je préfère… Bref !

Au détour d’une conversation sur le canal fedora-fr (IRC, sur freenode), Nicola Chanvet alias Kwizart me parle d’une section de RPM Fusion qui fait mon bonheur. Alors allons-y, lançons nous dans une installation propre de ce qu’il faut pour avoir les pilotes Nvidia, CUDAO 10, et les libs CuDNN nécessaires pour Tensorflow, mais aussi pour faire des rendus Blender rapides, ou encore jouer dans de bonnes conditions.

Étape 1, on dégage les vieilles libs pourries

C’est la phase la plus ennuyeuse, à faire si vous avez déjà installé des paqutes. Voilà comment j’ai fait:

# on vire cuda
sudo dnf remove cuda
sudo dnf remove cuda-*
sudo dnf remove $(sudo dnf list installed cuda*)
sudo dnf remove $(sudo package-cleanup --leaves | grep cuda)

Voilà, ça c’est fait.

Reste à nettoyer les déchets:

sudo rm -rf /usr/local/cuda /usr/local/cuda*

Ça fait du bien hein :)

Étape 2 (ou 1 pour certains) on installe les bon dépôts, les pilotes, etc…

Si vous n’avez pas encore RPM Fusion

Maintenant que vous avez nettoyé un peu, on peut passer à une installation cool.

Si ce n’est pas déjà fait, vous allez installé les dépôt RPM Fusion:

sudo dnf install \
   https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm \
   https://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

Installer le pilote nvidia

Si vous ne l’avez pas encore fait, on peut maintenant installer le pilote “nvidia” (propriétaire, c’est moche, mais pas le choix).

Avec ces dépôt, on peut installer les pilotes nvidia. Passez par akmod au lieu de kmod pour assurer une compilation du module lors des mises à jour du kernel, c’est selon moi bien plus sécurisant.

sudo dnf makecache
sudo dnf install akmod-nvidia

Là je vous conseille de redémarrer l’ordinateur.

Maintenant que le pilote nvidia est là, vous pouvez vérifier facilement si la carte est bien reconnue en tapant nvidia-smi dans un terminal:

nvidia-smi
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 418.56       Driver Version: 418.56       CUDA Version: 10.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 106...  Off  | 00000000:02:00.0  On |                  N/A |
|  0%   42C    P8     5W / 120W |    111MiB /  3019MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|    0      1795      G   /usr/libexec/Xorg                             39MiB |
|    0      1946      G   /usr/bin/gnome-shell                          69MiB |
+-----------------------------------------------------------------------------+

Bien, tout est là. On passe à CUDA et cuDNN.

Notez bien la version de CUDA, on va en reparler

Installer CUDA et cuDNN

C’est maintenant que vous allez installer les paquets qui changent tout pour TensorFlow, Blender, et certains jeux.

La documentation du site nvidia est vraiment pas claire, alors que dans les faits… c’est tellement plus simple de passer par une simple ligne d’ajout de dépôt à l’ancienne.

En se basant sur la page RPM Fusion, section “Machine Learning” comme me l’a indiqué Kwizart:

# on installe les dépôts cuda et machine learning de nvidia
sudo dnf install https://developer.download.nvidia.com/compute/cuda/repos/fedora29/x86_64/cuda-repo-fedora29-10.1.105-1.x86_64.rpm
sudo dnf install https://developer.download.nvidia.com/compute/machine-learning/repos/rhel7/x86_64/nvidia-machine-learning-repo-rhel7-1.0.0-1.x86_64.rpm

# puis les paquets:
sudo dnf install cuda
sudo dnf install libcudnn7 libcudnn7-devel libnccl libnccl-devel

Je vous préviens, CUDA prend presque 3.8Go sur votre disque, donc soyez prêt à attendre si vous avez une connexion internet compliquée. Mais en soit, enfin on évite une inscription sur le site Nvidia pour récupérer la lib CuDNN !

Et là, ne cherchez pas plus loin, on va avoir un problème

Ce qui va vous faire un peu mal… c’est que, à l’heure où j’écris ces lignes, TensorFlow 1.13 n’est pas compatible avec CUDA 10.1, mais CUDA 10.0 – et pour parfaire la crise, il faut aller récupérer le dépôt nvidia pour… Fedora 27. Sympa hein ?

En définitive, il faut installer une version antérieure de CUDA pour assurer la compatibilité avec TensorFlow… régulièrement…

Le plus simple, c’est de créer un fichier de dépôt à partir du premier, mais comme je voulais aussi changer le nom… voilà le fichier à créer:

sudo tee /etc/yum.repos.d/cuda-f27.repo << EOF
[cuda-old]
name=cuda-old
baseurl=http://developer.download.nvidia.com/compute/cuda/repos/fedora27/x86_64
enabled=1
gpgcheck=1
gpgkey=http://developer.download.nvidia.com/compute/cuda/repos/fedora27/x86_64/7fa2af80.pub
EOF

sudo dnf makecache

Et d’installer la version antérieure:

sudo dnf install cuda-10-0

Donc, à patir de maintenant, vous avez deux versions de CUDA sur votre poste, une 10.0 et une 10.1. Heureusement pour nous, CUDA s’installe dans /usr/local/, et sépare les versions en tant que telle en nommant les répertoires. Et c’est un lien sympbolique de /usr/loca/cuda sur un des répertoires qui active la version “par défaut”.

Cela veut dire que vous avez deux solutions:

soit vous forcez la variable LD_LIBRARY_PATH=/usr/local/cuda-10.0 avant de démarrer un shell python, jupyter ou ce que vous voulez…

soit vous modifiez le lien sympbolique:

ln -sf /usr/local/cuda-10.0 /usr/local/cuda

Dans le second cas, vous allez donc changer la version par défaut pour tout le système. En soit ce n’est pas très grave, mais il faut le savoir.

Testons…

C’est bien beau d’avoir installé CUDA et CuDNN, mais il va falloir au moins vérifier que tout fonctionne. Ce que je vous propose est une simple session TensorFlow qui doit soit vous péter une erreur limite insultante, soit vous donner le sourire.

La méthode la plus facile que j’ai à vous proposer est la suivante:

python3 -mvenv /tmp/tftest
source /tmp/tftest/bin/activate
pip3 install -U tensorflow-gpu
python3
>>> import tensorflow as tf
>>> tf.Session()

Vous devez alors voir une ligne dire que le GPU est présent et utilisable, chez moi ça donne quelque chose du genre (en supprimant des lignes qui ne vous intéressent pas):

2019-04-06 16:48:16.370115: I tensorflow/compiler/xla/service/service.cc:158]   StreamExecutor device (0): <undefined>, <undefined>
...

2019-04-06 16:48:16.635396: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1433] Found device 0 with properties: 
name: GeForce GTX 1060 3GB major: 6 minor: 1 memoryClockRate(GHz): 1.7085
pciBusID: 0000:02:00.0
totalMemory: 2.95GiB freeMemory: 2.77GiB
...
2019-04-06 16:48:16.635434: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1512] Adding visible gpu devices: 0
2019-04-06 16:48:16.637520: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1115] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 2541 MB memory) -> physical GPU (device: 0, name: GeForce GTX 1060 3GB, pci bus id: 0000:02:00.0, compute capability: 6.1)

Cela signifie que mon GPU est bien reconnu et utilisable par TensorFlow, c’est donc gagné !

Pour la suite

Lorsque TensorFlow sera enfin à jour pour CUDA 10.1, vous pourrez supprimer le paquet cuda-10-0 et le fichier /etc/yum.repos.d/cuda-f27.repo, puis remettre d’aplomb la base de packages: sudo dnf makecache.

TensorFlow est effectivmement un peu trop sensible à mon goût en ce qui concerne la version de CUDA. Cela étant dit, quand on connait un peu Fedora et la gestion de dépôts et de paquets, arriver à fire cohabiter deux versions de CUDA reste possible. Je dois bien l’admettre, c’est un peu trivial, mais je pense avoir donné les infos suffisantes ici pour arriver à travailler sans trop de souci.

En ce qui concerne CuDNN, vous pouvez vous en passer, l’utilisation de conda permet de soulager un peu le travail. Voici un exemple d’environnement conda qui vous permttra de faire du tensorflow sans trop de mal:

# installez conda depuis les paquets
sudo dnf install conda

# créez un environnement nommé tf avec tensorflow-gpu
conda new --name tf tensorflow-gpu

# activez l'environnement
conda activate tf

L’intérêt ici est que conda fourni la librairie cuDNN et semble ne pas avoir de souci de gestion de versions. Cela évite donc l’installation d’une série de RPM qui restent dans le système et de séparer par conséquent ces librairies dans un environnement spécifique. Personnellement je suis un gros consommateur de solutions de séparation d’environnement (cf. VirtualEnv, conda, Docker…) - j’évite le plus souvent possible d’avoir à modifier des fichiers dans les répertoire système.

À noter que, oui, je suis au courant de l’existence de “nvidia-docker” mais que je suis en train de tenter de passer de docker 1.13 (des dépôts Fedora) qui (selon ce qu’on me dit) n’est plus vraiment supporté, contre “moby-engine” qui est la version Docker “communautaire sans marque”. Je n’ai pas encore eut le temps de me pencher sur le sujet, mais ça va vite arriver.

Dans un prochain article, je vous montrerai comment créer un environnement “jupyter” capable de “voir” les autres environnements conda et par conséquent d’éviter la redondance d’installation de jupyeter pour les environnements séparés.

Mais pour l’heure, nous avons au moins installé les pilotes, conda en deux versions, et le tout sans tout casser dans notre système.

Me contacter

Thu, 14 Feb 2019 18:53:28 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Évidemment, je vais éviter de donner mon mail personnel ici, j’en ai un peu marre du spam, mais vous pouvez le deviner. C’est “Metal3d” sur le service mail de Google.

Sinon, je m’exprime sur Mastondo https://techlover.eu/@metal3d. Si vous ne connaissez pas cet équivalent plus sain à Twitter, j’ai écrit un truc ici : Je quitte Twitter

Inutile de tenter Facebook, même si vous m’y trouverez, je n’y vais jamais (pas plus d’une ou deux fois par an).

Et enfin, vous me trouverez certainement de temps à autre sur IRC, sur le canal “#fedora-fr” sur les serveurs freenode. Sur discord aussi (Metal3d#9371), et certainement à droite à gauche sur des forums Blender, Linux, et je ne sais quel autre service.

Qui c'est ?

Thu, 14 Feb 2019 18:53:28 +0100

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Il… est de retour

Le retour du blog m’sieurs dames !

Tout d’abord, un petit message sur le “retour” du blog. Ensuite, un coup de gueule face à des critiques qu’on me balance sur l’écriture inclusive que je n’utilise pas, et enfin, je me présente.

Il y a quelques mois, j’ai abandonné ce blog (mais je suis revenu hein).

L’ancien blog était développé en Go (comme aujourd’hui dans les faits), car je créais un petit framework rapide pour monter ce genre de site. À côté de cela, j’avais monté des outils pour travailler et que je léguais à la communauté. Je précise, je donnais les sources sous licence libre, mais aussi, j’hébergeais ces solutions :

un service PlantUML avec éditeur en ligne + partage
un émulateur assembleur que pas mal de professeurs d’informatique utilisaient (je le sais par leurs messages de remerciement, j’étais très heureux)
un outil de filtrage Bayesien (détection de commentaire spam via une API que je fournissais gratuitement)
et 5 ou 6 autres trucs, plutôt bien utilisés

Bilan ⇒ Presque 3 000 connexions par jour sur ce serveur.

Comprenez bien que j’y ai passé des heures, que ce serveur n’était pas gratuit pour moi, et que je l’avais fait pour proposer des choses qui pouvaient être hébergées par tout à chacun. Jamais je n’ai empêché qui que ce soit d’utiliser les sources, l’outil ou de le modifier, c’est contre ma philosophie.

Mais soyons clairs, j’avais donc besoin d’un serveur assez robuste, qui me coûtait assez cher.

À un moment donné, ça me revenait assez cher, trop cher. Avec les visites sur mon blog, j’ai décidé de poser un seul encart de pub, en bas de page, pour essayer de rentrer dans mes frais. Et ça n’a pas marché… Vous le sentez venir le coupable ?

Et oui, AdBlock…

De ce fait, j’affiche un message si je détecte le bloqueur pour demander de débloquer ce blog, que je ne cherche pas à polluer la page, que ça reste discret etc. Et j’ai été… comment dire… déçu par les réponses. Parce que, pour commenter un billet, il n’y a pas grand monde (je n’en veux à personne, je commente peu aussi), mais pour insulter l’auteur qui cherche à monétiser son site, là, on prend bien son temps !

Mails d’insultes, commentaires désobligeants, critique acerbes, tout… Voilà, j’en ai eu marre de modérer ces messages, de mettre des filtres dans ma boite mail pour dégager les insultes… J’ai tout arrêté.

Aujourd’hui, j’ai de nouveau envie. Je vais tenter une autre approche : faites un don de calcul (regardez sur la colonne de gauche).

Je suis étonné, mais ça fonctionne, j’ai régulièrement quelques micro-XMR qui arrivent sur mon portefeuille de crypto, donc merci à vous !

Écriture inclusive ?

Franchement, je n’ai pas le temps de reprendre mon contenu, et de toutes manières : je n’aime pas cette écriture. Elle impose trop de contraintes, et je sais que le jour où je vais oublier un mot à mettre dans les deux genres, on va me tomber dessus. Donc autant être clair :

J’utilise la forme “conventionnelle” (avec tout plein de fautes, je sais !!!)
Je vous demande de prendre les termes masculins comme étant “neutres”.

Je défends bec et ongle la cause féminine, je défends l’égalité, je respecte tout le monde de la même manière. Ne pas utiliser l’écriture inclusive ne veut en aucun cas dire que je défends un discours patriarcal ou que je me fous des femmes.

Partez du principe que, de base, je parle à tout le monde avec respect, que je ne différencie pas les capacités des lecteurs (et donc lectrices, je précise une bonne fois pour toutes) en fonction de leur genre. Quelle que soit la grammaire. Si par contre un de mes articles vous semble misogyne, n’hésitez pas à me le faire remarquer, je corrigerai au plus vite.

À propos de moi

Je vais enfin parler un peu de moi, rapidement, que vous sachiez qui est l’auteur du blog que vous lisez.

Mon nom est Patrice Ferlet, je suis “ingénieur en informatique”, c’est large, ce n’est pas précis, c’est même trompeur. Bref, je travaille depuis l’an 2001 dans le domaine de l’informatique.

Après un périple dans plusieurs entreprises, j’ai fini par me poser dans une boite qui me correspondait bien.

Mes débuts

J’ai en réalité commencé ma carrière comme développeur PHP, j’ai beaucoup travaillé sur Copix (un des tout premier framework PHP à l’époque, et franchement il marchait bien) dont je faisais partie de l’équipe de développement. Mais voilà… Nous avons pris notre envol sur d’autres sujets, nous avons tous changé de boite plusieurs fois, nous nous sommes même perdus de vue. Dommage. Mais…

Mais finalement, nous avons aussi tous pris des directions passionnantes. Pour ma part, j’ai clairement orienté mon métier vers une discipline qui me correspondait bien plus, à savoir l’architecture logiciel.

Doucement j’ai basculé sur d’autres sujets.

À force, j’ai surtout travaillé en Python, puis en Go, et j’ai ajouté dans mes bagages Docker, ensuite Kubernetes, et OpenShift (devenu OKD en version communautaire). Ces sujets intéressaient mon ancien directeur, une chance pour moi, il me propose alors de rejoindre l’équipe R&D pour travailler sur ces sujets.

Et une chose en entrainant une autre, j’ai mis les mains dans le Machine Learning (Keras, TensorFlow…), mais aussi dans Angular (rien à voir hein), Java, Ruby, Gstreamer, OpenCV… et même dans le WebGL

Les années “Smile”

Je travaillais depuis (ho la vache…) 2008 chez Smile. J’y travaillais, entre autre, dans le pôle de “Direction de l’innovation” - mes sujets de prédilections sont à ce jour le DevOps et le Machine Learning (TensorFlow, Keras, Scikit-learn… oui, tout en Python). Mais à la base, il faut être précis : j’étais développeur Web.

C’est au fil des ans que j’ai pris des responsabilités, que j’ai monté des équipes, que j’ai formé des gens, que j’ai partagé mes connaissances. Et que j’ai appris des autres, que j’ai appris des erreurs, que j’ai appris à ne pas juger, que j’ai appris à écouter, que j’ai appris à comprendre.

Les choses en entrainant d’autres, j’ai fini par être “Lead Tech” dans mon pôle, et j’ai pris des responsabilités sur des sujets. Et clairement, de “simple développeur” (et ne croyez pas que je dénigre ce métier, c’est un métier passionnant), j’ai fini par faire bien plus de choses que prévues.

Je suis donc, à ce jour, ce que l’on appelle un “Lead Tech”.

L’aventure “Klee” qui commence

Et aujourd’hui, (depuis 2023), c’est chez Klee que je travaille, toujours sur des sujets passionnants, en qualité de “Lead Tech, DevOps”. Mon rôle est toujours de faire en sorte que les équipes techniques puissent travailler dans les meilleures conditions possibles, et que les projets soient menés à bien. J’apporte donc mon lot de connaissances sur Linux, la conteneurisation, les langages que je maitrise, et je m’efforce de rester à jour sur les nouvelles technologies.

Autres sujets

À côté du taff, c’est Blender qui me prend pas mal de temps 🤘

En gros, ce métier n’est pas un labeur à mes yeux. C’est une passion dévorante, je ne vois souvent pas les heures passer et je déborde pas mal sur mes nuits pour lire, tester, comprendre.

KubeSpray, installer kubernetes et créer un utilisateur admin en quelques minutes

Mon, 04 Dec 2017 07:07:56 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si vous voulez vous mettre à Kubernetes, sur des machines physiques ou virtuelles, il serait bon de lire ce petit article pour ne pas vous trouver en état de panique après quelques minutes. Essayons de faire les choses simplement.

Kubernetes (développé par Google) est un orchestrateur de conteneurs qui permet une maitrise poussée du fonctionnement. Il fonctionne presque partout, apporte une normalisation des déploiements, une gestion des rôles poussés, etc… Google a vraiment bien faut le boulot et a proposé cet outil sous licence libre.

Red Hat a d’ailleurs refondu OpenShift en surcouche de la solution, ce qui induit que si vous comprennez Kubernetes alors OpenShift vous semblera très familier après coup. Les objets Kubernetes sont d’ailleurs utilisables dans OpenShift.

Bref, l’installation de Kubernetes est un sujet qui peut s’avérer un peu compliqué si on s’y prend mal, alors que la réalité est toute autre. Nous allons utiliser un projet nommé “kubespary” qui utilise Ansible pour le provionnement de machine.

Ensuite, on passera au paramètrage de notre client “kubectl” pour arriver à utiliser le dashboard depuis notre ordinateur.

Préparation de l’environnemnt

Il vous faut 3 machines (VMs, ou phyique) sur lesquelles vous pouvez vous connecter en ssh avec une paire de clefs.
Il vous faut Ansible version 2.4 (c’est ce que j’ai, ça marche peut-être avec une version antérieure).
Et on aura besoin de kubectl sur le poste client
Et enfin, il faut la commande “pip” (paquet python-pip sur Fedora) et que votre PATH ait “~/.local/bin”.

Faites en sorte que le répertoire ~/.local/bin soit dans votre PATH, ce sera plus simple…

Téléchargement de kubectl

Là c’est simple:

$ curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
$ chmod +x kubectl
$ mv kubectl ~/.local/bin
$ kubectl version
Client Version: version.Info{Major:"1", Minor:"8", GitVersion:"v1.8.4", GitCommit:"9befc2b8928a9426501d3bf62f72849d5cbcd5a3", GitTreeState:"clean", BuildDate:"2017-11-20T05:28:34Z", GoVersion:"go1.8.3", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"8", GitVersion:"v1.8.3+coreos.0", GitCommit:"f96beb2e925b0bb4e6ac0de746c7155dcd8fdc10", GitTreeState:"clean", BuildDate:"2017-11-13T10:18:37Z", GoVersion:"go1.8.3", Compiler:"gc", Platform:"linux/amd64"

Un truc pratique à savoir, kubectl permet la completion dans Bash, ce que vous pouvez faire c’est d’ajouter la commande suivante dans votre fichier ~/.bashrc:

source <(kubectl completion bash)

Vous pouvez aussi taper cette commande dans votre session bash actuelle por l’activer de suite.

Installation de kubspray

Le projet est sur la page github: https://github.com/kubespray/kubespray-cli

On commence par installer kubespray-cli - je préfère toujours utiliser “pip” en mode “user” pour que l’installation soit dans mon “home” (holalal que du franglais). C’est simplement que n’aime pas que mon utilisateur installe des trucs qui ne sont pas la distribution Linux que j’utilise, ailleurs dans le système. Et “pip” sait faire ça:

pip install --user kubespray

Si vous avez bien ~/.local/bin dans votre “PATH”, tout va bien se passer.

Maintenant, on va créer un inventaire Ansible. Vous pouvez le faire manuellement mais kubespray sait le créer pour vous:

kubespray-cli prepare --nodes node1 node2 node3

Vérifiez ensuite l’inventaire que vous allez certainement vouloir modifier. Il se trouve à l’emplacement ~/.kubespray/inventory/inventory.cfg

Voici le mien:

[kube-master]
origin-m1		
origin-m2		
origin-m3		

[all:vars]
ansible_user=root

[all]
origin-m1
origin-m2
origin-m3

[k8s-cluster:children]
kube-node		
kube-master		

[kube-node]
origin-m1		
origin-m2		
origin-m3		

[etcd]
origin-m1		
origin-m2		
origin-m3

Ici, j’ai donc 3 machines qui sont toutes master, node et noeud etcd.

J’ai ajouté la partie “[all:vars]” pour forcer l’utilsateur (root, c’est mal…), et notez aussi que vous pouvez ajouter des variables à chaque noeud du groupe “all” pour, par exemple, donner l’adresse IP de la machine cible (eg. origin-m1 ansible_ssh_host=xx.xx.xx.xx).

Bref, il faut quand même respecter deux ou trois choses:

etcd doit avoir 3 machines, c’est nécessaire pour le concensus
avoir au moins un node et un master
de l’aspirine si ça marche pas

On teste si tout est ok:

$ ansible -i ~/.kubespray/inventory/inventory.cfg all -m ping
origin-m2 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
origin-m1 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
origin-m3 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}

Toutes les machines doivent répondre par un pong. Si c’est pas le cas:

vérifiez les hosts
vérifier l’utilisateur
avez vous bien envoyez vos clefs aux serveurs ?
etc…

Provisionnement des machines

Bon, on passe à l’installation:

$ kubespray deploy
# [...]

PLAY [lb] **************************************************************************************************************
skipping: no hosts matched

PLAY RECAP *************************************************************************************************************
xxx            : ok=64   changed=19   unreachable=0    failed=0   
yyy            : ok=64   changed=19   unreachable=0    failed=0   
zzz            : ok=64   changed=19   unreachable=0    failed=0

C’est parti. l’installation prend entre 10 et 20 minutes environ selon le nombre de machines, la puissance de votre ordinateur, la phase de la lune et le cours de rouble.

Si tout est “ok” à la fin, bravo.

Chez moi ça a pété… j’ai relancé l’installation et cette fois tout est rentré dans l’ordre. Pour info, de mon coté, j’avais une perte de connexion entre un node et un master. Impossible de savoir pourquoi.

Alors oui, j’ai omis le fait que vous pouvez modifier plein d’options, comme le type d’overlay network, ou les CIDR à utiliser. Là je vous la fait simple.

Maintenant, il faut qu’on puisse se connecter au cluster pour le paramétrer. Et là… ça devient moins marrant.

Paramétrer un utilisateur

Si vous connaissez bien OpenShift, vous savez que l’on a le moyen de s’authentifier directement sur la plateforme, comme ça, en allant sur la “console web”. Mais sur Kuberentes c’est un poil plus compliqué. Car Kubernetes est légèrement plus bas niveau que OpenShift (rien de péjoratif).

On va donc faire en sorte que depuis votre PC vous puissiez vous connecter à votre cluster.

La méthode que je choisi est la méthode “certificat client”. Je la trouve plus sécurisée et surtout plus claire.

On va donc devoir créer une clef privée, puis une demande de signature (CSR), envoyer ce CSR à un master, signer la requête et récupérer le certificat.

Comme la version de Kubernetes actuelle est >= 1.8 on va se confronter au “role binding”, en gros c’est le fait que votre utilisateur a un certains nombre de droits associés. Là, on va carrément créer un admin.

Génération de clefs

On commence par créer un répertoire où on va stocker notre clef privée, le CSR, et le certificat signé. Puis on génère la clef privée.

# on crée un répertoire de config
mkdir -p ~/.config/kubernetes/

# Choisissez un pseudo, et mettez le dans _username
_username="votre pseudo"
_organisation="toto.com"

# clef privé à ne faire qu'une fois
openssl genrsa -out ${_username}.key 2048

Création d’un CSR

Vous avez donc ici une clef privée “votre_user.key”, créons une requête de signature (CRS = Certificate Signing Request):

openssl req -new \
    -key ${_username}.key \
    -out ${_username}.csr \
    -subj "/CN=${_username}/O=${_organisation}"

Ce qui compte ici, c’est surtout l’entrée “CN” (Common Name) qui correspondra à votre nom d’utilisateur.

Génération du certificat

Voilà, vous avez un “CSR”, on le dépose sur un des masters et on va créer le certificat associé à la demande. Pour cela il faut utiliser le certificat de l’autorité (le cluster kubernetes) et la clef privée de cette autorité. On va créer un certificat valable 1 an:

scp ${_username}.csr root@votre_master1:/tmp/${_username}.csr
ssh root@votre_master1 openssl x509 -req \
    -in /tmp/${_username}.csr \
    -CA /etc/kubernetes/ssl/ca.pem \
    -CAkey /etc/kubernetes/ssl/ca-key.pem \
    -CAcreateserial \
    -out /tmp/${_username}.crt \
    -days 365

Nous avons créé le certificat “votre_user.crt” sur le serveur maitre, on va le récupérer sur notre machine.

scp root@votre_master1:/tmp/${_username}.crt ~/.config/kubernetes/${_username}.crt

Configuration de kubectl

On fait le bilan:

on a une clef privé “votre_user.key”
un certificat signé par le serveur “votre_user.crt”
le tout dans ~/.config/kubernetes

On va maintenant paramétrer kubectl pour les utiliser.

Il faut:

créer une config de serveur (un cluster): indiquer quel machine on va interroger
créer un user en se basant sur la clef et le certig
créer un “contexte” qui rassemble cet user et ce “cluster”

Ces commandes font le boulot:

# création d'un config de cluster
kubectl config set-cluster NOM_DU_CLUSTER \
    --server=https://ip.du.master:6443 \
    --insecure-skip-tls-verify=true
    
# création d'un utilisateur utilisant des certif
kubectl config set-credentials ${_username} \
    --client-certificate=~/.config/kubernetes/${_username}.crt \
    --client-key=~/.config/kubernetes/${_username}.key

# on lie le cluster à un utilisateur
kubectl config set-context NOM_DU_CONTEXXT \
    --cluster=NOM_DU_CLUSTER \
    --user=${_username}

N’oubliez pas de changer les noms de cluster et de contexte avec un truc dont vous vous souviendrez.

Bon, voilà, on peut utiliser ce context:

kubectl config use-context NOM_DU_CONTEXXT

Et là, le drame:

kubectl get nodes
# ERROR, pas les droits

Et oui, votre utilisateur n’est pas dans les petits papiers de Kubernetes, il n’a pas de droits associés. On va remédier à ça.

Donner les droits “admin” à cet utilisateur

Il existe deux “binding” de droits, les RoleBinding sont utililsés pour les namespaces, et les ClusterRoleBinding pour les droits du cluster entier. Ici, nous voulons donner un droit à un utilisateur sur tout le cluster.

Si vous tapez “kubectl get clusterrolebinding” vous verrez une liste conséquente d’associations de droits possibles. Celui qui nous intéresse est le binding “cluster-admin”:

Allez sur un master (via ssh), et faites simplement:

# si vous n'aimez pas vi, tapez EDITOR=nano
# par exemple, avant cette commande
kubectl edit clusterrolebinding cluster-admin

Cela va ouvrir un éditeur “vi”, ajoutez dans “subjects” votre utilisateur:

#...
subjects:
# ...
- apiGroup: rbac.authorization.k8s.io
  kind: User
  name: nom_de_votre_user

Sauvez, et revenez sur votre machine à vous. Relancez:

$ kubectl get nodes
NAME        STATUS    AGE
origin-m1   Ready      X
origin-m2   Ready      X
origin-m3   Ready      X

Et voilà !

Evidemment, on est pas forcé d’ajouter l’utilisateur en admin, un “rolebinding” simple peut donner des droits à un utilisateur sur un namespacce en particulier, et il pourra au choix avoir le droit d’écriture, de lecture, etc…

Voir la page: https://kubernetes.io/docs/admin/authorization/rbac/

On résume

Ça parait bourrin et lourd, mais c’est en fait super simple quand on résume:

on crée une clef privée SSL
on crée une demande de signature de certif
on envoit ça à un serveur “master”
le master signe le certificat
on le récupère sur le pc

Ensuite:

on crée une config de cluster sur le client pour indiquer où se trouve le ou les masters
on crée une config utilisateur sur le client pour dire quelle clef et quel certif utiliser
on lie les deux dans un “context” (un utilisateur + un cluster)

Et enfin:

on ajoute des droits à l’utilisateur sur le cluster (admin ou autre)

Ouvrir le dahsboard

On va maintenant utiliser kubectl pour avoir le dashboard. La méthode que je recommande est d’utiliser kubectl en mode “proxy”, cela permet de ne pas laisser le dashboard entre toutes les mains et de ne pas avoir à paramétrer le navigateur pour accepter certains certificats.

$ kubectl proxy
Starting to serve on 127.0.0.1:8001

Ouvrez la page http://127.0.0.1:8001/ui et admirrez votre dashboard. Halalala ça fait plaisirs non ?

En bref

Si vous venez de version inférieures à 1.8 de Kubernetes, les RBAC (Role-Based Access Control) vont vous dérouter un petit peu en premier lieu. Ceux qui viennent du monde OpenShift ont déjà pas mal travaillé avec la gestion de rôles ce qui leur donne un petit avantage.

Cela-dit, kubespray est un outil super sympa depuis que le projet kubernetes-ansible n’esst plus supporté (devenu obsolète en faveur de kubespray) et je n’ai vraiment pas mis longtemps à adapter mes inventaires pour générer un cluster sur ScaleWay - j’ai encore des soucis avec GlusterFS et Heketi sur Scaleway dont les admin ont l’air de se foutre du fait que nous avons besoin de SELinux (ce qui m’a coincé pour OpenShift) malgré nos relances en ticket de support et sur l’issue Github https://github.com/scaleway/image-centos/issues/19

Mais bon, avec un peu de lecture et quelques tests, j’ai un cluster qui fonctionne en moins d’une heure avec Heapster, Traefik etc…

Reste helm qui refuse de fonctionner à cette heure, mais je vais bien finir par y arriver !

Adieu TeamViewer

Thu, 30 Nov 2017 00:17:54 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

J’en avais marre de TeamViewer, des soucis avec Wayland, incompatibilité de versions, et puis pour partager simplement un terminal ou un écran je ne voulais pas que le “client” ait quoique ce soit à installer. Et VNC est trop contraignant avec ces foutus ports. Voyons ce qu’on a sous la main pour virer ce logiciel.

Oui, je sais, vous en avez rien à faire que TeamViewer soit un truc qui appartienne à une boite qui ne vous dit pas comment elle peut loguer tout ce qu’il se passe quand vous partagez une session avec quelqu’un, mais moi ça m’intrigue. Et puis en plus, je préfère largement avoir plusieurs solutions sous la main selon mon besoin (pourquoi partager un écran si je veux juste montrer un terminal ?).

Bref, le but c’est que moi j’ouvre un logiciel et que celui à qui je veux partager mon terminal ou mon écran n’ait qu’à aller sur une page web. Et bha tu me crois, tu me crois pas, mais j’ai trouvé deux outils qui m’ont tué en terme de simplicité.

Ces deux solutions vont vous rendre la vie plus simple. L’une est purement pour partager un simple terminal, et l’autre ressemble plus à TeamViewer, sauf que vous n’aurez pas besoin d’un client lourd pour vous y connecter. Et il va en plus vous donner un peu plus d’info et de possibilités que ce bon vieux TeamViewer ou VNC.

On va donc parler de tmate et de DWservice

Tmate - partager un terminal

Vous allez me dire:

Oouais super, bha SSH avec “type” + “script” ça marche bien.

Oui… mais il se passe quoi quand je suis derrière ma box et que le copain à qui je veux montrer du code, un terminal, une sortie de commande, se trouve à l’autre bout du globe (amis platistes, bonsoir)

Il faut ouvrir un port, faire du NAT, créer un compte à l’utilisateur pour pas qu’il ait accès à votre home… puis lancer une sessions “script” ("script -f /tmp/session" par exemple) dans un fichier et demander à votre pote de lancer “tail -f /tmp/session” bref… c’est chiant.

Et là, on a “tmate” qui arrive avec sa cape et ses super-pouvoirs pour éviter de passer un diplôme d’ingé juste pour permettre un partage de session. Tmate est un “simple” fork de “tmux” avec des options de “broadcast” vers un serveur.

Ça va vous détendre… croyez moi !

On l’installe bêtement:

# Fedora
dnf install tmate
# debian, ubuntu
apt-get isntall tmate
# freebsd
pkg install tmate
# etc...

Ensuite vous lancez une session:

tmate

Là vous vous retrouvez dans un “tmux” qui peut partager (par défaut) votre session sur “tmate.io” avec des adresses secrètes.

Pour connaitre ces infos, c’est simple, dans votre session tmate:

$ tmate show-messages
Wed Nov 29 00:53:06 2017 [tmate] Connecting to ssh.tmate.io...
Wed Nov 29 00:53:06 2017 [tmate] Note: clear your terminal before sharing readonly access
Wed Nov 29 00:53:06 2017 [tmate] web session read only: https://tmate.io/t/ro-XXXXXXXXX
Wed Nov 29 00:53:06 2017 [tmate] ssh session read only: ssh ro-YYYYYYYYY@ln2.tmate.io
Wed Nov 29 00:53:06 2017 [tmate] web session: https://tmate.io/t/ZZZZZZZZZZZZ
Wed Nov 29 00:53:06 2017 [tmate] ssh session: ssh AAAAAAAAAAAAAA.tmate.io
Wed Nov 29 00:54:53 2017 [tmate] A mate has joined (77.XX.XX.XX) -- 1 client currently connected
Wed Nov 29 00:55:39 2017 [tmate] A mate has joined (77.XX.XX.XX) -- 2 clients currently connected
Wed Nov 29 00:55:51 2017 [tmate] A mate has left (77.XX.XX.XX) -- 1 client currently connected
Wed Nov 29 00:55:54 2017 [tmate] A mate has left (77.XX.XX.XX) -- 0 client currently connected

(j’ai pensé à masquer les infos)

Vous l’avez compris, il y a 4 façons de vous connecter à votre session:

en ssh READ ONLY,
en ssh normal (donc le participant peut contrôler le tmux)
en web READ ONLY - une page web où le participant voit le terminal
en web avec contrôle

Donc, vous donnez le lient ssh, ou web, à votre pote, et vous tapez “clear” dans le terminal pour cacher les infos si vous ne voulez pas qu’il voit la manière de se connecter en session “write” alors que vous lui avez donné que le droit de lire (vous suivez ? il est tard et je tape un peu à la va-vite là…)

Et si vous voulez, vous pouvez créer votre propre serveur tmate, du coup vous êtes sûr que les monsieurs derrière le serveur de tmate ne loguent rien, bien que j’ai confiance en leur outil et leurs intentions.

Bref, l’outil est magistralement simple et efficace.

DWService - un TeamViewer like, voir mieux

Autre outil que j’adore, DWService.

Là on a un outil qui déchire. Il existe plusieurs façons de l’utiliser et il offre des options de dingue.

La première chose que vous voulez faire, c’est contrôler un PC à distance. Le serveur est “autonome” et peut être utilisé sans installation. Il marche sur Linux, Windows, RaspBerry et OSX.

Allez sur la page d’accueil et regardez à droite, vous avez un lien de téléchargement, cliquez ou suivez ce que je vous propose pour linux pour le faire en ligne de commande:

Sur linux, vous pouvez faire:

curl -sSL https://www.dwservice.net/download/dwagent_x86.sh -o /tmp/dwservice.sh
bash /tmp/dwservice.sh

Une fenêtre s’ouvre, vous acceptez “sans installation” et l’outil vous donne un identifiant et un mot de passe que vous donnez à votre ami. Et là, hop, il voit votre écran en ligne. Pas de plugin, pas de truc compliqué, c’est simple et efficace.

En plus de l’affichage, vous avez à disposition:

accès aux fichiers
accès des des stats et des graphiques (utilisation cpu, mémoire, disque…)
création de terminal
etc…

DWService peut aussi être installé en service (il faut les droits d’admin) et il va donc démarer un “daemon” qui vous permettra d’accéder à vos machines depuis votre navigateur. Alors, là, il faut un compte (mais c’est gratos hein) et vous loguer sur le site.

Mieux encore, vous pouvez créer un partage “limité” (ou pas) ces options. Par exemple si je veux partager mon écran en lecture seule:

Il me suffit d’aller décocher “accès complet” et décocher aussi “accès à la souris et au clavier”, et voilà, je peux montrer mon écran à qui je donnerai le lien. Et c’est pareil pour toutes les ressources (terminal, logs, etc…)

DWService est un véritable petit bijou, mais il a ses contraintes… Le client est libre, mais pas le serveur - dans leur FAQ ils disent ne rien loguer, mais bon on doit compter sur votre confiance. Et puis, malheureusement, DWService est pas très rapide. Je soupçonne que le fait de passer dans un navigateur n’aide pas. Et comme le serveur est pas open source, et bien pas moyen de tenter d’aider.

Dernier point, j’ai un bug avec Chromium (~~ou Chrome~~ EDIT: ha bha non, seulement chromium en fait), impossible d’ajouter des contraintes de contrôle comme dans la capture ci-dessus. Le bug n’est pas valable sous FireFox et Chrome. Bref, des “détails” qui peuvent vous gêner un poil.

Mais, sans déconner, j’avais jamais imaginé que ça puisse être si simple. Je ne sais pas quoi leur dire à part “bravo”. Et ça donne envie de répondre à leur appel aux dons: https://www.dwservice.net/fr/contribute-sponsorshipsdonations.html

Franchement, le parrainage est pour les entreprises, mais donner 5-10€ en don (en bas de page) ce serait pas du luxe…

Conclusion

Bha que dire… ?

En général tmate suffit pour une démo rapide d’un outil avec un collègue.

DWService sur mon raspberry et mon pc de la maison pour y accéder à l’extérieur (parce que je vous rapelle que c’est du pur web là) me permet de dégager TeamViewer.

Et quand ma chère mère est bloquée sur son PC et bien elle lance simplement dwservice en cliquant sur l’icone et elle me donne les identifiant. Et sans me prendre le but, sans ouvrir des ports, sans rien avoir à faire de plus que d’aller sur le site, je peux l’aider sans rien installer de mon coté.

Bref, TeamViewer, adieu. Même si, il faut l’admettre, TeamViewer a le mérite d’être rapide, je préfère de loin tmate et DWService selon le besoin. Pour leur vitesse, pour leur justesse et les options que je ne trouve pas ailleurs (terminal, ressources cpu/mem, partage de dossier, etc…) je n’ai pas envie de passer à autre chose.

Et oui, avec l’IPv6 je pourrait aussi me connecter à mon PC à la maison, mais beaucoup d’endroits d’où je bosse n’ont pas activé l’IPv6. Et je déteste le NAT… donc voilà !

Angular, ReactJS, VueJS, comparer l'incomparable

Sat, 11 Nov 2017 13:05:51 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Angular, VueJS et React sont souvent comparés entre eux - et la mode est de comparer les bananes et les carottes on dirait…

Permière erreur, la plupart des articles que je lis sur les comparatifs React, Vue, Angular ne parlent pas d’Angular, mais de AngularJS. Seconde erreur très répandue: vouloir à tout prix comparer des technologies qui n’ont rien à voir - on va donc décrire le problème ici. Mais avant tout, pourquoi on parle d’eux ?

L’application monopage

JQuery fut à la mode et force est de constater que son reigne s’éffondre mois après mois. Aujourd’hui, on parle de SPA (Single Page Application) ou “application monopage” dans la langue de Jean-Pierre Pernaut. Et pour réussir à faire une application complète, active, réactive, structurée, il faut une technologie adaptée.

Jusque là, on ne jurait que par AngularJS, développé par Google, ou Knockout qui ont apporté le “two way data binding” de manière magistrale. Sauf que voilà, quand un truc mache bien, tout le monde s’empresse de vouloir proposer sa vision, sa version, sa technique. Il y en a d’autres, plus ou moins bien fichus, mais je ne suis pas là pour les comparer.

ReactJS est venu remuer le sac pour proposer une autre façon de faire. Développée et utilisée par FaceBook, cette librairie est devenue vraiment populaire et on comprend pourquoi !

Nous voilà donc avec deux grands noms (Google et Facebook) qui apportent tous les deux des technologies qui vont faire grand bruit.

Au milieu de tout ça vient le David contre les Goliath, j’ai nommé VueJS. Développé par un ancien de chez Google (de l’équipe AngularJS), le dénommé Evan You, cette librairie apporte un vent frais dans la fournaise.

Les technologies du net changent. Aujourd’hui les projets se portent de plus en plus vers une séparation “API/client léger” - les sites qui génèrent des pages de manière plus ancêstrale sont en train de devenir “old school”. Cela permet de vraiment séparer deux partie: la vue frontale et l’acquisition de la donnée. Nous ne sommes plus obligé de gérer la vue du coté où sont traitées les données, et ça en tout honnêteté c’est un vrai grand pas en avant.

Mais depuis quelques mois, AngularJS a changé… en fait il n’est plus, enfin si… mais non… bon je m’explique.

AngularJS n’est pas Angular !

Bien que ce soit la même équipe, le même éditeur (Google) et quasi le même site, les deux technologies sont différentes - et à tel point que beaucoup pense que le nom aurait du changer.

Angular n’est pas un framework JS, ni une librairie.

C’est un framework TypeScript, bien que vous puissiez développer en JS si ça vous chante, qui déporte littéralement tout le développement en dehors de la page. Car Angular “génère” votre application (en JS).

Petite note: VueJS permet de développer en TypeScript, c’est pas répandu mais ça se fait.

On est donc bel et bien en dehors de ce que propose ReactJS et VueJS qui, elles, sont des librairies qui s’intègrent dans une page. L’approche est différente, la techno est différente, alors pourquoi s’obstiner à les comparer ?

Je comprend bien que vous puissiez faire le comparatif puisque, au final, on se retrouve à travailler dans la même optique. Mais le choix ne doit pas se faire sur la technologie, elle doit se faire sur l’orientation du développeur ou intégrateur qui va travailler.

Certainement que dans l’esprit collectif, c’est AngularJS qui a laissé une empreinte trop persistente.

Imaginons que nous développions un Framework qui transforme tout mon PHP en une application JS/HTML. Vous comprennez bien que l’approche est différente de ReactJS et VueJS ? Vous ne feriez pas la comparaison parce que d’un coté on développe une application dans un langage dont le rendu se fera dans un navigateur, et de l’autre vous développeriez avec des librairies JS une application qui est “intégrée” dans une page.

Il n’y a rien de péjoratif dans le fait d’être une librairie JS, et il n’y a rien de gratifiant d’être un Framework TypeScript, ce sont juste deux approches très différentes, et pas comparables.

Et bien là c’est pareil ! Angular vous propose de développer des classes, des components, des services… vous propose de l’injection de dépendance, des méthodes d’appel HTTP vers les API, etc… et cela “compile” un site monopage qui saura utiliser un backend.

Bref, la cible de développeur n’est pas la même, l’approche est différente.

Donc on choisi comment ?

Il faut s’abstraire de la technique en premier lieu.

Posez-vous les questions suivantes:

est-ce que c’est une application poussée qui demande du développement “applicatif” ?
est-ce que ce sont des intégrateurs ou des développeur applicatifs qui vont bosser dessus ?
est-ce que c’est l’interface qui prime ou le fonctionnement applicatif ?

Avec ces questions, vous allez ensuite chercher les compétences utilisée pour intégrer la page. Les “dev” préfèrent généralement Angular, puis VueJS, les intégrateurs vont plutôt préférer ReactJS, puis VueJS.

Vous l’aurez compris: VueJS rassemble beaucoup, son approche mixe les deux concepts. Cela-dit, moi en tant que dev, j’ai une préférence pous le TypeScript (notamment pour son intégration dans un IDE qui est très avancée, sur Vim c’est vraiment bien fichu) - mais je ne choisi pas Angular parce qu’il est mieux que React ou Vue.

Je choisi Angular parce que l’orientation MVC est, de mon point de vue, plus adaptée à mes travaux.

Je ne suis pas intéressé pour générer du HTML depuis JS/JSX, loin de moi l’idée de critiquer cette approche, elle ne convient juste pas dans mes développements. Mais vous, certainement que oui, et je le comprendrai sans souci. Au boulot, un de mes collègue a justement préféré React puisque sont besoin étaiat de travailer sur l’interface en tapant sur quelques enpoints d’API REST.

Moi de mon coté, je développe une application qui demande 40 endpoints, du contrôle poussé dans le fonctionnement, et j’avais vraiment besoin d’injection de dépendance pour éviter le boxon inmaintenable vue la dose de code à engendrer. L’interfaçage est purement HTML (template) et je peux donner cette partie à une autre équipe, donc Angular est plus adapté à ce projet.

C’est l’approche qui est comparée, pas le fonctionnement… vous me suivez ?

Comparer autrement

Ce qui m’agace finalement, ce n’est pas de vouloir comparer les technologies, c’est le fait de l’orienter sur la “technique” alors que la comparaison devrait se faire sur l’oritentation de développement.

Si vous êtes un développeur orienté structure/class/objet (Java, Go, Python, PHP…) vous allez certainement préferer apprendre le TypeScript (qui est franchement pas sorcier) et créer l’application dans une optique de “framework”.

Si vous êtes plutôt intégrateur, que vous chercher à définir une interface plus “animée”, alors VueJS et ReactJS sont certainement plus adaptés à vos besoins.

C’est don inadapté de comparer les bananes et les carottes, demandez vous plutôt si vous en êtes au plat principal ou au dessert. Là, vous pourrez choisir entre des librairies JS ou des framework applicatif. Donc entre VueJS, React et Angular.

Et surtout, gardez bien à l’esprit que Angular != AngularJS pour ne pas comparer l’incomparable.

Golang, comment définir un destructeur

Thu, 16 Mar 2017 06:58:07 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si vous avez un peu bourlingué sur Go, vous savez qu’il n’existe pas de “destructeur” sur les structures. Mais en cherchant un peu, vous allez pouvoir utiliser le garbage collector et simuler un destructeur.

Je me suis rendu compte en utilisant un peu Go pour créer mon blog, que si je ne faisais pas attention je pouvais avoir des centaines de connections à la base Mongo ouvertes et jamais fermées. C’est évidemment un truc à éviter, mais le design de Go n’aide pas des masses. Du moins quand il s’agit de bosser avec des connections persistantes.

Il faut dire que le pattern très répandu en Go d’utiliser un “defer xxx.Close()” peut parfois passer à la trappe, personne n’est parfait et on peut simplement oublier de le faire. Et le résultat peut être relativement lourd, voir dangereux pour votre RAM.

Je vais réduire le problème à un cas simple, on va se créer un petit benchmark tout bête pour comprendre ce qu’il se passe.

Le bout de code qui fait mal

En premier je démarre une base mongo via Docker, c’est rapide à faire, ça fout pas en l’air le système, c’est jetable: j’aime ça!

docker run --rm -it -p 27017:27017 mongo

La base est là, elle attend plus que vous.

Voici maintenant un bout de code Go qui va exploser rapidement:

package main

import (
	"log"
	"time"

	mgo "gopkg.in/mgo.v2"
)

// Returns a NEW mongo session
func connect() *mgo.Session {
	s, _ := mgo.Dial("127.0.0.1")
	return s
}

// Create data in mongo
func createData(i interface{}) {
	s := connect()
	s.DB("data").C("foo").Insert(i)
	log.Println("create done")
}

func main() {
    for i := 0; i < 2000; i++ {
    	createData(map[string]string{
    		"user": "foo",
    		"date": time.Now().String(),
    	})
    	time.Sleep(50 * time.Millisecond)
	}
}

Pour la faire courte, la fonction “connect()” crée une connexion à Mongo, la fonction “createData()” va appeler cette fonction et ajouter du contenu en base. Sauf que…

Vous l’avez remarqué, j’oublie de fermer la session (pas de “s.Close()”) ce qui a pour effet de laisser la connexion active.

En lançant le programme (go run main.go) après quelques secondes… plantage ! la base n’arrive plus à gérer toutes les connexions !

Il existe heureusement un moyen de virer la connexion si elle n’est plus utilisée, et ce en demandant au garbage collector (le “ramasse miette” dans notre chère langue) mais il faut chercher un peu.

La fonction `runtime.SetFinalizer()`

Dans le paquet “runtime”, dans lequel on trouve la fonction “GC” qui permet de forcer une passe de nettoyage, on trouve la fonction “SetFinalizer” qui peut nous aider.

Le principe est simple, en premier argument on lui passe une référence (une adresse) et en second, une fonction qui prend en argument le pointeur.Je fais bien la distinction ici (même si au final c’est pareil), pour bien vous indiquer que le premier argument sert bien au GC à trouver “l’adresse” de la variable qui va être géré. La fonction doit quant à elle connaitre le type pointé. Mais arrêtez de vous embrouiller le cerveau et regarder le bout de code ci-dessous:

runtime.SetFinalizer(s, func(s *mgo.Session) {
	log.Println("Close db")
	s.Close()
})

Cela indique au garbage collector que la référence “s” qu’il va pouvoir éliminer “s” de la mémoire en passant par la fonction indiquée. Et dans cette fonction, on appelle “s.Close()” qui va fermer la connexion. Pratique hein, parce que si plus aucune fonction n’utilise ma connexion, alors elle sera coupée, purement et simplement.

Comment ça se passe: La fonction “connect” crée un pointeur sur “mgo.Session”, l’adresse est donc référencée par cette fonction, le GC ne l’a pas encore collecté. Ensuite, elle est récupérée par “createData()”, l’adresse est donc encore référencée, toujours pas de collectage. Après que les deux fonctions aient utilisé cette adresse “s”, plus personne ne l’utilise. À partir de maintenant, le collector trouve cette adresse contenant un “objet” que personne n’utilise, il va pouvoir utiliser la fonction qu’on lui a donné pour effectuer les opérations qu’on lui demande. Et par conséquent, ici, on ferme la connexion.

Après cela, la mémoire est libérée.

Mais y’a un effet de bord à prendre en compte… Si jamais l’utilisateur a pensé à couper la connexion, le “finalizer” sera quand même appelé (car la référence est toujours présente lors de la passe de GC). On ajoute donc une opération (la fonction en argument) à exécuter lors d’une passe de GC. C’est le prix à payer…

Avant d’aller plus loin, je vous met en garde et je vous demande de lire ce très bon article:

https://lk4d4.darth.io/posts/finalizers/

Il faut effectivement utiliser cette fonction dans des cas précis, si et seulement si c’est vraiment nécessaire.

Un autre article intéressant:

https://making.pusher.com/golangs-real-time-gc-in-theory-and-practice/

le nouveau code

On a donc maintenant ce code:

package main

import (
	"log"
	"runtime"
	"time"

	mgo "gopkg.in/mgo.v2"
)

// Returns a NEW mongo session
func connect() *mgo.Session {
	s, _ := mgo.Dial("127.0.0.1")
    // clean session when GC pass
    runtime.SetFinalizer(s, func(s *mgo.Session) {
    	log.Println("Close db")
    	s.Close()
    })
	return s
}

// Create data in mongo
func createData(i interface{}) {
	s := connect()
	s.DB("data").C("foo").Insert(i)
	log.Println("create done")
}

func main() {
	for i := 0; i < 2000; i++ {
    	createData(map[string]string{
    		"user": "foo",
    		"date": time.Now().String(),
    	})
    	time.Sleep(50 * time.Millisecond)
	}
}

Coupez le conteneur Docker mongo (parce qu’il est pété là hein…) et relancez le. Puis on relance le programme: go run main.go

Après un certain temps (chez moi, après 200 connexions environs), je vois une pile de connexions se fermer. Je vous d’ailleurs le compteur de connexion active dans les logs Mongo descendre d’un coup.

On a donc ici une manière assez élégante de nettoyer les connexions orphelines. Le but n’est pas de permettre à un utilisateur de ne pas fermer lui-même la connexion, mais si il l’a oublié alors on indique au GC qu’il pourra faire le ménage de cette manière. En gros, c’est “en cas d’oubli, on fixe plus tard”.

Aller un peu plus loin

Il est possible de forcer le garbage collector à nettoyer la mémoire en appelant “runtime.GC()”, dans le cas où votre programme est relativement chargé, cela peut avoir son effet. Il faut simplement prévoir à quel moment lancer la commande, voir créer une goroutine qui le fait régulièrement.

C’est en général une mauvaise idée, car normalement le GC passe nettoyer la mémoire tout seul comme un grand assez régulièrement. Mais il se peut que dans de rares cas ce soit vraiment nécessaire (j’ai eu ce cas malheureusement), et dans ce cas vous pouvez demander un nettoyage forcé.

Mais on le fait ou pas ?

En général, il faut éviter. Gardez à l’esprit que le développeur qui bosse avec vous doit avoir les informations nécessaires pour faire ce qu’il faut. De ce fait, il faut préciser qu’après chaque connexion à la base de données il sera nécessaire de faire un bon vieux:

defer s.Close()

Sauf que comme je le dis plus haut, un oubli peut arriver. Et si vous utilisez fortement des opérations qui ont un risque de faire un leak par oubli du développeur, là franchement je conseille de protéger l’exécution avec un “finalizer”. Si votre équipe a pensé à fermer les connexions, ça n’impactera pas les performances. Si ne serait-ce qu’une connexion est oubliée, au moins vous êtes certain qu’elle sera fermée du moment ou elle n’est plus du tout utilisée.

Je précise un point important quand même: dans notre exemple, si je ferme la connexion après utilisation tout se passe bien. Mais si j’oublie de la fermer, elle reste active le temps que je GC fasse une passe. D’où l’intérêt de ne pas attendre que le GC passe et de fermer la connexion manuellement (avec un defer). C’est bien plus optimal de faire cette opération au plus tôt !

Ce que je dis, et je sais que j’insiste, c’est qu’un finalizer est une solution “de secours”, ça ne doit pas être le fonctionnement par défaut !

Simuler un destructeur

Je suis pas fan de la simulation de POO en Go, mais comme le langage permet de faire du pseudo objet, on peut parfois avoir envie de travailler à la manière d’une classe avec destructeur.

Dans l’absolu, un “finalizer” est aussi un moyen de simuler un destructeur, qu’on va appeler “Close” dans l’exemple ci-après:

type  User struc {
    Name string
}

func (u *User) Close() {
    log.Println("Destruction of user", u.Name)
}

func NewUser() *User {
    u := &User()
    runtime.SetFinalizer(u, func (u *User) {
        u.Close()
    })
    return u
}

Si on pense bien à utiliser “NewUser” (le constructeur), alors l’objet retourné peut être détruit quand le garbage collector fera une passe, et seulement si l’adresse “u” n’est plus utilisée. Aussi, pensez à laisser la fonction de destruction accessible aux développeur pour qu’il puisse supprimer manuellement l’objet (ce qui est encore une fois la recommandation !).

Donc, on pourra faire:

// là le GC ne passera jamais (on a pas utilise de constructeur)
u := &User{}
defer u.Close()

// ou

u := NewUser()
// et laisser faire le GC 
// ou utiliser u.Close() manuellement

La première méthode étant la plus judicieuse car elle n’attend pas une passe du GC. Mais encor faut-il que le développeur pense bien à utiliser “u.Close()”…

Une autre manière de voir les choses

Puisqu’on veut éviter de manipuler le GC, on peut adapter des pattern venus d’autres langages pour réduire l’impact. J’apprécie fortement le pattern “with” de Python (qui existe dans d’autres langages) et on peut très facilement l’implémenter en Go.

En premier lieu, on se prévoit une interface “Closer” qui sait “fermer quelque chose”:

type Closer interface {
    Close()
}

Reste à imaginer une fonction “With” qui va imiter ce que fait Python:

func With(c Closer, f func()) error {
    defer c.Close()
    f()
}

Admettez que c’était pas compliqué hein.

“mgo.Session” contient justement une méthode “Close” qui respecte l’interface, c’est voulu.

Du coup, on peut coder notre fonction de création de données ainsi:

sess := connect()
With(sess, func() {
	sess.DB("data").C("foo").Insert(i)
	log.Println("create done")
})

La cloture fonctionnera comme désiré, pas la peine de passer par de la manipulation de GC.

Voilà l’exemple complet:

package main

import (
	"log"
	"time"

	mgo "gopkg.in/mgo.v2"
)

type Closer interface {
	Close()
}

func With(c Closer, f func()) {
	defer c.Close()
	f()
}

func connect() *mgo.Session {
	s, _ := mgo.Dial("127.0.0.1")
	return s
}

func createData(i interface{}) {
	sess := connect()
	With(sess, func() {
		sess.DB("data").C("foo").Insert(i)
		log.Println("create done")
	})
}

func main() {
	for i := 0; i < 2000; i++ {
		createData(map[string]string{
			"user": "foo",
			"date": time.Now().String(),
		})
		time.Sleep(50 * time.Millisecond)
	}
}

Cette fois, plus de problème, les connexions sont fermées en sortie de With, et le code est relativement clair.

Conclusion

J’arrête pas de le dire, mais il faut que ce soit clair: il faut éviter d’utiliser SetFinalizer. Cela-dit, je sais que vous avez certainement rencontré un souci de variable non supprimée, de connexion qui persiste sans intérêt. Ainsi, on peut faire en sorte de contrôler le GC, de l’appeler explicitement et même de forcer des comportements de destruction.

Dans la mesure du possible, j’estime qu’un développeur Go doit être informé des spécificités du langage et par conséquent il doit connaitre les problématiques de fermeture de descripteurs. Prendre l’habitude d’ajouter un “defer p.Close()” n’est pas une complexité insurmontable. Mais je suis aussi un défenseur du principe KISS, et je suis absolument d’accord avec le fait d’utiliser des patterns si et seulement si ils s’avèrent vraiment utiles et que le langage pose un souci. J’ai beau adorer Go, je ne peux pas défendre le fait qu’il soit aussi user-friendly que Python ou JS. Dans ce cas, j’admet volontier que certains patterns soient utiles et adaptés. Mais j’en reviens à mon article sur les design patterns - donc, adapter un code source pour utiliser “With” tel que je le montre, ou ajouter un “finalizer” ne me pose pas plus de problème que ça à condition que ça ne devienne pas un foutoir ingérable et imbitable.

Faites juste attention de ne pas en abuser. Soyez judicieux, simplement !

POO vs Composinting

Sat, 04 Mar 2017 21:11:15 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si vous vous êtes intéressé au langage “Go”, alors vous devez savoir qu’il n’est pas un langage purement objet mais “de compositing”. Mais quand vous codez en Go, vous avez cette impression de coder avec des classes et des objets. Alors c’est quoi la différence ?

On va se réferer à la page de FAQ: https://golang.org/doc/faq#Is_Go_an_object-oriented_language et on lit:

Is Go an object-oriented language?

Yes and no. Although Go has types and methods and allows an object-oriented style of programming, there is no type hierarchy.

La réponse peut paraitre claire pour certains, pourtant la mailing-list est bourrée de la même question, “mais je comprend pas la différence puisqu’on peut hériter et utiliser des objets”. La phrase peut paraitre sensée mais elle est en opposition avec la réponse donnée dans la FAQ.

Pour comprendre, il faut comparer Go avec un autre langage. On va utiliser Python, et faire de l’instrospection de type. Dans cet exemple, on va créer une classe Foo qui sait retourner le nom de la classe (donc “Foo”) et la dériver en Bar.

Ok, donc en appelant la méthode “name” de l’instance de classe Bar, on appelle la méthode définie dans la classe “Foo”. Mais le résultat est bon: l’instance de classe Foo répond par “Foo” et l’instance de Bar répond par “Bar”.

Faisons la même chose avec Go.

Là, ça marche plus… Les deux appels retournent “*main.Foo” !

Mais pourquoi donc ?

Le fait est que Go utilise le modèle “composite”, ce qui veut dire que la définition de Bar contient une instance de Foo. Clairement, Bar n’hérite pas de Foo. Bar transporte une variable de type Foo (ou *Foo) dont on peut utiliser les méthodes sans utiliser le nom de variable. Mais en réalité, ce qu’il s’est passé, c’est que nous avons appelé “new(Bar).Foo.Name()” - et c’est très différent de l’héritage. Et on retrouve la réponse donnée dans la FAQ: les types n’héritent pas les uns des autres.

Alors qu’en Python, Bar a hérité de la méthode “name”. Cela induit que Bar “réplique” la méthode pour son propre compte.

En d’autres termes, il n’est pas possible pour une méthode de structure Foo, de connaitre la signature des objet “enfants”.

C’est pour cela que le développement en Go “ressemble” à de la POO sans en être réellement.

Et si vous pensez que ce modèle n’est pas une bonne idée, sachez qu’il a un sacré nombre d’avantages. Entre autre, le polymorphisme est plus facile à gérer, car en composant une structure avec d’autres structures, je peux m’assurer que la méthode que j’appelle provient bien du bon type qui la compose en appelant explicitement la méthode avec le nom du type inclu.

Autre intérêt, je peux modifier l’instance du type qui est inclu ou encore l’enregistrer dans une autre instance. Ce qui veut dire que je peux faire en sorte que deux instances de Bar ait des propriétés différentes, mais qu’un appel à la méthode de Foo utilise le même “objet”.

Et j’en passe.

Donc, certes, quand on est habitué à de la POO traditionnelle tout cela peut être déroutant, mais avec l’habitude on trouve son compte dans le modèle composite, et on trouve même ça très pratique. Ce n’est donc pas un défaut, ni une atout, c’est juste un design de langage différent avec ses spécifités à maitriser.

Faire une présentation avec deux écrans sous linux

Wed, 02 Nov 2016 21:47:50 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Demain matin je vais présenter au BlendWebMix une petite conférence mais une question s’est posé à moi… Comment faire en sorte d’utiliser un bureau étendu tout en faisant un miroir de certaines fenêtres ? Et bien il existe plein de solutions sans avoir besoin d’installer un client particulier. Suivez-moi.

Cela fait… houlala plusieurs mois que je n’ai rien posté. J’en parlais avec Xavier Deneux, un ami, ex-collègue, revu avec plaisirs ce mercredi, et je me suis dit ce soir que l’occasion est trop belle pour ne pas poster un truc que j’utilise régulièrement quand je donne des conférences.

L’objet de la conférence de demain (le jeudi 3 novembre 2016 - Kubernetes et le déploiement continu) fera l’objet un autre billet.

Bon, comment ça se passe ?

En général, si vous êtes conférencier, vous allez avoir à disposition un appareil de projection qui se trouve dans votre dos. Vous allez brancher votre PC et avoir deux possibilités:

utiliser un mode “miroir”, donc l’écran de votre portable est projeté directement sur l’écran principal, et par conséquent ce que vous voyez sur votre ordinateur est ce que voit le public
utiliser un mode “étendu”, ce qui vous permet d’avoir un écran différent de celui projeté

Dans le premier cas, pas de souci, si ce n’est que vous ne pouvez pas mettre l’écran “secondaire” de LibreOffice ou RevealJS afin de voir la diapo suivante, vos notes, etc… et ça me plait pas

Dans le second cas, si vous n’avez que des slides à montrer, pas de souci. Mais moi je fais souvent des démos, et j’ai besoin d’un terminal (pour vim, des sorties de commandes, ou autre…) ou encore d’un navigateur pour des interfaces Web… Donc à moins de passer d’un mode à l’autre, rien de pratique.

Il existe heureusement des solutions.

Terminal Mirroring avec “script”

Le terminal mirroring est très simple, dans le terminal que vous voulez “partager”, vous tapez:

script -f /tmp/term

Ouvrez ensuite un autre terminal (à montrer au public) dans lequel vous tapez simplement:

tail -f /tmp/term

Et voilà, tout ce que vous tapez dans le terminal de base est vu en temps réel sur le terminal 2. Pour terminer, dans le premier terminal, vous pouvez taper CTRL+D, ce qui va couper la commande “script” et donc fermer “/tmp/term”. Simple et efficace.

Et pour n’importe quelle fenêtre ?

Pour un terminal c’est simple, il existe une méthode plus “universelle” qui fonctionne vraiment très bien. Ça va vous paraitre fou, bête, vous allez même vous dire “mais pourquoi j’y ai pas pensé avant ?” (chose que je me suis dit la première fois): streamer une fenêtre

Et gstreamer est là pour vous ! (encore lui ?!)

Bon, l’idée est d’avoir l’identifiant d’une fenêtre, et d’utiliser le plugin “ximagesrc” puis de tout envoyer dans un “ximagesink”

Le seul souci, avoir l’ID de fenêtre. Pour ça il faut utiliser une commande assez simple:

xwininfo | awk '/Window id/{print $4}'

Votre curseur se transforme en petite croix, cliquez sur une fenêtre pour sélectionner la fenêtre voulue.

Ensuite coller cet id dans la commande suivante (à la place de ICI_ID):

gst-launch-1.0 ximagesrc xid=ICI_ID ! queue2 ! videoscale ! videoconvert ! queue2 ! ximagesink sync=false

Notez que j’ai ajouté deux “pads” nommés “queue2” pour soulager un peu le CPU. Je n’ai pas d’explication claire sur le sujet, j’ai juste remarqué que, voilà, ça souffle moins coté ventilo…

sync=false permet de laisser tomber des trames vidéo si la vidéo est trop “rapide” pour la lecture, et croyez-moi sans cette option vous aller avoir un paquet de warning dans la console. Et une fois de plus, cette option fera en sorte que votre CPU vous fera des bisous.

Cela ouvre une fenêtre vidéo avec, vous l’avez compris, la vidéo de capture en temps-réel de la fenêtre choisie.

Reste à se faire ça en script bash, en le placant dans votre PATH (moi j’utilise ~/.local/bin/mirror-this):

#!/bin/bash

WID=$(xwininfo | awk '/Window id/{print $4}')
gst-launch-1.0 ximagesrc xid=$WID ! queue2 ! videoscale ! videoconvert ! queue2 ! ximagesink sync=false

Pensez à faire un chmod +x ~/.local/bin/mirror-this ou sur l’emplacement choisi pour le script !

Du coup, quand je dois montrer une fenêtre, je lance ma commande, je clique sur la fenêtre à partager, je la place sur l’écran projeté au mur, et quand j’ai fini, hop un petit CTRL+C dans mon terminal.

Et du coup, là, plus de commande “script”, je l’utilise aussi pour mes terminaux.

Résultat

Tout simplement, je peux utiliser deux écrans différents, un pour avoir mes notes, l’écran de contrôle de mes slides, et pourtant je peux partager certaines choses avec l’auditoire.

J’espère vous avoir donné de quoi vous amuser :)

Un beau document en LaTeX

Sun, 08 May 2016 15:36:30 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Faire un joli document avec une couverture “design”, des pages de chapitre originales, le tout en LaTeX, c’est ce que nous allons voir aujourd’hui. Quand on se penche sur la puissance de certains packages LaTeX on se rend compte que “tout est possible”. C’est là la grande force de ce “langage” créé en 1983!

Cet article va vous permettre de créer ce thème LaTeX :

LaTeX ?

Pour commencer, résumons ce qu’est LaTeX. C’est un langage de “balise” qui permet de générer des documents de différents types tels que des rapports, des articles, des livres, des présentations (slide type Beamer), etc. Il a surtout été apprécié par les doctorants scientifiques par la qualité de présentation des équations.

TeX est né en 1977 et LaTeX, la suite de macros pour faciliter son écriture, date lui de 1983. Il y a eu très peu d’évolution majeure ce qui le rend très stable, presque dépourvu de bug, et cela assure aussi une pérennité de package rarement égalée.

Dans ces packages, on trouve des styles, des macros qui permettent de colorer du code tel que l’excellent “minted”, mais aussi un package que j’adore : “TikZ”.

TikZ est un package de création de “dessin”. Cela va de simples formes (rectangle, cercles…) à des diagrammes, des graphiques, et du placement de nœuds (pour faire des mind-map par exemple). Plus on se penche sur les possibilités du package, plus on s’étonne de la puissance de l’outil.

Bref, je viens d’être amené à refaire du LaTeX. J’ai retrouvé ce plaisir de taper du texte sans me poser la question de “comment ça va rendre au final”, sachant que je pouvais me poser sur le “design” après coup. Autant vous dire, je ne vais pas vous mentir, quand vous décidez de passer à la phase “design” vous allez y passer un moment. Car, bien que je sois un fervent défenseur de LaTeX et de sa productivité, je ne suis pas de ceux qui estiment que c’est magique. Non, il faut se pencher sur de la documentation, il faut tester, se former, se planter 20 fois, recommencer… Mais ce qui est intéressant c’est que je ne crains jamais de tuer mon projet. Au pire, je supprime les packages qui m’embêtent, au mieux je vire mes adaptations.

Pour bien faire les choses

Pour commencer, il faut toujours penser à séparer la description du document, le document et le style. Personnellement je fais ainsi, un fichier “main.tex” :

\documentclass[12pt]{book}
\usepackage[frenchb]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

% là je mets tout ce qui est voué
% à styliser mon document
\input{_monstyle}

\begin{document}

\maketitle
\tableofcontents

%% ici j'inclu mon contenu
\input{_structure}

\end{document}

N’oubliesz pas: on inclue les fichiers sans donner l’extension, donc j’ai bien deux fichiers “_monsytle.tex” et “_structure.tex”.

L’intérêt de cette manière d’écrire un document est simplement que si jamais mon style est inutilisable, je peux commenter l’inclusion. Si mon fichier principal ne me plait plus, je peux refaire un “main.tex” simple et inclure ma structure. C’est donc bien “_structure.tex” qui est mon élément central, c’est-à-dire le contenu.

Le fichier de structure est simplement une liste d’inclusion d’autre partie du document:

% j'inclue ici mes docments, ou
\input{partie1}
\input{les_caramels_mous}

% une autre manière que j'utilise:
\chapter{Introduction}
    \section{Qui je suis}
    \input{moi}

    \section{Ce document}
    \input{apropos}

\chapter{Les caramels mous}
    \section{C'est bon ou pas ?}
    \input{gouts_et_couleurs}

    \section{etc...}

A vous de choisir votre méthode de construction. Il y en a qui tape tout le document dans “_structure”, d’autres incluent les fichiers les uns après les autres ou représentent la table des matières comme je le fais souvent. Là c’est une question de méthode et de gout.

Juste un petit point à préciser, j’utilise la classe de document “book”, mais si les alternances de marge de page “doite-gauche” ne vous intéresse pas, passez la classe de document à “report”. Cette classe permet de faire une page de couverture et des chapitres à l’inverse de “article” par exemple. Mais encore une fois, c’est à vous de voir.

Bon, on va passer au design.

Packages utiles au design

LaTeX génère par défaut un document très sobre. Personnellement je trouve la forme de base austère. Pas moche mais pas sexy. À coté d’un document généré avec ~~Word~~ LibreOffice, qui a des entêtes avec des images, des logos… on ne peut pas dire le contraire. Mais je vous le répète, LaTeX permet de faire énormément de choses.

Pour nous amuser un peu, on va changer la police de caractères, et intégrer quelques packages:

“fancyhdr” pour changer les entêtes et pieds de page avec aisance
“TikZ” qui va nous permettre de dessiner sur nos pages
“titlesec” pour changer la forme des titres plus facilement
“color” pour créer des couleurs

Ouvrons notre fameux fichier “_monstyle.tex”, et commençons:

% change la fonte
\usepackage[default]{sourcesanspro}

% on insert TikZ et des sous-packages
% très utiles
\usepackage{tikz}
\usetikzlibrary{calc}
\usepackage{tikzpagenodes}

% modification des titres
\usepackage{titlesec}

% création de couleurs
\usepackage{color}

% entêtes et pieds de page
\usepackage{fancyhdr}

Ces packages donnent accès à des nouvelles directives (ou commandes) que nous allons pouvoir utiliser. Sachez que pour 90% de mes documents j’inclue ces packages.

Quelques couleurs

On va définir une ou deux couleurs pour notre document, je vais définir un blanc pur et un bleu agréable à mes yeux. Dans “_monstyle”, toujours, on insert:

\definecolor{white}{rgb}{1,1,1}
\definecolor{myblue}{RGB}{126,136,150}

Un petit mot sur TikZ

À l’origine, TikZ sert surtout à dessiner des diagrammes, des graphiques, etc… en tant que figure dans le document. Mais son uilisation ne se limite pas à cela. TikZ est un “environnement”, c’est-à-dire qu’il définie sont propre espace de travail. LaTeX propose d’autres environnements tels que les entêtes, les pieds de pages, les marges, la page de titre, etc. Il suffit donc de placer l’environnement TikZ dans un environnement choisi pour dessiner où l’on veut.

C’est ce que nous allons faire.

Chapitres

Les pages de chapitres sont franchement les plus difficiles à modifier. Mais avec un peu de bon sens et des tests, on y arrive. De base, LaTeX propose une page de chapitre très simple mais j’avais envie de bien les “extraire” pour que le lecteur ne s’ennuie pas.

Le package “titlesec” fourni (entre autre) une commande un peu violente à lire, mais qui s’avère finalement plus simple qu’on le pense:

\titleformat{command}[shape]{format}{label}{sep}{before}[after]

La documentation est très complète, je vous conseille d’aller la lire.

Pour faire court, “command” est la commande titre à changer, on va utiliser “\chapter”, shape est optionnel, vient alors le “format” qui défini comment afficher le titre (couleur, taille, etc.)

Ensuite, le “label” pour définir le titre, “sep” défini la séparation vertical entre le document et le titre, et “before” va nous permettre de définir ce qu’on place “avant” le chapitre. C’est ce dernier bloc qui va être le sujet de toute notre attention.

Comme “shape” est optionnel, tout comme “after”, on va juste faire ceci:

\titleformat{command}
    {format}
    {label}
    {sep}
    {before}

\titleformat{\chapter}
    {\Huge\color{white}}
    {\thechapter}
    {0}
    {Et là notre dessin... on y vient}

Le dessin avec TikZ va être un peu déroutant au premier abord de la lecture, mais surtout ne paniquez pas.

Le dessin avec TikZ

Dessiner avec TikZ n’est pas “intuitif”, bien que je ne vois pas comment on pourrait faire plus simple en LaTeX. L’idée est que vous allez définir un canva de travail et dessiner dedans. Vous pouvez y injecter des textes, des images, dessiner des traits, remplir des formes, relier des noeuds, etc.

Bref, nous allons nous amuser à dessiner un quadrilatère qui va partir du coin haut-gauche, aller au coin haut-droit, descendre de quelques lignes, et aller rejoindre le bord gauche en oblique.

Si je pars du principe que la page est en “position absolue” pour ne pas perdre les fans de CSS, on va rejoindre 4 points:

0,0
largeur de page, 0
largeur de page, 8
0, 10

Sauf que…

Si je pars de 0,0, TikZ va partir de la position “0,0” du texte… Heureusement, TikZ propose des positions cardinales qui vont nous aider. Par exemple “current page.north west” correspond au coin haut-gauche de la page (nord ouest).

Voilà le code de dessin, qu’on va injecter:

\begin{tikzpicture}[remember picture,overlay]
  \draw[fill=myblue] (current page.north west)
    -- (current page.north east)
    -- ++ (0, -8)
    -- ++ (-\paperwidth, -2)
    -- cycle;
\end{tikzpicture}

Ok, je vous vois somber. C’est pourtant super simple, j’ai ajouté un “environnement” tikzpicture et je lui dis de:

se souvenir des positions des éléments et de leurs noms (on ne va pas trop en parler dans cet article)
de ne pas se baser sur les positions du “document” mais de passer en mode “overlay”, c’est-à-dire “sur la page”

J’utilise ensuite la commande “\draw” en lui disant que le dessin dois se remplir de la couleur “myblue” qu’on a défini plus tôt. Et je lui donne les positions. Je joins les points par des “–”, ce qui signifie “trace le trait”.

L’option “++” veut simplement dire: au lieu d’aller au point en position absolue, vas-y en position relative à la position en cours.

Ainsi, quand j’ai inséré “-- ++ (0, -8)” je demande à TikZ de ne pas bouger en “x” mais de descendre de “8” vers le bas. Alors que “-- (current page.north east)” a demandé à TikZ de déplacer le crayon à ce point sans prendre en considération d’où je viens.

Enfin, la commande “cycle” demande simplement de fermer la forme. En gros, rejoindre le dernier point au premier point déclaré.

Ça ressemble à un peu à du “tortue logo” cette affaire :)

Bon, et bien on a plus qu’à poser ce super dessin dans notre bloc de chapitre:

\titleformat{\chapter} % type
    {\Huge\color{white}} % style
    {\thechapter} % quoi afficher
    {0} % espacement
    {\begin{tikzpicture}[remember picture,overlay]
      \draw[fill=myblue] (current page.north west)
        -- (current page.north east)
        -- ++ (0, -8)
        -- ++ (-\paperwidth, -2)
        -- cycle;
    \end{tikzpicture}
    } % "before"

% on déplace un peu le titre vers le haut
\titlespacing*{\chapter}{-18pt}{0pt}{50pt}

Oui, comme ça de visu ça peut faire peur, mais prenez le temps de repérer les blocs, de comprendre, vous allez voir que ce n’est finalement pas si compliqué.

J’ai déplacé le titre vers le haut de -18pt tout simplement parce que notre dessin se pose “avant” le titre, et par conséquent le texte apparait après. C’est en quelque sorte un “margin-top” en CSS. Et le “0pt” c’est l’écart à gauche, le “padding-left” en CSS. Le “50pt” est l’écart que je force “après” le titre, là on parle de “padding-bottom” en CSS.

Et voilà ! On a dessiné notre page de chapitre. Passons aux autres pages.

Entêtes et Pieds de pages

La partie la plus compliquée est passée, on passe maintenant aux pages. J’ai envie de dessiner une image dans l’entête qui fasse la taille de la page, bord à bord.

Entêtes

J’ai donc créé une image à la va-vite dans Gimp, assez grande pour éviter de pixeliser. On va l’injecter encore une fois grâce à TikZ. Le paquet “fancyhrd” va nous permettre de modifier l’entête.

Petite astuce, pour initialiser les entête et pieds de page à vide, on utilise “\fancyhf{}” ce qui veut dire, mot pour mot, “défini header et footer à vide”. Autre chose, la barre qui sépare l’entête et le pied de page du texte nous gêne, donc on va la mettre à 0pt.

% à placer après l'insertion de
% package "fancyhdr"
\pagestyle{fancyplain} % ou "fancy", testez
\fancyhf{} % vire le contenu de header et footer
\renewcommand{\headrulewidth}{0pt} % vire la barre de séparation

Maintenant, on définie l’entête. Fancyhdr permet de placer des trucs à droite, à gauche et au centre. On va utiliser le bloc central, mais c’est absolument arbitraire. On déclare notre entête avec “\chead{...}” qui est un alias de “\fancyhead[C]”:

\chead{%
    \begin{tikzpicture}[remember picture, overlay]
    \node [yshift=-100, inner sep=0, outer sep=0]
        at (current page.north){\includegraphics[width=\paperwidth]{head.png}};
    \end{tikzpicture}
}

Bon je vous avoue que j’ai “tatoné” un peu pour trouver le “yshift”. Sans cela, l’image se place bien au “nord” de la page, mais c’est le centre de l’image qui est placé à cet endroit, donc je demande à TikZ de “descendre” l’image un peu (un genre de margin-top), ce qui fait que l’image est légèrement plus basse. Mon image est relativement large et haute, donc “-100” est une très grosse valeur. Mais je voulais que l’image déborde sur le texte, l’effet est voulu.

En ce qui concerne les “inner et outer sep”, ce sont en gros les marges et “paddings” que je le mets à 0. Encore une fois, je ne peux que vous conseiller de modifier les valeurs pour comprendre le comportement.

Pour que l’image prenne toute la largeur de la page, je lui donne une largeur qui vaut “\paperwidth”. De cette manière si vous avez une partie de l’image qui doit bien atteindre le bord droit de la page, elle sera bien collée à droite.

C’est pas mal. Mais c’est vide.

On va ajouter le titre du chapitre sur l’image avec un peu de couleur. À savoir que fancyhdr propose des commandes:

“\leftmark” est ce qu’il devrait afficher sur les pags de “gauche”
“\rightmark” est ce qu’il devrait afficher sur les pags de “gauche”
et d’autre, voir la documentation http://texdoc.net/texmf-dist/doc/latex/fancyhdr/fancyhdr.pdf

Bref, voilà un exemple:

\chead{%
    \begin{tikzpicture}[remember picture, overlay]
    \node [yshift=-100, inner sep=0, outer sep=0]
        at (current page.north){\includegraphics[width=\paperwidth]{head.png}};
    \node[yshift=-40,rotate=5, text width=0.5\paperwidth]
        at (current page.north) {%
            \Huge
            \textbf{``} % un guillemet à l'envers
            \textcolor{myblue}{\leftmark} % le titre
            \textbf{''} % un guillemet à l'endroit
        };
    \end{tikzpicture}
}

Et oui, si vous avez bien lu l’exemple, je fais tourner le texte de 5 degrés, j’aime bien :)

Vous commencez à comprendre à quel point on peut aller loin ? Là j’ai mis une image, mais rien ne vous empêche de dessiner avec TikZ dans l’entête.

On passe au pied de page.

Pieds de pages

On va faire un truc un peu comme pour les pages de titre de chapitre, on va dessiner une forme, et y coller du contenu.

Alors, un petit rappel à ceux qui utilisent Word ou LibreOffice (je n’ai rien contre), n’oubliez pas que LaTeX est vraiment un outil d’édition. De ce fait, on pense aux pages de droite et gauche, et notamment on les désigne comme étant les pages “paires” et “impaires”. Rappelez-vous que impair en anglais ce dit “Odd”, et pair “Even”. C’est important pour la suite.

Je pars du principe que nous allons utiliser la classe de document “book”, qui change les marges des pages paires et impaires. Donc, je vais moi aussi gérer les pieds de pages correctement en orientant la forme dessinées un coup dans un sens, un coup dans l’autre, et placer mon numéro de page un coup au bord gauche (pages paires) et un coup au bord droit (pages impaires)

Je ne vais pas tout détailler, référez-vous à notre exemple sur les entêtes, je ne fais rien de différent à part modifier les coordonnées :

\fancyfoot[CE]{%
\begin{tikzpicture}[remember picture, overlay]
    \draw [fill=myblue]
        (current page.south east)
        -- (current page.south west)
        -- ++ (0, 4)
        -- cycle;
    \node [yshift=28pt,xshift=50pt]
        at (current page.south west)
        {\color{white}\rightmark};
    \node [yshift=28pt]
        at (current page.south)
        {\color{white}\thepage};
\end{tikzpicture}
}


\fancyfoot[CO]{%
\begin{tikzpicture}[remember picture, overlay]
    \draw [fill=myblue]
        (current page.south west)
        -- (current page.south east)
        -- ++ (0, 2)
        -- cycle;
    \node [yshift=28pt, xshift=-50pt]
        at (current page.south east)
        {\color{white}\thepage};
\end{tikzpicture}
}

Que signifient les lettres “CE” et “CO” ?

Et bien c’est simple. “C” veut dire que je définis le centre de mon “footer”, encore une fois c’est arbitraire puisque nous avons réinitialisé les contenus avec “\fancyhf” et que par conséquent les blocs de droite et gauche sont vides.

Par contre “O” signifie que je travaille sur le pied de page des pages “paires” (Odd), et “E” sur les pieds de pages “impaires” (Even). J’inverse donc la forme et le placement de “\thepage” qui donne le numéro de page actuel.

Voilà ce que me donne ces blocs:

Oui, j’ai fait exprès de ne pas avoir la même forme à droite et à gauche.

Nous y voilà, les pages sont terminées, on peut passer à la page de titre.

La page de titre

LaTeX est un langage de “balise”, et chaque balise est en fait une macro “TeX”. Par conséquent, la balise “\maketitle” qui génère la page de titre est une macro.

Et en LaTeX, on peut redéfinir des macros. C’est ce que nous allons faire pour la page de titre.

De manière générale, voilà comment vous allez vous y prendre :

\renewcommand{\maketitle}{%
    \begin{titlepage}
    % ici le contenu de la page titre
    \end{titlepage}
}

Et encore une fois, TikZ va nous servir.

Mon image d’entête est assez grande, vous n’avez vu qu’une petite partie de celle-ci. Je vais m’en servir dans ma page, placer le titre, l’auteur, etc. Rien de bien compliqué (mais non).

% pour récupérer le titre...
\usepackage{titling}

% je définis le titre
\title{Mon example de thème}
% l'auteur (moi)
\author{%
    Patrice FERLET\\
    metal3d@gmail.com
}

% et la page de titre
\renewcommand{\maketitle}{%
    \begin{titlepage}
    \begin{tikzpicture}[remember picture, overlay]

    \node [yshift=-230, inner sep=0, outer sep=0]
        at (current page.north)
        {\includegraphics[width=\paperwidth]{head.png}};

    \node [shape=rectangle,
            fill=myblue,
            anchor=west,
            minimum width=1.4\paperwidth,
            xshift=-0.7\paperwidth,
            inner sep=2cm,
            rotate=10]
        at (current page.center)
        {\Huge\textcolor{white}{\textbf{\thetitle}}};

    \node [yshift=120, text width=\paperwidth, align=center]
        at (current page.south)
        {\Huge\color{myblue}\theauthor};
    \end{tikzpicture}
    \end{titlepage}
}

C’est du vite-fait pour l’article, je vous laisse une fois de plus imaginer ce que vous pouvez faire avec un peu de travail.

On peaufine

Reste une ou deux choses à adapter, personnellement, j’ajoute déjà des règles de séparation de paragraphe ainsi que l’indentation de paragraphe :

\setlength{\parindent}{12pt}
\setlength{\parskip}{6pt plus 2pt minus 1pt}
\setlength{\emergencystretch}{3em}

Et en ce qui concerne l’entête, j’ajoute le “titre” du chapitre seulement à partir des pages > 2. Sinon, on se retrouve avec des guillemets qui ne contiennent rien à la page 2 (page de garde).

Donc revenez sur le code “\chead” et ajouter un test:

\chead{%
\begin{tikzpicture}[remember picture, overlay]
    \node [yshift=-100, inner sep=0, outer sep=0] at (current page.north) {\includegraphics[width=\paperwidth]{head.png}};
    \node[yshift=-40,rotate=5, text width=0.5\paperwidth] at (current page.north) {%
    \ifnum\value{page}>2
        \Huge
        \textbf{``}
        \textcolor{myblue}{\leftmark}
        \textbf{''}
    \fi
    };
\end{tikzpicture}
}

Et voilà, on a fini.

Conclusion

Ce n’est pas du grand art, je ne suis pas un fin designer, mais ça vous donne une idée de la possibilité qu’offre LaTeX et TikZ.

Je suis conscient que LaTeX n’est pas “aisé” quand on entre dans ce genre de détail. Mais rappelez-vous que vous allez certainement créer un thème (template) une fois et le garder pour le reste de vos travaux. Je peux aussi utiliser différents thèmes pour le même article, livre, rapport…

Apprendre LaTeX est souvent considéré comme désuet face à markdown ou RST, mais si je prends l’exemple de PanDoc (que j’adore) il passe bien par LaTeX pour générer le document. Et par conséquent, créer un template pour pandoc revient à faire ce que j’ai fait dans cet article. Alors un bon conseil, penchez-vous dessus.

Un dernier point, si vous maitrisez LaTeX, vous allez pouvoir générer des rapports en PDF en utilisant des templates à vous. Comparer l’utilisation d’un fichier .doc, ou .odt et la génération de document en PDF avec LibreOffice (sans le critiquer, je le trouve très bien), et LaTeX, vous vous rendrez compte que c’est peut-être bien plus évident de se taper un thème et des macros que de se battre avec les thèmes et règles d’un outil “de traitement de texte”.

Personnellement, j’utilise LaTeX pour pas mal de travaux et je vous invite à passer un peu de temps à vous former dessus pour gagner beaucoup de temps à l’avenir.

Gogs - le vrai clone de github

Tue, 26 Apr 2016 11:26:02 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vous trouvez gitlab lourd et pas facile à installer, je vais vous parler de Gogs ! Le service Git qui est, pour le coup, vraiment un clone très proche de GitHub et très facile à mettre en place.

Apparement je suis super à la bourre niveau news parce que le projet Gogs a plus de 2 ans. Mais c’est pas grave, j’ai envie de vous parler de mes tests.

C’est au détour d’une conversation que @fredix me parle de ce Gogs. Je trollais grassement Ruby et je disais que pourtant j’utilisais des outils développés en Ruby comme GitLab. Et, sachant que j’adore le langage Go, il me glisse un “tu devrais regarder Gogs alors”… Et effectivement il a retweeté ceci, que j’ai zappé sans le faire exprès:

Gogs, un serveur Git avec Docker // @gogitservice @docker https://t.co/BOgKGHMXUY pic.twitter.com/tW9jqpIgyF
— Valentin Ouvrard (@Valentin_NC) 19 avril 2016

Arrivé le soir à la maison, je ne peux m’empêcher de le tester. Et ça m’arrive rarement ces derniers temps, mais j’ai bien assisté à un “effet waouh”.

Installation

Deux solutions:

le binaire, puisque le projet est développé en Go, il suffit de lancer l’exécutable. Pas de dépendances. C’est ce qu’il y a de bien avec Golang :)
ou le conteneur Docker qui permet d’isoler tout ça et de faire “mumuse” avec des BDD différentes en un coup de cuillère à pot.

Le binaire se suffit à lui-même et pèse 32Mo complété d’une dizaine de megas d’images, de templates et de css en tout genre. Le conteneur pèse lui environ 81Mo (normal, on inclut ici un FS).

Bref, rien à voir avec les 700Mo de l’image Gitlab… Cela peut passer comme un troll ou une critique mais ça n’en est pas une. Gitlab a énormément d’options et d’outils, et les dépendances nécessaires sont assez nombreuses. Donc rien de surprenant. Mais au-delà de cela, il y a “Ruby”. Pour rappel: Go permet de compiler en binaire natif le projet, alors que des sources Ruby ont besoin de tout le runtime. Cela alourdi considérablement une image qui en a besoin.

On évite de troller et on passe à la suite.

Pour démarrer le conteneur Gogs, c’est simple, je pars du principe que vous avez Docker 1.9 minimum pour créer un volume, sinon vous devrez monter les “data” dans un répertoire local.

![En deux lignes c'est prêt](/static/upload/9c5ce5c7-3fae-4181-b332-3e06b04332a4-gogs.gif)

Deux petites commandes:

# création d'un volume pour garder les
# fichiers de conf
docker volume create --name gogs-data

# on utilisera le port 10022 pour ssh
# et 10080 pour l'interface web
docker run --name gogs -p 10022:22 -p 10080:3000 -v gogs-data:/data gogs/gogs

Bon, la page de configuration est pas compliquée, il suffit de renseigner quelques broutilles comme le serveur de base de données (j’ai pris Sqlite pour tester) et j’ai tout laissé par défaut sauf une entrée:

Application URL: http://localhost:10080

Simplement parce que je le fais tourner sur Docker et que j’ai “bindé” le port ici. Sinon, la prochaine étape ne fonctionne pas.

En cas d’erreur, no panic:

coupez le conteneur “docker stop gogs”
supprimez le avec “docker rm gogs”
supprimez le volume “docker volume rm gogs-data”
refaite le volume et lancez le projet comme expliqué ci-dessus

Après cette étape terminée, vous voilà avec un serveur Gogs. Créez un utilisateur en passant pas “sing-up”, le premier compte est administrateur (à moins que vous ayez utilisé les options avancées de l’installeur juste avant).

Et le contenu

J’ai cru que ce projet n’allait pas me donner beaucoup d’options. C’est une erreur. Presque tout est là !

Créer un dépôt, paramétrer les webhooks, ajouter des clefs SSH, etc. Tout est là.

Les captures tirées du dépôt parlent d’elles même:

Impressions (personnelles)

C’est fluide, propre, ça ressemble vraiment à github (à s’y méprendre) et je suis franchement étonné qu’un si “petit” projet (dans le sens “poids”) puisse faire tant de choses et si bien.

J’ai joué presque 4h avec, j’ai créé des dépôts, ouvert plusieurs comptes, créé des pull-requests, foutu le boxon pour voir ce que ça pouvait engendrer. Rien à redire ça répond bien à tout ce dont j’ai besoin.

Je ne sais pas à quel point c’est scallable et je n’ai pas encore d’avis sur la question “sécurité”, mais j’ai largement moins galéré à utiliser SSL via un reverse proxy qu’avec Gitlab (y compris avec des images Docker super bien faites). Je reste franchement très impressionné.

Seul hic, mais c’est certainement parce que le projet est encore jeune, je n’ai pas trouvé l’équivalent de “gitlab-ci” (les fameux runners) qui me permettrait de faire des “builds” automatiques. Mais je compte bien sur la communauté pour bosser sur le sujet. Dans tous les cas, un Jenkins à côté (ou un truc plus léger…) fera bien l’affaire.

Et coté “addons”

En premier lieu, l’interface est traduite dans un certain nombre de langages y compris le français.

Il y a ce qu’il faut pour le minimum:

webhooks,
service mail,
issues,
connexion LDAP,
api…

De ce que j’en ai vu, il est possible de connecter Drone.io mais ayant investigué dans le forum, il apparait qu’à ce jour il n’y a pas moyen de valider une pull-request via un service externe type Jenkins.

Pour le moment j’en suis à la phase de test et je découvre un peu l’outil. Donc tout ce que je dis ici ne doit pas être pris comme paroles d’évangile. Il se peut que cela soit possible mais je ne trouve pas l’info.

Autre “addon” si on peut appeler cela comme ça, l’API est peu documentée. Elle est pourtant bien là et permet de faire quelques opérations. Je n’en dis pas plus, je n’ai pas franchement creusé le sujet.

Mais qui s’en servira ?

Alors, on change ? On passe de GitLab à Gogs ? Attendez un peu quand même…

Je ne vais pas vous dire de l’utiliser comme dépôt ouvert au public. Ce serait vite m’avancer. Mais pour un “github like” d’entreprise c’est souvent bien suffisant. Un indépendant qui gère pas mal de dépôts et qui veut laisser l’accès proprement à ses clients et collaborateurs trouvera aussi son bonheur avec Gogs. Il est moins compliqué à gérer, très simple à installer et ne dépayse pas les utilisateurs qui connaissent déjà GitHub.

Par contre, il est encore jeune, n’offre pas tout d’un gitlab et n’est pas, pour l’heure, assez éprouvé. À ce jour, il faut savoir dans quoi on met les pieds en l’utilisant. Mais je suis persuadé qu’il va vraiment faire des prouesses rapidement.

Je suis même en train de me demander si je ne devrai pas tenter de créer l’équivalent de “gitlab runner” sur Gogs… D’après les auteurs le fait de “bloquer” une PR et de la rendre “mergeable” par la suite est un peu complexe à l’heure actuelle.

Une chose est sûre, les auteurs de Gogs sont ouverts à la discussion, le forum est actif et le projet est en vie depuis déjà assez longtemps pour imaginer avoir un support (communautaire) conséquent.

Ressources:

https://gogs.io/
https://github.com/gogits/gogs
https://try.gogs.io/ (démo dont les projets sont supprimés régulièrement)
https://discuss.gogs.io/ (le forum)

Validation de pull request Github avec "lgtm"

Fri, 22 Apr 2016 11:35:03 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Les “code reviews” sont souvent sous-estimées alors qu’elles sont une des phases les plus importantes pour la pérennité d’un projet et son bon fonctionnement. LGTM.co propose une solution pour renforcer un peu cette phase.

Avant toute chose, ce que je vais vous montrer ne remplace pas Gerrit. Mais il arrive que, par manque de temps, manque de moyens ou d’infrastructure, vous ne puissiez pas en profiter. C’est donc un outil super intéressant que j’ai testé pour vous: LGTM qui est un commentaire fréquemment utilisé pour dire “Looks Good To Me” (traduction: “ça semble correct”). Ce commentaire va être utilisé par un outil externe lgtm.co qui se connecte en tant qu’application tierce sur GitHub.

Comment ça marche ?

Il suffit de se connecter avec son compte github sur lgtm.co et d’activer la gestion de code-review:

Il faut ensuite impérativement ajouter un fichier “MAINTAINERS” qui doit lister les mainteneurs dont les commentaires seront comptabilisés. Voir: https://lgtm.co/docs/maintainers/ Il en faut un par ligne.

Là par contre j’ai eu un léger bug et la forme suivante ne passait pas:

Patrice FERLET <metal3d@...> (@metal3d)

Donc pour le moment j’utilise:

metal3d <metal3d@...>

Si besoin, vous pouvez aussi ajouter un fichier “.lgtm” pour modifier le nombre de review minimale (2 par défaut), la forme du commentaire (LGTM par défaut), etc. Voir https://lgtm.co/docs/customize/

Pour le test, j’ai demandé à un collègue de se prêter au jeu et j’ai limité le nombre de review à 1:

approvals = 1
pattern = "(?i)LGTM"

Notez que j’ai bien aussi le “pattern” pattern = "(?i):\\+1:" qui fait apparaitre un pouce jaune :)

Bref, à vous de décider.

Phase de review

La phase est assez simple:

quand une pull-request est créé, LGTM va “bloquer” la possibilité de la merger
quand un nombre de review positive est atteint, le bouton “merge” est déverrouillé

L’idée est super simple:

vous paramétrez lgtm pour définir le nombre de reviews positives minimales à trouver
qui sont les “mainteneurs” dont les commentaires seront comptabilisé
vous laissez faire

Et pour les dépôts privés ou entreprise ?

Là c’est un peu plus compliqué, mais ce n’est pas non plus l’enfer. La licence du projet est assez claire:

Licensing

This product is free for small teams and non-profits, however, we will require a modest licensing fee for on-premise enterprise use in the near future. Pricing to be published soon.

– https://lgtm.co/docs/install/

Et je ne connais pas vraiment le tarif… Mais bon, passons au test.

En gros, il suffit de faire tourner le conteneur Docker:

$ docker pull lgtm/lgtm
$ docker run \
	--volume /var/lib/lgtm:/var/lib/lgtm \
	--env-file /etc/lgtm/lgtmrc \
	--restart=always \
	--publish=80:8000 \
	--detach=true \
	--name=lgtm \
	lgtm/lgtm

Il faut bien entendu mettre les clefs d’accès GITHUB dans le fichier “/etc/lgtm/lgtmrc”:

GITHUB_URL=https://github.mycompany.com
GITHUB_SCOPE=user:email,read:org,repo
GITHUB_CLIENT=
GITHUB_SECRET=

Bilan

On est en train de proposer ça à nos équipes, le but étant d’éviter l’auto-validation de masse et d’ajouter un côté ludique à la phase de “review”.

Je le répète, ça ne remplace pas Gerrit, mais ça peut franchement ajouter une valeur de plus à votre gestion de projet.

docker - arrêtez d'utiliser des conteneurs data-only

Mon, 18 Apr 2016 11:51:18 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Le voilà le titre racoleur. Et en le lisant vous êtes en train de vous dire que je vais aller à l’encontre des bonnes pratiques. Vous vous trompez !

Non mais sérieusement, je sais qu’on vous a répété maintes fois “utilisez un conteneur data-only”, et je comprends bien l’intérêt. Cela-dit, je vais faire durer un peu le suspens et commencer par réexpliquer ce qu’est un “volume” et ce que fais un conteneur “data-only”. Je vous donnerai enfin la meilleure option pour vous en passer, et pour éviter de vous torturer la tête: non je ne vais pas non plus faire un montage de volume local tout bête. Mais je ne vais pas non plus rendre plus complexe l’opération.

En clair, on va se passer de conteneur data-only, que ce soit avec docker ou docker-compose tout en gardant la souplesse de l’opération.

EDIT: Merci à Adirelle, dans les commentaires, d’avoir précisé que les volumes nommés sont une “nouveauté” de Docker 1.9, ce qui explique l’utilisation massive de conteneurs data-only avant cette version

EDIT: Merci aussi à cedvanet pour sa question: Effectivement je n’ai pas été clair sur le fait que les conteneurs “host:conteneurs” ne sont pas le sujet de cet article, ils sont bel et bien très utiles, par exemple pour développer en partageant les sources entre votre IDE et votre conteneur, ou pour placer de la configuration. De plus, effectivement, il arrive que des “data-only containers” soient utiles, le titre du billet est peut-être trop brutal. Ce que je tente de vous démontrer n’est pas qu’un data-only container est “inutile” ou “à ne jamais utiliser”, mais qu’il faut les utiliser que certains cas.

C’est quoi un volume ?

Docker propose des volumes depuis le début. Le principe est parfois mal compris et très souvent mal utilisé. Il existe deux types de volumes très utilisés:

les volumes “host:conteneur”
les volumes “conteneur:conteneur”

Ces noms sont donnés à titre indicatif et n’existent pas dans la documentation de docker, c’est juste pour vous donner une définition simple.

Le premier, “host-conteneur” est un bête montage de répertoire local que vous choisissez vers le conteneur. Pour faire simple:

$ docker run -it --rm -v ~/Documents:/opt/docs alpine sh
> ls -la /opt/docs

Vous voyez dans le répertoire “/opt/docs” du conteneur les fichiers et répertoires “~/Documents”. C’est simple et c’est pratique. Par exemple quand on travaille en PHP, Python ou je ne sais quel autre langage, il suffit de monter les sources du projet dans le conteneur qui aura loisir de démarrer votre projet.

L’autre type de volume est plus sournois. Une image va définir un volume qui pourra alors être monté dans d’autres conteneurs. Outre le fait que la majeure partie des gens n’ont pas conscience de ce qui découle de déclarer un volume dans une image (et, brisons le suspens, c’est la finalité de l’article), c’est certainement l’une des notions les plus intéressantes de Docker.

Prenons une image simple:

FROM alpine
# on déclare un volume
VOLUME /opt/data
# pas la peine le de le laisser tourner
# les volumes sont accessibles même
# quand le conteneur ne tourne plus
CMD ["true"]

Maintenant démarrons un conteneur avec cette image:

$ docker build -t $USER/dataexample .
$ docker run -it -d --name data $USER/dataexample

Et lions les volumes de ce conteneur dans un nouveau conteneur:

$ docker run --rm -it --volumes-from data alpine sh
> touch /opt/data/foo
> exit

Maintenant, créons un nouveau conteneur qui monte, une fois de plus, les volumes du conteneur “data”

$ docker run --rm -it --volumes-from data alpine sh
> ls /opt/data
> foo

Vous l’avez compris. Le fait de déclarer un volume dans une image permet de partager un répertoire depuis le conteneur vers d’autres conteneurs.

Maintenant, pour bien poser l’idée, le conteneur “data” est un conteneur “data-only”. Il ne fait rien d’autre que de garder les données d’un répertoire qu’il a déclaré comme étant un volume.

Sans passer par la case “image”, on peut tout à faire créer un conteneur “data-only” directement:

docker run -it --volume /opt/data --name data2 busybox

Le fait de ne pas donner de point de montage local va créer un volume.

Ok, mais il stocke où alors ?

Et justement… Voilà ce qui me chagrine avec l’utilisation de conteneurs “data-only”.

Le volume est bel et bien stocké, par défaut, sur votre système. Sauf que peu d’utilisateurs en ont conscience.

Si je ne déclare pas de volume, les fichiers sont stockés dans le conteneur lui-même (en fait, dans le répertoire /var/lib/docker/SHA_IMAGE…). Mais quand on déclare un volume, docker va créer un répertoire prévu à cet effet. Que l’on soit bien clair, Docker déclare un volume, et vous pouvez le voir par vous-même:

$ docker -d run -it --name data -v /opt/data busybox
$ docker inspect  --format "{{ .Mounts }}" data
[{ab099654cc0be... /var/lib/docker/volumes/ab099654cc0be.../_data /opt/data local  true }]

$ docker volume inspect ab099654cc0be...
[
    {
        "Name": "ab099654cc0be...",
        "Driver": "local",
        "Mountpoint": "/var/lib/docker/volumes/ab099654cc0be.../_data"
    }
]

Et voilà où je veux en venir. Supprimez le conteneur “data”, et relancez la commande d’inspection de volume:

docker stop data
docker rm data

Vous venez de supprimer le conteneur, mais son volume est toujours là…

docker volume inspect ab099654cc0bef6c8b0f18e3fb8efe2b564b39832cd1db6b277f4c92bf84272c
[
    {
        "Name": "ab099654cc0be...",
        "Driver": "local",
        "Mountpoint": "/var/lib/docker/volumes/ab099654cc0be.../_data"
    }
]

On vient de créer un orphelin.

Autre souci, je ne peux plus monter ce volume:

$ docker run --rm -it --volumes-from data busybox
docker: Error response from daemon: No such container: data

Donc, voilà la première raison qui me pousse à ne pas utiliser des conteneurs “data-only”, mais plutôt d’utiliser un volume.

Ok, utilisons un volume

Maintenant que vous avez compris le principe, sachez que docker peut vous permettre de créer un volume sans passer par un conteneur. C’est là que je veux en venir !

Prenons un exemple que j’utilise beaucoup, un conteneur mongo dont je ne veux pas perdre les données. J’utilisais, avant, un répertoire perso pour y stocker les données.

Plus tard, j’ai utilisé un conteneur data-only, ce qui fonctionne bien, je ne dis pas le contraire. L’image mongo déclare un volume “/data/db”, donc je n’avais qu’à faire:

docker run --name mongodata -v /data/db -it -d busybox
docker run --rm -it --volumes-from mongodata mongo

Oui, mais c’est bête !

Voilà la meilleure façon de faire:

docker volume create --name mongodata
docker run --rm -it -v mongodata:/data/db mongo

Cette fois, je définis où je monte le volume, et je n’ai qu’un seul conteneur qui tourne: le conteneur mongo. Le volume est local (par défaut) et se trouve ici:

$ docker volume inspect mongodata
[
    {
        "Name": "mongodata",
        "Driver": "local",
        "Mountpoint": "/var/lib/docker/volumes/mongodata/_data"
    }
]

C’est bien plus efficace et ça limite largement le nombre de conteneurs à démarrer. On notera aussi la facilité à retrouver les volumes par leurs noms.

et avec docker-compose ?

Docker-compose est vraiment un outil pratique et j’attendais avec impatience l’arrivée d’une version “2” qui me permettais de jouer avec un peu plus d’options. Et justement, depuis cette version, nous pouvons créer des volumes.

Exemple:

version: '2'
services:
	database:
		image: mongo
		volumes:
		- mongodata:/data/db
volumes:
	mongodata:
		driver: local

Et voilà, un conteneur, un volume, pas la peine de créer un conteneur simplement pour garder des données au chaud.

Les drivers

Par défaut nous utilisons des volumes locaux. Mais il existe d’autres drivers qui permettent de monter le volume autrement que sur votre disque.

La liste est déjà conséquente et se trouve ici: https://docs.docker.com/engine/extend/plugins/

J’ai utilisé, pour le fun https://github.com/gondor/docker-volume-netshare qui permet d’utiliser NFS (entre autre). Ça marche bien !

Suites aux commentaires

J’ai reçu pas mal de commentaires sur Twitter, Google plus et ici qui sont trés intéressants. Je vais donc repréciser un point:

Effectivement, il peut arriver que, à l’inverse, un “volume nommé” tel que je le présente ne soit pas la panacée. Un “data-only container” peut avoir tout son intérêt, par exemple pour partager un volume avec beaucoup de conteneurs avec en plus un accès “host”.

Clairement, je ne suis pas là pour juger les utilisateurs de conteneurs data-only, ni pour définir une règle. Ce que je tenais à démontrer ici, dans ce billet de blog, c’est simplement que pour pas mal de cas, la plupart même, un conteneur “data-only” n’est pas une évidence.

En clair:

vous développez et devez avoir accès au répertoire de travail localement: faites un volume host:container
vous voulez partager un volume avec beaucoup de conteneurs et avoir accès localement aux données: faites un conteneur “data-only”
vous voulez persister des données mais y avoir accès localement n’est que ponctuel ou anecdotique: créez un volume nommé

Donc

Donc voilà, le titre, je le répète, “arrêtez d’utiliser des conteneurs data-only”, c’est en fait rarement utile et surtout c’est moins efficace. Docker gère très bien les volumes en tant qu’entité.

Docker, Xvfb et links

Sun, 17 Apr 2016 10:38:02 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Un conteneur = un service, c’est une règle qui peut parfois vous donner du fil à retordre. Et justement, un cas nous est tombé dessus au travail: un service qui doit utiliser Xvfb. Ça fait bien deux services, et il faut les séparer.

Docker, l’outil de la décennie, le projet qui change la face du monde de l’informatique, et son lot de mauvaises idées par exemple, utiliser un conteneur qui lance plusieurs services à coup de supervisord.

Je comprends que parfois ça puisse permette de faire “d’une pierre 1568 coups”, mais ce genre de pratique va à contre-courant du principe de “micro-service”.

Avant de lire la suite ! je sais que certains vont me dire “bha c’est évident !!!”, ou alors “super… Tu découvres qu’on peut lier des conteneurs…”. Stop, j’estime connaitre assez bien docker, et je milite depuis très longtemps sur le fait de séparer les services. Mais je ne suis pas infaillible (et vous non plus). Il arrive que l’on passe à côté d’un chose évidente et ce fut le cas ici. Je ne vais pas prétendre vous révéler un truc incroyable, mais plutôt vous montrer que parfois on peut oublier la règle de l’art et passer à côté d’une notion simple qui vous sauve. Utiliser Xvfb dans un conteneur séparé n’était pas “évident” dans mon esprit, cela ne veut pas dire que je ne savais pas le faire :) bon là je me suis bien brossé, on va pouvoir passer à l’article !

Pourquoi séparer les services ?

Si vous ne séparez pas les services en plusieurs images:

d’abord la taille de l’image va être conséquente car vous allez y injectez tous les services
vous forcez le service principal à utiliser une version gelée des services dépendants
vous risquez d’avoir des soucis si un des services plante sans couper les autres (on va y venir)

Je vais reprendre les deux premiers point. Prenons un exemple “bête et méchant” d’un service web utilisant:

nginx
mysql
php

Si vous créez une image qui embarque tout ça, alors vous allez avoir besoin des 3 logiciels, de lancer le service nginx et mysql en parallèle (via supervisord) et vous ne laissez pas le choix des versions. Si par exemple je décide d’utiliser MariaDB à la place de MySQL, alors je vais devoir reconstruire l’image moi-même et par conséquent perdre un temps précieux. Alors que Docker permet de lier des conteneurs et donc de ne pas m’imposer telle ou telle version de MySQL.

Bref, vous l’aurez compris, la bonne pratique est de créer 3 images et de lier les conteneurs.

Mais comment ça se passe avec Xvfb ?

Si vous ne connaissez pas Xvfb, je vous fais un résumé rapide. C’est un serveur d’affichage, sans affichage. Voilà… En gros, c’est un serveur Xorg qui n’a pas besoin d’écran. On peut alors utiliser la variable d’environnement “DISPLAY” pour lancer un programme graphique. Inutile ? Si vous avez envie de lancer des tests Selenium par exemple, dans un conteneur, et bien sans ce bijou ce sera une douleur.

Bref. Ici au boulot, nous utilisons un service que j’ai développé, nommé Belphegor, qui permet de prendre une capture de site et nous renvoyer l’image en png, jpeg, etc. Nous utilisons Docker, et j’ai donc simplement intégré à l’image un service Xvfb pour lancer le service sur l’affichage virtuel. Erreur de ma part, j’utilise Xvfb-run, un script fourni avec le service, qui a la fâcheuse tendance à ne pas éteindre mon service Belphegor quand Xvfb plante.

Cyril Compigne, collègue sysadmin, me dit alors “bha dois bien y avoir un moyen de séparer les deux services en deux conteneurs, comme ça quand Xvfb plante, on le relance sans couper Belphegor”.

Mais bon sang!!! Pourquoi j’y ai pas pensé ?

Il a raison, et voilà la méthode dite “de bourrin” que vous pourrez améliorer.

Conteneur 1: Xvfb. On crée une image depuis une distribution qui offre Xvfb. Alpine (la distribution que j’adore pour les conteneurs docker) propose un paquet “xvfb” qui fonctionne très bien.

FROM alpine
MAINTAINER Patrice FERLET <metal3d gmail.com>

RUN set -xe; \
    apk add --update xvfb;\
    rm -rf /var/cache/apk/*;
    
CMD ["Xvfb", "-ac", "-listen", "tcp", ":99"]

Juste une petite explication. L’option “-ac” de la commande veut dire “accepte tout le monde”. Vous pourrez l’améliorer plus tard. Vous pourrez, plus tard, adapter cela en sécurisant le service pour n’accepter que les connexions de conteneur choisi. Je n’ai pas poussé plus que ça pour trouver la solution, on n’avait pas trop le temps…

Conteneur 2: Belphegor à qui j’ai viré l’installation et le lancement de Xvfb. On utilisera la variable “DISPLAY” pour définir où se trouve le serveur d’affichage.

Et voilà !

On build et on lance le serveur:

docker build -t $USER/xvfb .
docker run -it --rm --name xvfbserveur $USER/xvfb

Maintenant, prenons l’image “metal3d/belphegor:noxvfb”, ou tout autre conteneur ayant besoin de X:

docker run --rm -it -p 8000:8000 -e DISPLAY=xvfbserver:99 metal3d/belphegor:noxvfb

Le nom “xvfbserver” est celui de mon conteneur Xvfb, docker va résoudre ce nom. Mais c’est pas tout…

Si jamais je coupe le conteneur xvfbserver alors Belphegor n’arrive plus à s’y connecter. Sauf que depuis deux versions, Docker utilise une gestion réseau qui me permet de relancer le conteneur Xvfb sans avoir à relancer le conteneur Belphegor car la résolution de nom ne se fait plus (par défaut) via le fichier “/etc/hosts”.

Du coup, en utilisant l’option “restart=always”, le conteneur xvfbserver redémarre sans intervention humaine. Le conteneur Belphegor, quant à lui, retrouve le nouveau serveur fraichement redémarré. Bref, un QOS amélioré.

Le mot de la fin

Quel que soit le type de conteneur que vous voulez créer, par pitié, évitez supervisord. Je sais que c’est pratique en soi, que ça permet de faire “un seul conteneur” qui gère tout comme un seul service. Mais cela va à l’encontre de la philosophie de micro-service.

À la place, proposez un fichier “docker-compose” et séparez vos services. Le monde en sera que meilleur !

Go-Pipe, streamez à la unix/like en Go

Mon, 11 Apr 2016 20:01:23 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vous connaissiez les “pipelines” de Gulp, et bien voici celles de Go grâce à un boulot intéressant (mais datant d’un an déjà) de Gustavo Niemeyer sur sa page Go.pipe - un package permettant de traiter des flux, d’ajouter ses propres traitements, et surtout sans trop de douleurs.

L’idée est simple. En bash, on utilise des pipelines. C’est une notion courante qui utilise une notation spéciale qui permet de rediriger des entrée/sorties de commandes en commandes. L’idée de Gustavo est de permettre une notion de “pipeline” tout comme le fait Gulp-pipe.

Comment ça marche ?

Installation

Pas de grande surprise:

go get gopkg.in/pipe.v2

Exemple simple

Prenons l’exemple en bash:

cat /etc/passwd | sort | cut -f 1 -d ":"

Cette commande lit le fichier “/etc/password”, envoit la sortie dans la commande “sort” qui va classer le contenu. Enfin, on envoit ceci dans la commande “cut” pour récupéérer la première partie (parties séparées par des “:“).

Et bien en Go, grâce à “pipe”, le code va être:

package main

import (
    "fmt"

    "gopkg.in/pipe.v2"
)

func main() {
    p := pipe.Line(
        pipe.ReadFile("/etc/passwd"),
        pipe.Exec("sort"),
        pipe.Exec("cut", "-f", "1", "-d", ":"),
    )

    if output, err := pipe.CombinedOutput(p); err != nil {
        fmt.Printf("%v\n", err)
    } else {
        fmt.Printf("%s", output)
    }
}

Pour faire simple: “pipe.Line” attend autant d’argument que de partie de pipeline à brancher entre eux. À la fin, vous pouvez récupérer la sortie “combinée”. Vous pouvez aussi bien utiliser “pipe.DividedOutput()” qui retournera la sortie standard, la sortie d’errer et une “erreur” (dans cet ordre).

Bref, c’est jolie.

Et quoi d’autre ?

On ne s’arrête pas aux simples “commandes brnachées entre elles”, car Gustavo a pensé à ajouter deux trois fonctions bien sympatiques.

Par exemple, on trouvera:

pipe.ReadFile(path) qui lit le contenu d’un fichier
pipe.WriteFile(path) qui écrit dans un fichier
pipe.Filter() qui prend en paramètre une fonction pour filtrer la sortie
pip.Tee() pour permettre la double redirection (comme le fait la commande “tee”)
et d’autres…

Vous pouvez voir la liste des fonctions ici: https://godoc.org/gopkg.in/pipe.v2 - inutile de vous préciser qu’il est important de lire la doc !.

Créer sa propre commande

Au lieu d’appeler des commande “sh”, vous pouvez créer votre propre fonction qui peut être injectée dans le pipeline. C’est très simple (ou presque).

L’idée c’est que “pipe.Line()” attend des “pipe.Pipe”. Et justement, une fonction du package permet de créer cette structure en fonction de l’état du pipeline. Si c’est pas génial ça !

Admettons que je veuille créer une fonction “ToUpper” qui puisse chopper le flux et mettre les caractères en lettre capitale.

La fonction sera alors:

func ToUpper() pipe.Pipe {
    // returns the pipe.Pipe created by
    // a new Task
    return pipe.TaskFunc(func(s *pipe.State) error {
        var err error
        b := make([]byte, bytes.MinRead)

        // read stream
        for err == nil {
            if _, err = s.Stdin.Read(b); err != nil {
                break
            }

            // create buffer with uppercase letters
            // and copy it to output
            buff := bytes.NewBuffer(nil)
            buff.Write(bytes.ToUpper(b))
            _, err = io.Copy(s.Stdout, buff)
        }

        if err != io.EOF {
            return err
        }
        return nil
    })
}

Je clarifie un point: une tâche (pipe.Task) utilise un état (pipe.State) dans lequel les entrées/sorties sont définies. Le “pipe.Pipe” aura donc le contexte du pipeline en cours. C’est évident quand on y réfléchis.

J’aurai put utiliser “ioutil” et faire un “ReadAll” sur “s.Stdin”, mais l’idée c’est de “streamer”, donc de récupérer “coup par coup” la sortie de la tâche qui fourni le flux. Donc, je préfère lire par paquet de 512 octets (bytes.MinRead), et envoyer les données dans “s.Stdout” au fur et à mesure.

Il ne reste plus qu’à injecter ma fonction dans le pipeline:

p := pipe.Line(
    pipe.ReadFile("/etc/passwd"),
    pipe.Exec("sort"),
    ToUpper(),
)

Et ça marche super bien !

Vous imaginez maintenant comment faire des choses sympas ? Par exemple, lire le contenu d’un flux HTTP, l’envoyer dans une commande de traitement et l’enregistrer dans un fichier tout en l’envoyant dans un port ouvert.

Ça ressemblerai à ça:

p := pipe.Line(
    ReadHTTP("http://url.to.read"),
    ToUpper(),
    Tee(portWriter),
    WriteFile("save.stream.txt"),
)

En gros, ça va soulager pas mal de projets qui ont des flux à balancer un peu partout.

En bref, c’est du “pipeline” propre et sans bavure.

Bref, bilan ?

Inutile de préciser que certaines choses ne peuvent pas marcher partout. Par exemple la commande “Exec” devra utiliser des commandes qui existent sur l’OS cible.

L’auteur ne précise pas franchement comment créer un “pipe.Pipe” proprement, j’ai du lire le code pour comprendre. C’est un peu dommage mais honnêtement un peu de lecture de la doc plus approfondie m’aurait permi de trouver, de suite, la section qui en parle

Voilà, personnellement je vais garder ça dans un coin parce que je suis persuadé que ça va me servir très bientôt.

HubiC le service de stockage en ligne qui me fait presque aimer OVH

Mon, 11 Apr 2016 20:01:10 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Avoir un service de stockage sympa, gérant les sauvegardes, pour environ 30Go à 50€/an, c’est quand même une idée intéressante que je ne pensais pas voir apparaitre. Mais OVH a réussi à me créer la surprise avec Hubic qui fonctionne suffisamment bien pour que je fasse ce que je veux. À savoir, non pas avoir un disque monté (ce qu’il sait faire) mais me permettre des sauvegardes incrémentales versionnées de différents répertoires. Un peu de scripting pour améliorer tout ça, et voilà mon billet qui vous explique.

Avant toute chose, j’ai tout de même fouillé pour voir si DropBox ou Google pouvaient me permettre ce genre de chose.

DropBox: version “pro” pour 1To à 99€/an non mais sérieusement ?!
GoogleDrive: 15Go gratuit (ce que je trouve très bien), mais 299€/an pour 30To, je ne plaisante pas c’est quand même une fortune !

Sachant qu’en plus Google ne propose pas de client Linux (officiel), ne permet pas la sauvegarde de répertoire choisis, ni de version… non sérieusement c’est pas ce dont j’avais été habitué de la part de la firme. Et ne me parlez pas du montage que propose Gnome, la lenteur d’accès est limite honteuse, à tel point que je l’ai désactivé.

Bref, Xavier D. encore lui, m’a parlé de HubiC - quand j’ai appris que ça venait de OVH j’ai un peu déchanté, mais je suis bon joueur et je me dis qu’il faut tester ce produit avant de baver sur leur tête. Et force est de constaté que pour le prix, c’est pas mal. À part un point crucial, le débit.

10To pour 50€/an c’est un offre intéressante, certainement la moins chère que j’ai vu. Restait alors à tester le client Linux et de voir si je pouvais sauvegarder une partie de mon serveur et mes fichiers locaux de mon poste de travail sans trop avoir mal.

Installer le client

L’installation est simple pour Debian, un peu moins simple sur les autres distributions.

Grosso-modo, soit vous installez le .deb depuis l’espace Linux, soit vous êtes sur une autre distribution et vous devez passer par le .tar.gz

Je vais me pencher sur Fedora et CentOS:

sudo dnf install mono-core mono-data-sqlite mono-data
cd /tmp
wget http://mir7.ovh.net/ovh-applications/hubic/hubiC-Linux/2.1.0/hubiC-Linux-2.1.0.53-linux.tar.gz
tar xf hubiC-Linux-2.1.0.53-linux.tar.gz
cd hubic
sudo make install

Voilà, c’est pas si compliqué mais ça méritait d’être montré.

Maintenant on va lancer le service, se loguer et voir ce que ça donne

Premier coup d’œil

Il suffit de démarrer le service:

hubic start

Puis de se loguer avec, optionnellement, le répertoire de stockage de base à monter localement.

mkdir ~/HubiC
hubic login mon_mail@domain.tld ~/HubiC
# ou si vous n'aver pas envie de ce répertoire
hubic login mon_mail@domain.tld

Vous pouvez omettre le répertoire si vous ne voulez utiliser que le système de sauvegarde que je vais vous expliquer après.

Si vous voulez utiliser hubic sur un serveur sur lequel vous vous êtes connectés en SSH, il faut exporter les variables DBUS. La technique la plus simple est de mettre cette ligne dans votre “~/.bashrc“:

export $(dbus-launch)

Vous pouvez aussi lancer cette commande manuellement. Maintenant ça va fonctionner.

Petit édit: vous pouvez enregistrer votre mot de passe dans un fichier et utiliser “–password_path=/chemin/vers/ce/fichier” à la commande de login pour automatiser le login

Permier test…

Hou bordel… c’est super lent. Un débit inadmissible ! Mon épouse a payé 50€ pour avoir le même débit, grosso-modo on table sur du 100ko/s en moyenne, c’est presque honteux !

Je parle d’une synchro faite sur mon serveur de prod, donc je n’ai pas de contrainte de débit. En fouillant un peu, j’ai appris que HubiC limite la bande passante upload à 10Mps/s soit 1200ko/s donc 1Mo/s environ… (si je ne me trompe pas hein, 10Mpbs/s = (10.000.000/8)/1024 ≈ 1220ko/s)

Sauf que là je suis 10 fois en dessous du débit possible !

Bref, passons sur ce sujet en priant pour que les 2 ans de messages du forum d’utilisateurs énervés fassent réagir l’équipe de OVH.

Au passage: http://travaux.ovh.com/?do=details&id=17305 et http://travaux.ovh.com/?do=details&id=17008 montrent que c’est le sacré merdier en ce moment.

Les sauvegardes

HubiC, outre le répertoire de partage qui ne me sert pas pour le moment, me permet de faire des sauvegardes. J’ai vu le client graphique tourner sur Windows et l’intégration est pas mal. En gros sur Windows vous pouvez faire un clique droit sur un dossier et paramétrer sa sauvegarde.

Sur Linux, c’est dans un terminal que ça se passe. Et en fait ça m’arrange, surtout sur mon serveur, car j’ai vu un paquet d’options qui m’ont vraiment rendu service.

Voilà comment créer une procédure de sauvegarde de manière “basique”:

hubic backup create --name="un_nom_unique" \
    --kept_versions=3 \
    --frequency="Daily" \
    /répertoire

Les options sont franchement explicites.

Ce qui m’arrange, c’est le fait de nommer mes sauvegardes. J’utilise par exemple un nom “metal3d.org_www” pour sauver mon répertoire “/var/www”, et je l’identifie bien.

Sans option “–frequency” la sauvegarde ne se lancera pas. Et c’est tout aussi intéressant car je peux la déclencher “à la Unix” via un crontab. Du coup, je peux par exemple lancer un dump de base de données avant de lancer ma sauvegarde.

Bref, pour ne pas avoir de synchro programmée:

hubic backup create --name="un_nom_unique" \
    --kept_versions=3 \
    /répertoire

Et à moi de faire un crontab pour réellement lancer une sauvegarde via la commande “update”:

hubic backup update un_nom_unique

Vous pouvez voir l’état de vos backup de cette manière:

hubic backup info
  Name                 Attached  Local path   Last backup      Size
  metal3d.org_etc      Yes       /etc/                        -  30,44 MB
  metal3d.org_opt      Yes       /opt/                        -  42,32 MB
  metal3d.org_www      Yes       /var/www/        -           0 B
  pferlet_Documents    No        -           06/04/2016 13:31  15,92 MB

Ce qu’il faut bien comprendre, c’est que “pferlet_Documents” n’est pas attaché à mon serveur, il provient de mon poste de travail. Du coup je ne connais pas son chemin “local”.

Reparlons du débit. La sauvegarde de mon “/etc” qui doit prendre 30Mo a pris (accrochez-vous) 2h !

Monitorer

Pour voir ce qu’il se passe, il y a au moins deux points d’accès: les logs et la commande “status”.

La commande de status est simplement “hubic status”.

Personnellement j’aime “watcher” l’état de ma synchro de cette manière:

$ watch -n0 hubic status

State: Busy
Up: 0 B/s (0 B/s)       Down: 0 B/s (0 B/s)

Account: XXX@XXX.XX
Synchronized directory: /rep/hubic/
Usage: 88,62 MB/25 GB

Queue:
        Uploads: 1998 (5,23 MB) + 1 running
        Downloads: 0 (0 B) + 0 running
        Misc: 0 + 1 running

Running operations:
        Upload for /opt/XXX/YYYY
        RemoteMkdir for /opt/XXX/YYY

Last events:
        [06/04/2016 18:51:21|Warning] Skip synchronisation for XXXXXXX

Et l’autre méthode:

tail -f ~/.config/hubiC/application.log

En clair, ils ont pensé à respecter les chemins standard freedesktop, ça à le mérite d’être salué.

Revenons au débit…

Bon sang, je me tatais à taper mon numéro de carte pour avoir les 10To mais honnêtement j’ai du mal. Ce débit en m’enchante pas car le jour où je veux récupérer une sauvegarde pour vite remettre un serveur en place, je sens que je vais pleurer pendant 3 jours avant d’avoir le backup en main.

J’ai suivi quelques idées trouvées par-ci par-là, notamment un “tweak” à faire sur votre installation.

Éditez le fichier “~/.mono/registry/CurrentUser/software/ovh/hubic-sync/values.xml” et ajoutez une valeur juste avant la balise fermante (</values>):

<value name="ParallelUploads" type="string">1</value>

Cette option est censée permettre des uploads en parallèle… mouais… ça n’a rien changé pour moi, ou alors c’est tellement ridicule comme optimisation que je ne la perçois pas.

Bilan

Il ne manque que du débit. Sérieusement ! Je me fiche de l’interface graphique manquante ou de leur interface Web, elles ne me servent pas. L’outil en ligne de commande est largement suffisante et a un grand nombre d’options.

Le mode “sauvegarde” est vraiment bien pensé. Mais ce foutu débit m’a directement fait ranger HubiC dans un tirroir “à voir plus tard”. Sachant que depuis 3 ans tout le monde se plaint du débit minable que propose OVH sur ce service, j’ai peur que ça ne bouge pas pendant plusieurs mois, voir années.

Donc, pour dresser le bilan:

Points faibles:

lent, mais leeeeeennnnt
des bugs… parfois le “update” refuse le “nom de sauvegarde” et me demande de donner le chemin
pas de RPM (sérieux, je vais en proposer un en copr parce que pffff….)
utilisation en ligne de commande seulement pour le moment
l’interface Web est infâme, lente, plante, refuse parfois de s’afficher

Points forts:

le rapport espace/prix, indéniablement
utilisation en ligne de commande, je peux l’utiliser sur mon serveur
la gestion de backup versionnées en dehors de l’espace de base
récupérer une sauvegarde depuis le site, ou juste un répertoire, ou juste un fichier: bravo
les options pour voir l’état du service local (status, backup info…)

Ressources

Ces liens m’ont aidé:

Monter un partage webdav sharepoint sur Linux

Mon, 11 Apr 2016 20:00:58 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Quand on m’a posé cette question, au boulot, chez un client “full Microsoft”, j’ai bêtement cru que tout allait se passer comme sur des roulettes. Et en fait non… Alors, comment créer un point de montage Microsoft sharepoint (qui utilise webdav) sur Linux avec le moins de douleur ? La solution est expliquée ici.

On prépare la machine

D’abord, il vous faut “davfs2”. Je ne sais pas comment ça se passe sur Ubuntu mais sur Fedora je passe par la ligne:

sudo dnf install davfs2 Quand ce paquet est installé, je passe mon utilisateur dans le groupe “davfs2”

sudo usermod -a -G davfs2 $USER

Maintenant, deux possibilités:

soit vous reconnectez votre utilisateur à sa session Gnome (quitter, revenir)
soit vous ouvrez un nouveau shell avec la commande bash su - VOTRE_USER

Le fait est qu’à partir de là, il faudra que le shell soit au courant que votre utilisateur est dans le groupe “davfs2”, et malheureusement sous UNIX/Linux il faut “reloguer” le compte. C’est-à-dire “ouvrir une nouvelle session”.

Premier test

Normalement, vous devez connaitre l’adresse Web du sharepoint. On va prendre un exemple: http://monsharepoint/Sites/

Si tout va bien, vous avez accès à un dossier, on doit donc être capable de visiter http://monsharepoint/Sites/MonDossier

Bref, le but maintenant c’est de monter cet espace dans un répertoire local.

On va créer un répertoire “sharepoint” et monter le dossier dedans.

mkdir -p ~/sharepoint
sudo mount -t davfs  http://monsharepoint/Sites/MonDossier ~/sharepoint -o user,rw,nosuid,noauto,uid=$(id -u),gid=$(id -g)

Normalement, la commande vous demande:

votre mot de passe pour sudo
votre compte de domaine (compte active directory)
votre mot de passe de domaine

Et, malgré un warning, vous devriez avoir des fichiers dans le répertoire “~/sharepoint”.

Si tout est ok, on va passer au mode “automatique”. Démontez le dossier avant de passer à la suite:

sudo umount ~/sharepoint

Automatisation

C’est bien beau de taper une ligne de commande longue comme une compilation Java, mais on a pas envie de se taper constamment un login et un mot de passe tous les jours, juste pour monter le dossier. Bref, l’idée est de créer un point de montage propre qui, en plus, permettra de ne pas se battre avec les uid/gid.

Et en plus, on pourra se passer de “sudo”, elle est pas belle la vie ?

On va donc éditer le fichier “/etc/fstab”. Partons du principe que je suis l’utilisateur “FOO”, vous aurez donc à remplacer “FOO” par votre nom d’utilisateur:

http://monsharepoint/Sites/MonDossier /home/FOO/sharepoint davfs noauto,user 0 0

Petit rappel: les zéros veulent dire, dans l’ordre:

pas de montage au démarrage de la machine
si le montage plante, on s’en fout

Bref, tout ça ne suffit pas.

Dans un terminal, créez un répertoire “~/.davfs2” dans lequel on place un fichier “secrets” qui ne doit être lisible que par l’utilisateur:

mkdir ~/.davfs2
touch ~/.davfs2/secrets
chmod 600 ~/.davfs2/secrets

Maintenant éditez ce fichier et entrez les informations suivantes:

/home/FOO/sharepoint LOGIN_AD PASS_AD

Dans ces lignes, remplacez bien:

FOO par votre nom d’utilisateur Linux
LOGIN_AD par votre login sur le domaine
PASS_AD par votre mot de passe sur le domaine

On y est !

Tapez maintenant:

mount ~/sharepoint

Hop, plus de sudo, plus de mot login/pass à taper. C’est sympa hein !

Automatiser le tout

Reste que vous avez certainement envie de monter ce dossier automatiquement.

Si vous mettez un “1” à la place du premier “0” dans le fichier “/etc/fstab” alors il peut que ça fonctionne. Mais personnellement j’ai plusieurs utilisateurs sur mon pc et je préfère que le montage se fasse au login de mon utilisateur et seulement si il n’est pas déjà monté.

Il y a deux méthodes. La première utilise la commande “mountpoint” que je trouve fabuleusement utile mais qui peut ne pas exister sur votre système; la seconde méthode utilise “mount” combiné à “grep”.

Pensez à bien adapter les commandes et scripts à votre installation !

Ici “sharepoint” est le nom du répertoire, mais cela peut tout aussi bien être un mot contenu dans l’url webdav qui identifie, de manière unique, ce point de montage. Bref, je vous fais confiance.

Méthode avec “mountpoint”

Dans “~/.bashrc“:

mountpoint -q ~/sharepoint || mount ~/sharepoint

Sinon pour les utilisateurs de “fish”, dans “~/.config/fish/config.fish“:

mountpoint -q ~/sharepoint; or mount ~/sharepoint

Méthode avec “Mount” et “Grep”

Si vous n’avez pas la commande “mountpoint” vous pouvez quand même vous débrouiller en combinant “mount” et “grep”.

Dans “~/.bashrc“:

mount | grep sharepoint 2>&1 >/dev/null || mount ~/sharepoint &

Sinon pour les utilisateurs de “fish”, dans “~/.config/fish/config.fish“:

mount | grep sharepoint 2>&1 >/dev/null; or mount ~/sharepoint &

Et donc…

Bha, ça fonctionne. C’est ce qu’on demandait.

Bilan

Peu de documentation, bien que le manpage de “mount.davfs” est particulièrement fourni, il faut se creuser les méninges avant de comprendre ce qui foire.

Par exemple, ici, on a eut ce genre de problème:

certains utilisateur ont besoin de renseigner leur “utilisateur” avec le domaine (domain\username)
si on montre un répertoire “trop haut”, alors l’accès est refusé ouvrir un fichier xlsx ou docx demande “deux ouvertures”, une qui plante avec une erreur “entrée/sortie”, et une qui enfin fonctionne

Bref, je ne sais pas si c’est WebDav ou Active Directory mais franchement c’est pas la technologie du siècle, et Linux souffre fortement d’une absence de support en ce qui concerne ce protocole.

Soit dit en passant, il parait que Nautlilus, le navigateur de fichier Gnome, arriverait à ouvrir un emplacement Webdav avec un “scheme” de la forme “dav://“. L’explication est sur ce site. Mais ça refuse de fonctionner chez moi, certainement une histoire de certificat ou je ne sais quoi…

Le souci n’est pas webdav en soi. J’ai testé à la maison avec un montage webdav simple (apache) et je n’ai pas eut de souci. Inutile d’utiliser un point de montage, nautilus fonctionne bien. C’est bel et bien une des deux raisons ci-dessous qui est la cause de tous nos soucis:

l’installation est pas bonne
Microsoft ne sait pas utiliser correctement le protocole

Misez sur la raison qui vous semble la plus juste :)

Ressources

Utiliser les closures en Javascript

Mon, 28 Mar 2016 18:40:32 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

J’en ai parlé il y peu de temps en Go mais je sais que beaucoup d’entre vous utilise Javascript. Et justement, l’utilisation de closure en JS est très intéressante. On va voir dans ce billet que bien souvent on devrait réfléchir avec ce pattern que ce soit avec du JS pur ou avec Angular.

Petit rappel: une closure est une fonction. Cette fonction sait garder en mémoire l’état de variables. Ainsi, on peut créer des générateurs et/ou retourner des fonctions. Car en JS, comme en Go ou en Python (pour ne citer qu’eux), une fonction est un type et donc peut être assignée à une variable.

Douleur aux yeux

Combien de fois j’ai vu ça:


function foo(){
    function bar(){
        console.log("coucou");
    }

    document.querySelector('a').addEventListener('click', onClick);
    
    
    var self = this;
    function onClick(){
        self.bar()
    });
}

Vous le repérez ce foutu souci qu’on a en JS (ES5) ? Et oui, le fameux “this” perdu dans des fonctions appelantes qui nous force à garder une référence dans une variable. Ici, c’est “self” qui fait office de gardien.

Tous les développeurs un peu expérimentés et ayant bossé un temps soit peu dans les profondeurs de JS ont eut ce souci au moins une fois. C’est agaçant, on perd en lisibilité et franchement c’est moche.

Oui on peut utiliser “bind()” dans pas mal de cas, l’idée n’est pas d’outrepasser cette méthode, mais souvent on ne peut pas l’utiliser.

Une autre façon de faire est d’utiliser les closures.

Les closures, pensez-y !

Il suffit de générer la fonction “onClick”. C’est tout bête mais c’est franchement plus logique. Surtout si vous avez dans l’idée que “self” puisse représenter d’autres classes.

Voici donc un premier exemple plus “propre”:


function foo(){
    function bar(){
        console.log("coucou");
    }

    document.querySelector('a').addEventListener('click', getOnClick(this));
    
    // génère une fonction qui utilise "obj"
    function getOnClick(obj) {
        return function (){
            obj.bar()
        });
    }
}

Ça parait con comme ça, mais ça règle le souci. D’une part nous n’avons plus besoin de “self”, mais en plus la fonction retournée peut utiliser n’importe quel objet qui contient la méthode “bar”.

Et c’est pas fini !

Et en plus…

Je me suis retrouvé à devoir utiliser du “jsonp”. Il n’y a pas de faute de frappe, le “p” à la fin de “jsonp” est bien là pour une raison. JsonP est une manière détournée de pouvoir utiliser un appel “asynchrone” d’une ressource externe sans se prendre une exception si la ressource est en dehors du domaine appelant, et que ce dernier ne gère pas les CORS (Cross Origin Resource Sharing).

Prenons un exemple.

J’ai plusieurs articles qui affichent des “tags”.

Je veux appeler une API qui récupère des images à insérer dans chaque article à partir de leurs tags. Sauf que voilà, cette API ne me permet pas d’utiliser XHTTPRequest (faussement appelée AJAX), et je dois donc fournir le nom d’une fonction en “callback”. Callback qui prend en argument les données que l’appel doit me retourner.

En gros, je crée une balise “script” qui pointe sur “api.to.call/?&callback=TOTO” => le contenu de cette appel va me retourner quelque chose du genre:

TOTO({
    // ... du contenu
})

Et donc, comme c’est une balise “script” que j’ai utilisé, la fonction “TOTO” sera appelée.

Je simplifie mais c’est grosso-modo ceci que je vais faire et qui ne marchera pas.

Il va falloir:

stocker une fonction par article sinon on ne saura pas où injecter l’image - on va les appeler “addImage0”, puis “addImage1” etc. On les gardera dans “window”.
appeler l’api en question en fournissant le nom de la fonction à appeler quand on a un résultat

Qu’on soit bien clair sur la question des fonctions “addImageN”, je dois les enregistrer dans “window” parce que la balise d’appel en jsonp va appeler la fonction globale “addImageN”; or je génère tout ça depuis une fonction (addEventListener), donc je force l’insertion de ces fonctions de manière globale. C’est tordu mais c’est quasiement inévitable.

Et je suis obligé de créer une fonction par article parce que l’API ne me permet pas de définir un argument personnel qui me permet de savoir dans quel article je dois injecter l’image.

Bref, c’est le boxon. Mais c’est gérable. Sauf que ce code ne va pas marcher:


/*CODE FOIREUX, NE MARCHERA PAS !!!*/

document.addEventListener('load', function(){

    var head = document.querySelector('head');
    var articles = document.querySelectorAll('.article')
    var i, j, script, article, tags, fncName;
    
    for (i=0; i<articles.length; i++) {
        article=articles[i];
        tags = article.querySelector('.tag');
        
        // le nom de la fonction à appeler
        fncName = 'addImage' + i;
        
        // on crée la fonction globale qui ajoute l'image dans "article"
        window[fncName] = function(data){
            var img = document.createElemen('img');
            img.src = data;
            article.appendChild(img);
        };
        
        // pour chaque tag
        for (k=0; k<tags.length; k++) {
            script = document.createElement('script');
            script.setAttribute('src', 'http://api.to.call/?&callback'+fncName+'&q='+tags[k]);
            head.appendChild(script); // on inject le script
        }
    }
});

Et bien rien ne marche comme on le veut. Dans mon cas (si j’ai pas merdé mon exemple), toutes les images apparaissent dans le dernier article. Et c’est très logique.

La variable “article” change à chaque itération. Quand la fonction “fncName” sera appelée, par exemple “addImage1”, et bien la variable “article” est positionné sur l’article “4” par exemple. Donc, c’est pas bon.

La solution la plus simple, qui n’ajoute pas de “classe css”, qui ne cherche pas à manipuler des variables rémanentes dans la fonction, etc, est de générer la fonction qui ajoute l’image.

Voici comment je m’y prends:


/*CODE QUI FONCTIONNE !!!*/

document.addEventListener('load', function(){

    var head = document.querySelector('head');
    var articles = document.querySelectorAll('.article')
    var i, j, script, article, tags, fncName;

    // cette fonction génère une fonction.
    function generateAddImageFnc(elem) {
        // on retourne la fonction qui 
        // manipule un element passé en argument.
        return function(data){
            var img = document.createElemen('img');
            img.src = data;
            elem.appendChild(img);
        }
    }
    
    for (i=0; i<articles.length; i++) {
        article=articles[i];
        tags = article.querySelector('.tag');
        
        // le nom de la fonction à appeler
        fncName = 'addImage' + i;
        
        // on appelle le générateur
        window[fncName] = generateAddImageFnc(article);
        
        // pour chaque tag
        for (k=0; k<tags.length; k++) {
            script = document.createElement('script');
            script.setAttribute('src', 'http://api.to.call/?&callback'+fncName+'&q='+tags[k]);
            head.appendChild(script); // on inject le script
        }
    }
});

Et cette fois ça fonctionne. La raison est simple: à chaque appel du générateur nous passons l’élement (article) qui est gardé en mémoire dans la closure (generateAddImageFnc). Chaque appel à cette fonction alloue de la mémoire qui reside pour la fonction retournée.

Nous n’avons pas utilisé de “bind”, nous avons simplement éliminé le souci en utilisant un générateur ou plutôt une closure. Un générateur ayant plutôt pour vocation de rester actif (par exemple un compteur ou un itérateur infini comme je l’ai présenté dans mon article pour Go)

Ainsi, quand nous appellerons “addImage2” nous serons sûrs que l’article est celui qui a été référencé dans la closure.

Ça parait obscure pour certains mais c’est pourtant l’un des avantages des closures, et surtout c’est certainement la meilleure raison de les utiliser.

L'intérêt des closures en Go

Sun, 20 Mar 2016 10:58:07 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vous avez entendu parler des “closures” et “generators” qui sont implémentés par plusieurs langages (comme le Python). Mais je sais aussi que beaucoup n’ont pas conscience de l’intérêt particulier de ce pattern. Et comme je me suis retrouvé dans une situation où un generator m’a fait gagné beaucoup de temps, je vais vous montrer à quoi ça sert avec deux exemples: un qui explique le fonctionnement, et un autre qui peut vous rendre service, à savoir “itérer indéfiniement”.

Une closure est une fonction. Si si, je vous assure ce n’est ni plus ni moins que cela. A la différence près que la closure peut garder son état en mémoire. Mais vous allez me dire que quand on a appelé une fonction et qu’on a traité la valeur la de retour alors on perd son état. Oui, effectivement. Sauf dans le cas où ce que vous retournez est une fonction.

Le premier exemple est celui que je donne souvent pour montrer ce qu’est une closure de type “generator”. Elle va initialiser un compteur et retourner une fonction qui permet d’incrémenter ce dernier, et le retourner.

// Counter retourne une fonction qui retourne un entier
func Counter() func() int {
    count := 0
    return func() int{
        count++
        return count
    }
}

Voilà, on va s’en servir de cette manière:

c := Counter()
fmt.Println(c())
fmt.Println(c())
fmt.Println(c())

A chaque appel de "c()", la variable “counter” est incrémentée et on l’affiche. L’intérêt est aussi de pouvoir avoir plusieurs compteurs:

c1 := Counter()
c2 := Counter()
fmt.Println(c1())
fmt.Println(c2())
fmt.Println(c1())
fmt.Println(c2())
fmt.Println(c2())

Cela va afficher:

Bien. C’est un générateur simple, pas super utile en soi mais qui a le mérite de vous montrer le principe. Passons à l’exemple qui, lui, va vous permettre de réalier un générateur plus intéressant.

Imaginons que nous ayons un “map” dont les clefs sont des chaines. Et imaginons que nous voulions itérer sur les clefs indéfiniement. Quand nous atteignons la fin de la liste, il faut revenir au début. J’explique:

items := map[string]int{
    "A" : 0
    "B" : 0
    "C" : 0
}

Je veux donc être capable d’itérer en ayant, coup par coup:

A
B
C
A
B
C
...

Il existe plusieurs façons de faire, mais celle que j’apprécie est le generator. Je vous montre étape par étape.

L’algo de rotation infini est à peu près:

for {
    for key, _ := range items {
        // faire un truc avec key
    }
}

Vous avez compris, je fais une boucle “for” sans sortie et une autre qui itère sur les “items”. Ainsi, quand la boucle interne qui itère sur les clefs a terminé, et bien on recommence.

Mais il faut “faire un truc” avec la clef. Si j’assigne indéfiniement, je vais faire boucler ma fonction comme un bourrin et à l’arrivée on sera pas plus avancée. L’idée pas trop débile est donc d’écrire la valeur dans un canal qui va bloquer tant qu’on l’a pas lu.

// attendez, ça marchera pas encore

func Loop(c chan string){
    for {
        for k, _ := range items {
            c <- k
        }
    }
}

// et plus loin:

c := make(chan string)
go Loop(c)
fmt.Println(<-c)
fmt.Println(<-c)
fmt.Println(<-c)

C’est déjà pas mal. Mais c’est pas “élégant”.

Pourquoi je trouve pas ça élégant ? nous devons nous même créer le canal, puis lancer la goroutine (tâche en concurrence) ce qui me chagrine un peu.

On va donc faire autremement. Faire en sorte d’avoir un générateur qui va lancer la goroutine, fournir les valeurs au canal et permettre d’avoir la valeur suivante à chaque appel.


// generateur
func Loop() func() string {
    // le canal qui prend les valeurs
    c:=make(chan string)
    
    // on lance ça en tache de fond
    go func(){
        for {
            for k, _ := range items {
                c <- k
            }
        }
    }()
    
    // on retourne une fonction qui retourne
    // la valeur lue depuis le canal
    return func() string {
        return <-c
    }
}

Et on va l’utiliser de cette manière:

g := Loop()
fmt.Println(g())
fmt.Println(g())
fmt.Println(g())
fmt.Println(g())
fmt.Println(g())
//...

Vous pouvez tester, ça fonctionne très bien. Chaque appel à “g()” débloque le canal, la goroutine interne insert alors la prochaine clef du map dans le canal. Si on atteind la fin de la liste, on recommence.

L’exemple se trouve ici: http://play.golang.org/p/a_xC4l4NoL

Une question vous tourmente, je le sais. Pouquoi je retourne pas le canal ? Effectivement:

// generateur
func Loop() <-chan string {
    // le canal qui prend les valeurs
    c:=make(chan string)
    
    // on lance ça en tache de fond
    go func(){
        for {
            for k, v := range items {
                c <- k
            }
        }
    }()
    
    // on retourne le canal
    return c
}

// plus loin

c := Loop()
fmt.Println(<-c)
fmt.Println(<-c)
fmt.Println(<-c)

Ça marche aussi très bien ! MAIS !

Si jamais un jour je me rend compte que j’ai besoin de changer la valeur lue, ou qu’un opération doit être effectué avant que mon programme lise effectivement la prochaine entrée, je suis coincé. Alors qu’avec un generator je sais que je peux manipuler la fonction retournée. Par exemple, si je veux écrire un log lors de la lecture:

func Loop() func() string {
    // le canal qui prend les valeurs
    c:=make(chan string)
    
    // on lance ça en tache de fond
    go func(){
        for {
            for k, v := range items {
                c <- k
            }
        }
    }()
    
    // on retourne une fonction qui retourne
    // la valeur lue depuis le canal
    return func() string {
        // je décide de faire un truc avant
        log.Println("Je fais un truc avant")
        return <-c
    }
}

Ce n’est pas possible avec l’exemple qui retourne le canal. Oui, on pourrait le faire dans la boucle qui écrit la valeur dans le canal, mais dans ce cas le “truc fait avant” est effectué quand la valeur est insérée dans le canal, et non pas quand on la lit. La différence peut être très importante.

Bref, je vous invite à utiliser les générateurs quand vous le pouvez. C’est un pattern puissant qui trouve sa place en Go, en Python, mais aussi en Javascript…

Introduction à Angular2

Sun, 06 Mar 2016 15:13:12 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Angular2 est en phase “beta” depuis maintenant quelques semaines et je pense qu’il est temps de parler de mon expérimentation sur le sujet. Je ne vais pas vous proposer une documentation mais plutôt un genre de “howto” de mon point de vue.

Je ne vais pas vous faire un manuel ou un “cookbook”, mais juste un retour sur mon expérience qui vous permettra de démarrer sans trop de douleurs avec Angular 2.

Attention, je vais beaucoup vulgariser, résumer et il se peut que je dérive de la réalité. Donc, amis experts de Angular 2, ne tenez pas compte de ces raccourcis, et amis débutants, ne prenez pas tout comme parole d’évangile.

Sachez avant tout que j’utilise Docker pour éviter de saloper mon système avec un paquet de dépendances node, et l’image est récupérable via:

docker pull metal3d/ng

Tout est expliqué sur la page de mon image docker.

Angular2

J’ai aujourd’hui pas mal d’expérience sur Angular 1. J’apprécie énormément les principes qu’a apporté ce framework. D’abord parce que ce n’est pas une “librairie” en soit, qu’il impose une certaine manière de faire et que l’injection de dépendances permet de ne pas faire du code noué.

Passer à Angular2 a été douloureux pendant les premières heures. Car au lieu de faire une évolution, les développeurs de Angular ont littéralement changé le framework. Ça peut surprendre au premier regard, et le fait de passer à un autre langage (typescript) a une tendance à faire tomber dans les pâmes (et non pas dans les pommes) certaines personnes.

Typescript n’est pas le seul langage que l’on peut utiliser. En fait, on peut toujours utiliser javascript. Mais je ne vous le conseille pas. Il existe aussi Dart, mais je n’ai pas encore assez de recul sur le langage pour en parler. On va donc parler essentiellement de Typescript.

Les décorateurs

C’est un concept très connu en Java, en Python, en C#, etc. Mais absolument inconnu en Javascript (bien qu’il existe des manières de faire). Un décorateur est un pattern et une notation qui permet de modifier un comportement ou des attributs d’un élément du code (classe, méthode, propriété) et ce via une fonction décoratrice.

Comme dans la plupart des langages, Typescript utilise la notation “@Foo” où “Foo” est le décorateur.

Exemple:

@Foo
class Bar {

}

Ici, “Bar” est décoré par “Foo”. En fait le décorateur précède simplement l’élément à décorer.

Je ne vais pas vous expliquer comment créer un décorateur, je tenais juste à préciser qu’ils existent et qu’ils sont fortement utilisés sur Angular2. Il ne faut retenir qu’une chose: un décorateur modifie un type pour lui attribuer des comportements. Et ce sera le cas pour transformer une classe en Component, en Injectable, etc.

Une dernière chose, il est possible d’utiliser plusieurs décorateurs en multipliant les annotations:

@Foo
@Bar
class Baz {
    // classs décorée par Foo et Bar

    @admin
    delete(){
        // ... méthode décorée par @admin
        // par exemple pour interdire son utilisation
        // à moins d'être loggué en tant qu'administrateur
    }

}

Component

Si vous comprenez ce qu’est un component, vous avez déjà compris 50% du fonctionnement de Angular 2. Je ne plaisante pas, c’est clairement la notion à comprendre.

Pratiquement tout ce que vous allez développer en Angular2 sera des “Components”. Vous pouvez traduire ça en “Composant”.

Angular2 bénéficie de la possibilité en Typescript d’utiliser des décorateurs (annotations), et c’est de cette manière qu’une classe devient un “Component”. Pour résumer, vous aurez ce genre de code:

import {Component} from 'angular2/core';

@Component({
    // des trucs ici
})
export class MaClasse {
    // et ici le contenu de la classe
}

Car effectivement, en Typescript, on utilise des classes, des vraies.

Mais que propose un Component ?

Et bien sachez qu’ils existaient en Angular 1, la preuve ici - un component est un type de directive très simple qui se configure d’une traite. En Angular2 c’est devenu le composant de base.

En gros, pour résumer (c’est le but de l’article hein), un Component défini une directive, son controlleur, les styles, la vue… et voilà.

Pour vous donner un exemple:

@Component({
    selector: 'mycomponent',
    template: '<div>...</div>',
    // ou
    templateurl: 'app/components/mycomponent/view.html'
})
export class AnExample{}

Les routes

Ce qui m’a dérouté (sans jeu de mot) c’est le fonctionnement des routes. Je ne dis pas que c’est compliqué, mais je me suis fait avoir par le client angular…

En effet, “angular-cli” permet de créer des routes en tapant:

ng generate route example

Or, une route, du point de vue du client angular, est une “jeu d’urls”, c’est à dire qu’il propose en gros le principe d’état de “ui.router” dans Angular 1.

Et honnêtement, nettoyer le code généré par angular-cli est tout bonnement infâme. Je peux paraitre peut-être méchant là, mais je vous assure que la première fois c’est loin d’être marrant.

Ce que j’ai compris c’est qu’il ne faut pas générer des routes pour tout et n’importe quoi.

Pour résumer, générer une route équivaut à générer un chemin qui aura des descendants, par exemple “/heroes’ pour lister les héros, puis “/heroes/:id” pour voir le détail d’un héro en particulier

Le client génère un Component “racine” qui va permettre de router plusieurs uri vers des components. Donc effectivement, pour vous “montrer un exemple”, le client Angular va générer pas mal de choses:

un Component racine (XxxRoot)
un Component liste (XxxList)
une classe de service pour lister des “items”
deux chemins, un pour la racine, et un pour la liste (formulaire qui modifie les items du service)

Donc, je vous préviens, c’est une liste de fichiers générés qu’il faut aller manipuler, nettoyer, etc…

Ce qui m’a posé problème, c’est de savoir comment faire pour que que l’url “/heroes” pointe sur le composant HeroesRoot. Et bien c’est vraiment tout con.

Dans le code du projet (project.ts) il faut:

importer HeroesRoot
ajouter la route dans le décorateur RouteConfig
et bha c’est tout hein.

Petite subtilité, puisque que HeroesRoot est un “router” qui permet de faire descendre des sous-routes, il faut suffixer la route par “…”. Pour une route vers un component simple, ce n’est pas le cas. Voyez l’exemple:

import {RouteConfig, ROUTER_DIRECTIVES} from 'angular2/router';
import {HeroesRoot} from './heroes/heroes-root.component';
import {Hello} from './components/hello/hello';
//...

@Component({//...
})
@RouteConfig([
    // Cas d'une route "heroes" générée avec
    // $ ng generate route heroes
    // Le chemin fini par "..." ce qui signifie qu'il y aura des "sous-éléments"
    {path: '/heroes/...', component: HeroesRoot, name: 'Heroes', useAsDefault: true},

    // Cas d'une url vers un component généré avec
    // $ ng generate component hello
    {path: '/hello', component: Hello, name: 'Hello'}
])
export class Project {//...
}

Form

Les formulaires avec Angular 2 et surtout le “binding” de model est quant à lui, pour ma part, un bonheur sans nom. Exit l’utilisation de “$scope”, tout se passe coté classe et html sans aucune peine.

Prenons un exemple:


@Component({
    template: `
    <form (submit)="onSubmit()">
        <input type="text" [(ngModel)]="user.login" />
        <input type="password" [(ngModel)]="user.password" />
        <input type="submit" value="OK" />
    </form>
    <pre>
    {{ user | json }}
    </pre>
    `
})
export class User{
    user = {
        login: "foo",
        password: "bar"
    }

    onSubmit(){
        console.log("USER:", this.user);
    }
}

On décrypte.

D’abord, le template. Vous avez remarqué le “(submit)” ? Angular propose une notation de template déroutante de prime abord, mais aggréable quand on la comprend:

“[X]="Y"” permet de changer l’attribut “X” de l’élément avec la valeur “Y” du Component.
“(X)="Y"” permet de binder Y sur l’évènement “X”

Donc, ici, quand le formulaire est soumis, l’évènement “submit” appelera la méthode “onSubmit” de mon Component.

Mélangeons les deux bindings:

“[(X)]=Y” va donc naturellement faire un “two way data binding”

Et on le voit bien avec “ngModel” (directive Angular 2) qui va modifier la propriété “user” de mon component, et inversement si le component modifie la propriété “user” alors la vue sera notifiée.

Car, oui, Angular 2 soulage fortement la notion de “scope” en le supprimant purement et simplement. La vue est directement connecté à la classe lors de la décoration “Component”.

Angular 2 me paraissait super abstrait à ce sujet (il y a encore peu d’article sur le net qui parle de Angular 2), mais à force de tester j’ai vite compris qu’il ne faut pas chercher midi à quatorze heure. Faire au plus simple, et aggrémenter après.

Reste le dernier point que je veux traiter dans cet article, le requêtage HTTP.

Http

Honnêtement, là, j’ai passé des plombes à lire et relire des didacticiels tous plus ou moins compliqué pour finalement me rendre compte que tout est super simple. Ce que je n’avais tout simplement pas assimilé à la base, c’est la notation de lambda…

Pourtant, j’en ai bouffé de la lambda en Python. Mais connement je n’ai pas pris en compte un concept important: Typescript est compatible ES6. Et bha ouais… Quand on ne prend pas ça en compte, tous les exemples que vous lirez vous rendrons la vie dure. Et je n’avais pas compris que la notation que j’avais sous les yeux était une notation de lambda.

Mais c’est quoi une lambda ?

C’est tout simplement une “fonction sans corps”. Oui je résume. En gros, avant, au temps de Javascript ES5, vous aviez un lot de “callback” du genre:

obj.onSubmit(function(data){
    obj.result = data.name
})

En Typescript (et ES6), vous pouvez faire:

obj.onSubmit( data => this.result = data);

Ce qui revient exactement au même !

Là où ça devient intéressant, c’est que vous pouvez désormais avoir une notation plus claire pour réagir à des évènements, et c’est le cas pour la classe Http proposé par Angular.

Voici un exemple de Component qui embarque la vue et l’appel à une API - bien que je vous conseille de séparer l’appel dans un service:

import {Component} from 'angular2/core",
import {Http, Response} from 'angular2/http';

@Component({
    template: `
        <form (submit)="onSubmit">
            <input type="text" [(ngModel)]="model.data" />
            <input type="submit" value="Send" />
        </form>
    `
})
export class Example{
    // le model dans le formulaire
    model = {data:""}

    // resultat
    res = ""

    // constructor, ici on crée 
    // une propriété "this.http" de type Http (injectée)
    constructor(private http: Http){}

    // lors d'un submit de formulaire
    onSubmit(){
        // on utilise this.http, on appelle l'url "/api/url"
        this.http.post("/api/url", JSON.stringify(model))
            .subscribe(res => this.res = res.json())
    }
}

La méthode “subscribe” attend une fonction (en premièr argument) qui prend en argument les données retournées par l’appel. Au lieu de faire une fonction, j’utilise une “lambda” qui assigne à “this.res” le résultat décodé. L’équivalent serait:

export class Example{
    // le model dans le formulaire
    model = {data:""}

    // resultat
    res = ""

    // constructor, ici on crée 
    // une propriété "this.http" de type Http (injectée)
    constructor(private http: Http){}

    // lors d'un submit de formulaire
    onSubmit(){
        // on utilise this.http, on appelle l'url "/api/url"
        this.http.post("/api/url", JSON.stringify(model))
            .subscribe(function(res){
                this.res = res.json();
            })
    }
}

Vous n’ête pas forcé d’utiliser une lambda, il se peut que justement vous ayez besoin d’une méthode pour faire effectuer plusieurs opérations. Mais dans le principe, il est souvent très pratique d’utiliser une notation lambda.

Si vous ne voulez pas vous occuper de l’argument, ou simplement que la fonction attendue n’en utilise pas, vous devez utiliser “()” en guise d’argument:

obj.onFoo(() => console.log("bar"));

Du moment que vous comprennez qu’une lambda est une forme simplifiée de noter une fonction “inline”, alors tout s’éclaire. Ainsi, une manière de faire un formulaire d’authentification pourrait utiliser ce genre de code:


export class Auth{
    constructor(private http: Http){}
    auth = {
        login: "",
        pass : ""
    }

    onSubmit(){
        // subscribe prend en fait 3 arguments:
        // - onsucess
        // - onerror
        // - ondone
        this.http.Post("/login", this.auth)
            .subscibe(
                res => this.onLogged(res.json()),
                err => this.handleError(err),
                () => console.log("loggin done")
            )
    }

    onLogin(res){
        // res est décodé via la lambda, j'ai bien un objet
        window.localStorage.setItem('token', res.token);
        //... etc ...
    }

    handleError(err){
        console.error(err);
    }
}

Screencast

J’ai fait rapidement un petit screencast pour vous montrer comment on peut rapidement faire fonctionner Angular 2. J’ai réduit le temps d’init du projet dans la vidéo dans les premières secondes, en réalité le temps que npm récupère les paquets est assez long (près de 2 minutes…).

Et vous verrez aussi que je me plante bien souvent sur les chemins d’import ;)

Désolé, votre navigateur ne gère pas les vidéo au formal WebM...

Petit bilan

En toute honnêteté, j’ai perdu beaucoup de temps à lire des didactitiels eronnés ou trop vieux (datant de l’époque de Angular alpha). J’avais pris Angular 2 comme quelque chose de complexe, trop strict et franchement pas adapté. Mais en me penchant un peu, en arrêtant de copier-coller du code d’articles qui m’apportaient plus de questions que de réponses, j’ai compris rapidement que tout était bien plus simple que ça n’y parait.

Evitez de vous perdre dans des notions abstraites telles que les “observers” et allez-y “naturellement” pour commencer. Créez vous un composant simple, un truc qui affiche des valeurs contenues dans la classe. Ensuite, créez un formulaire et essayez de binder les valeurs, de réagir au “submit”. Rapidement les concepts s’imbriquent et la lumière apparait.

Angular 2 propose quelque chose de bien plus orienté “développement” que ne le faisait sa version 1. Le fait de passer à Typescript rend le projet bien plus structuré et largement moins compliqué à partager dans une équipe.

Développer avec Angular 2, Vim et Docker

Tue, 01 Mar 2016 12:18:33 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Angular 2 commence à faire des émules. C’est un fait. Mais passer de la version 1 à la version 2 est un peu déroutant. Bref, j’ai aujourd’hui quelques outils qui me permettent de bosser efficacement avec Angular 2 sur Vim avec en plus une petite image Docker qui peut vous rendre service.

Passer de Angular 1 à 2, c’est comme passer de la voiture à la moto. On a bien un moteur, on roule sur des routes, on se déplace… Mais la conduite est considérablement différente.

Clairement, Angular 2 n’a quasiment rien à voir à avec la version 1. D’abord dans l’approche, puisqu’on a plus de contrôlleur, plus de “$scope”, etc. Mais aussi parce que le langage utilisé n’est plus Javascript. Pour être plus précis, on peut utiliser Javascript mais il semble que la majeure partie des développeurs passent à la version “TypeScript” qui propose une syntaxe plus poussée en termes de POO. Car Typescript est un langage qui propose une définition de classe avec encapsulation.

Mais nous n’allons pas parler de cela aujourd’hui, je veux vous parler essentiellement des outils que j’ai installés sur mon poste pour tester Angular 2 avec Vim.

On va donc passer par deux étapes, la première est la configuration de vim pour avoir l’auto-completion typescript, et la seconde vous montrera comment je démarre un projet Angular 2 (avec une image docker, et oui… On se refait pas)

Installation des outils

Typescript

Malheureusement, il faut installer globalement le transpiler “typescript”. J’ai cherché à m’abstraire de cette contrainte sans succès.

C’est assez facile, mais bon, ça installera le module dans votre système…

Rien de grave hein, c’est juste que je n’aime pas trop qu’un outil tiers manipule mon installation Linux si ce n’est pas un RPM (ou un .deb pour les debian/like)

Sans paniquer, vous pouvez y aller:

sudo npm install -g typescript

C’était pas compliqué.

Plugins Vim

Je travaille sur “neovim”, mais si vous avez “vim” traditionnel cela devrait passer sans souci. Personnellement j’utilise “Vundle” pour installer mes plugins vim, c’est plus rapide et plus maintenable que Pathogen selon moi.

Donc, dans votre “~/.vimrc” vous allez ajouter ces lignes:


" Mainly for typescript
Plugin 'Shougo/vimproc.vim'
Plugin 'Quramy/tsuquyomi'
Plugin 'leafgarland/typescript-vim'

Sauvez votre fichier et fermez vim, puis ouvrez vim et tapez:

:PluginInstall

Quand c’est terminé, fermez vim.

Si vous n’utilisez pas “Vundle”, vous devrez alors suivre les instructions des pages:

Bref, admettons que vous ayez enfin installé les plugins.

Maintenant allez dans le répertoire “~/.vim/bundle/vimproc.vim/” et tapez la commande “make”. Sans cela, rien ne fonctionnera.

Le troisième plugin ajoute la coloration syntaxique.

Voilà, on a terminé… Si si je vous assure !

Créer un projet

Plusieurs solutions s’offrent à vous. La première est d’utiliser l’outil officiel angular-cli en l’installant avec “npm”.

Personnellement je n’aime pas cette méthode, pour des raisons déjà expliqué plus tôt: je n’aime pas installer “globallement” des choses sur mon système.

Vous pourriez utiliser nvm aussi pour installer tout ça dans votre HOME, mais encore une fois j’ai un peu de mal avec cette méthode. Car si vous partagez votre projet avec une équipe, je suis prêt à parier qu’à un moment ou un autre vous allez oublier une dépendance dans votre “package.json” tout simplement parce que la librairie est accessible sur votre poste, et installée depuis un autre projet.

J’ai eut le cas… Donc personnellement je vais passer par une image Docker (vous vous y attendiez si vous me connaissez bien).

L’image que je vous propose est ici: metal3d/ng. Vous pouvez attraper cette image:

docker pull metal3d/ng

Créons donc un projet:

mkdir ~/Projects/angular2-test
cd ~/Projects/angular2-test
docker run --rm -it      \
    -v $(pwd):/project   \
    -u $(id -u):$(id -g) \
    metal3d/ng new myproject

Cela crée le projet “myproject” dans votre répertoire.

Attention, à partir de là il va y avoir un piège !

Le répertoire de “projet” est désormais “~/Project/angular2-test/myproject” !

Donc, maintenant, vous devez vous déplacer dans ce répertoire pour faire fonctionner votre application, ou changer le volume dans la ligne de commande.

Vous avez donc deux solutions:

vous décidez que votre projet se trouve dans le répertoire “myproject” et donc vous avez simplement à vous déplacer dans ce repertoire pour lancer les commande docker
vous décidez que “myproject” est un sous-repertoire de votre projet principal, il faut adapter le répertoire dans les commandes docker en ce qui concerne le volume

A partir de là, j’estime que vous avez choisi la première solution, à savoir que le répertoire “myproject” est le répertoire de projet. Vous pouvez donc taper:

cd myproject

Pour gagner en confort, je vais créer deux fichiers:

un docker-compose.yml pour lancer le projet en mode “service”
un Makefile pour éviter de taper de longues commandes docker pour créer des fichiers de projet

Allons-y…

Un peu de confort

Nous somme donc désormais dans le répertoire “~/Projects/angular2-test/myproject”.

Mon fichier docker-compose.yml ressemble à ceci (remplacez bien 1000:1000 par vos uid et gid):

version: '2'
services:
    app:
        image: metal3d/ng
        user: 1000:1000
        command: serve
        ports:
        - 4200:4200
        - 49152:49152
        volumes:
        - ./:/project

Le service s’appelle “app”, je vais l’utiliser dans un Makefile.

Voilà donc le fichier “Makefile” que j’utilise:

.PHONY: ng
DIR:=$(PWD)
APPNAME:=app
UID:=$(shell id -u)
GID:=$(shell id -g)

run:
    docker-compose up

ng:
ifndef DO 
    @echo 'You must provide a "DO" parameter'
    @echo 'Example: make ng DO="generate component foo"'
    exit 1
endif
    docker-compose run --rm $(APPNAME) $(DO)

Comme ça, je pourrais taper:

$ make ng DO="g component foo"
installing component
  create src/app/components/foo/foo.css
  create src/app/components/foo/foo.html
  create src/app/components/foo/foo.ts
installing component-test
  create src/app/components/foo/foo.spec.ts

Et donc, en tapant “make” ou en tapant “docker-compose up”, j’ai bien un service angular qui fonctionne.

app_1 | Could not find watchman, falling back to NodeWatcher for file system events.
app_1 | Visit http://www.ember-cli.com/user-guide/#watchman for more info.
app_1 | Livereload server on http://localhost:49152
app_1 | Serving on http://localhost:4200/

Conclusion

Je ne suis pas encore entré dans les détails de Angular 2. Je suis encore en cours d’apprentissage. Mais cette image docker, créée en quelques minutes, et les fichiers “Makefile” et “docker-compose.yml” que je vous ai montré accélèrent vraiment le boulot.

Encore une fois, vous pouvez vous passer de Docker ici, mais je pense honnêtement que si vous travaillez en équipe alors l’utilisation d’une image qui propose les outils et le serveur “dev” évitera pas mal de dérapages.

Vim, configuré comme je vous l’ai montré, me donne une bonne completion de code et des informations utiles ainsi qu’une coloration propre. Le confort de travail est suffisant pour moi.

En espérant que tout ça vous aide.

JWT en Go

Sun, 28 Feb 2016 13:34:48 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vous avez envie de gérer l’autorisation de vos API REST en Go avec JWT ? Personnellement c’est mon cas. Alors voilà comment on s’y prend.

JWT (JSON Web Token) est fortement utilisé depuis plusieurs années maintenant. Il permet de signer une clef et de permettre l’autorisation d’un utilisateur dans des échanges client-serveur. Il est intégré au protocole OAuth2 et bénéficie d’une RFC.

Pour faire simple, c’est un peu comme gérer des sessions… Mais sans session.

Hein ? Keskidi ?

– un lecteur bourré

Bon pour faire simple, sans aller dans le détail de OAuth2 que nous n’allons pas utiliser, voilà en gros le déroulé:

un utilisateur se connecte sur le serveur en envoyant un login et mot de passe
le serveur authentifie (ou non) l’utilisateur
le serveur crée alors un “token” signé et crypté qu’il retourne à l’utilisateur

Et après cela, à chaque requête de l’utilisateur, le client doit envoyer ce token pour être reconnu par le serveur.

Mais comment le serveur sait que ce token est bien au format attendu ? C’est ultra simple ! Le token est en fait une combinaison d’information dont un JSON qui contient des informations reconnues par le serveur (et lui seul, à moins de donner la clef secrète à d’autres).

Donc, quand le serveur reçoit une requête, il décrypte le token avec une clef secrète (qui a servi à encrypter le token) et il vérifie des informations. Dans ces informations il y a généralement au moins une date d’expiration. Si cette date est dépassée, le client va devoir redemander un token.

Bref, c’est assez bien fichu. C’est pas non plus infaillible (il parait), mais ça a le mérite de faire le job attendu, et ça permet surtout d’éviter au serveur de retenir des sessions. Du coup, on peut utiliser le même token sur une application “scallée”, à condition de partager la clef avec tous les noeuds afin qu’ils puissent tous authentifier l’utilisateur.

En visitant la page https://jwt.io/ j’ai découvert que le package “jwt-go” proposé est celui-ci: https://github.com/dgrijalva/jwt-go

Voyons donc comment il marche.

Exemple Simple en Go

On va juste faire un petit test, on commence par installer le package:

go get -u github.com/dgrijalva/jwt-go

Et on se fait un petit programme pour voir. On crée un répetoire “~/jwt-test” et on crée le fichier “~/jwt-test/main.go”:

package main

import (
    "log"
    "time"
    "github.com/dgrijalva/jwt-go"
)

var SECRET = []byte("Une phrase longue pour encrypter/décrypter le token")

func main(){
    token := jwt.New(jwt.SigningMethodHS256)
    // dans Claims, on peut mettre ce qu'on veut
    token.Claims["id"] = 123456

    // la clef "exp" est là par défaut, on peut la modifier
    // c'est la date d'expiration du token
    token.Claims["exp"] = time.Now().Add(time.Hour * 24)

    // on récupère la chaine
    jwtstring, err := token.SignedString(SECRET)
    if err != nil {
        log.Fatal(err)
    }
    // voilà la clef
    log.Println(jwtstring)
}

Cette clef peut donc être retournée au client. Il va la garder dans un coin et l’envoyer dans une entête ou en argument pour faire des requêtes. Le serveur doit donc maintenant être capable de décrypter le token. Voilà comment faire:

// je vous laisse faire la fonction "getHeader"
jwtstring := getHeader("Authorization")

// on décrypte
// je vais revenir sur la fonction utilisée pour récupérer le secret
token, err := jwt.Parse(jwtstring, func(token *jwt.Token)(interface{}, error){
    return SECRET, nil
})

if !token.Valid {
    log.Fatal("Et bha non...", err)
}

log.Println("id utilisateur: ", token.Claims["id"])

A quoi sert la fonction utilisée dans “Parse()” ? C’est assez simple, vous pouvez créer une fonction qui, selon les entêtes, la requête, le type d’utilisateur, retournera une clef spécifique. C’est loin d’être idiot. Mais dans notre cas nous n’allons pas faire compliqué et retourner la variable “SECRET”.

Le miracle opère, vous avez l’id utilisateur. Puisque le token est valide, c’est à dire que le serveur a réussi à le décrypter et que la date “exp” n’est pas dépassée, et bien vous pouvez être certain que l’utilisateur est le bon.

À vous de choisir quoi mettre dans le token, ici nous avons intégré l’identifiant du compte, mais vous pouvez ajouter son email, son login, sa pointure de chaussure… Bref, ce qui vous intéresse. Certains s’amusent à foutre tout l’objet utilisateur à l’intérieur. C’est bourri hein…

J’aime les auteurs de package !

Franchement, en Go, je ne sais pas pourquoi, mais je trouve que les auteurs de package s’arrachent vraiment pour rendre la vie facile aux développeurs. Là, par exemple, l’auteur du package jwt-go a pensé à mettre une méthode “ParseFromRequest” qui fonctionne super bien.

Plutôt que de chercher vous-même l’entête ou la variable postée par le client, la fonction le fait pour vous:

// une méthode qui demande une authentification
func GetSomething(w http.ResponseWriter, req *http.Request){

    // on décrypte
    token, err := jwt.ParseFromRequest(req, func(token *jwt.Token)(interface{}, error){
        return SECRET, nil
    })

    if !token.Valid {
        http.Error(w, "Problème avec ton token", http.StatusUnauthorized);
        return
    }

    w.Write([]byte("Yes !"))
}

Pour faire simple, la méthode cherche l’entête “Authorization” ou la valeur POST “access_token”. Vous voyez, c’est pas compliqué.

Conclusion

JWT est une notion essentielle de nos jours, il faut dire que les API REST sont à la mode et que la scallabilité n’aide pas la gestion de session. Donc, JWT est une bonne réponse à cette problématique et elle a le mérite d’être assez sûre.

En Go, c’est finalement pas si compliqué.

Ubuntu et Debian, pourquoi je les évite

Tue, 23 Feb 2016 12:47:14 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Debian et Ubuntu sont aujourd’hui des distributions extrêmement bien positionnées et disons-le, incontournables. Mais personnellement, je rechigne depuis des années à utiliser ces deux distributions pour des raisons que je vais vous exposer.

Oui je sais, ça peut ressembler à un troll vu de loin. Mais je vous demande de ranger les armes et de me lire dans une optique de réflexion et non d’une agression. Car le fond de ma pensée n’est pas si négative qu’elle peut paraitre, je vais donc préciser deux choses:

Debian est une excellente distribution basée sur un modèle de communauté que j’apprécie énormément.

Et pour la seconde:

Je ne remets pas du tout en question que Ubuntu ait permis une forte augmentation de l’utilisation de Linux par d’autres personnes que des professionnels.

Ce serait malhonnête de ma part de dire le contraire. Sauf que depuis tant d’années que je travaille dans le développement, et ayant utilisé quotidiennement ces distributions (que ce soit en poste de travail ou en serveur), j’ai un avis assez tranché sur la question.

On va commencer par Debian et finir par Ubuntu.

Debian

Debian est une distribution gérée par une communauté de passionnés bénévoles. Sur ce point, elle se démarque de Ubuntu ou RedHat. Par contre, elle utilise le même principe que CentOS ou Fedora.

En réalité, c’est CentOS qui est véritablement sur la même ligne de front. Car je fais partie de ceux qui pensent que Debian n’est pas une distribution adéquate pour le Desktop, tout comme CentOS. Ce sont des distributions que je trouve franchement plus portées “serveur”. Avis personnel, oui.

Debian utilise un logiciel de gestion de paquets nommé “apt”, dont un outil plus facile et bénéficiant d’une interface utilisateur en console nommé “aptitude” peut vraiment soulager le non spécialiste.

En bref, Debian est une distribution très complète et ce n’est pas par hasard si elle est fortement utilisée coté serveur.

Alors pourquoi je ne l’aime pas ? C’est pas que je ne l’aime pas, c’est quelle me pose des soucis tant philosophiques que techniques. Je n’ai rien contre elle, croyez-moi. Mais laissez-moi exposer ce qui m’amène à l’éviter.

Pour certain cela va paraitre dérisoire, mais j’estime que cela a un impact très important sur le confort de travail. Debian ne respecte pas certains standards et ne fait pas grand-chose, à mes yeux, pour corriger le tir.

Je vais parler ici d’une tendance à vouloir “trop en faire”. Parlons des paquets Nginx et Httpd.

A trop vouloir en faire…

En premier lieu, Debian a voulu “simplifier le nommage” (c’est une hypothèse de ma part) et à décidé de renommer Httpd (le service http de apache) en “apache”. Or… Apache est une fondation qui propose d’autres produits, par exemple Tomcat.

Apache est donc, si on reste dans une optique de service, un utilisateur qui fournit des services. C’est d’ailleurs de cette manière que l’ensemble des distributions non basées sur une Debian ont défini “apache”. Il y a un utilisateur nommé comme tel (apache) et des services nommés comme le proposent “apache”, c’est à dire “httpd” et “tomcat”.

Debian a décidé d’avoir un utilisateur “www-data” (avec un tiret dans le nom …) qui en plus de ne pas être clair (data signifiant “données”, nous avons là un utilisateur qui s’appelle “données www”) est utilisé pour tous les services “internet”. Sur ce point à la limite, je peux me raviser. Car effectivement un utilisateur standard pour le web n’est pas une mauvaise idée en soi. Ce sera le même utilisateur qui pourra toucher les fichiers nginx et apache. Donc en soit, c’est une demi mauvaise idée (et donc une demi bonne idée).

Et le service nommé “httpd” sur tous les systèmes Unix non Debian devient alors “apache”. Ce qui fait que nous avons un mot, “apache” qui désigne un utilisateur sur toutes les distributions sauf Debien, et qui désigne un “service” sur les distributions Debian… Et là par contre c’est une mauvaise idée de la part de Debian, car il répand un amalagame sur ce qu’est “apache”.

Et ça ne s’arrête pas là.

Debian propose des outils que je trouve, sans ironie, très intelligents. C’est “a2ensite, a2dissite” ou encore “ngensite et ngdissite”. Ces deux commandes vont activer ou désactiver des “sites” sur apache2 et nginx.

En soit l’idée est très bonne, je le répète. Cela permet d’avoir une série de configurations de site que l’on peut activer ou désactiver en une commande.

Sauf que Debian modifie fortement l’arborescence standard des fichiers de configuration (celle proposé par les auteurs des logiciels Httpd et Nginx pour ne citer qu’eux). Pour réussir ce tour, Debian supprime le répertoire “conf.d” où toutes les autres distributions permettent l’écriture de configuration personnelle, et crée deux autres répertoires:

sites-available où se trouve les sites “disponibles”
sites-enabled où un lien symbolique est créé depuis les fichiers du répertoire précédent pour activer un site

Encore une fois, c’est une excellente idée, je ne dis pas le contraire… Dans le fond. Mais dans la forme cette manipulation de répertoire casse le “standard”. Et cela induit des erreurs.

Par exemple, l’image Docker officielle “nginx” s’est vu avoir un fonctionnement ambigue. J’ai d’ailleurs participé au bug report qui est l’exemple type de l’ambigüité induite par l’utilisation de Debian en “base d’image”. Ici, l’auteur utilisant Debian mais installant une version “standard” de nginx à travers les dépôts des auteurs de Nginx s’est retrouvé dans une confusion, et donc des soucis aux utilisateurs qui ont suivi la documentation.

Cela est bien plus grave que ça n’y parait. Docker en soit propose des images pour des services qui, théoriquement, sont “distribution agnostic” (ce n’est pas une règle en soit, mais la logique d’utilisation nous permet de le percevoir ainsi). Si les images suivent les principes de Debian, alors le coté agnostique disparait, car les chemins de configuration seraient typique Debian.

Sauf que Debian n’est pas la seule image de base utilisée par les créateurs d’image Docker, et par conséquent cela complexifie l’utilisation d’une image pour y injecter de la configuration.

En clair, Debian pose un souci.

Ce qui est étonnant c’est que Debian aurait pu trouver une solution qui ne brise pas le standard. Simplement en utilisant deux répertoires:

sites-available, ça, ça ne change pas
conf.d où les liens sont écrits par a2ensite ou ngensite.

Ou encore, il leur suffirait de faire un lien symbolique de “site-enabled” vers “conf.d”… Par contre, ce serait un peu plus compliqué pour les images Docker dont les liens symboliques peuvent engendrer des incohérences ou des complexités. Mais en soit, il y avait des moyens de faire en sorte de rester “standard”.

De cette manières, que l’on écrive une configuration de manière “standard”, ou en passant par “sites-available” et un outil de lien automatique, tout fonctionnerait de la même manière.

Et pour finir, ce qui me choque un peu, c’est que seuls les services Web ont cette méthode d’écriture de configuration. Les autres services tels que Fail2Ban utilisent, pour le coup, des répertoires “conf.d” comme toutes les autres distributions. C’est comme si Debian imagine que les ingénieurs ou développeurs de site web sont un peu plus bête que les autres et qu’ils ont besoin d’avoir des répertoires “clairement identifiés par leur nom” (je suis un peu méchant sur les intentions de Debian, je vous l’accorde)

Mais les outils et l’arborescence ne sont pas les seuls problèmes qui me gênent.

Qualité et respect

Là je sais que je vais énerver pas mal de fans de Debian. Mais il faut clairement comprendre que si j’en suis venu à cette conclusion, c’est parce que j’ai longuement testé et utilisé Debian

Notamment, je l’utilise encore sur mon serveur (celui-ci, qui propose mon blog) et je vais rapidement devoir réinstaller cette machine pour revenir à ma CentOS que j’avais quitté pour une raison peu évidente à la base.

Mes services que je propose ici (il n’y a pas que ce blog), tournent pour 99% d’entre eux sur des conteneurs Docker. Un jour j’ai décidé de supprimer mes paquets pour réinstaller proprement le service Docker.

Et j’ai été vraiment surpris, et franchement dans la panade, quand je me suis rendu compte que les packageurs Debian avait décidé de supprimer des dépots les paquets Docker. Voir https://packages.qa.debian.org/d/docker.io/news/20150331T163915Z.html

Mon serveur s’est donc retrouvé dans une situation compliquée… à cause de mainteneur qui, du jour au lendemain, supprime les paquets des dépôts officiels.

Heureusement que docker.io propose des dépôts et paquets…

Bref, ce genre de comportement m’exaspère. Et pour le coup l’estime que j’avais pour Debian est descendu encore d’un cran.

Pour le coup, ma colère va parler là, je trouve ceci complètement irrespectueux pour les utilisateurs de Debian, et j’imagine la tête des administrateurs systèmes qui utilisaient Docker à ce moment là lors des mises à jour et/ou d’une réinstallation (comme moi). C’est vraiment pas pro de la part des packageurs.

On va maintenant passer à Ubuntu.

Ubuntu, le coup de grâce

Ubuntu est basée sur Debian, ce qui me pose donc déjà un souci en soit pour les raisons expliquées ci-dessus. Mais Ubuntu est aussi une distribution qui est développée par une entreprise nommée “Canonical” dont les intentions ne sont pas très claires… ou plutôt, elles le sont, et elles ne me plaisent pas du tout. Pour résumer, l’idée est clairement de “devenir une référence en faisant en sorte que les autres distributions ne soient pas compatible avec ce qu’elle propose” (ça vous rapelle rien ?)

Donc, amis de Debian, je vous le dis en toute franchise, personnellement je n’apprécie pas le coup que vous fait Canonical. Car se baser sur votre boulot et s’attirer les éloges en massacrant dans le même temps tout le travail que vous faites, moi je trouve ça limite.

Bon je l’admets, c’est le militant pour le logiciel libre qui va parler là.

En gros, elle se base sur Debian qui lui fourni une base sans dépenser un sou, et elle retourne la communauté en lui faisant croire que seule Ubuntu est super géniale, rend fertile et riche, alors que les autres sont des trucs de vieux geek boutonneux qui recompilent leur kernel au dessert.

Car oui, quand je lis des avis sur le net, ou que j’écoute certaines personnes, la première phrase qui ressort est “bha ouais mais Ubuntu c’est facile, c’est pas comme les autres où tu dois installer à la main en tapant des commandes”. Je vous assure que ce que je vous dis est vrai. L’image de Ubuntu est “Linux pour les humains”.

Ouais parce que moi je suis sur Fedora, donc je ne suis pas humain… Ou alors faut un doctorat pour installer Fedora hein…

Mais si ce n’était que ça…

Ubuntu propose des outils propriétaires par défaut, dépose un “market” Amazon, et fourni de base des pilotes propriétaires.

Là déjà je ne suis pas franchement à l’aise avec cette politique. D’abords pour des raisons clairement techniques: on ne voit pas le contenu des sources des logiciels qui sont “imposés” et cela va à l’encontre de mes convictions. Mais en plus de cela, l’image de “Linux” (intentionnellement, je ne mets pas de GNU devant) proposé à une classe d’utilisateurs généralement débutante est tronquée.

Aux yeux de Canonical, Linux est une base de vente, un peu comme le fait Google avec Android (basé sur Linux). Sauf que Google ne cherche pas à tuer GNU… Canonical montre tous les signes qu’elle cherche clairement à imposer Ubuntu au détriment du travail effectuer par ceux qui lui permettent de se faire de l’argent. Je trouve ça malhonnête.

Il y a peu, un ami, non-informaticien, m’a sorti “dis donc toi, tu m’as dit que Linux c’est libre et tout, j’ai installé Ubuntu et bha il me demande de payer des logiciels et j’ai vu que c’était pas du tout libre comme tu me l’avais dit”

Effectivement, il est passé par l’outil (dont j’ai perdu le nom) qui propose des logiciels payants, et dont les licences ne sont pas libres…

Pour ceux qui défendent le fait que la connaissance doit être offerte à tous, que le logiciel doit être accessible sans restriction… voir une boite proposer une distribution qui trahi ces objectifs me fait mal au cœur.

Sans compter que tous les développeurs qui bossent avec moi et qui ont une Ubuntu dans leurs mains ont généralement des soucis. La faute étant la qualité des paquets proposés par Ubuntu.

Parfois le binaire est inexistant, parfois le paquet est vide… Ou encore une erreur de dépendance…

Et je ne parle pas des “PPA”, ces dépôts créés par des utilisateurs, dont la qualité est parfois très limite.

En gros, cette distribution bénéficie d’une communauté très vaste de par son image “facile”. Mais la qualité n’est pas là… Et je pense franchement que ces utilisateurs “Ubuntu” devraient tenter de passer à une autre distribution avant de juger hâtivement de la simplicité.

LTS - le piège

Le LTS me fait aussi doucement rigoler. Je ne connais pas beaucoup de personnes qui utilise une distribution qui a plus de 2 ans. La plupart (et le mot est faible) essait plutôt de se mettre à jour.

C’est même un piège ! Car du coup, vous vous trainez une distribution qui n’est pas à jour et qui ne reçoit que des patchs de sécurité pendant 5 ans… Je le répète, vous n’êtes donc pas à jour.

Le LTS est intéressant sur un serveur, et encore… Tout dépend du serveur. Sur un Desktop, avec des utilisateurs Ubuntu qui aiment en plus jouer, rester sur une version 14.04 est tout simplement étrange.

Bref, LTS n’est, pour moi, et pour beaucoup, absolument pas un argument, et n’a rien à voir avec la qualité ! Car on me l’a sorti ça… “ouais mais Ubuntu elle est LTS, c’est vachement mieux pour la stabilité”

Pardon ???

Séparation

Et dernièrement Ubuntu a clairement décidé de se séparer de la communauté, celle-là même qui lui a permis de vendre et de se répandre. Là où un consensus se porte sur Gnome (pour des raisons qui peuvent ne pas vous plaire) et que l’effort de compatibilité est fait pour que KDE ou Xfce reste de bonnes alternatives, Ubuntu nous pond “Unity”. Déjà le nom est un joli doublon avec le moteur 3D du même nom, mais en plus il a été fortement critiqué pour ses soucis de stabilité et la perte de place qu’engendre l’installation de base sur le coté de l’écran.

Et pour bien, disons le mot, “emmerder les autres”, et bien là où enfin on a une prévision de refondre le serveur graphique et que Wayland est franchement une optique intéressante, et bien Ubuntu décide de développer dans son coin un autre serveur nommé “Mir”.

Le risque est sévère en ce qui concerne la compatibilité. Si en plus vous regardez à quel point les “industriels” ne se penche que sur cette distribution, malgré toutes les mises en gardes faites (y compris par les développeurs Debian), on peut très vite imager à quel point les communautés Linux vont se séparer. Car si ça se passe mal, Steam ne proposera pas de compatibilité avec les distributions autres que Ubuntu…

Pour une distribution qui vient d’Afrique du Sud, parler de “séparation” est limite un “point Godwin” à atteindre si je me laissais aller… (pour les personnes intéressées, allez voir la page Wikipedia Apartheid ainsi que la signification de ce mot)

C’est déjà compliqué d’installer Steam sur autre chose que Ubuntu, je n’ose pas imaginer l’avenir avec Mir et Wayland qui vont s’opposer.

D’ailleurs, à ce propos…

Petite parenthèse

Je commence à en avoir un peu marre de voir des éditeurs de logiciels comme Genymotion ne proposer que des “.deb”…

Ça leur prendrait à peine plus de temps de proposer un tarball et/ou un RPM, surtout que des outils automatiques permettent de le faire rapidement, comme FPM.

Je suis pas fan de Debian et Ubuntu, et pourtant je me débrouille pour proposer des .deb en plus de tarball et RPM, et ça ne m’a pas pris plus de 20 minutes pour y arriver. Sérieusement, ça fatigue.

Donc, moi qui développe sur Fedora, je n’ai pas droit à Genymotion. Je les ai contacté, je n’ai pas eut de réponse…

Pour Steam, il existe des dépôts où des packageurs se sont cassé la tête pour réussir une installation sur autre chose que Ubuntu. Mais c’est assez dingue que les “.deb” soient si répandu, surtout quand on connait les défauts de ce type de paquet en ce qui concerne la construction (sifflotements…)

Docker, encore

Ce qui m’a choqué… C’est que des images officielles de services sous Docker se basent sur “Ubuntu” !

Déjà, je me suis exprimé sur le fait d’utiliser une distribution “desktop” ou “serveur” pour créer une image Docker, alors que des distributions bien plus légères sont bien plus adaptées pour cet effet.

Si encore on utilise CentoOS ou Debian, je peux comprendre. Si l’utilisation d’une distribution “desktop” est nécessaire pour des cas particuliers (j’ai une image qui utilise Fedora pour une raison particulière) alors ok…

Mais la plupart des images que je voyais utilisaient Ubuntu sans aucune raison valable… Juste un “c’est une distribution répandue” en guise de défense.

Effectivement, vous devriez écouter du Justin Bieber et apprécier, puisqu’il vend des millions de disques…

Conclusion

Honnêtement, je vais me répéter mais… Debian est une très bonne distribution. Je suis simplement gêné par l’irrespect de certains standards qui, je le conçois, ne sont pas des “lois”… Mais par souci d’homogénéité j’aimerai que les packageurs et autres décisionnaires de cette distribution se penchent un peu plus sur ce qui les entoure. Un peu plus d’échanges, un peu plus de recherche de respect de standard et que nous soyons plus homogènes.

Je me fiche de l’utilisation ou non de systemd, j’attends simplement que les hiérarchies de répertoires et les noms de fichier, de services et d’utilisateurs soit basé sur les noms conventionnels. Ceux-là même qui sont définis par les “développeur du service”.

Par contre, Ubuntu est selon moi une distribution à éviter.

Une politique que je déteste, des paquets de piètre qualité, un bureau par défaut infâme et une tendance à briser le travail d’ouverture et de standardisation avec les acteurs du libre, tout ça me choque. Si Ubuntu fonctionne, c’est avant tout grâce à Debian et toutes les autres distributions qui ont essuyé les plâtres, et qui aujourd’hui encore travaille sur la qualité d’un système d’exploitation fiable. Et au lieu de l’aider, elle “vole” la partie intéressante pour se l’accaparer et enfin développer des systèmes qui ne seront plus compatibles avec le reste de l’univers GNU.

Il existe tellement d’autres distributions plus fiables, plus respectueuses et pourtant pas plus compliquées à installer, que je vous invite à y réfléchir à deux fois avant de faire une bêtise.

Donc, oui, j’apprécie Debian, je suis juste un peu déçu, mais non, je n’aime pas Ubuntu et je la déconseille et ce tant qu’elle ne sera pas plus qualitative.

Bon, ça va troller…

Alpine ou comment faire une image Docker très légère

Mon, 01 Feb 2016 12:25:20 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Puisque ces temps-ci je met à profit mes compétences CoreOS/Docker de manière plus soutenue, je me suis dit que quelques articles sur mon blog pour partager quelques astuces pourrait être de bon allois (t’as vu !). Alors aujourd’hui, je vais parler de Alpine, une distribution pour conteneur très légère et pourtant très fournie.

L’un des soucis majeurs avec Docker c’est bien l’espace nécessaire pour une image. Certes, le fait de partir d’une même image de base (debian, fedora, centos…) ne va pas dupliquer l’espace (parce que Docker utilise un système d’union fs) mais tout de même… Quand on se retrouve à vouloir fournir une image qui contient un seul binaire de 1 ou 2 Mo, on a une image de 100Mo voir 200Mo à fournir. Et j’exagère à peine.

L’idée est donc de réduire un maximum l’espace nécessaire. Il y a, en premier lieu, des astuces simples à connaitre:

tenter de faire un maximum de chose en une seule commande “RUN”
supprimer les fichiers inutiles (cache apt, yum…) très rapidement et surtout dans la commande qui génère ces fichiers; par exemple, supprimer le cache et faire un “autoremove” juste après un “apt-get install” ou un “dnf install”

Mais quoiqu’il arrive, une distribution “commune” telle que debian, fedora, centos, etc. ont la facheuse tendance à installer, de base, pas mal d’outils inutiles dans une image Docker. Ce n’est pas de leur faute, loin de là, elle ne sont juste pas optimisée pour ça. Ces fichiers sont présents parce que ces distributions sont faite pour “booter” sur une machine (virtuelle ou physique).

Busybox - la base

Il existe deux distributions (si on peut les appeler comme ça) faites pour de l’embarqué et les images Docker. La première est très légère: busybox. Cette distribution embarque réellement le strict minimum et, à moins que vous ne vouliez embarquer que des binaire statiquement compilés ou ne l’utiliser que pour faire un conteneur “data only”, elle ne vous sera pas très utile. Personnellement je m’en sers pour des outils développés en Go qui n’ont pas besoin d’enregistrement libc particulier, donc sitôt que je fais un binaire qui utilise du réseau, je me retrouve avec un binaire qui ne veut pas s’exécuter sur busybox.

Heureusement pour moi, une autre distribution embarquée existe, basée sur busybox.

Alpine - la solution

Alpine est une distribution qui n’occupe que quelques megaoctets (4 Mo). La différence entre busybox et celle-ci est que Alpine propose un gestionnaire de paquet qui, en plus, propose pas mal d’outils paquagés, allant de Mysql et Mongo à Nginx en passant par Java, Go et Python.

L’outil se nomme “apk” et il est assez simple à utiliser. Tentons l’expérience.

$ docker run --rm -it alpine sh

/ # python
sh: python: not found

/ # apk add --update python
... 
OK: 51 MiB in 21 packages

/ # python
Python 2.7.11 (default, Jan 23 2016, 12:34:14) 
[GCC 5.3.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.

L’option “–update” permet de ne pas passer par deux commandes “alpine update; alpine add python”.

Donc, dans un Dockerfile, on aura le loisir d’installer des outils et de les supprimer si nécessaire.

Par exemple, si je veux compiler un binaire de mon projet Go, je n’ai qu’à faire:

deposer mes sources dans l’image
installer go
compiler mes sources
déplaccer le ou les binaires dans /usr/bin/
supprimer go (puisque j’ai compilé mes binaires)

Voilà un exemple:

FROM alpine:latest
MAINTAINER Patrice FERLET <metal3d@gmail.com>

ADD src/ /opt/src

RUN set -xe;                \
    apk add --update go     \
    cd /opt/src;            \
    go build;               \
    mv macommande /usr/bin; \
    cd /; rm -rf /opt/src;  \
    apk del --purge go;     \
    rm -rf /var/cache/apk/* 

CMD macommande

Pour résumer, après compilation, je supprime mes sources (inutile en fait puisque le layer précédent utilis ADD et que les sources sont donc préservées) puis je supprime “go” (en purgant si nécessaire) et je vire le cache “apk” qui n’a plus d’utilité.

Et le tout se fait en une commande RUN afin de ne pas avoir un layer chargé de fichiers qui seraient préservés. Donc, le principe est finalement le même qu’avec n’importe quel autre gestionnaire de paquet.

Par contre, la taille de mon image passe de 120Mo avec une Debian, à 10Mo avec Alpine.

Bilan

Voilà pour ce premier petit article parlant de Alpine. Le prochain va vous présenter CoreOS et quelques méthodes de balancing automatique. Pour l’heure, pensez à Alpine si vous voulez créer des images Docker rapidement, allégée, et ce pour des service NodeJS, Go, Java, PHP, Ruby… car le dépot apk est bien fourni

Fish shell - adopté

Tue, 08 Dec 2015 12:35:55 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Je pense que beaucoup connaissent déjà le “SHELL” nommé Fish. Je l’ai adopté depuis un certain temps et je vais vous donner mes impressions ainsi que ma configuration.

En premier lieu:

Attention, ne confondez pas un terminal et un shell. Le terminal affiche le shell.

Fish est un “SHELL”, à l’instar de bash, sh, ou encore zsh. Ce shell a un certain avantage: il est moderne. Vous allez me dire qu’il y a une antiphrase en parlant de “shell” et de “modernité” mais trolleurs et mauvaises langues n’ont plus beaucoup d’impacts sur moi. Travailler sur un terminal est efficace, fiable, rapide et clair, on est dans la modernité. Sauf que, malgré tout l’amour que j’ai pour bash ou zsh, l’interfacage et l’interaction n’était pas ce que l’on peut appeler un modèle du genre. Ce n’est pas une critique acerbe, mais je trouve que depuis tant d’années ces shells n’ont pas franchement bougé en terme d’expérience utilisateur.

Fish est un shell un peu à part, il propose une interaction poussée et un visuel attrayant.

Il existe depuis plus de 10 ans mais, je ne sais pas pourquoi, il est de plus en plus répandu ces derniers temps. Beaucoup de projets proposent des bindings fish, par exemple Docker qui fourni depuis longtemps les fonctionnalités d’auto-completion pour fish.

Il est donc, à coup sûr, dans les dépots de votre distribution. Donc, un coup de “dnf install fish” ou “apt-get install fish” doit théoriquement fonctionner. Reste maintenant à le paramétrer.

Fish par défaut

Puisqu’on est pas des froussards, on va passer utiliser Fish à la place de Bash pour notre utilisateur. C’est simple comme chou:

sudo chsh -s /usr/bin/fish $USER

Vous pouvez maintenant relancer une session utilisateur:

su - $USER

Et hop, vous voilà sur fish !

En général, il faudra redémarrer Gnome pour que cette modification soit complètement prise en compte.

Si vraiment Fish ne vous plait plus:

sudo chsh -s /bin/bash $USER

Allez on passe au paramétrage.

Première impression

Je vous conseille vivement de taper “help” dans le terminal. Cette commande va ouvrir un navigateur avec la documentation. Cette documentation est primoriale pour ne pas pêter un câble. Vous y trouverez la liste des commandes spécifiques, des informations importantes, et tout ce dont vous aurez besoin pour faire passer vos anciennes commandes bash en fish.

D’abord le prompt est pas mal, il est simple, ça me va bien. En tapant des commandes je remarque que le shell auto-complète en fonction de mon historique.

Autre chose interessante, la manière dont Fish complète les options, il suffit de taper “–” puis ma touche “tabulation” et on peut naviguer dans les options. De plus, il donne de la documentation.

Et ça marche avec les page de “man”, “git”, etc… donc en tapant “git” suivit de “tabulation”:

En bref, je sentais bien, quand j’ai commencé à tester ce shell, que ça allait me plaire.

Oh My Fish

Tout comme zsh, il existe un outil “oh my …” qui va mettre un coup de boost à votre shell pour lui fournir des options sympathiques tels que des thèmes. On commence donc par cela.

curl -L https://github.com/oh-my-fish/oh-my-fish/raw/master/bin/install | fish
omf update
omf install

Si tout se passe bien, vous avez maintenant la commande “omf” et vous allez pouvoir changer de thème, installer des plugins, etc…

Pour ma part, j’utilise le thème “cmorrell” qui m’affiche l’état de mes projets git sur la droite, ainsi que le nombre de fichiers modifiés dans le projet. Bien entendu, si je ne suis pas dans un dossier de projet, rien ne s’affiche. Donc voilà comment faire:

# on regarde la liste des thèmes existants
omf theme
# installons cmorrell
omf install cmorrell
# on utilise le thème
omf theme cmorrell

C’est tout !

Configurons

Maintenant, on va configurer un peu le prompt (couleur, texte…) et c’est là que j’adore fish. Dans le terminal, tapez :

fish_config

Un navigateur va apparaitre, et vous allez pouvoir changer le thème de couleur, le type de prompt, etc.

J’utilise pour ma part le thème de couleurs “Lava”:

En ce qui concerne le “prompt”, je passe en mode “Minimalist”:

Et voici ce qu’il se passe dans un répertoire qui contient un projet Git:

Encore un peu de “tweak”

Il nous reste quelques modifications pour aller un peu plus loin. Dans le fichier “~/.config/fish/fish.config” vous allez pouvoir modifier vos chemins par défaut, créer des fonctions, des alias, etc…

Voici ce que je mets:

# Path to Oh My Fish install.
set -gx OMF_PATH /home/patachou/.local/share/omf

# Customize Oh My Fish configuration path.
#set -gx OMF_CONFIG /home/patachou/.config/omf

# Load oh-my-fish configuration.
source $OMF_PATH/init.fish

set -x GOROOT ~/go
set -x GOPATH ~/goprojects
set -x PATH $GOROOT/bin $GOPATH/bin/ ~/.local/bin/  $PATH
set -x EDITOR vim

# function to have gnome notification
# FEDORA ONLY !
if test "$VTE_VERSION" -ge 3405
    switch "$TERM"
        case 'vte*' 'xterm*'
            function __notify_vte_command_completed --on-event fish_postexec --description 'Notify VTE of command completion'
                printf '\e]777;notify;Command completed;%s\a' (echo "$argv" | cat --show-nonprinting | tr --delete \;)
            end
    end
end

[EDIT]: la fonction de notification ne fonctionne que sur Fedora 22 minimum. Désolé.

Comme vous l’avez remarqué, fish n’utilise pas la syntaxe Bash, par exemple pour exporter une variable, il faut utiliser “set -x” et non “export”.

La fonction que je place en fin de fichier est expliquée dans mon billet Fish et les notications Gnome et ne fonctionne que sur Fedora >= 22.

À vous d’adapter tout ça pour votre propre configuration.

Les soucis

Utiliser fish par défaut va vous entrainer quelques soucis mais il n’y a rien d’insurmontable.

Mon CTRL+R !!!

Ha zut, plus de recherche dans le terminal… Effectivement en Bash on pouvait utiliser “CTRL+R” pour rechercher des commandes dans l’historique. Fish ne fourni pas ce genre d’option, mais c’est normal !!! puisque l’autocompletion est native.

Or, moi j’aime bien taper le terme à chercher et utiliser CTRL+R. Donc on va utiliser un super outil codé en Go, nommé FZF.

On l’installe:

git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

Et voilà, terminé ! Relancez une session fish avant de tester, sinon ça ne marchera pas.

On tente ? Je tape un début de commande et CTRL+R:

Je trouve même que cet outil est meilleur que le CTRL+R de bash…

Syntaxe modifiée

Pas mal de choses changent en Fish:

Ne pas utiliser “&&” mais “; and”. C’est un peu énervant, je sais, je suis d’accord, mais on s’y fait vite et c’est finalement assez lisible.

grep "foo" /bar; and echo "Cool"

Les redirections sur STDERR peuvent être remplacées par un accent circonflexe “^”. Par conséquent:

commande >/tmp/out 2>/tmp/err
# équivalent
commande >/tmp/out ^/tmp/err

commande 2>>/tmp/err
# équivalent
commande ^^/tmp/err

On peut enfin revenenir à la ligne en tapant une boucle, et en plus le shell indente tout seul. Autre chose intéressante, les flèches permettent de se déplacer dans la boucle

Et j’en passe…

Vim

Si vous utilisez certains plugins vim, tels que Vundle, les auteurs n’ont pas pensé à “forcer” un shell par défaut. Pour corriger le souci, ouvrez votre “vimrc” et ajouter, au plus haut possible:

set shell=sh

VirtualEnv

Suivez simplement les indications du projet VirtualFish et utilisez la commande “vf” pour créer, activer et désactiver les environnements virtuels python.

Bilan

Que ce soit en termes visuels ou en termes d’options et y compris l’affichage, les raccourcis claviers etc… Fish m’a franchement convaincu. Certes il faut un temps d’adaptation, mais l’aide est très bien fichue, l’auteur répond rapidement sur GitHub et la communauté s’active.

Difficile pour moi de revenir sur Bash pour mon travail quotidien. J’ai adopté le poisson :)

Let's encrypt nginx

Thu, 03 Dec 2015 21:44:20 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

C’est enfin le grand jour, Let’s encrypt passe enfin en version “beta publique”, ce qui signifie qu’il n’est plus nécessaire de passer par une phase de demande pour tester ce nouveau service gratuit de certification SSL/TLS. Le petit bémole, c’est que pour nginx, le mode est expérimental. Alors voici comment procéder pour avoir un certificat SSL gratuit avec ce superbe outil.

TL;DR

Notez bien: dans cette solution il faut couper le serveur web le temps de lancer le mode “standalone”, mais il existe d’autres méthodes dont une “expérimentale” pour nginx qui permet de se passer de cette coupure. Je ne l’ai pas testé. Il existe aussi une manière de faire en mode “manuel” où le client vous donne des instructions pour déposer un fichier texte contenant un code qui doit être accessible par les serveurs letsencrypt. Pour ma part, la coupure n’était pas un souci majeur, mais pour ceux qui ont la contrainte de ne surtout pas couper le serveur web, je vous invite à lire la documentation

Sur votre serveur Web:

git clone https://github.com/letsencrypt/letsencrypt
cd letsencrypt
# cela va paramétrer virtualenv 
# et récuperer les dépendances
./letsencrypt-auto --help

# coupez nginx, c'est nécessaire, désolé
systemctl stop nginx
# ou 
service nginx stop

# puis lancez la procédure de certification
./letstencrypt-auto certonly --standalone \
    --agree-tos \
    --email VOTREMAIL -d VOTREDOMAINE.TLD \
    -d AUTRE...

Les certificats sont maintenant dans /etc/letsencrypt/live/VOTREDOMAINE/..., vous n’avez plus qu’à utiliser les certificats fullchain.pem et privkey1.pem dans votre configuration nginx.

EDIT, virer le SSLv3 en activant seulement les protocols TLS, merci à Matthieu

server {
    //...
    listen 443 ssl;
	ssl on;
	server_name VOTREDOMAINE;
	ssl_certificate /etc/letsencrypt/live/VOTREDOMAINE/fullchain.pem;
	ssl_certificate_key /etc/letsencrypt/live/VOTREDOMAINE/privkey1.pem;
	# stop sslV3 and poodle attack
	# see https://www.linode.com/docs/security/security-patches/disabling-sslv3-for-poodle
	# thanks to Matthieu L.
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
}

Puis redémarrer nginx:

service nginx start
# ou pour systemctl
systemctl start nginx

Explications

Le client

Le client letsencrypt ne gérant pas (pour le moment) la configuration automatique de nginx, à moins d’activer le mode expériemental, le mode “standalone” va lui même faire office de service Web le temps de la certification. C’est pour cela qu’il faut couper le service nginx le temps de faire la manipulation.

Donc en appelant letsencrypt-auto --help avant de couper nginx, je m’assure de ne pas couper trop longtemps le serveur avant de lancer la véritable phase de certification. Car le client va installer un certain nombre de dépendances et initialiser un virtualenv.

Ensuite, il suffit de couper le serveur web, et appeler la commande:

letsencrypt-auto certonly --standalone ...

Si vous ne mettez pas les options “–email” et “–agree-tos”, alors le client va vous demander d’entrer un email, et d’accèpter les “terms of service”. Or, il va s’avérer très intéressant d’utiliser les options --email et --agree-tos pour vous permettre de faire le renouvellement dans 90 jours de manuère automatique (un petit script bash).

Ensuite suivent les options “-d” à la chaine pour chaque domaines et sous domaines. Dans mon cas, j’ai certifié:

metal3d.org
www.metal3d.org

Ce qui donne:

./letsencrypt-auto --email secret@...com --agree-tos \
    -d www.metal3d.org  \
    -d metal3d.org

En à peine une seconde la séquence a été effectuée. Les certificats sont générés dans le répertoire /etc/letsencrypt/live/metal3d.org et je n’ai eut qu’à modifier la configuration de nginx.

Et ça marche ?

Oui ! Regardez par vous-même le “https” en vert dans la barre d’url de mon site.

Mais comment ils font ça ?

Let’s encrypt est un projet lancé par la “linux fundation” il y a plus d’un an afin de permettre de faire “passer le web en mode chiffré pour tous” et ce gratuitement. Je dois bien avouer que l’offre alléchante m’avait donné une impréssion de “on va se faire avoir quelque part” et pourtant… il y a 1 mois, j’ai accédé à une beta privée qui a fonctionné sur mon service gitlab.

Comment ils font pour certifier comme ça plus de 11.000 domaines lors de la beta privée sans demander un sou ? Et bien tout se passe coté “sponsors”. Sur la page des sponsors apparaissent Mozilla, Cisco, Akamai et EFF, mais on compte aussi Faceboock, ou encore IdentTrust qui est justement l’autorité de confiance qui a permis de faire fonctionner le projet.

Et aujourd’hui, on y est ! Vous allez enfin pouvoir certifier vos serveurs de manière simple, rapide et gratuite.

Mais où est le vice caché ? et bien il n’y en a pas.

La seule chose que vous devez comprendre c’est que “let’s encrypt” permet de certifier votre connexion SSL/TLS et rien de plus. Enfin “rien de plus” est peu dire, car c’est déjà énorme, c’est ce dont 90% des services ont besoin.

Seuls les systèmes bancaires ou les services dont les données qui transitent entre clients et serveur sont très sensibles ne vont *certainement pas utiliser letsencrypt.

Donc ne vous y trompez pas, “let’s encrypt” est un formidable outil pour avoir accès à des connexions client/serveur sécurisées (tels qu’un site web, un registre docker privé ou des clients particuliers) mais il n’est pas conseillé, à mon humble avis, de l’utiliser pour sécuriser un service de paiement en ligne.

Petit edit de Matthieu L., un ex-collègue, dont le commentaire arrive à générer une erreur 500 (?!), le voici:

Après avoir fait tout cela il est préférable d’avoir une config SSL correct de son serveur. Pour cela on peu se rendre sur un site de Mozilla : https://mozilla.github.io/server-side-tls/ssl-config-generator/

Et après aller sur un autre site pour vérifier que tout est en ordre : https://www.ssllabs.com/ssltest

Par exemple tu as une note «C» seulement https://www.ssllabs.com/ssltest/analyze.html?d=metal3d.org

Effectivement j’ai une note “C” à cause d’une vulnérabilité SSL v3. Je vais mettre en place la configuration générée par l’outil Mozilla proposé par Matthieu et voir si ça bouge :) Merci à Matthieu pour ce commentaire !

Et me voilà en grade B, en virant le sslv3, voir la conf nginx modifiée plus haut.

Atom.io, l'IDE qui me donne presque envie de me passer de vim

Fri, 13 Nov 2015 00:32:28 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Atom.io est un IDE multiplateforme, libre, pratique et modulaire. Bourré de plugins, ergonomique, il entre peu à peu dans mon univers de logiciels à utiliser quotidiennement. À tel point, que je pense à me passer de Vim pour certains projets et utiliser ce dernier. Pouquoi ? bha je vais vous expliquer.

Depuis 2001 que je fais ce métier, j’ai utilisé un bon paquet d’IDE (Integrated Development Environment) tels que Eclipse, PyCharm, Netbeans, et autres Anjuta, etc. Chacun de ces IDE m’ont laissé sur ma fin, certains m’ont énervé, d’autres m’ont juste déçu, et dans tous les cas je suis revenu à Vim. Vim est certes un “editeur” d’un certain point de vue, archaïque pour certains, mais tellement puissant. Vim me permet de développer efficacement avec des plugins qui enlèvent littéralement la complexité d’un tel environnement.

Auto-completion, gestion de Git, terminal intégré (surtout avec neovim), coloration propre, rapide, et utilisable dans mon terminal. Vous me direz “oui mais bon, c’est pas à la portée de tous”, j’en conviens. Cela-dit, en quelques heures, voir quelques jours, Vim s’adopte pour la plupart des gens qui s’y penchent. En gros, quand on y goûte, on a du mal à passer à un autre outil.

Sauf que là… je tombe sur Atom.io, et je doute… oui mesdames et messieurs, je doute !

À première vue

Atom n’est pas l’unique projet à chercher à convaincre. LightTable et Brackets sont deux exemples très proches de SublimeText qui visent à rendre l’environnement de développement “agréable”. Je les ai testé, sans conviction, et je suis revenu (pour les 3) à Vim après quelques heures. Alors pourquoi Atom.io me convainc un peu plus ?

Pourtant, Atom ne paye pas de mine. A première vue on dirait un éditeur “décoré” pour faire “pro”, qui va nous claquer dans les doigts quand on va chercher à faire de l’auto-completion complexe. Par exemple, avec Go, faut utiliser un binaire nommé “gocode” qui permet d’auto-compléter le code. Et je me dis que je vais me marrer quand je vais tenter le coup.

Mais bon, je suis bon joueur, je suis pas du tout fermé et j’aime tester. Donc j’installe “Atom.io” via le RPM fourni, et je lance la bête.

Test 1, on lance allume le jouet

Bon sang… il se lance vite le bougre ! Sérieusement je m’attendais à un chargement de plusieurs secondes, il n’en est rien. Atom a démarré en 1 seconde, la page de “welcome” est pas mal, elle explique en quelques lignes que je vais pouvoir m’amuser à y placer des plugins, des thèmes, etc.

Ça me plait bien ça, je peux directement ajouter des “snippets”, apprendre les racourcis clavier, et l’interface est propre, sans trop de fioritures, en bref c’est simple et beau.

Test 2, on code !

Bon allez j’ai du boulot moi! J’ouvre un projet Go et je me lance dans le code. Hop un fichier ouvert et… arrrggg pas de completion, pas de formatage auto de mon code… Zut et zut.

Ok, j’avoues, pour Vim j’ai du installer un plugin “vim-go”. Donc dans Atom, je vais certainement faire pareil. Allez, sans conviction, je tente. Direction des settings, “install” et je cherche “golang”.

Etonnement ! Des plugins existent. Je vérifie les deux qui me paraissent intéressant: go-plus et go-runtime. Mais en lisant la doc du plugin, je découvre un truc: on a deux façons d’installer un plugin.

Soit en cliquant sur le bouton “installer”
Soit en utilisant la ligne de commande “apm”

Allez, je me fais un kiff, je tente les deux :)

D’abord, “go-runtime” en cliquant sur “install”: ça marche.

J’ouvre un terminal et je tape:

apm install go-plus

Et bha ça marche aussi. Et cerise sur le pompon: pas la peine de redémarrer Atom.

Voyons voir mon code, j’édite mon fichier, je tape le nom d’un objet suivi d’un point et hop, la completion s’active.

Bien, sérieusement bien !

Le racourci qui sauve

Ce qui parrait toujours compliqué sur Vim, c’est l’apprentissage des racourics. J’ai beau adoré mon vieux copain Vim, je ne peux pas mentir en disant que c’est parfois un peu… allez, disons-le, “tordu”.

Mais une chose absolument géniale à laquelle ont pensé les auteurs de Atom, c’est que quand vous démarrez l’IDE “à vide”, c’est-à-dire sans fichier ouvert (ou si vous fermez tous les fichiers), des messages d’astuces défilent sur l’écran. Et je découvre le racourci “CTRL+Maj+P”.

C’est tout bonnement “LE” racourci à connaitre. Il permet de trouver les fonctionnalités classés par plugin.

Les plugins que j’ai adoré

Le premier, vous allez dire que je suis franchement intoxiqué, c’est “vim-mode-plus” qui me permet d’avoir les “racourcis” de vim. Je ne voyais pas comment me passer du racourcis “cit” pour changer le texte “entre tag” d’un fichier HTML. Et je préfère me passer des “CTRL+C CTRL+V”, trouvant “dd”, “p” et “yy” plus accessibles sur mon clavier.

Oui, je sais, il existe plein de plugins pour simuler Vim dans plein d’IDE. Je ne dis pas le contraire, et c’est pas ce qui a fait la différence. Le fait est que sans ce plugin, j’aurais peut-être fermé Atom après quelques heures. Ce plugin a le mérite d’exister.

Sinon, les plugins git:

git-plus
git-control
git-log
merge-conflicts tout simplement impréssionnant, allez voir le gif animé sur la page pour comprendre pourquoi j’adore ce plugin

Le plugin pour avoir un terminal de commande:

terminal-plus

Et comme je vous l’ai dit, pour Go:

Et pour pas péter mon cable, j’ai installé

vim-mode-plus

Il existe énormément de plugins pour vos projets, autocompletion pour Angular, projet Python, etc…

La seule chose qui me manque, mais je suis certain qu’un jour il va apparaitre, c’est le fait de lancer un debugger (Gdb et Pdb). Il existe un plugin pour Gdb mais apparement il n’y a pas de “watcher” (pour voir le contenu de la variable). Donc pour debugger mes programmes en Go, c’est pas gagné à ce jour.

Alors, oui, je l’admet sans problème, Atom me donne presque envie de me passer de vim… Je me tate les amis, je me tate…

Je me tate mais…

Mais voilà… Je me force à utiliser Atom pour lui donner sa chance, pour par mourir bête et parce que je trouve que les développeurs de cet IDE méritent le respect. Cela-dit, j’ai toujours un terminal ouvert dans un coin pour plein de trucs et j’ai le réflexe de taper “vim” pour éditer un code source rapidement.

Impossible à ce jour de me résoudre à passer “tout le temps” par Atom. Vim est ancré dans mes habitudes, je connais tous les racourcis utiles à mon travail…

C’est d’ailleurs un truc qui me travaille sur tous les IDE: les racourcis étranges. Expliquez moi pourquoi je dois faire “CTRL+Shift+X” pour commiter un fichier ? Quelle est la logique derrière le “X” ? Vim a pour lui le fait d’être plus clair à condition de lire une fois la doc. Exemple, je veux “indenter dans le bloc”, je fais “>iB” pour “indent Inside Block”. Quand on comprend la logique de Vim, ça se retient en un rien de temps. Par contre, dans Atom, sans le racourci “CTRL+Shift+P”, pas moyen de retenir la séquence de touches proposée qui n’a pas de valeur sémantique.

C’est bête, mais c’est une des principales raisons qui gâche le plaisir de passer sur un autre IDE. Vous me direz, je pourrais modifier les bindings, mais y’en a tellement.

Mais je vous le dis, sans honte, Atom me donne bien envie de pousser l’expérience plus loin.

Rooter votre Galaxy S6

Thu, 12 Nov 2015 11:33:56 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Après quelques mois d’utilisation de mon Galaxy S6, je me suis retrouvé, comme toujours, dans le besoin de “rooter” mon téléphone pour utiliser ProxyDroid ou avoir des optimisations SD Maid. Jusque-ici, impossible de trouver une méthode qui fonctionne… mais j’ai trouvé! Voici donc comment rooter en quelques minutes (sans exagération) votre Galaxy S6. Cela fonctionne sur un Linux récent, avec le logiciel heimdall.

Avant toutes choses, le traditionnel message qui va me protéger de tout procès:

Je ne peux être tenu responsable de dégradations subies par votre téléphone en suivant les explications de cet article. En suivant ces explications, vous accéptez de ne pas me tenir responsable des problèmes que vous pourriez rencontrer.

Voilà qui est dit.

Rooter son téléphone Galaxy S6 se fait en 4 étapes:

activation du mode développeur
activation du debug USB
démarrage en mode “download'
injection du “boot.img” (root)

Toutes les infos ont été trouvées sur ces pages de highonandroid.

Prérequis importants

Cela fonctionne pour les téléphones Galaxy S6 ayant une version de Android 5.1.1 seulement. Si vous avez une autre version de Android, allez voir cette page qui vous indiquera la marche à suivre et ne suivez pas mon article !

Il faut que vous récupériez le numéro de version de votre téléphone, c’est très important. Dans “Paramètres” » “À propos de l’appareil” vous devez trouver la section “Numéros du modèle”. Notez le !

Allez ensuite sur la page ROOT KERNELS [ANDROID 5.1.1] et téléchargez le fichier qui correspond à votre téléphone.

Vous allez récupérer un fichier “tar” qui contient un fichier “boot.img”, il suffit d’extraire ce fichier dans “/tmp”. Donc à partir de là, je pars du principe que vous avez un fichier “/tmp/boot.img”.

Enfin, il vous faut le logiciel “heimdall”, sur Fedora 22:

sudo dnf install heimdall

Voilà, tout est prêt. On peut commencer !

Activer le mode “développeur”

Il vous faut ce mode activé pour permettre le “debug USB”. Sans cela, impossible de pousser l’image de boot sur votre téléphone. Ce mode s’active simplement.

Allez dans les paramètres de votre téléphone » “À propos du téléphone” (en bas)

Pressez 5 fois sur l’entrée “Numéro de version”, un message va vous indiquer que vous avez activé le mode “développeur”.

Activer le mode “usb debug”

Sans cette étape, le download de boot.img ne fonctionnera pas, vous aurez un message “Protocol initialisation failed”. Si vous l’oubliez, rien de grave, il suffira de redémarrer le téléphone et faire la maniuplation suivante, puis revenir en “démarrage en mode download” expliqué plus bas.

Dans les paramètres » mode développeur, activez “debug usb”

Démarrage en mode “download”

Maintenant, éteignez le téléphone. Quand il est éteind, appuyez, sans relacher les boutons, sur:

volume bas
home (le bouton principal du téléphone en dessous de l’écran)
bouton d’allumage

Le tout, pendant environ 5 secondes.

Le téléphone se retrouve en mode “boot download”, le message vous préviens que vous allez modifier l’OS, c’est ce qu’on veut, donc pressez “volume haut”. Maintenant le téléphone est fin prêt à reçevoir notre nouveau boot root.

Vous pouvez, si besoin, redémarrer le téléphone en pressant de nouveau les 3 boutons “volume bas, home, power” si vous avez un souci (par exemple, si vous avez oublié d’activer le mode debug usb)

Injecter le boot.img

Branchez votre téléphone avec un cable USB.

Dans un terminal:

$ heimdall detect
Device detected
$ heimdall flash --BOOT /tmp/boot.img

Le téléphone va alors récupérer le fichier “boot.img” et redémarrer tout seul. C’est normal ! Attendez qu’il soit bien reparti et tapez votre code PIN. On passe à la vérification.

Vérification

Normalement, vous devez avoir un nouvelle application dans le menu: “SuperSU”. L’icone doit ressembler à un gros dièse.

Voilà, c’est bon, vous avez rooté votre téléphone Galaxy S6.

Optimisons un peu notre Linux en limitant les accès disques

Sun, 01 Nov 2015 17:16:27 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Que vous ayez un SSD ou non, je pense que ce qui va suivre va vous intéresser. Ceux qui ont un SSD vont apprécier le fait de ne pas écrire constamment sur le disque et de tuer son espérance de vie. Et les autres vont aimer le fait d’accélerer l’utilisation de caches. Rien de révolutionnaire ici, nous allons utiliser des RAMDisks et soulager, si vous en avez, nos SSD. Je vous précise que vous n’aurez aucune surprise ici, je vais parler de méthodes vieilles de plusieurs siècles (ok… de plusieurs années) et qui ne sont absolument pas des hacks ou des nouveautés. Rien que du bon sens !

TL;DR

[EDIT] 03/11/2015 - Une modification importante a été ajoutée suite à différents commentaires sur Google+. Ainsi, je vous propose une partie supplémentaire de “sauvegarde de cache”

[EDIT] 03/11/2015 - Bonne remarque dans les commentaires à propos de l’utilisation de “rsync” dans le cas où vous souhaitez sauvegarder vos caches. L’idée est de ne plus supprimer la sauvegarde de cache et de la synchroniser lors de l’extinction/démarrage avec le cache. Voir le point 5 et les explication à propos des caches utilisateurs dans l’article. Merci à Frédéric Thouin auteur de la distribution Viperr.

Je vous demande de prendre tout ce qui suit, y compris les explications, avec des pincettes ! Lisez et comprennez avant de lancer les commandes. Si vous vous loupez, vous pouvez faire planter le redémarrage. Rien n’est irreversible, vous pouvez réparer sans souci mais évitez-vous une crise d’arrachage de cheveux et ne faites rien sans comprendre les commandes et éditions de fichiers qui suivent.

Pour résumer:

utilisez des RAMDisk pour vos caches (cache utilisateur, cache dnf, cache packagekit…) et adaptez la taille max selon votre RAM
utilisez des services pour mettre en place les caches
faites un TRIM régulier sur les disques SSD (si vous en avez un)

Donc rien de spécialement “génial” mais un minimum qui va soulager votre SSD et utiliser votre RAM pour le cache.

Utiliser un RAMDisk pour /tmp même si les gens de chez Debian sont pas d’accord. C’est déjà le cas sur Fedora, sinon:

Vérifiez que tmp n’est pas déjà monté en ramdisk:
```
$ mount | grep /tmp
tmpfs on /tmp type tmpfs (rw,seclabel)
```
Notez bien que “seclabel” est ajouté par SELinux, ne le mettez pas vous-même. Il sera ajouté par SELinux.

Si le répertoire “/tmp” nest pas monté, éditez /etc/fstab et ajoutez la ligne:
```
tmpfs       /tmp    tmpfs   rw     0   0
```
Pensez à supprimer le contenu de /tmp AVANT de monter /tmp,

Montez les caches utilisateurs dans un ramdisk

Fermez toutes les sessions, allez ensuite dans un tty (CTRL+ALT+F1) et connectez-vous en root:

for c in /home/*; do
    mv $c/.cache $c/oldcache
    echo -e "tmpfs\t$c/.cache\ttmpfs\tnoatime,nodev,nosuid,size=500M\t0\t0" >> /etc/fstab
    mount $c/.cache
    mv $c/oldcache/* $c/.cache
    rm -rf $c/oldcache
done

Placez les caches dnf et PackageKit dans un ramdisk

systemctl stop PackageKit
rm -rf /var/cache/PackageKit/*
rm -rf /var/cache/dnf/*
echo -e "tmpfs\t/var/cache/PackageKit\ttmpfs\tdefaults,noatime\t0\t0" >> /etc/fstab
echo -e "tmpfs\t/var/cache/dnf\ttmpfs\tdefaults,noatime\t0\t0" >> /etc/fstab
mount /var/cache/PackageKit
mount /var/cache/dnf
systemctl start PackageKit

Créez un service pour charger le cache dnf quand le réseau est prêt

Créez le fichier /etc/systemd/system/mydnfcache.service:

[Unit]
Description=DNF cache creation 
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/usr/bin/dnf makecache

[Install]
WantedBy=multi-user.target

Activez le service pour qu’il démarre au prochain redémarrage, et lancez le service:

systemctl enable mydnfcache
systemctl start mydnfcache

Si vous souhaitez sauver vos caches, par exemple pour PackageKit qui, lors d’une mise à jour, va redémarrer et en plus retrouver le cache, vous pouvez faire ceci:

Créez un script de sauvegarde de cache /usr/local/bin/savecaches.sh:

#!/bin/bash

PKGKIT=/var/cache/PackageKit
DNF=/var/cache/dnf

# create backup for PackageKit and dnf
[[ -d  ${PKGKIT}.bkp ]] || mkdir -p ${PKGKIT}.bkp
[[ -d  ${DNF}.bkp ]]    || mkdir -p ${DNF}.bkp

case $1 in

	restore)
		# move backup to real cache
		for c in $PKGKIT $DNF; do 
			rsync -ra --delete-after ${c}.bkp/ ${c}/
		done
		;;

	save)
        # restore backup cache
        for c in $PKGKIT $DNF; do 
            rsync -ra --delete-after ${c}/ ${c}.bkp/
        done
        ;;

esac

Créez un “unit” systemd qui démarrera avant PackageKit, /etc/systemd/system/cachesave.service

[Unit]
Description= Save caches at shutdown - reset cache at startup
Before=packagekit.service packagekit-offline-update.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStop=/bin/bash /usr/local/bin/savecaches.sh save
ExecStart=/bin/bash /usr/local/bin/savecaches.sh restore

[Install]
WantedBy=multi-user.target

Puis activez le service

sudo systemctl enable cachesave
sudo systemctl start cachesave

Vous pouvez aussi créer un “unit” pour vos caches utilisateurs en suivant le même modèle. Voir l’article…

Si vous avez un SSD, vérifiez qu’il accèpte la commande “TRIM” - si oui:
```
systemctl start fstrim.timer
systemctl enable fstrim.timer
```

Voilà, un conseil maintenant: redémarrez votre machine. Tout devrait bien se passer.

Ok, tu m’expliques ?

Le TL;DR est conséquent mais je pense que quelques explications peuvent vous aider à comprendre.

Le but de toutes ces opérations est simple: utiliser un peu plus la RAM que ce qui est prévu par défaut. En effet, Linux (du moins les distributions Linux) a l’intérêt de pouvoir tourner sur des petits systèmes avec très peu de RAM. Mais dans la plupart des cas, les postes utilisateurs sont plutôt caustauds.

J’entend par là que vous avez certainement pas mal de mémoire RAM (plus de 4Go, certains se balladent avec plus de 32Go de RAM…) et que celle-ci est finalement pas exploitée complètement. Or, la RAM est très rapide, bien plus que votre HDD traditionnel, et plus rapide que les SSD actuels.

Donc, si vous avez un poste assez récent, vous pouvez utiliser la RAM comme “disque dur temporaire”.

C’est justement ce que nous appelons un RAMDisk.

Mais utiliser un RAMDisk a une conséquence non négligeable… il se vide quand la machine est éteinte. Et par conséquent, il va falloir faire quelques réglages.

Ensuite, les gens ayant un SSD tremblent face à leur durée de vie dite “limitée”… utiliser quelques RAMDisk va calmer un peu vos frayeurs.

Les RAMDisk

Sous Windows, c’est pas drôle à faire. Enfin j’en sais rien mais de ce que j’en ai lu sur le net, il faut installer un logiciel, paramétrer des trucs à la souris… franchement j’ai remercié le ciel d’être sous un Unix Like (et pourtant je ne suis pas croyant)

Un RAMDisk n’est pas un disque dur à brancher sur votre système. C’est bêtement un disque temporaire accessible comme un répertoire (comme tout périphérique sous Linux) dont le contenu est écrit en RAM.

Il y a déjà pas mal de RAMDisk préconfigurés sur votre distribution. Depuis quelques années, le répertoire /dev/shm (shared memory - mémoire partagée) est justement un répertoire donc le contenu est en RAM. Certains programmes écrivent dedans pour partager des informations sans avoir à écrire sur le disque. C’est effectivement très simple d’écrire un fichier contenant des informations.

Le système de montage est “tmpfs” ou “ramfs”. La différence entre les deux est simple: si la RAM est saturée, un point de montage TMPFS va “swapper”, c’est-à-dire utiliser votre disque dur temporairement, le temps que de la place se libère. Alors que le RAMFS va misérablement bloquer. C’est débile ? non, c’est voulu ! RAMFS est surtout utilisé pour des programmes qui ne veulent surtout pas toucher au disque.

Pour nous, humbles utilisateurs, TMPFS est bien plus sécurisé.

Si vous voulez tester, créer un répertoire /mnt/testramdisk et montez un espace tmpfs dessus:

mkdir /mnt/testramdisk
mount -t tmpfs tmpfs /mnt/testramdisk

Voilà, si vous écrivez dans ce répertoire, et bien le fichier sera dans la RAM, et il ne sera pas écrit sur votre disque dur. Y accéder est très rapide ! Bien plus que depuis votre disque dur.

Alors attention, écrire un fichier de 4Go dans le répertoire, alors que vous avez 2Go de RAM va effectivement déborder ! C’est pourquoi on doit:

limiter la taille du ramdisk
éviter de les utiliser pour tout et n’importe quoi si on a peu de RAM

Une option intéressante au point de montage est justement “size”. Testons:

umount /mnt/testramdisk
mount -t tmpfs tmpfs /mnt/testramdisk -o defaults,size=1Mo

Le disque ne fait que 1Mo, essayez de déposer un fichier de plus de 1Mo et le message est sans appel “no space left on device”. C’est une sécurité nécessaire, croyez-moi.

Allez, on nettoie et on passe à la suite:

umount /mnt/testramdisk
rm -rf /mnt/testramdisk

Montage des caches

Il existe un paquet de “caches” sur votre installation.

les répertoires utilisateurs “home” ont un répertoire “.cache” dans lequel écrivent Google Chrome, Firefox, Gnome, votre client mail…
des répertoires systèmes pour dnf, packagekit, et j’en passe…

Un cache est un espace qui peut être effacé sans affecter vos données. J’insiste, si un programme plante quand le cache est vidé, alors ce programme est mal foutu. Personnellement je n’en connais pas… Soit dit en passant, il convient de ne pas vider le cache d’un programme qui est en train de l’utiliser. Non pas que ce soit grave, mais il sera peut-être nécessaire de le redémarrer pour qu’il réinitialise le cache.

Bref, on a de la RAM, on va faire en sorte que notre utilisateur arrête d’écrire sur le disque le cache. J’ai vérifié ce que mon utilisateur en cours utilise dans $HOME/.cache. Je ne dépasse pas les 200Mo par session. Je me prends un marge et j’estime que sur mes 8Go de RAM, je peux utiliser 500Mo pour mon utilisateur.

Donc, j’édite /etc/fstab et je mets:

tmpfs   /home/metal3d/.cache    tmpfs   noatime,nodev,nosuid,size=500M      0       0

Évidemment, vous remplacerez “metal3d” par votre nom d’utilisateur…

Les options que j’ai utilisé:

noatime parce que je n’utilise pas de logiciel qui se basent sur la date d’accès au fichier
nodev hors de question de mettre des périphériques dans le cache
nosuid pour ne pas les bits suid - inutile dans le cache
size=500Mo pour autoriser 500Mo maximum dans le cache

Ne montez pas le disque de suite, il faut vider le répertoire avant de le monter. Car si vous montez le disque de suite, le contenu sera toujours présent sur le disque mais inaccessible - à moins de démonter le cache. Donc au lieu de perdre bêtement cet espace, on va couper la session Gnome (ou KDE, ou XFCE…) et allez dans un TTY (CTRL+ALT+F1) pour s’y connecter en “root”. Puis on supprime ce cache, et on le monte:

rm -rf /home/metal3d/.cache/*
mount /home/metal3d/.cache

Évidemment, vous remplacerez “metal3d” par votre nom d’utilisateur…

Voilà, vous pouvez vous reloguer sur Gnome…

On va en faire autant pour les cache dnf et PackageKit

Dans /etc/fstab:

tmpfs   /var/cache/dnf              tmpfs   defaults,noatime        0   0
tmpfs   /var/cache/PackageKit       tmpfs   defaults,noatime        0   0

On fait pareil que pour les users, on vide le répertoire et on le monte. Par contre, on coupe le service PackageKit avant, histoire de ne pas lui couper la chique en plein milieu d’une opération.

systemctl stop PackageKit
rm -rf /var/cache/PackageKit/*
rm -rf /var/cache/dnf/*
mount /var/cache/dnf
mount /var/cache/PackageKit
systemctl start PackageKit

Voilà qui est fait !

Réparer PackageKit

[EDIT] partie ajoutée le 03/11/2015

Un souci va apparaitre, si vous décidez d’utiliser PackageKit pour vos mises à jour, il va y avoir un effet de bord très important: ça ne marchera plus.

La raison est la suivante: l’interface vous propose de redémarrer. Or, en redémarrant, le RAMDisk est supprimé et les RPMs qui ont été téléchargés sont perdus. Vous avez alors trois possibilités:

vous ne mettez pas /var/cache/PackageKit en RAMDisk
vous utilisez “dnf update” au lieu de rebooter
vous sauvegardez le cache lors de la fermeture, et vous le récupérer en RAMDisk au démarrage

Pour le troisième point, il suffit de faire un script et un fichier “unit”. Le script est simple et à placer, par exemple dans “/usr/local/bin/savecaches.sh”:

[EDIT] Utilisation de rsync - plus de suppression du backup en dur. La synchro est plus rapide et limite l’accès disque (ainsi que les écritures).

#!/bin/bash

PKGKIT=/var/cache/PackageKit
DNF=/var/cache/dnf

# create backup for PackageKit and dnf
[[ -d  ${PKGKIT}.bkp ]] || mkdir -p ${PKGKIT}.bkp
[[ -d  ${DNF}.bkp ]]    || mkdir -p ${DNF}.bkp

case $1 in

	restore)
		# move backup to real cache
		for c in $PKGKIT $DNF; do 
			rsync -ra --delete-after ${c}.bkp/ ${c}/
		done
		;;

	save)
        # restore backup cache
        for c in $PKGKIT $DNF; do 
            rsync -ra --delete-after ${c}/ ${c}.bkp/
        done
        ;;

esac

Basiquement, appeler ce script avec un argument “save” va sauver le cache sur le disque dur, et l’argument “restore” va simplement le remettre en RAM (et supprimer le répertoire du disque dur).

Maintenant, on va créer un fichier “unit”, je vais expliquer après à quoi servent les directives intéressantes. Le fichier à créer est “/etc/systemd/system/cachesave.unit”:

[Unit]
Description= Save caches at shutdown - reset cache at startup
Before=packagekit.service packagekit-offline-update.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStop=/bin/bash /usr/local/bin/savecaches.sh save
ExecStart=/bin/bash /usr/local/bin/savecaches.sh restore

[Install]
WantedBy=multi-user.target

C’est assez simple:

RemainAfterExit=yes signifie que quand la commande ExecStart a fonctionné, on garde l’état “actif” afin de ne pas le redémarrer en cas de dépendance.
ExecStart=… lance la commande au démarrage du service, donc dans notre cas ce sera quand packagekit ou packagekit-offline-updown aura démarré (et pas avant)
ExecStop=… lance cette commande quand le service est éteint, donc quand la machine redémarre ou s’éteind

On perd un peu de l’optimisation d’écriture pour les SSD, car pour le coup nous allons écrire réellement des fichiers sur le disque. Mais en l’occurrence, vous aurez quand même une belle optimisation de lecture des paquets lors du dépaquetage à la mise à jour.

Si en plus, comme moi, vous éteignez rarement votre PC, la sauvegarde du cache sera rare.

Et pour mes caches utilisateurs ?

[EDIT] partie ajoutée le 03/11/2015

[EDIT] utilisation de rsync pour limiter les écritures/accès disque et optimiser la vitesse de synchro - plus de suppression de backup en dur.

Effectivement vous pouvez avoir envie de faire pareil pour vos caches utilisateurs. Le principe reste le même: vous créer un script qui sauve tous les répertoires “/home/*/.cache” dans “/home/*/.cache.bkp” et inversement. Par exemple dans “/usr/local/bin/savehomecaches.sh”:

CACHE=.cache
BACKUP=.cache.bkp

# commands
case $1 in
    save)
        for c in /home/*; do
            # create backup cache directory if not exists an
            # ensure that owner is correct
            if [[ ! -d ${c}/${BACKUP} ]]; then
                mkdir -p ${c}/${BACKUP} 
                chown -R $(stat -c "%U:%G" $c) ${c}/${BACKUP}
            fi

            # synchronize cache to backup
            rsync -ra --delete-after ${c}/${CACHE}/ ${c}/${BACKUP}/
        done
        ;;

    restore)
        for c in /home/*; do
            # synchronize backup to cache
            rsync -ra --delete-after ${c}/${BACKUP}/ ${c}/${CACHE}/
        done
        ;;
esac

Et pour l’unit:

[Unit]
Description=Home cache backup/restore

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStop=/bin/bash /usr/local/bin/savehomecaches.sh save
ExecStart=/bin/bash /usr/local/bin/savehomecaches.sh restore

[Install]
WantedBy=multi-user.target

Ici, plus besoin d’attendre les services PackageKit. Donc on ne met pas de “Before” dans l’unit. La synchronisation va se faire, bha, quand ça peut se faire… Mais rapidement, bien avant que vous ne vous loguiez à Gnome.

Bref, encore une fois, vous allez écrire sur votre SSD, ce qui induit une usure (voir la suite de l’article). C’est donc une opération propre à de l’optimisation lors de l’utilisation de votre machine, mais pas pour la réduction d’usure du SSD. Dans le même temps, il est clair que cette opération de sauvegarde de cache sur le SSD n’est pas pire que si vous ne mettiez pas de RAMDisk.

Donc, pas de panique.

Et puisque j’ai modifié l’article en fonction des commentaires, et que j’utilise rsync, et bien le ressenti sur le disque est encore adouci. Une nouvelle fois, merci à Frédéric Thouin pour cette idée !

Recharger le cache au démarrage pour DNF

La commande “dnf” se met à jour si le cache est vide ou s’il est trop vieux. Le souci c’est que nous le vidons à chaque redémarrage, donc la prochaine fois que vous allez demander une mise à jour ou une installation, et bien “dnf” va télécharger les informations de dépôts.

PackageKit le fait avec un service… on va en faire autant.

À tous ceux qui ont bavé sur systemd, je vous mets au défi de faire ce que je vais faire en si peu de caractères. C’est-à-dire de faire en sorte que le cache se charge quand on a accès au net, au démarrage du système.

Créez un fichier /etc/systemd/system/mydnfcache.service:

[Unit] 
Description=DNF cache creation 
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/usr/bin/dnf makecache

[Install]
WantedBy=multi-user.target

Et activez-le pour le démarrage:

systemctl enable mydnfcache

Pour le lancer de suite:

systemctl start mydnfcache

Voilà… c’est fini.

Tu chipotes pas un peu ?

Certains me disent à propos de mes montages en RAMDisk:

À comparer du nombre de trucs écrits par ton OS par rapport à tes écritures, tu te fais suer pour rien.

Ma réponse est la suivante:

Non, je ne chipote pas. D’une part monter des RAMDisk est super simple et mon paramétrage ne bouge pas. J’ai passé 5 minutes à toucher mon fstab, ça vaut le coup.

D’autre part, le nombre de fichiers que j’écris, même involontairement, est très conséquent. On parle de plusieurs gigaoctets par jour. Entre le cache navigateur, le cache de mails, les pages web et mes développements, l’intérêt des caches montés dans un tmpfs (ramdisk) est franchement loin d’être insignifiant.

À vous de voir… Si vous pensez que j’ai tort, ne faites rien de ce que je dis, après tout ce n’est que mon avis.

Et au fait, mon SSD ?

Un SSD ça fait peur quand on l’achète. Oui c’est super rapide, ça soulage vraiment, et le confort de travail est réellement augmenté. Honnêtement, démarrer un PC en moins de 3 secondes, charger des programmes conséquents en un instant et voir enfin son CPU ne plus être bridé par les lectures disque, ça change la vie. Et je pèse mes mots.

Mais tous les articles du net que j’ai lu me sortaient que

la durée de vie allait décroitre à mesure que j’allais écrire sur mon disque
ça allait être de plus en plus lent
j’allais devenir stérile
mes ongles allaient prendre feu
je serai voué à écouter du Céline Dion jusqu’à la fin des temps…

Et vraiment, Céline Dion, je peux pas…

Un SSD n’a pas de mécanique comme sur les HDD traditionnel (on dit “mécanique”). Un HDD a une série de disque magnétiques en rotation. La tête de lecture lit les “blocs” quand ils passent au dessous. Donc il faut un temps pour que le disque se trouve sous la tête afin qu’un bloc soit lut. Et pour reconstituer un fichier, il faut lire plusieurs centaines, voir plusieurs miliers de blocs. C’est lent…

Un SSD par contre n’a pas ces soucis. Il ne contient que de l’électronique. C’est comme si vous aviez un bloc de RAM dont la mémoire ne s’efface pas quand on coupe le courant. Sans la mécanique, les temps de lecture/écriture sont très rapide. On parle de plusieurs centaines de fois plus rapide ! Vous imaginez bien (si vous n’avez pas de SSD) le gain de performance, les temps de démarrages ou encore le gain significatif de batterie pour les portables puisque nous n’avons pas de moteur à faire tourner.

Pourquoi cette frayeur répandue sur ces articles ? Aurai-je eu tort d’acheter mon SSD ? Je vous le dis de suite, faut arrêter d’avoir peur. D’une part parce que votre SSD va tenir bon pendant quelques années, et surtout parce qu’on peut réduire les risques. D’abord avec les RAMDisk (puisqu’on ne va pas écrire sur le SSD) et ensuite en suivant quelques réglages que je vais vous donner. Bon ça sera pas le sauvetage du siècle, mais ça peut franchement augmenter la durée de vie selon votre utilisation. Mais d’abord, un peu de théorie.

1 ko à pied, ça use, ça use…

En gros, le souci du SSD, c’est que quand vous écrivez sur un block, ce dernier s’abîme… et après 100.000 écritures environ, ce block de 4ko sera inutilisable.

Vous pouvez d’ailleurs connaitre l’état d’usure (wearout) de votre disque, simplement avec la commande “smartctl” fourni dans le paquet “smartmontools”:

sudo smartctl -a /dev/sda

Cherchez la ligne “Wear_Leveling_Count” ou contenant “Wear” (parfois ça change d’une verison à l’autre de smartctl). Vous verrez alors plusieurs colones. La colonne “VALUE” indique son état de vie. Donc une valeur de “100” indique que vous avez “100%” de la capacité de vie.

À partir de 20%… je vous conseille fortement de sauvegarder vos données et de rapidment aller acheter un autre disque dur.

Continuons…

Pour éviter d’abïmer rapidement les blocks en effacant les valeurs qui s’y trouvent, les constructeurs ont eut une idée fabuleuse: ne pas écrire dedans quans on a des blocs propre plus loin. Par con hein…

Attention je vulgarise (et ça va rester un peu confus pourtant):

Quand on efface un fichier, on indique simplement que, sur le disque, les blocs utilisés pour ce fichier sont “libres”. On efface pas vraiment le contenu, c’est la table des matières qui n’a plus l’index pour ce contenu.

Si vous voulez maintenant écrire un nouveau fichier, on va aller sur le bloc libre et écrire une donnée. Or, à force de faire cela, on va user les premiers blocs plus vite que les derniers. Donc pour éviter cette usure, le contrôleur de disque va chercher des blocs qui ne contiennent pas de valeur (des blocs avec aucune charge). Et pour ce faire, il va tester les blocs qu’il trouve en chemin. Si le bloc n’est pas utilisé par une resource et qu’il a une valeur nulle, alors il peut l’utiliser. Sinon, il en cherche un autre, et un autre, etc… car il ne veut pas abîmer les blocs en écrivant “null” (vidage de charge) et en chargeant le bloc ensuite. C’est pas idiot, croyez moi, c’est même très intelligent.

Mais cela induit un effet de bord: le contrôleur va devoir tester chaque bloc pour vérifier s’il est vide dans les zones où la donnée est considéré comme “effacée”. Et ça, ça ralenti le système. Plus vous créez et supprimez des fichiers, plus ça ralenti les process. Donc, il faut de temps en temps faire en sorte que le contrôleur ne se prennent pas la tête à vérifier tous les blocs.

Fin de la théorie, on passe à l’action.

TRIM

L’idée est donc de soulager ces tests de temps en temps en mettant vraiment un zéro (en vidant la charge) sur les blocs qui ont reçu un jour une donnée et dont on a supprimé le contenu. C’est ce que nous appelons un “TRIM”. Pour simplifier, on va chercher tous les blocs du disque, vérifier s’ils sont utilisés par une ressource (fichier) et mettre “null” dedans (vider la charge) si ce n’est pas le cas. Par conséquent, le contrôleur va pouvoir écrire dedans sans avoir à l’éffacer, et il ne va pas chercher d’autres blocs libres.

Pour vérifier si vous pouver “trimer” votre disque:

$ sudo hdparm -I /dev/sda | grep -i trim 
 *  Data Set Management TRIM supported (limit 8 blocks)

Si vous n’avez pas de ligne qui apparait… bha désolé pour vous.

Sur Fedora, et certainement d’autres distributions, il existe un service systemd qui va le faire pour vous:

systemctl enable fstrim.timer
systemctl start fstrim.timer

Sinon, si vous n’avez pas ce service, vous pouvez le faire vous-même.

Sous linux, la commande “fstrim” va donc faire le “TRIM”. D’ailleurs le service systemd “fstrim” ne fait ni plus ni moins qu’un “fstrim -a” toutes les semaines.

Donc, si vous n’avez pas ce service sur votre système, vous pouvez créer une tâche “cron” qui s’en occupera.

Selon le nombre d’écritures sur le disque, vous pouvez placer le script suivant dans /etc/cron.weekly ou /etc/cron.daily. La recommandation est “weekly” à moins que vous ayez vraiment un nombre très conséquent d’écritures disques

Le script /etc/cron.weekly/fstrim:

#!/bin/sh
LOG=/var/log/fstrim.log
echo "===" $(date -R) "===" >> $LOG
fstrim -a 2>&1 >> $LOG

Rendez-le exécutable:

chmod +x /etc/cron.weekly/fstrim

Tous les dimanches à minuit, ou au prochain démarrage si cette date est passée et que la machine n’était pas active, un “TRIM” est fait sur le disque.

Quelques autres idées

Les RAMDisk sont faciles à créer. Personnellement quand je bosse sur un développement qui génère des fichiers temporaires, je me débrouille pour écire dans “/tmp” ou mon “.cache” personnel. Mais parfois ce n’est pas facile de changer le comportement de l’outil de génération.

Si, et seulement si les fichiers générés sont jetables, vous pouvez repérer simplement le répertoire de sortie de ces fichiers et monter un ramdisk.

Je prends un exemple… on bosse avec gulp qui génère des fichiers temporaires dans un répertoire “.tmp”, lui-même contenu dans le répertoire du projet. Comme on est 5 à bosser dessus, et qu’on est pas tous sur le même OS, on impose pas l’écriture dans “/tmp”. Du coup, je monte un disque:

rm .tmp/*
sudo mount -t tmpfs tmpfs $(pwd)/.tmp 
gulp serve

Le résultat est que je n’écris pas ce cache sur le disque. Je n’impacte pas mon SSD et en plus l’accès est bien plus rapide.

Idem avec les “builds”, les fichiers n’ont pas vocation de rester sur mon disque dur. Je prend l’exemple de mon blog (développé en Go). J’ai un paquet de css à minifier dans un fichier. Et bien je monter un disque tmpfs dans un coin et j’écris dedans. Quand je teste mon application, l’accès à ce fichier est rapide et je n’impacte pas mon SSD…

Bilan

Personnellement j’ai ressentis les effets des caches utilisateurs avec l’utilisation d’un HDD traditionnel, moins avec un SSD. Quand je dis “moins”, je ne veux pas dire “pas du tout”. Simplement qu’en toute logique, le ressenti est plus léger car les accès disques SSD sont très rapides.

Donc, pour commencer, que vous soyez avec un SSD ou non, de toutes manières je vous recommande de monter des RAMDisk pour les données temporaires - la vitesse de lecture en RAM va relativement soulager votre travail. Pensez à utiliser “/tmp” et (si vous avez suivi mon article) votre répertoire “~/.cache”. Montez à la volée des RAMDisks.

Niveau mémoire, l’ensemble de mes RAMDIsks prennent 1Go réel sur mes 8Go de RAM. Htop ne me montre pas de niveau alarmiste, bien au contraire - et j’en suis toujours étonné.

Le fait d’avoir mis un cache sur PackageKit et dnf a largement accéleré les grosses mises à jour, par contre il faut avouer que pendant la mise à jour l’utilisation de la RAM grimpe en flèche. Logique, l’ensemble des RPM se trouve dans le cache pendant l’installation, et par conséquent dans la RAM puisque le répertoire est un RAMDisk. Donc clairement, il vous faut de la RAM, un minimum de 4Go pour ne voir le pc ralentir pendant une mise à jour, et je pense que 8Go est le minimum recommandé pour ne pas avoir trop de ressenti. Au prix de la RAM, ne nous privons pas. Cela soulage le SSD, ça soulage les nerfs des propriétaires de HDD et c’est franchement facile de configurer des RAMDisk sous Linux du moment où on comprend comment les monter.

Personnellement, je réfléchis à mettre encore d’autres répertoires en RAM, et à me payer 16Go, voir 32Go de RAM…

Quant au TRIM, et bien je ne peux pas trop vous dire ce qu’il en est. J’ai suivi des recommandations, je n’ai pas de points de comparaisons sous la main. Si vous en avez, contactez moi, commentez l’article, bref, tenez-moi au courant.

Un exemple Golang de résolution de tâche parallèle

Fri, 30 Oct 2015 01:41:33 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

J’ai participé aux BlendWebMix 2015 en tant que “speaker” avec un grand plaisirs. J’y ai présenté “Golang pour le web” afin d’expliquer comment ce langage est en train d’entrer dans les moeurs et va permettre de développer des applications Web performantes. Je vais vous montrer un exemple que j’ai traité lors d’une démo improvisée le lendemain sur un coin de bureau. Le fait est qu’on m’a beaucoup parlé après la conférence au stand “Smile” et qu’une question récurrente m’était posé: “As-tu un exemple concret que je ne peux pas résoudre en PHP par exemple, dans mon application/site Web ?”. J’en avais quelques-uns, et j’ai décidé de montrer le suivant: des miliers de personnes veulent remplir un formulaire de contact en simultané, comment je vais gérer tout ça en parallèle sans planter mon serveur de mail SMTP ? Voilà la démo, revue et corrigée.

Pour remettre les choses dans leur contexte, la conférence présentait le développement d’un prototype de site avec Martini. Mais j’ai laissé entendre que Go pouvait permettre la résolution de tâche concurrente de manière simple. Bien entendu les connaisseurs du langage savent très bien que toute la saveur de Go se trouve dans ce principe de gestion et de synchronisation de “goroutines”.

J’ai donc improvisé une démo hors conférence le lendemain en 10 minutes, entre deux pilones, sur un coin de bureau. Et comme je suis un éternel insatisfait (laissant une coquille en fin de démo pour avoir le temps de conclure), je ne peux pas aller dormir sans mettre au clair mon explication. La voici.

Mettre le contact

Prenons un exemple de page de “contact” qui permet d’envoyer un mail à un destinataire. La fonction qui va récupérer le formulaire ressemblerait à cela (avec mon framework Kwiscale):

// je passe le détail du handler, 
// on traite ici la méthode "POST" 
func (handler *ContactHandler) Post() {
    from := handler.GetPost("from")
    message := handler.GetPost("message")
    
    // on envoie le message
    sendMail(from, message)
    
    //on signale que c'est ok
    handler.Redirect("/contact/ok")
}

Pour clarifier, bien que ce soit peu utile à mon avis, on récupère les champs de formulaire “from” et “message” et on appelle la fonction “sendMail()” (que nous allons coder plus bas), puis on signale à l’utilisateur que le message a été envoyé.

La fonction “sendMail()” peut être simulée par une tâche longue, par exemple ici on va faire en sorte qu’elle prenne 3 secondes à s’exécuter:

func sendMail(from, message string) {
    log.Println("Envoi du message...")
    time.Sleep(3 * time.Second)
    log.Println("Message envoyé !")
}

Que va-t-il se passer ?

L’utilisateur va remplir son formulaire, cliquer sur “Envoyer” et attendre sagement 3 secondes que le mail parte pour enfin voir un message lui signifiant que le message est envoyé.

Ce fonctionnement est répandu… et complètement idiot…

Attendre est inutile

Qu’on soit clair. En PHP (pour ne citer que lui) vous déroulez le code en partant du haut vers le bas sans vous poser de question. C’est simple, clair mais pas efficace. Si la connexion au serveur SMTP est contrainte, lente, foireuse, ou je ne sais quel adjectif employer, vous allez faire poireauter l’utilisateur pendant des plombes. Et pendant tout ce temps vous avez votre handler (ou votre controlleur) qui traine des pieds dans la mémoire. C’est encombrant et ça sert strictement à rien.

La plus efficace des solutions consiste à envoyer le mail dans une tâche concurrente, ce que nous appelons une “goroutine” en Go, et que PHP (je suis désolé de lui casser du sucre sur le dos) ne sait (à ce jour) pas faire “facilement”.

En go, c’est simple: on ajoute le fabuleux mot clef “go” devant l’appel:

// je passe le détail du handler, 
// on traite ici la méthode "POST" 
func (handler *ContactHandler) Post() {
    from := handler.GetPost("from")
    message := handler.GetPost("message")
    
    // on envoie le message *en parallèle*
    go sendMail(from, message)
    
    //on signale que c'est ok
    handler.Redirect("/contact/ok")
}

Cette fois, la redirection est faite alors que le mail est en cours de traitement. Que l’envoi foire ou pas !

Question très pertinente d’un de mes auditeurs “oui mais si le mail ne part pas, on ne peut pas prévenir l’utilisateur et gérer le problème dans notre éxécution principale”.

Je suis d’accord avec le principe mais pas sur l’approche, ma réponse est la suivante:

L’utilisateur ne saurait quoi faire de l’erreur. La routine peut gérer l’erreur dans son coin en sauvegardant le message quelque part, en déportant une nouvelle tentative d’envoi plus tard, en loguant l’erreur pour les admins. Mais en aucun cas l’utilisateur n’a besoin de savoir, ici dans notre cas, que le mail est bien parti, il s’en moque je dirai, pire ça le génerai. Je suis conscient que parfois vous aurez besoin de traiter l’erreur et de faire un retour visuel à l’utilisateur. Mais dans bien des cas, et c’est notre cas, ce n’est absolument pas pertinent puisque nous sommes en mesure de gérer ces plantages sans embêter l’utilisateur.

Ça suffit ?

Dans 90% des cas, cette simple modification suffit.

Mais imaginons maintenant que nous ayons une contrainte de volume. Par exemple, nous savons que nous allons avoir des centaines d’utilisateurs qui vont se connecter en même temps et tenter d’envoyer un mail avec notre formulaire de contact.

Ces centaines de mail vont être traités en même temps, dans autant de goroutines que de message à envoyer. Et ça, c’est pas bon pour les nerfs de notre serveur SMTP.

Il va falloir “mettre en queue” les messages et envoyer un nombre limité de mails en simultané.

J’ai déjà tenté de résoudre ce souci en Python, ça a été épique mais pas insurmontable. En PHP je n’ai pas de solution simple qui me vienne à l’esprit. En Go par contre, c’est limpide.

Faites la queue !

Le principe:

la fonction “sendMail()” ne va plus envoyer directement le message mais déposer le message dans un canal ("chan")
on va lancer une goroutine qui va lire le canal en continu et envoyer les mails au fur et à mesure
voilà…

Donc on commence par notre “consomateur de message”:


// une structure pour mieux empaqueter le message.
type Mail struct {
    From string
    Message string
}

// on crée un canal de mails.
// Pour des questions de perd, on va utiliser l'adresse de la structure
// et non pas la valeur. Donc "*Mail" => pointeur.
var mailsQueue = make(chan *Mail)

// la fonction qui va traiter les messages.
func MailSender(){
    // lit continellement le canal et traite le message
    for mail := range mailsQueue {
        time.Sleep(3 * time.Second)
        log.Println("Message envoyé", mail.From, mail.Message)
    }
}

A noter que j’aurai put écrire:

// la fonction qui va traiter les messages
func MailSender(){
    // lit continellement le canal et traite le message
    for  {
        mail <- mailsQueue
        time.Sleep(3 * time.Second)
        log.Println("Message envoyé", mail.From, mail.Message)
    }
}

On modifie maintenant “sendMail”:

func sendMail(from, message string) {
    log.Println("Envoi du message...")
    mailsQueue <- &Message{from, message}
}

On envoie donc notre pointeur sur “Message” (l’adresse…) dans la queue, et on attend que le canal soit lut pour quitter la fonction.

Rappelez vous que dans notre handler nous avons lancé “sendMail()” en tant que “goroutine”. Donc, même si “mailsQueue” est plein à craquer, on a déjà répondu à l’utilisateur que le mail est traité.

On aura bien des centaines de goroutines qui vont attendre de pouvoir écrire dans le canal mais ça ne coute pas grand chose. Une goroutine ne prend que quelques kilo-octets en mémoire. Ce qui compte c’est que nous n’aurons pas des centaines de connexions simultanées sur notre SMTP.

Bref, il reste un dernier point, lancer autant de “MailSender” qu’on veut pour gérer l’envoi en simultané. On peut le mettre dans notre fonction “main”:

func main(){
    // on lance 10 MailSender en parallèle 
    // et on passe à la suite
    for i := 0 ; i < 10; i++ {
        go MailSender()
    }
    
    // on lance notre service web
    kwiscale.NewAppFromConfig()
    kwiscale.ListenAndServe()
}

C’est fini.

Nous avons 10 goroutines qui tentent de lire le canal “mailsQueue”.
Quand un client poste un message, on crée une goroutine “sendMail()” qui envoie un “Mail” dans “mailsQueue”
On répond tout de suite au client que le mail est traité, sans attendre la fin de la goroutine
Pendant ce temps (à Veracruz) “MailSender” lit le canal et envoie le message

Si 11 clients appuient en même temps sur “Envoyer” de notre formulaire:

Les 10 premiers appels vont ajouter un “Mail” dans le canal “mailsQueue”
Les 10 goroutines “MailSender” en parallèle vont lire le canal “mailsQueue” et traiter la demande pendant 3 secondes
Le 11ième “Mail” se retrouve bloqué dans “sendMail” au moment d’écrire dans le canal (car personne ne le lit pour le moment)
La première goroutine “MailSender” qui a traité un des “Mail” va alors lire de nouveau “mailsQueue”
Et par conséquent la 11ième goroutine “sendMail” se débloque puisque le canal dans lequel elle écrit vient d’être lut

On a traité le souci. On ne traite que 10 mails en parallèle, on ne bloque pas le client et on a soulagé le SMTP.

En bref

Les BlendWebMix 2015 m’ont donné l’occasion de parler à un grand nombre de développeurs en tout genre. Java, PHP, Ruby, AnjularJS, ReactJS, etc. Mais aussi de décisionnaires, de gestionnaires et de professionnels du marketing. Ce que je leur ai montré a, selon eux, donné dujet à discussion, ouvert des possibilités pour pas mal de problématiques à résoudre et c’est le contrat que je voulais remplir. Certes Golang ne répond pas à tout. Il a aussi ses défauts, ses contraintes, ses complexités. Mais dans l’ensemble, je suis très content d’avoir démontré l’intelligence de ce langage et qu’il n’a rien d’archaïque, de compliqué et qu’il n’est pas fait que pour le système.

Petit et grands sites peuvent utiliser Go sans souci: ce blog est codé en Go, et un grand nombre de grand comptes se sont penché sur cette technologie pour différentes raisons (scalling, streaming, …).

En attendant la mise en ligne de la vidéo de ma conférence, vous pouvez toujours visiter le slide interfactif sur GoTalks: “Golang pour le web” en prenant bien en compte que les exemples Martini ne peuvent pas tourner sur le serveur GoTalks.

Les exemples se trouvent sur Github: github.com/metal3d/blendwebmix2015/

Fish et les notifications de Gnome terminal

Sun, 18 Oct 2015 08:54:35 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Sur Fedora 22, gnome-terminal vous permet d’avoir une notification quand une commande se termine et que vous êtes sur une autre fenêtre. Très pratique quand vous avez executé une commande “curl” ou “wget” dans un coin ou si vous lancez des procédure d’installation ou de compilation qui prennent un certain temps. Or, si vous passez au shell “fish”, les notifications ne marchent plus. Voilà comment on s’y prend pour les retrouver.

TL;DR;

Dans .config/fish/config.fish:

if test "$VTE_VERSION" -ge 3405
    switch "$TERM"
        case 'vte*' 'xterm*'
            function __notify_vte_command_completed --on-event fish_postexec --description 'Notify VTE of command completion'
                printf '\e]777;notify;Command completed;%s\a' (echo "$argv" | cat --show-nonprinting | tr --delete \;)
            end
    end
end

Et relancez votre sessions.

Détaillons

Depuis quelques temps les terminaux VTE (Virtual Terminal Emulator, le widget gnome qui permet d’afficher un terminal) comprend quelques “séquences d’échappement” (escape sequence) qui permettent de s’amuser un peu. L’une de ces séquence est \e]777.

En général, il suffit d’afficher une suite d’argument à cette séquence:

\e]777;argument 1; argument 2; etc...

Le premier argument définit quelle action exécuter. Dans notre cas, ce sera “notify”. Les arguments suivant sont définis en fonctione de l’action. Pour “notify” on défini:

le titre
le texte

La notification ne se fera que si votre focus se trouve sur une autre fenêtre. Donc l’idée c’est d’ouvrir un terminal gnome et une autre fenêtre (par exemple restez sur cette page web).

Dans le terminal, tapez:

# sur fish
sleep 2; and echo -e '\e]777';notify;Le titre;Le contenu"

Rapidement, passez sur une autre fenêtre et vous devez avoir une notification de bureau.

Fish config

En cherchant un peu, je suis tombé sur ce ticket: Issue 2102 - apparement fish avait intégré le fait d’envoyer des notification Gnome mais certaines personnes ont eut quelques soucis. Du coup, l’auteur à retiré (temporairement ?) le test qui permettait l’envoit de notification.

Mais, le commit qu’il a retiré est lisible ici et on voit que c’est une simple fonction à ajouter dans la configuration.

Il suffit donc de prendre le bloc qu’il a supprimé, et le mettre dans votre propre configuration.

Sachez qu’en l’état, c’est un peu moins fin que ce que nous avions avec Bash. En effet, vous n’aurez que des notifications qui vous indiqueront qu’une commande est terminée mais pas son état. Alors que sur bash, on avait connaissance du fait que la commande avait planté ou réussi. Il doit y avoir une solution à cela, mais en l’état c’est déjà bien utile (selon moi) d’avoir au moins la notification.

Docker Apache Mysql PHP

Thu, 24 Sep 2015 11:33:18 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Ce matin un collègue me demande “comment tu ferais pour travailler en PHP avec Docker ?” - la question étant de pouvoir “développer localement en PHP + Apache + MySQL sans avoir à tout installer”. Ma réponse a été “docker-compose et des liens + des volumes”. Du coup, un petit billet pour expliquer la méthode s’imposait. Voici comment je procède.

Docker et Docker-Compose

En premier lieu, il vous faut Docker et docker-compose. En théorie, votre distribution propose des paquets tout prêts, il s’agit de les installer. Personnellement j’ai quand même installé “docker-compose” avec “pip”. La raison est simple, je peux mettre à jour l’outil rapidement sans avoir à attendre que le packageur propose un paquet.

Donc, en gros (sous Fedora 22):

sudo dnf install python-pip
pip install --user docker-compose
docker-compose --help

Voilà. Maintenant on s’atèle à mettre en place notre pile de conteneurs.

Les conteneurs

Rappel: il est fortement conseillé d’utiliser un conteur par service, comprennez bien “un conteneur pour mysql et un autre pous apache” dans notre cas. La raison est simple: je peux changer de version de php ou de mysql indépendament.

Bref, on se penche sur nos deux images Docker à utiliser:

php: https://hub.docker.com/_/php/ => le tag “apache” permet d’avoir PHP sur Apache
mysql: https://hub.docker.com/_/mysql/

Pour qu’on soit prêt:

docker pull php:apache
docker pull mysql:latest

Voilà, on a les images sur notre système. Sachez que si vous ne faites pas le “pull”, docker-compose le fera pour vous, mais je préfère préparer le terrain pour ne pas avoir à attendre le téléchargement quand je vais tester mon installation.

Docker-compose

Maintenant on va paramétrer notre composition de conteneur. En gros il faut que Apache démarre et qu’il sache lire mes sources PHP. Il faut que MySQL démarre, et il faut que PHP sache où trouver le serveur MySQL. Car je vous le rapelle, le conteneur MySQL peut changer d’IP à chaque redémarrage.

Le principe, pour partager un peu de configuration entre deux conteneurs, est d’utiliser un “lien”.

Bref, on prépare le terrain.

Créez un répertoire de travail, par exemple $HOME/workspace/monsite et allez dans ce répertoire.

Dans ce répertoire, on crée:

un répertoire de sources php
un fichier docker-compose.yml

Voyons le fichier YAML:

apache:
    image: php:apache
    volumes:
    - "src/:/var/www/html"
    links:
    - mysql
    ports:
    - "8080:80"
    privileged: true

mysql:
    image: mysql:latest
    environment:
        MYSQL_ROOT_PASSWORD: passroot

Explications:

La première entrée que j’ai nommé “apache” correspond à un conteneur. Il va utiliser une image “php:apache”. Dans ce conteneur, je “monte” le répertoire “src” local (qui contiendra mes sources php) sur le répertoire /var/www/html du conteneur.

Ainsi, quand apache va lire ce répertoire, il verra en fait ce que j’ai sur mon poste.

Je crée un lien dans la section “links” (qui est une liste), où je spécifie que mon conteneur “mysql” (défini plus bas) doit être démarré avant pour qu’il me fournisse des information (ip, nom, ports, etc…)

Je spécifie ensuite que je “bind” le port 8080 de ma machine sur le port 80 du conteneur. C’est le port 80 qu’écoutera apache sur le conteneur. Du coup, quand je vais requêter ma machine sur le port “8080” via http://localhost:8080, c’est le conteneur qui va répondre.

En dernier lieu, parce que je suis sur Fedora et que j’ai pas trouvé plus simple pour corriger un souci de droit que je déteste, je met “privileged: true”. Cela permet à mon conteneur d’avoir le droit de lire le volume monté. Le jour où je trouve une autre solution (qui ne me demande pas de labelliser avec SELinux) je donnerai des nouvelles.

Ensuite vient la section “mysql”, elle va utiliser l’image “mysql:latest”, et comme le spécifie la documentation je définir un mot de passe root pour la base.

Allons dans le répertoire “src” et créons un simple fichier “test.php”:

<?php
phpinfo()

Maintenant, on démarre le conteneur:

docker-compose up

Vous allez voir les logs des deux conteneurs, vous pouvez aller voir l’adresse http://localhost:8080/test.php

Variables d’environement

Descendez dans la page, et chercher la section “PHP Variables” où se trouve les entrées “_ENV”. Vous allez voir ce genre de chose:


`_ENV["MYSQL_1_PORT_3306_TCP"]`	tcp://172.17.0.22:3306
`_ENV["HOSTNAME"]`	813ce8655fd2
`_ENV["MYSQL_ENV_MYSQL_ROOT_PASSWORD"]`	passroot
`_ENV["DOCKER_MYSQL_1_PORT_3306_TCP_ADDR"]`	172.17.0.22
`_ENV["DOCKER_MYSQL_1_PORT_3306_TCP_PROTO"]`	tcp
`_ENV["MYSQL_1_PORT_3306_TCP_PROTO"]`	tcp
`_ENV["MYSQL_1_PORT_3306_TCP_PORT"]`	3306

Ces variables proviennent du lien que nous avons effectué dans docker-compose.yml. Cela va vous permettre de modifier la configuration de vos scripts ou du framework en utilisant la fonction php “getenv()” pour spécifier où se trouve le serveur mysql. Notez que docker permet aussi au conteneur qui reçoit le link d’utiliser le nom de conteneur en tant que nom de machine.

Or, docker-compose renomme les conteneurs en les suffixant avec un numéro (car docker-compose sait démarrer plusieurs conteneurs d’une même entrée). Il faudra alors tricher un peu et utiliser, par exemple, “mysql_1” au lieu de “mysql”. Je rappelle que “mysql” est le nom donné dans le fichier yaml, et non pas le nom de l’image.

En d’autres termes, vous utiliserez:

<?php
//via les variables d'environnement
$mysql_server = getenv("DOCKER_MYSQL_1_PORT_3306_TCP_ADDR");

//ou
// en admettant qu'on puisse utiliser un nom de machine
// ce qui est vrai pour le module php-mysql
$mysql_server = "mysql_1"; 


//

Ne pas perdre la base de donnée ?

Effectivement dans notre configuration on ne sauve pas la base localement. Si vous supprimez le conteneur mysql, vous perdez vos données. On règle le souci:

apache:
    image: php:apache
    volumes:
    - "src/:/var/www/html"
    links:
    - mysql
    ports:
    - "8080:80"
    privileged: true

mysql:
    image: mysql:latest
    volumes:
    - "data/:/var/lib/mysql"
    environment:
        MYSQL_ROOT_PASSWORD: passroot
    privileged: true

On a rajouté un volume à notre conteneur mysql, désormais le répertoire /var/lib/mysql où mysql stocke toutes ses bases sera sur notre répertoire local “data”. Pensez à le créer avant.

Et encore une fois, “privileged: true” si vous êtes sous Fedora ou une distribution qui utilise SELinux et qui refuse l’écriture depuis le conteneur.

Bilan:

En un seul fichier “docker-compose.yml” on peut aisément démarrer un développement PHP/MySQL sans trop d’effort, encore faut-il être sur Linux et avoir Docker d’installer. Mais vue la tendance du moment…

Intérêt certain, il est possible de prendre cette installation, de la déployer sur un serveur de production (même si Docker dit qu’ils sont pas encore prêt pour de la production…) et lancer docker-compose en tant que service. Restera alors à votre charge de faire un reverse-proxy (nginx, apache…) qui pointera sur localhost:8080

Vous n’aurez donc pas à installer php et mysql, et vous pourrez aisément mettre en production plusieurs sites avec différentes versions de PHP.

Voilà comment on passe de LAMP à DAMP :)

Golang, résoudre le souci d'indexation de type défini

Sat, 19 Sep 2015 14:04:46 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Golang permet de créer ses prores types et notamment de faire un alias de “map”, mais un jour, en voulant récupérer une valeur indexée dans le map, vous recevez un fameux “type *Foo does not support indexing” lors de la compilation. Ce souci peut-être rapidement réglé à condition de comprendre pourquoi et comment cette erreur arrive.

TL;DR

Vous vous trompez ! Un map est déjà un pointeur, donc arrêtez d’attendre un pointeur sur ce type. Changez votre fonction pour attendre “Foo” et non “*Foo”.

Si vraiment vous voulez utiliser un pointeur sur pointeur, il faut déréférencer, c’est à dire: utiliser (*var)["index"] au lieu var["index"] dans votre fonction

Explication détaillée

Go serait-il aussi chiant que C/C++ alors ?

En gros, que ce soit en C/C++ ou en Go, les tableaux sont des pointeurs. Le fait de définir un type qui surcharge un tableau (map, slice, etc…) prête à confusion.

Imaginons un type Foo qui surcharge un map[string]interface{}:

type Foo map[string]interface{}

Un fonction qui utiliserai ce type pourrait être:

func Modify(f *Foo) {
    //... fait des choses 
}

Le souci est que “f” est un pointeur sur un map, donc un pointeur sur un pointeur… et la modification (expliquée dans la seconde partie) demande un déréférencement. C’est-à-dire “(*f)[…]”.

En réalité, la fonction devrait être:

func Modify(f Foo) {
    //... fait des choses 
}

Ici, “f” est un pointeur puisque c’est un “map”. Donc:

package main

import "fmt"

type Foo map[string]interface{}

func Modify(f Foo) {
	f["hello"] = "world"
}

func main() {
	a := make(Foo)
	Modify(a)
	fmt.Println(a)
}

On teste:

$ go prog.go
map[hello:world]

Cela fonctionne, car “Foo” est un type “pointeur” de par le fait qu’il est un “map”.

Cas d’un pointeur sur pointeur

Dans certains cas, on se force à uiliser un pointeur sur le type défini, même se celui-ci est un map. Cela va induire que la fonction qui récupère un “*Foo” récupère un pointeur sur pointeur, puisque c’est un pointeur sur un map et qu’un map est un poitneur… Vous suivez ?

Prenons un exemple simple.

package main

import "fmt"

// type alias pour un map[string]interface{}
type Foo map[string]interface{}

// affiche l'index "test"
func Test(f *Foo) {
    // l'erreur arrive ici:
    if v, ok := f["test"]; ok {
        fmt.Println(v)    
    }    
}

func main() {
    // on crée notre variable Foo
	a := make(Foo)
	// on assigne une valeur à l'index "test"
	a["test"] = "hello"
	// on l'affiche
	Test(&a)
}

Et là:

$ go run prog.go
prog.go:11: invalid operation: f["test"] (type *Foo does not support indexing)

Le problème est simple. La variable “f” est ici un pointeur. Comprennez bien que “f” est donc une adresse !

Et comme à cette adresse on trouve… un autre adresse - car la valeur est un map et qu’un map correspond à une adresse… houlalala… ça se complique…

Bon..:

f est de type Foo
Foo est un map, donc un pointeur
f *Foo => f est donc un pointeur sur un pointeur

Donc, la réponse est simple, il faut déréférencer la variable, ou pour être plus près de la vérité, il faut “utiliser la valeur pointée” par l’adresse récupérée dans la fonction.

Ce que je veux dire c’est que “f” étant une adresse, si on récupère la valeur à cette adresse, on tombe sur le “map”.

Donc dans la fonction “Test” on va utiliser “(*f)” pour retrouver le map… Ça va ?

En clair:

package main

import "fmt"

// type alias pour un map[string]interface{}
type Foo map[string]interface{}

// affiche l'index "test"
func Test(f *Foo) {
    // On corrige, on utilise maintenant "la valeur pointée par f"
    if v, ok := (*f)["test"]; ok {
        fmt.Println(v)    
    }    
}

func main() {
    // on crée notre variable Foo
	a := make(Foo)
	// on assigne une valeur à l'index "test"
	a["test"] = "hello"
	// on l'affiche
	Test(&a)
}

Cette foi:

$ go run prog.go
hello

et pourquoi pas “`*f["test"]`” ?

Simplement parce que *f["test"] veut dire “valeur pointée à l’adresse f["test"]” - et c’est pas ce que nous voulons.

Alors que “(*f)["test"]” veut dire “prend la valeur pointée en f (donc on a le map) et récupère dans ce map l’index ’test’”.

Sémantiquement, c’est différent.

Git et les fichiers zip

Sat, 01 Aug 2015 14:07:40 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si un projet se base sur un fichier zip (pas seulement les fichier “.zip”, mais tout fichier qui zipe le contenu comme les fichiers libreoffice, openoffice, vym, etc…) alors vous allez vous confronter au souci de versionnement par Git. Car celui-ci les gère comme étant des fichiers binaires. Or vous voulez versionner le contenu. Et bien voilà ma méthode (certes pas des plus jolies mais ça marche)

Je me suis trouvé confronté à cette situation en voulant versionner un livre sur le langage Go que je tape depuis pas mal de temps. Jusqu’ici je versionnais le fichier “.vym” (car j’utilise vym pour ça, je parle bien de View Your Mind hein, mais j’en reparelarai bientôt de tout ça) qui est ni plus ni moins qu’un fichier zippé et renommé en “.vym”. Or, je me suis fais une bonne frayeur en écransant connement mon fichier après un “git pull” trop rapidement validé.

Résultat, git a écrasé le fichier sans faire de “diff” - ce qui est logique car il ne le fait pas pour les fichier binaires.

Bref, pour éviter ce genre de boulette je me suis simplement ateler à versionner non plus le fichier, mais son contenu. Ça vous parait peut-être barbarre mais ça marche.

Premier chose à faire, on teste !

Testons la construction

On commence par se placer dans un dossier et on va décompresser le contenu du fichier (vous pouvez le faire avec un fichier .odt, un .vym ou un .docx si vous êtes nostalgique de Word…)

mkdir ~/test/constructor && cd ~/test/constructor
unzip /chemin/vers/fichier.vym

On voit alors quelques fichiers et répertoires, on reconstruit:

zip -r test ./*
mv test.zip ../fichier-reconstruit.vym

Et on ouvre ce fichier (placé dans “~/test/”). Tout à l’air ok ! Bien on passe à la suite.

Automatison

Dans mon répertoire git, j’ai donc créé un Makefile, et voilà ce que j’ai entré:


FILE="monfichier.vym"

explode:
    mkdir src/ || :
    cd src && unzip ../$(FILE)
    
implode:
    cd src && zip -r ../temp ./*
    mv temp.zip $(FILE)

Ainsi, quand je tape “make explode” le contenu de mon projet est décompressé dans le répertoire “src” que je vais pouvoir versionner. Et quand je récupère le projet depuis “git” ("git pull") alors je tape simplement “make implode” pour reconstruire mon fichier.

Coté git

Coté git, je ne sauvegarde pas le fichier de travail (ici mon fichier “.vym”) car il va être reconstruit par le makefile. Donc mon fichier .gitignore est de la forme:

*.vym

Du coup, je suis tranquile, et surtout que la suite des opérations va engendrer une création de fichiers de sauvgarde, par conséquent on les ignorera aussi puisqu’ils utiliseront l’extension “.vym” (encore une fois, adaptez mes exemples à votre type de fichier)

Maintenant… les problèmes commencent…

Les problèmes et les solutions

Il se peut que votre “fichier zip” ait besoin de répertoires vides, par exemple Vym demande un répertoire “flags” et un autre “images” non vide. Or, git ne les versionne pas. Git ne peut gérer que des fichiers en fonction de leur chemin, et par conséquent un répertoire “vide” n’est pas un fichier, il va le zapper.

La solution, est simplement de créer des fichiers vides dans ces répertoires. Ainsi dans le Makefile, on va créer une cible de préparation “_prep” (le underscore pour éviter de le faire apparaitre dans l’autocompletion de bash) qui va écrire des fichiers nommés “.gitkeep” seulement dans les répertoires de projet (en évitant donc .git). Je remercie cette réponse de StackOverFlow.


FILE="monfichier.vym"

explode: _explode _prep

_explode:
    mkdir src/ || :
    cd src && unzip ../$(FILE)
    
implode:
    cd src && zip -r ../temp ./*
    mv temp.zip $(FILE)

_prep:
    find . -type d -empty -not -path "./.git/*" -exec touch \{\}/.gitkeep \;

J’ai décalé la cible “explode” en “_explode” pour changer l’ordre d’appel. Si vous suivez bien le Makefile, “make explode” va appeler “_explode” qui va decompresser le zip, puis “_prep” qui prépare les répertoires en “touchant” des fichier “.gitkeep”.

Autre chose, j’ai décidé de sauvegarder mon fichier de travail avant de le recréer. On ajoute une dernière règle nommée “_backup” qui copie le fichier en le datant à la seconde.

J’ajoute aussi un peu de propreté en séparant le nom de fichier et son extension.


BASE:="monfichier"
EXT:=".vym"
FILE:=$(BASE)$(EXT)
DATE=$(shell date "+%Y%m%d-%H%M%S")

explode: _explode _prep

_explode:
    mkdir src/ || :
    cd src && unzip ../$(FILE)
    
implode: _backup
    cd src && zip -r ../temp ./*
    mv temp.zip $(FILE)

_prep:
    find . -type d -empty -not -path "./.git/*" -exec touch \{\}/.gitkeep \;

_backup:
    cp $(FILE) $(BASE)-$(DATE)$(EXT)

Comme ça, chaque fois que j’appelle “make implode” pour reconstruire mon fichier “vym”, j’ai une sauvegarde de faite.

Petite parenthèse, dans un makefile on peut assigner une variable en utilisant “:=” ou “=”. La différence est que “:=” var interpréter “de suite” la valeur à assigner; alors que “=” attendra qu’on appelle la variable pour que sa valeur soit interprétée. Du coup, ici, la variable “$(DATE)” sera interprété au moment de l’appel dans “_backup”. C’est pas super utile ici mais par habitude…

Et dans la vie réelle ?

Dans la vie réelle, j’ai testé et ça se passe bien ! Voici ce qu’il peut arriver (et qui d’ailleurs m’ait arrivé):

je prend mon pc portable et je commence à toucher mon fichier vym
je suis content, je me dis que je peux pousser tout ça sur mon serveur git
je lance “make explode” puis “git commit src && git push” et là… le drame !

Git me dit que je suis pas à jour ! ça veut dire que j’ai oublié de faire un “pull” avant de pousser. Effectivement, la veille j’ai travaillé sur mon pc de bureau et j’avais poussé. Mais tête en l’ait que je suis, j’ai oublié cette scéance de boulot.

Il va se passer quoi ?

En premier lieu, je pull ! et je reconstruit mon fichier avec “make implode”. Vym recharge mon fichier. Deux possibilités:

Ça a l’air pas mal - auquel cas on peut refaire un “make explode” et pousser les le merge.
Tout est pété - là on transpire…

Si tout est pété, comme on a été intelligent, on a une sauvegarde qui a été créé lors du “make implode” dont le nom est la date d’aujourd’hui + l’heure de sauvegarde. Je peux reprendre cette version, me débrouiller pour reconstruire le fichier et commiter.

Au pire, on peut toucher le fichier XML contenu dans “src” car, je vous le rappelle, on travaille désormais avec des fichiers non compressés ce qui a pour effet de vous donner les “diffs”, voir les lignes qui ont sautées, etc.

Donc en clair, ma méthode de décompression + makefile qui fait le travaille de sauvegarde à ma place, ça me sauve des heures de travail et ma tension me remercie.

Notez aussi que cette technique peut s’appliquer aux fichier “.tar”, “.tar.gz” ou encore “.7z”. Le tout étant simplement de s’adapter au format. Le principe, je vous le rapelle, étant de versionner le contenu du fichier compressé et non pas le fichier compressé lui-même.

D’autres solutions ? d’autres méthodes ? faites le moi savoir !

Neovim va-t-il remplacer Vim ?

Mon, 06 Jul 2015 22:40:50 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Lorsque Nicolas Engel m’a parlé de neovim, je n’ai pas eut l’occasion de tester étant donné que j’étais sur Fedora 20 et qu’aucun paquet n’avait été fourni. Mais depuis mon passage en Fedora 22, j’ai accès à Copr et donc à un build de neovim. Voilà mon avis: Whaouuu !

Début des hostilités: je passe à Fedoda 22 et je rage de voir le terminal “Terminator” ne pas me donner de notification quand une commande se termine en arrière plan. Résultat des courses je reviens à ce bon vieux “gnome-terminal” qui, finalement, est pas si mal. Mais j’utilise Vim depuis des lustres, et j’adorais avoir un split de terminal pour avoir d’un coté l’éditeur, et de l’autre un terminal pour lancer une commande ou laisser les tests unitaires tourner.

Bref, je trouve un plugin pas dégueulasse: Conque - sérieusement, pour ceux qui ne veulent pas aller plus loin et passer à Neovim, utilisez ce plugin c’est tout bonnement génial.

Mais voilà, je me souvenais que neovim permettait directement d’avoir un terminal dans l’éditeur. Alors je retourne sur le projet Git et je vois que l’installation sur Fedora se fait en un rien de temps, et ce grâce à Copr.

Installation

Ça va aller vite:

sudo dnf copr enable dperson/neovim
sudo dnf install neovim

Et voilà… c’est tout!

Comme le spécifie la doc: https://copr.fedoraproject.org/coprs/dperson/neovim/ - vous pouvez lier votre “.vimrc” et votre “.vim” respectivement sur “.nvimrc” et “.nvim”

Reste à installer les module python:

pip install --user neovim
pip3 install --user neovim

Comme ça on est tranquile pour les version de python 2.7.x et 3.x, les plugins vous diront merci plus tard.

Alors ça change quoi ?

Au premier regard, absolument rien. Mais alors rien !

Si, à la limite, la commande pour lancer neovim:

nvim

Vous avez un éditeur vim comme d’habitude, vous vous demandez presque pourquoi vous l’avez installé. Et puis vous tapez

:terminal

Et là, vous comprennez déjà que rien que pour ça vous allez adorer NeoVim.

Avoir un terminal dans nvim me sert absolument à tout, entre lancer des tests ou démarrer “Gdb”, en passant par un “htop” dans un coin… bref, plus besoin d’avoir un Terminator.

Truc qui me fait délier: lancer “mutt” sur le coté pour avoir les mails pendant que je code :) Et j’en passe, comme weechat par exemple. En bref tous ce qui se lance dans un terminal est accessible dans nvim. C’est un bonheur sans nom.

Puisque la touche “echap” est nécessaire pour certains logiciels dans le terminal, il a fallut changer de raccourci pour quitter le mode “term”. Pour reprendre la main et passer en mode “normal”, pressez CTRL+\ puis (rapidement) CTRL+n ou simplement maintenez la touche Control et pressez “" puis “n”.

Pour ceux qui parle courament le vim: “<C-\><C-n>”

Libre à vous de splitter les fenêtres, lancer des commandes, utiliser le mode “visual” pour copier des résultats de commandes dans un buffer, bref le pied. (Je rappelle la commande pour spliter: Control+W puis “s” ou Control+w puis “v” pour le split vertical)

Quoi d’autre…

Autre petit truc que j’adore, lors d’une recherche en presant “/”, le buffer scrolle durant la frappe de recherche. C’est tout bête mais c’est très confortable.

Pour le reste je vous laisse taper:

:help vim-differences

On notera des options par défaut (comme le mode “mouse=a”) et les options de compatibilité avec les anciennes versions de “vi” supprimées. En clair, on fait table rase.

Neovim est aussi plus léger, il a toutes les features compilées (alors que vim doit être compilé en mode “HUGE” pour avoir accès à toutes les features) et il promet aussi pour la suite: une meilleure intégration dans n’importe quel GUI, support de pleins de langages, plus rapide, plus proche des dernières configurations, bref NeoVim donne envie.

Attention toutefois, NeoVim n’est pas “stable” (perso j’ai eu aucun crash pour le moment, et pourtant j’ai une foule de plugins, je code en Go dedans, j’ai un tagbar et un nerdtree en boucle…), et rien ne dit que la version Copr maintenue par “dperson” soit viable longtemps. Bref, vous prennez vos responsabilités en le testant.

Alors, le verdict ?

Digne successeur de Vim, ou plutôt “nouvelle génération” de vim, je pense que NeoVim va faire du bruit dans quelques mois. Le projet est développé depuis longue date et les commits sont réguliers, donc la communauté est active et le projet se stabilise. Il est clair que Vim (déjà lui-même un remplaçant de “vi”) commence à vieillir. Un nouveau souffle avec ce projet va certainement donner de nouvelles perspectives.

En tout cas, pour moi, c’est “alias vim=nvim”

Assigner une variable lors de la compilation en Go

Sun, 21 Jun 2015 15:57:57 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Je viens de faire une release de mon outil idok et je me suis posé cette fameuse question: comment faire pour assigner la version dans mon binaire sans avoir à modifier le code source ? Et bien c’est simple comme tout mais il faut le savoir. Voilà la méthode.

Prenons un exemple de programme dont vous avez assigné une valeur de version et qui l’affiche:

package main

import (
    "fmt"
)

const VERSION="heuuuu"

func main(){
    fmt.Println(VERSION)
}

Le résultat est logiquement:

$ go run main.go
heuuu

Très bien… sauf que là c’est “en dur” et qu’à chaque release je dois penser à monter la version dans le source. Un peu de recherche et je comprends qu’on peut modifier les drapeaux “ld”. En gros, on peut “modifier les variables au moment de l’édition de lien”.

Attention, on ne parle pas de “ld”, l’éditeur de lien GNU, mais de celui de Go !, voir https://golang.org/cmd/ld/ et on voit une ligne très intéressante:

-X symbol value

Set the value of a string variable. The symbol name should be of the form importpath.name, as displayed in the symbol table printed by “go tool nm”.

Et c’est la variable “main.VERSION” qu’on va changer, c’est à dire “la variable VERSION dans le package main”. On va utiliser le drapeau “X” de la librairie “ld”

Cela dit vous devez penser à utiliser une variable et non une constante. Donc on modifie le programme en :

package main

import (
    "fmt"
)

// on met une variable
var VERSION="heuuuu"

func main(){
    fmt.Println(VERSION)
}

Et on va tenter:

$ go run main.go
heuuu
$ go run -ldflags '-X main.VERSION 0.0.1' main.go
0.0.1
$ go run -ldflags '-X main.VERSION alpha1' main.go
alpha1

Du coup, tout devient plus simple. On peut utiliser un Makefile qui utilise, par exemple, git pour avoir le tag en cours:

VERSION:=$(shell git describe --tags)
OPTS:=-ldflags '-X main.VERSION $(VERSION)'

build:
    go build $(OPTS) main.go

Reste alors à changer “main.go” pour ajouter la possibilité d’avoir une option -version:

package main

import (
    "flag"
    "fmt"
    "os"
)

// on met une variable - UNDEF 
var VERSION="UNDEF"

func main(){
    v := flag.Bool("version", false, "get the current version:"+ VERSION )
    flag.Parse()
    
    if *version {
        fmt.Println(VERSION)
        os.Exit(0)
    }
    
    fmt.Println("No version flag set...")
}

Et donc:

$ git tag 0.0.1
$ make
$ ./main -version
0.0.1
$ git tag 0.0.2
$ make
$ ./main -version
0.0.2

Quand je vous disais que c’était simple…

Juste une petite note, je n’ai pas trouvé comment assigner autre chose qu’une chaine de caractères… si vous avez la solution, merci de me prévenir que je modifie le billet.

Rendre homogène une équipe de dev avec docker et docker-compose

Sun, 14 Jun 2015 12:28:11 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Quand on veut bosser avec Docker sur des projets plus ou moins complexes, il existe un outil qui permet de vous soulager de pas mal de contraintes: le bien nommé “docker-compose” anciennement nommé “fig”. Bien plus qu’un “makefile pour docker” il peut entrer dans votre projet de développement en équipe.

Docker a vraiment un potentiel plus qu’intéressant. En ce qui concerne son intégration dans les système de “cloud”, pour déployer des services ou encore pour tester une installation ponctuellement c’est déjà un outil merveilleux. Mais j’ai l’impression que son utilisation dans un pole de développement n’est pas encore très répandu. Peut-être parce que beaucoup (trop) d’équipes de développement travaillent encore sur Windows et que Docker n’est pas encore un produit prêt à l’emploi sur cet OS (quoique maintenant… il existe Docker Toolbox).

En ce qui me concerne, je travaille avec une équipe qui a:

soit un pc sur Linux
soit une VM pour lancer les services

Du coup, on a put utiliser Docker dans nos projets.

La problématique du prérequi

C’est tout bête. Nous devons travailler par exemple sur une application AngularJS qui interroge une API REST. Il nous faut NodeJS pour installer des outils tels que gulp, karma, protractor, des plugins gulp, bower, etc… Nous devions donc installer tout ça avec les bonnes versions puis démarrer chacun de notre coté le projet (phase d’init d’installation).

Imaginez un peu, il faut installer “node” dans la version demandée, donc utiliser “nvm” - puis toucher les ~/.bashrc, ensuite installer “globalement” des outils tels que “bower”, ou “gulp” - ce qui du coup impose une écriture avec les droits administrateurs. Vous allez me dire que ça se fait en 3 ou 4 commandes mais ce n’est pas si évident en pratique.

En clair, on passait beaucoup de temps à initialiser le projet sans compter les soucis à régler sur certains postes, entre les soucis de version et la capacité des ingénieurs à installer les prérequis (sans compter que certains développeurs ne sont pas forcément à l’aise avec Linux).

Autre problème, on passait souvent d’un projet à l’autre, parfois 3 à 4 fois dans la journée. Les projets n’ont pas forcément les mêmes prérequis. Le pire étant qu’une installation globale va masquer une dépendance manquante dans un autre projet, et on se pose pas mal de questions quand Jenkins nous balance une erreur sur des tests qui passent super bien sur nos postes.

Donc, en bref, c’est pas si évident d’installer et d’isoler les développements sur un poste. Mais quand j’entend “isolement”, je ne peux m’empêcher de penser “virtualisation”, “para-virtualisation” et “Docker”. Et pour cause.

Docker va nous abstraire de ces soucis, surtout en l’alliant à Docker-Compose. Tout va être géré via cet outil.

L’image Docker - la base

On utilise notre exemple: un dev AngularJS utilisant bower et gulp.

On part du principe que, par défaut, on utilise la cible “gulp serve” qui va lancer un service http pour voir notre projet angular tourner. On a produit un Dockerfile tout simple qui suffit à notre démarrage de projet (dans le monde réel, il est un peu plus fourni)

FROM node:10.3
MAINTAINER Patrice FERLET <metal3d@...>

VOLUMES ["/project"]

RUN npm install -g bower karma gulp

WORKDIR /project
CMD ["gulp","serve"]

Du coup, on peut “builder” l’image et la fournir aux développeurs… Là encore, trois solutions:

on fourni l’image buildée sur un serveur
on utilise un registry privé
chaque dev build l’image

Le premier point est lourd, le développeur qui gère la création du Dockerfile va devoir builder l’image puis la pousser sur un serveur. Si la connexion est lente, que le serveur est loin ou que quelqu’un met le pied sur le câble LAN, vous imaginez l’angoisse. Bref..

Le second est intelligent et rapide, mais… chaque poste doit avoir le certificat du registre installé, il faut gérer le registre, penser à sauvegarder, etc. Donc du boulot en trop.

Le troisième point est sympa, on pourrait donc fournir notre fichier dans le dépot du projet. Mais le souci c’est que les options de démarrage d’un conteneur ne sont pas forcément faciles à trouver - on documenterai autant qu’on veut, on aurait toujours un membre de l’équipe pour nous péter à la gueule un “ça marche pas ça m’énerve”.

Et c’est là que “docker-compose” entrera en jeu. Mais voyons d’abord ce qu’il se passe sans cet outil.

Sans docker-compose, c’est un peu plus compliqué

Sans docker-compose, un membre de l’équipe de développement va devoir builder l’image et lancer l’init dans le bon ordre.

# En premier lieu
docker build -t jeanjacques/imageprojet docker/.

# Ensuite il va intialiser npm et bower via un conteneur temporaire
docker run -it --rm -v /rep/vers/projet jeanjaques/imageprojet npm install
docker run -it --rm -v /rep/vers/projet jeanjaques/imageprojet bower install

# et enfin créer un conteneur qui lance, par défaut, "gulp serve"
docker run -it --name projet1 -v /rep/vers/projet jeanjaques/imageprojet

Le développeur coupe le conteneur, et le lendemain il veut relancer les tests (comme tous les jours):

docker run -it --rm -v /rep/vers/projet jeanjaques/imageprojet gulp test

Vous le voyez, plein de commandes compliquées avec pas mal d’options, il faut qu’il pense à réutiliser l’image de base, et comprendre les mécanismes de docker. En clair, le confort est pas si évident.

Au pire, on fournirai un “Makefile” qui fait tout ça, mais justement il existe un autre outil spécialisé pour docker qui ressemble à un makefile, c’est ce fameux “docker-compose” que je vous rabache depuis le début du billet.

Et Docker-compose arrive sur son cheval blanc

Le prérequis, demander à l’équipe d’installer “docker-compose” en suivant cette page de doc - c’est relativement rapide et simple.

Docker-compose va donc être bien plus pratique car il évite au développeur de réfléchir à “Docker en lui même”. Il ne va finalement que préfixer les commandes habituelles d’un projet “node - gulp” par “docker-compose run [nom du projet]” ou utiliser “docker-compose up”. Voyez plutôt (le chien de Mickey):

Voici un exemple de fichier docker-compose.yml:

site:
    build: ./docker/
    ports:
    - "3000:3000"
    volumes:
    - ./:/project

Je précise, “build” donne le répertoire où se trouve le Dockerfile pour builder localement l’image, et “volumes” permet ici de monter le répertoire courrant dans un répertoire définis.

Vous avouerez que c’est pas si long à taper hein. Voyons comment un développeur va démarrer son projet:

# initialise le projet
docker-compose run --rm site npm install 
docker-compose run --rm site bower install 

# pour lancer le "gulp serve" de base
docker-compose up


# pour lancer les tests
docker-compose run --rm site gulp test

La première fois que vous lancez une commande docker-compose, l’image se build. Si une mise à jour est nécessaire, il suffit de faire:

docker-compose build

C’est incroyablement simple, facile à comprendre et ça ne demande pas trop de configuration.

En gros, dans nos projets, nous avons au minimum:

un ficher docker-compose.yml
un répertoire docker avec le Dockerfile et les dépendances (script entrypoint, des truc à déposer si besoin dans l’image…)

Comme tout est versionné en tant que fichier texte (pour le yaml et le Dockerfile), c’est vraiment pratique à gérer.

Et le pompon sur la cerise: Jenkins peut utiliser la commande docker-compose pour lancer les tests lui-même. Si ça c’est pas géant !

Les soucis à régler

Il y a des soucis à régler. Ici je vous ai donné un Docker file et un docker-compose.yml très simples. Or il ne faut pas oublier que Docker va exécuter les commandes en “root”. Et lors de la génération de fichiers, sur votre répertoire de travail, ce sera bien “root” qui est utilisé. “Bower” va vous engueuler, et vous allez vous battre avec les droits localement sur votre poste. Je vais vous donner quelques trucs qui permettent de ne pas avoir ce genre de soucis.

Souci numéro 1: mapper les UID et GID à l’utilisateur hôte

[EDIT] Cette solution de création d’utilisateur + entrypoint qui fait un “sudo” est valable pour les anciennes version de de docker et docker-compose. Merci de prendre en compte la solution qui utilise “user” dans le fichier yaml.

Solution pour les nouvelles versions

Depuis peu, il est possible de forcer les identifiants utilisateur d’un compte qui se trouve dans le conteneur.

Par exemple:

docker run -it --rm --user 1000:1000 busybox

Cela induit que l’utilisateur qui va lancer le premier processus dans le conteneur écrira avec les identifiant user:group à 1000:1000. Dans “compose”, il suffit d’utiliser la directive “user”:

site:
    build: ./docker/
    ports:
    - "3000:3000"
    volumes:
    - ./:/project
    user: "1000:1000"

Vous allez me dire “ouais… et si nos développeurs ont pas le même uid sur leurs postes”, ne vous inquiétez pas j’ai une solution.

Docker-compose a désormais la capacité de faire de l’héritage de définitions.

L’idée et d’utiliser cette capacité en générant un fichier “de base” qui va être dynamiquement renseigné. On va y placer les uid et gid de l’utilisateur en cours (le développeur) avec un Makefile.

On commence par un “POC”, on crée un fichier “.docker-base.yaml” (je mets un “.” devant le nom pour faire un fichier caché):

mother:
    user: "1000:1000"
    environment:
        USER: root

Pour être clair, je laisse “$USER” à “root” pour garder le nom d’utilisateur malgré le changement de “uid” et “gid”. Sans cela, vous aurez un message “I have no name” dans le prompt shell… c’est juste gênant à la lecture, pas à l’utilisation. Bref…

Il arrive aussi parfois que j’ai besoin d’assigner la variable “HOME”, car en changean les uid:gid et le nom d’utilisateur, certains services ne retrouvent plus le chemin du dossier utilisateur. Donc je le place dans “/tmp” ou dans le volume par défaut, au choix et selon le projet.

Dans mon yaml de service maintenant, je vais hériter de ce fichier et utiliser “mother”:

site:
    build: ./docker/
    ports:
    - "3000:3000"
    volumes:
    - ./:/project
    extends:
        file: .docker-base.yaml
        service: mother

Désormais, le service “site” hérite de “mother” depuis le fichier “.docker-base.yaml”.

Si vous lancez “docker-compose up” et bien désormais, c’est un utilisateur “root” ayant les uid et gid à 1000 qui va lancer les processus (gulp, etc.) Pratique n’est-ce pas ?

Bon, et bien on va utiliser un makefile qui va générer ce fichier “de base” et lancer les services:

UID:=$(shell id -u)
GID:=$(shell id -g)
CC:=docker-compose

serve: _docker-base
    $(CC) run --rm gulp run

init: _docker-base
    $(CC) run --rm npm install
    $(CC) run --rm bower install

test: _docker-base
    $(CC) gulp test
    
_docker-base:
    @echo "mother:" > .docker-base.yaml
    @echo "    user: $(UID):$(GID)" >> .docker-base.yaml
    @echo "    environment:" >> .docker-base.yaml
    @echo "        USER: root" >> .docker-base.yaml

Je vous explique, ne paniquez pas.

On commence par la dernière directive de Makefile, “_docker-base”. Cette directive va créer un fichier “.docker-base.yaml” qui contient notre service de base, le service “mother”. Dans ce service, on défini l’environnement et les identifiants à utiliser qui correspondent à $UID et $GID (définis dans l’entête du Makefile).

J’ai ensuite 3 directives: serve, init et test. Ces trois directives dépendent de “_docker-base”. Donc chaque fois que je vais lancer une tâche “make”, le fichier sera généré avec les bons UID et GID, et docker-compose exécutera mes conteneurs en mappant tout ça bien gentillement.

Cette solution marche à condition que vos postes aient bien des versions récentes de docker et docker-compose. Sans cela, ça ne marchera pas.

Solution pour les anciennes versions

Pour éviter que tout soit écrit par root, on va demander à Docker d’utiliser un compte utilisateur local. On va l’appeler “dev”.

L’idée est de créer un utilisateur dans le conteneur qui ait les mêmes IDs que celui du compte développeur sur l’hôte. Par défaut, avec un peu de bol, vous avez un UID et GID vallant “1000”. Donc je modifie le Dockerfile:

FROM node:10.3
MAINTAINER Patrice FERLET <metal3d@...>

VOLUMES ["/project"]

RUN npm install -g bower karma gulp

# création d'un utilisateur normal
RUN useradd -u 1000 -g 1000 dev

USER dev
WORKDIR /project
CMD ["gulp","serve"]

Mais ça peut ne pas suffir… malheureusement.

Mon PC a deux comptes, et celui que j’utilise pour développer a un UID et GUID “1002”, ce qui pose un souci. Pour résoudre ça, j’ai ajouté un “entrypoint” au conteneur (dans le répertoire docker):

#!/bin/bash

# force le changement d'id utilisateur
if [ ! -z $_UID ] && [ $_UID != "1000" ]; then
    su -c 'usermod -u $_UID dev'
fi

# change l'id de groupe de l'utilisateur
if [ ! -z $_GID ] && [ $_GID != "1000" ]; then
    su -c 'groupmod -g $_GID dev'
fi

exec $@

Et par conséquent, le Dockerfile:

FROM node:10.3
MAINTAINER Patrice FERLET <metal3d@...>

VOLUMES ["/project"]

RUN npm install -g bower karma gulp

# création d'un utilisateur normal
RUN useradd -u 1000 -g 1000 dev

# je supprime le mot de passe root pour que
# la commande "su" ne bloque pas
RUN usermod -p "" root

ADD entrypoint.sh /entrypoint.sh

USER dev
WORKDIR /project
ENTRYPOINT ["sh", "/entrypoint.sh"]
CMD ["gulp","serve"]

EDIT: j’ai ajouté la solution Makefile

Ensuite deux solutions, soit un script qui lance docker-compose avec les variables d’environnement:

#!/bin/bash
# fichier: ./start.sh

UID=$(id -u)
GID=$(id -g)

action=$1
shift

docker-compose $action -e _UID=${UID} -e _GID=${GID} $@

Et donc, pour lancer mes commandes:

./start.sh up
./start.sh run gulp serve
./start.sh run gulp test

Soit passer par un Makefile, c’est encore plus joli:

UID:=$(shell id -u)
GID:=$(shell id -g)
CC:=docker-compose

serve:
    $(CC) run -e _UID=$(UID) -e _GID=$(GID) gulp run

init:
    $(CC) run -e _UID=$(UID) -e _GID=$(GID) npm install
    $(CC) run -e _UID=$(UID) -e _GID=$(GID) bower install

test:
    $(CC) run -e _UID=$(UID) -e _GID=$(GID) gulp test

Ce qui donne à l’utilisateur:

make ou make serve -> lance le serveur
make init -> initialise les dépendances npm et bower
make test -> qui lance les tests…

A vous de faire votre sauce…

Mais pour résumer: à chaque fois, l’id et le gid sont passés à la commande docker-compose, l’entrypoint vérifie sur l’id et le gid sont présents et différent de l’id de base, et le change au besoin. C’est rapide et ça fait gagner du temps.

Souci numéro 2: l’utilisation de git et SSH

Il se peut que vous ayez besoin de git dans votre conteneur, par exemple nous avons deux projets angular dont un doit récupérer le build de l’autre via bower. Dans le fichier “bower.json”, nous avons une url de dépendance sous la forme “git”, et ce dépot est privé. Or, pour s’y connecter et permettre la récupération de code, il faut un compte SSH valide.

Il est inconçevable de devoir créer une clef à chaque conteneur et la poser dans notre compte github, du coup, voilà comment procéder.

Il suffit, bêtement, de “monter ~/.ssh en volume”, donc dans le fichier “docker-compose.yml”:

site:
    build: ./docker/
    ports:
    - "3000:3000"
    volumes:
    - ./:/project
    - ~/.ssh:/home/dev/.ssh:ro

Le “:ro” final dit clairement de le monter en mode “read only” (lecture seule) pour éviter un malencontreux “pétage de répertoire” qui va vous rendre dingue. Autant dire que le risque serait minime, mais on bosse sérieusement et on préfère faire attention.

Du coup, l’appel à “bower install” utilise la clef SSH du poste client et tout se passe bien.

En bref

En clair, on a commencé, chez mon client, à travailler de cette manière. Le résultat est que nous ne passons plus des plombes à installer base de développpement, à nous battre avec les versions des outils, tout le monde a, quelque soit sa distribution, un services standard pour exécuter les commandes. On appelle ça “l’homogènéité” :)

Nous avons par exemple créé des conteneurs pour:

Python Google App Engine
Gulp + protractor + karma + node + etc.

Récupérer le code depuis GitHub et lancer la commande “docker-compose up” est la seule chose à faire pour démarrer les projets. Certains projets ont un makefile partagé avec le conteneur - les cibles permettant de faire des packages, des builds, de simplifier des appels. Par exemple, de faire: docker-compose run site make init qui lance tout la phase de préparation (npm install, bower clean cache, bower install, etc.)

grep et vimgrep plus rapide, passez à "ag"

Thu, 11 Jun 2015 11:46:14 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Utilisant vim depuis des années pour développer, je suis toujours étonné de découvrir des trucs à droite à gauche qui améliorent encore mon confort de travail. Et même sans utiliser vim, la ligne de commande est mon outils quotidien. Aujourd’hui, parlons d’un programme qui pourrait bien remplacer votre bon vieux “grep” et l’utilisation de “vimgrep”: “the silver searcher”.

Découvert sur la page de projet github, “the silver searcher” est une réimplémentation de “ack”, un outil de recherche de texte dans un répertoire comme le ferai “grep”. L’intérêt principal est tout simplement sa vitesse. Elle est tout bonnement impressionnante.

Petite note: “the silver searcher” est une référence direct à “the silver surfer” alias “le surfeur d’argent”, le personnage de comics.

“ag” est compatible avec le prototype de “ack”, un autre outil de recherche dont elle respecte les options et format ce qui lui confère la possibilité d’utiliser le plugin “ack” pour vim… je vous perds ? Bon on y va pas à pas.

Le programme “ag”

Comme expliqué sur la page github, “the silver searcher” est déjà packagé sur pas mal de distros. donc:

apt-get install silversearcher-ag
# ou
yum install the_silver_searcher
# ou encore avec pacma, emerge, etc.

Vous avez maintenant la commande ag sur votre ordinateur.

Pour lancer une recherche, par exemple trouver “foo” dans le répertoire courant:

ag foo

On remarque d’abord qu’on a pas à préciser le répertoire, ce qui est plus sympa quand on veut taper vite… et ensuite, la vitesse de réponse et le format agréable de lecture:

![Capture sortie ag](/static/upload/adb744f7-79ed-4912-934b-83e582fb4de9-Capture d’écran de 2015-06-11 10:26:17.png)

Deux remarques:

le “pattern” à chercher peut être une expression régulière
le format de sortie est adaptable

Vous pouvez préciser le répertoire si vous ne voulez pas chercher dans le répertoire courant, et en lisant la “man page” vous allez découvrir des tonnes d’options.

Si vous voulez comprendre pourquoi je suis passer à “ag”, regardez juste les benchmarks réalisés dans la section “What’s so great about Ag?” - c’est sans appel…

Mais encore ?

Avec “grep”, dans un projet “git”, je devais me débrouiller pour gérer des “exclusions”, en d’autres termes il me fallait éviter de chercher dans le répertoire “.git” sous peine de me prendre des résultats complètement inutiles dans la face. “ag” évite ces répertoires par défaut, la commande reste donc très légère et confortable.

Il est possible de dire à “ag” dans quel type de fichier on veut trouver le pattern. Pour connaitre les types supportés:

ag --list-file-types

La liste est longue, croyez moi. Donc par exemple:

ag --pyhton foo

ne cherchera “foo” que dans les fichier de type “python”. L’option est d’autant plus intéressante qu’un type de fichier peut avoir plusieurs extensions possibles. Par exemple, le HTML peut se trouver sour la forme “.html” ou “.htm”. et le “markdown” peut être suffixé par “.markdown”, “.mdown”, “.mdwn”, “.mkdn”, “.mkd” ou “.md”. Du coup, pas de commande à rallonge pour filtrer les extensions. Si ça c’est pas utile, faut m’expliquer votre pensé.

Dans Vim, deux méthodes

Deux solutions. Soit vous suivez la “manpage” (man ag) et vous ajoutez à votre “vimrc” ces lignes:

set grepprg=ag\ --vimgrep\ $*
set grepformat=%f:%l:%c:%m

Ce qui va vous permettre de taper (en remplaçant “pattern” par ce que vous cherchez):

:grep pattern

Puis tapez, comme avec vimgrep, :cwindow pour voir la liste des occurences, et de pouvoir ouvrir le fichier au bon endroit en pressant “Enter” sur le fichier en question.

Soit vous passez par le plugin Ack.vim et vous placez dans votre “vimrc”:

if executable('ag')
  let g:ackprg = 'ag --vimgrep'
endif

et vous pourrez utiliser la commande vim:

:Ack pattern

Cette commande va faire la recherche, ouvrir la mini-fenêtre de résultats et vous laisser ouvrir les fichiers de différentes manières (en onglet, directement dans le buffer en cours, etc… pressez “?” dans la fenêtre pour voir les options)

La vitesse de réponse est vraiment étonnante - vimgrep me gênait énormément à cause de sa lenteur. Mais tellement pratique que je ne pouvais pas m’en passer. Le combo “ag + ack.vim” s’installe en moins de 5 minutes et me fait gagner du temps et réduit le stresse de l’attente de résultat.

OpenSSH et les socket de contrôle

Sat, 30 May 2015 09:52:47 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Garder une connexion SSH active en arrière plan et pouvoir la stopper quand on veut, sans garder son PID, quelle idée merveilleuse hein ? Personnellement j’en avais besoin. Autre possibilité, se connecter une fois à un serveur et ne pas avoir à se reloguer à chaque fois que je veux retourner sur le serveur, pareil ce serait bien. Et bien c’est possible. Suffisait de lire la doc en fait. Voilà un petit billet qui va vous parler de tout ça.

Clairement j’avais besoin de lancer un tunnel SSH et le garder ouvert un certain temps, puis le couper à la volée. Et ce sans avoir un terminal ouvert dans un coin. Oui vous allez me dire “l’option -f de ssh sert à mettre en background la connexion”, mais pour fermer la connexion il faut alors passer par “ps” pour trouver le PID, et se débrouiller par des moyens détournés. Je me doutais bien que OpenSSH proposait quelque chose pour ça, et j’ai visé juste.

Il suffit de chercher sur le net des articles et documentations parlant de “multiplexed ssh connections” par exemple pour trouver son bonheur.

La page qui m’a été super utile est OpenSSH/Cookbook/Multiplexing - mais la “manpage” a aussi pas mal d’infos.

Comment ça marche ?

L’idée est qu’en se connectant à un serveur SSH, un fichier “socket unix local” soit créé. Ce socket permet de faire pas mal de choses:

se reconnecter au serveur dans une autre session sans avoir à recréer l’appel complet (donc pas de mot de passe demandé)
pouvoir couper toutes les connexions au serveur (si elles utilisent ce socket)
pouvoir vérifier si des connexions sont actives
et j’en passe

Il y a deux façon (au moins, à ma connaissance) pour paramétrer cette fameuse création de socket:

soit dans la ligne de commande
soit dans la config ssh

Il faut aussi prendre en compte qu’une connexion sera considérée comme “maitresse” (master) et que si celle-ci est coupée alors les autres connexions “esclaves” vont se couper, par défaut. On peut tout à fait éviter cette coupure des esclaves en manipulant un peu les options. On va en parler, n’ayez pas peur.

Voyons comment ça se passe.

Explication avec la ligne de commande

Créons une connexion à serveur en la spécifiant comme “maitresse” (via l’iption -M). L’option -S spécifie le chemin du socket unix.

$ ssh -M -S /tmp/test.ssh.sock user@server.tld

Normalement votre connexion fonctionne et un fichier /tmp/test.ssh.sock vient d’apparaitre. Dans un autre terminal, sans couper cette connexion, vous allez pouvoir vous reconnecter au même serveur en utilisant cette socket unix et sans demande de mot de passe. Cette fois on ne demande pas à devenir “maitre”, donc on supprime l’option -M:

$ ssh -S /tmp/test.ssh.sock user@server.tld

Alors faites cette expérience; retourner sur le premier terminal et coupez la connexion en tapant “exit”. Ce terminal reste bloqué, et pour cause ! Cette connexion est “maitre”, elle attend la coupure des autres esclaves. Donc allez dans le second terminal où vous avez lancé une seconde connexion SSH et faites pareil: “exit”. Là, enfin, les deux connexions sont coupées.

Les commandes de socket

Cette socket unix ne sert pas seulement à multiplexer les connexions. On peut y passer des commandes.

Recommençons l’expérience précédente:

un terminal avec ssh -M -S /tmp/test.ssh.sock user@server.tld
un second terminal avec ssh -S /tmp/test.ssh.sock user@server.tld

Ouvrons un troisième terminal et tapons:

$ ssh -S /tmp/test.ssh.sock user@server.tld -O check
Master running (pid=5764)

Intéressant - nous pouvons savoir le PID du processus maitre. C’est le PID de la commande ssh qui utilise l’option -M. Mais ce n’est pas tout, on sait qu’elle est active !

Le prototype de l’appel est simplement: ssh -S chemin_socket -O commande user@server.ssh

L’option -O (la lettre “O”) permet de passer des commandes de contrôle. Ici on utilise “check” mais on peut aussi utiliser:

stop - qui dit au socket de ne plus prendre d’autres connexions et de se couper après fermeture des maitres et esclaves - la socket disparait quand aucune connexion n’est présente (c’est le mode soft)
exit - qui demande à couper toutes les connexions en cours sur ce socket (donc coupe les connexion ssh au serveur, c’est le mode “bourinasse”)

Ainsi, tapez:

$ ssh -S /tmp/test.ssh.sock user@server.tld -O exit

Regardez les deux autres terminaux, la connexion SSH est coupée, maitre et esclave compris !

C’est donc super pratique, par exemple pour lancer un tunnel SSH qu’on peut stopper quand on veut:

$ ssh -M -S /tmp/tunnel.sock -N -L :8889:localhost:10085 root@server.tld

Et pour le couper, plus tard:

$ ssh -S /tmp/tunnel.sock -O exit root@server.tld

Utiliser la conf

C’est bien sympa de mettre des options en ligne de commande, mais peut-on configurer SSH pour qu’il fasse ça tout seul ? La réponse est “oui” (sinon j’aurais pas fait cette section hein).

Ouvrons notre fichier ~/.ssh/config et paramétrons un service:

Host server.tld
	ControlPath /tmp/%r@%h:%p
	ControlMaster auto

Voilà, la prochaine connexion au serveur “server.tld” va créer un socket /tmp/user@host:port (en remplacant user, host et port par les valeurs qui vont bien).

Une nouvelle connexion au serveur, alors que l’autre est active, va fonctionner comme précédemment, et comme d’habitude vous pourrez utiliser l’option -O pour passer des commandes de contrôle.

Une autre option super intéressante est “ControlPersist” qui, si elle vaut “yes”, va laisser la socket même si aucun maitre n’est présent.

Host server.tld
	ControlPath /tmp/%r@%h:%p
	ControlMaster auto
	ControlPersist yes

C’est plutôt sympa et ça permet de vraiment accélérer les nouvelles connexions au serveur. Si vous désirez forcer la fermeture de ce socket c’est simple:

$ ssh user@server.tld -O stop

Aucune connexion ne sera acceptée, et quand tous les esclaves auront quitté, la socket sera supprimée.

Plutôt que de mettre yes, vous pouvez aussi donner une valeur de temps: 10m pour 10 minutes, 1h pour une heure… la socket va donc persister le temps donné si aucune connexion maitresse n’est en cours. C’est un chouillat plus sécurisé.

Utilité

On parle de pouvoir contrôller des connexions à un serveur. Si vous sauvez une configuration dans /etc/ssh/ssh_config alors toutes les connexions de n’importe quel user sur le poste seront accélérées et contrôllables, donc par exemple vous pourrez fermer toutes les connexions à un serveur en particulier simplement en utilisant le socket adéquat.

L’autre utilité est clairement la possibilité de créer des tunnels et de les couper rapidement sans passer par la case “ps”, trouver le pid etc. Une commande “exit” dans le socket et le tour est joué.

Il y a bien d’autres options et utilités, je vous laisse regarder la page que j’ai donné en haut de l’article.

Bref, encore une option OpenSSH que je suis content d’avoir découvert. Entre le tunnelling, la création de pseudo VPN, les sockets de contrôle et tous les outils qui suivent, y’a pas, SSH c’est le pied.

Mise à jour du blog en Go

Sun, 12 Apr 2015 21:47:31 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Si vous connaissiez mon blog, vous avez remarqué qu’à partir d’aujourd’hui sa tête a changé. Je me suis décidé à refondre la totalité du site, ce qui va apporter son lot de soucis car tester le tout est pas simple du tout. Mais dans l’ensemble ça va aller vachement mieux. Le blog fonctionne maintenant en Go (Golang), dans un conteneur Docker et avec mon framework (kwiscale). Je vous raconte ?

Il y a des mois de cela, j’avais sauté le pas depuis PHP (sous Copix) et NodeJS (avec un framework maison nommé Knotter). Pour le coup j’étais super content. Et puis au fil des semaines et des mois les soucis se sont accumulés. Commentaires en double, voir plus de commentaire du tout, runtime node qui tombait (car je tentais de gérer de l’interprocess), et j’avais accumulé du code franchement pas beau. Bon clairement j’ai pas été bon sur le coup. Javascript étant très permissif, j’ai vraiment mal codé certaines parties et j’ai eut du mal à corriger l’ensemble. Coder des systèmes asynchrones est, certes, génialissime en terme de concept, mais très compliqué à maintenir si, pour N raisons, vous avez une coquille dans l’architecture logicielle.

Je vais calmer le jeu tout de suite: j’adore NodeJS. Mon mini framework marchait, le principe était pas mauvais. Le souci c’est que j’aime coder de manière “modulaire” et avoir des couches de séparation entre mes structures fonctionnelles. Et malheureusement le concept de mon code de gestionnaire de blog était trop éparpillé pour un tel framework sur cette technologie.

Autre souci, et pas des moindres, je ne maitrisais pas bien MongoDB. Depuis j’ai énormément lut et testé et je me suis rendu compte que j’avais vraiment fait n’importe quoi sur le blog.

Aujourd’hui je sais assurer une écriture viable ou une modification de document dans la base. Et ça change la vie.

Mongo, j’en parlerai dans un prochain ticket. Il y a des problèmes qu’un débutant peut rencontrer, ne pas savoir ou simplement imaginer de mauvais concepts. J’ai d’ailleurs utilisé une chose que j’avais laissé de coté sur Mongo: la recherche full-text.

Technos utilisées

J’en parle depuis un moment au boulot, j’adore Go (ou Golang). Ce langage apporte tellement de plaisirs à coder que me suis lancé dans la création d’un vrai framework nommé kwiscale. Ce qui m’a étonné en codant ce framework, c’est que la langage pousse à faire en sorte que tout se passe bien. Si si, vraiment. Pas moyen de faire “n’importe quoi n’importe comment”. On est proche du C, sans en avoir la complexité. On s’étonne à utiliser des pointeurs partout et sans en avoir peur. On s’impressionne à réussir à lancer et synchroniser des “goroutines” (ou coroutine, c’est à dire des tâches parallèles) sans se taper les neuronnes dans le fond du crâne. En clair, ce langage est un pied d’enfer pour un développeur qui cherche à maitriser une grosse batterie modulaire.

A l’inverse de mon framework “maison” nommé “Knotter” en NodeJS, je savais très bien où j’allais, comment j’allais amener la configuration, comment le rendre modulaire.

Je me répète mais… j’adore NodeJS et je ne crache pas sur PHP. J’ai codé près de 10 ans sur PHP et j’ai toujours défendu ce langage. L’idée c’est que Go m’apporte un peu plus de contôle, de maitrise, de bonnes performances et une gestion de la concurrence plus abordable et maitrisable. Je n’ai plus à me poser des questions sur l’implémentation, je me penche quasi essentiellement sur l’algo. Ça change la vie.

Développer ce blog sur le framework Kwiscale m’a pris 3 soirées. Sachant que je gère:

la détection de spam via un filtre bayésien et gestion de demande de modération
envoit de mails
traitement des drafts (pour les tickets)
page statique (ficheri markdown)
ticket en base Mongo (format markdown)
sitemaps
flux RSS (au passage j’ai abandonné Feedburner)

et j’en passe… Je reparlerais de Kwiscale dans un autre ticket, le jour où je releaserai une version stable (disons en fin Avril 2015 si tout se passe bien).

Ce qui m’a éclaté c’est la facilité à générer du XML ou du JSON avec ce que Go propose en built-in. Du coup, les flux RSS ou encore les sitemap m’ont pris 10-15 minutes à les réaliser. Un bonheur je vous dis.

Bref, j’utilise Kwiscale et le plugin que j’ai créé pour utiliser le moteur de template Pongo2. Ce moteur m’apporte la possibilité de traiter du markdown très facilement dans les templates, la syntaxe est proche de Jinja2. Pour un développeur comme moi qui a usé Python dans toutes les directions, c’est un gain de temps d’apprentissage non négligeable. Les développeurs PHP/Syfony connaissent aussi cette syntaxe via Twig.

Développer en Go sans recompilation

Go demande une compilation de votre projet (tout comme C/C++ ou Java). L’intérêt est qu’il compile très vite, le temps est quasi négligeable (de l’ordre de la centaine de miliseconde). Du coup Go propose une commande go run ... qui exécute le programme juste après la compilation. Ça donne l’impression d’utiliser un langage interprété, sans en avoir l’arrière gout.

Le souci, c’est qu’il aurait fallut que je relance la commande go run à chaque modification de code.

Gin justement nous affranchit de cette contrainte. C’est un programme en Go qui permet de détecter et relancer la compilation au moindre changement de code. Il agit comme un proxy et transmet les connexions au programme que vous développez. C’est tout bête et ça marche bien.

Il ne me restait que la base Mongo à installer, configurer… mais non, j’ai utilisé Docker !

Je vais pas trop développer le sujet dans ce ticket, mais j’ai trouvé un trio gagnant pour développer sans prise de tête un site en Go:

Godep - gère les dépendances Go dans un workspace
Gin - un outil qui relance votre code lors d’une modification qui sait utiliser Godep
Docker-compose - anciennement “Fig”

En gros, j’ai créé un fichier docker-compose.yml qui lance:

un serveur nginx avec la conf montée dans le répertoire /etc/nginx/conf.d
la base mongo (avec les data sauvé localement sur l’hôte)
une image golang (de base) qui utilise un makefile qui installe ce qu’il faut (2 packages) et lance une commande gin avec l’option qui demande à utiliser Godep.

Toutes les dépendances étant enregistrées via Godep depuis mon host, et ayant “monté” mon répertoire de travail dans le conteneur, le conteneur Go n’avait besoin que de Gin et Godep. Godep se servant du répertoire Godep qui se crée en tapant godep save (je ferai un autre ticket pour ce sujet, patience). Seulement deux pacakges à installer via le Makefile, rien de méchant donc… et pas la peine de le modifier si j’utilise un nouveau paquet dans mon projet. Godep se charge de tout.

Arrivée en production, j’utilise un second docker-compose.yml nommé “docker-compose-prod.yml” qui, lui, n’instancie pas nginx (car j’en ai un sur le serveur qui tape sur d’autres services web) et surtout qui n’utilise plus Gin, juste Godep. Effectivement en production je n’ai pas besoin d’écouter les modifications de code.

Cette fois, il utilise une autre directive du makefile qui ne lance que les commandes:

go get github.com/tools/godep
godep go run main.go

La commande “godep” va simplement spécifier GOPATH au compilateur “go”. c’est à dire le réperoire “Godep” livré avec mon projet. Donc, pour être clair:

je déploie depuis ma machine le code + le workspace Godep (qui contient tous les packages nécessaires) avec rsync
docker-compose lance les deux instances (mongo et golang)
le conteneur golang lance “make prod”
le makefile installe godep puis lance le service en utilisant le workspace Gedep via la commande godep go run main.go

Promis, je ferai un ticket sur le sujet. Car je pense que mon modèle est loin d’être mauvais et peut être réutilisé. Je me la pète un peu non ? si… tant pis… soyons fier de ce qu’on réalise parfois !

Comprennez juste que je suis “certain” que ce qui tourne sur mon poste va tourner de la même manière en production.

Et ça, c’est vraiment une révolution

– ® S.Jobs

Spam

Mon site est fortement spammé. J’ai donc utilisé 2 bloquages:

le premier est tout bête, le formulaire de commentaire a plein de champs inutiles qui, s’ils sont remplis, le sont à coup sûr par un robot - le CSS les cache, donc vous, vous ne les voyez pas
un filtre bayésien que j’ai codé en 15 minutes - il charge un index de mot depuis les commentaires que j’ai classé en spam et en “commentaire sûr”.

Ce filtre bayésien est sensible, car comme je vous le disais, mon blog à énormément de messages de spam. Du coup, si vous commentez vous avez de forte chance de vous retouver classé en tant que spammeur. Mais pas de panique, Si vous le premier filtre est passé (donc vous n’êtes pas un robot qui a rempli des champs interdits) alors je vous propose sur une page de cliquer sur un bouton pour me signaler l’erreur. C’est automatique, ça m’envoit un mail, et j’ai plus qu’à valider votre commentaire.

Le commentaire devenant “sûr”, il entre dans le jeu de données “message non spam” (qu’on appelle “ham”). La prochaine fois, qu’un commentaire arrive, votre commentaire est aussi utilisé pour la vérification. C’est le principe de Bayes, la probabilité “à posteriori”. Ça marche pas mal.

Plus vous commentez, plus le filtre est fiable.

Reprise de contenu, le cauchemard

Par contre, la reprise de contenu m’a pris une bonne semaine… et le pire c’est que c’est toujours pas bon.

La base utilisée est toujours “Mongo”. J’ai implémenter un moteur de recherche full text en partant de ce que propose MongoDB. Dans les prochains jours je parlerai de quelques aspects de MongoDB souvent négligés, voir des erreurs de base qu’on peut faire (et que j’avais fait avec mon ancien système de blog)

Finalement, ce qui m’a pris le plus de temps, c’est de récupérer le contenu du site “ancienne version”. Et je dois bien avoué que j’ai baissé les bras à un moment donné. En effet, sous Copix j’utilisais une syntaxe “wiki” spéciale qui est très compliqué à transformer en Markdown. Du coup, les vieux messages ont de sérieux soucis… pour ceux tapés en RST ça a été plus simple (merci à Pandoc).

J’ai corrigé les tickets les plus lut… mais je sais qu’une passe complète ne sera jamais possible. Tant pis…

Les anciennes URL

Restait un point qui me faisait grogner, j’ai modifié la forme d’url et la forme du slug (le titre rendu lisible dans l’url). Avant, la date du ticket apparaissaient dans l’url et j’ai décidé (à tort peut-être) de m’en passer. D’abord parce que je trouve pas ça beau, que la date apparait dans la page et enfin parce que j’ai utilisé un truc pour ne pas avoir de doublon de slug. Donc, inutile à mon gout.

Mais voilà… certains ont bookmarké quelques unes de mes pages. Il y a même quelqu’un qui a référencé un de mes tickets dans Wikipedia (pour Gstreamer), et la forme d’url a changé. Google va se plaindre, ça m’embêtait vraiment. La solution a été finalement simple. Ne sachant pas reproduire les vieux slug, j’ai décidé de ruser.

Je prend un slug, je vire les tirets: ça me donne une liste de mots. Je lance une recherche full-text dans Mongo. Sachant que le titre correspond au slug, et que le titre a un poids important dans mon indexation (par rapport au contenu), je suis sûr à 99% que le premier résultat que me retournera la recherche est le ticket initial. Une réponse “HTTP Permanent Redirect (301)” et le tour est joué.

Style CSS, en avant flexbox !

Exit Bootstrap ou Skeleton. Non pas que je ne les aime pas, mais ce blog est là pour que je teste des technos et que je donne des idées, des solutions et des méthodes. Bootstrap est génial, Skeleton est vraiment cool, mais CSS apporte depuis quelques temps la gestion de “boites flexibles” qui permet de réduire le travail.

Du coup, j’ai tenté le coup. À mon grand étonnement, j’ai put sortir ce que je voulais: un design responsive en 205 lignes de CSS tout compris.

Ok, Internet Explorer < 10 va me taper une gueulante, mais IE ne représente que 4% de mon auditoir. Par contre, ça marche bien sur Android (tablette et mobile).

Question couleur, j’adore les couleurs “sombres”. J’ai utilisé la couleur du gopher (en haut à droite du site) pour les liens (merci à mon épouse pour l’idée) et je pense que ça reste sobre, lisible et pas aggressif.

Bilan

Golang est vraiment un langage prêt pour la production. Kwiscale approche de son but et mon blog fonctionne largement mieux qu’avant.

Je suis plutôt content du résultat et je vais pouvoir réécrire des tickets plus régulièrement.

En finir avec l'erreur Virtualbox VERR_VD_IMAGE_READ_ONLY

Wed, 19 Nov 2014 14:44:52 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Au travail, on est sur des poste Windows 7… et comme on veut bosser on a des VM Linux :) bref, qui dit Windows dit “anti-virus”, et qui dit “anti-virus” dit un foutoir dans les lock… Vous avez souvent, comme moi, une erreur VERR_VD_IMAGE_READ_ONLY qui vous empêche de démarrer votre VM ? vous n’arrivez pas à trouver quel processus a locker vos disques ? moi j’y ai remédié avec Python :)

Au travail, c’est ce bon vieux McAfee (toutes blagues avec Mac à Fille sera rejeté) qui avait la fâcheuse tendance à me verrouiller mes disques virtuels pour ma VM sur VirtualBox. J’ai trouvé, de ci, de là, des commentaires dans des forums qui disent “ouiiiin j’ai une tâche qui lock ma VM, je l’ai trouvé et killé et hop ça marche”. Bha un tour dans le gestionnaire de tâche (et services) de Windows 7 m’a juste fait chialé.

Et ne parlons pas des commandes de base dans “cmd”, un équivalent de base de “lsof” vous le trouverez pas. Par contre, Microsoft propose des outils à télécharger. Genre: http://technet.microsoft.com/en-us/sysinternals/bb896655.aspx

Vous pouvez donc récupérer “Handle.exe” et le placer dans un dossier facilement accessible.

Reste à faire un script pour cmd.exe, c’est tellement puissant, tellement facile de traiter des chaines… non de déconne. Installez donc python 2.7 https://www.python.org/downloads/windows/ installez tout ça.

Tiens une super astuce de la mort pour “forcer Windows à mettre à jour les variables d’environnement”, accrochez-vous c’est jouissif !

ouvrir le gestionnaire de tâche
killez le processus “explorer.exe”
créez une nouvelle tâche “explorer.exe”

C’est pratique hein ? (un corbeau passe derrière ma tête)

reste à placer ce script python sur le bureau:

# -*- encoding: utf-8 -*-
import subprocess
import re

HANDLE = "c:\Users\pferlet\Handle.exe"

# bon oui, changez les chemins pour que ce soit en accord avec votre installation
vids = ["\Users\pferlet\VirtualBox VMs\Viperr\Viperr.vdi",
    "\Users\pferlet\VirtualBox VMs\Viperr\Viperr2.vdi"]
reg = re.compile(r"pid: (\d+)",re.MULTILINE|re.IGNORECASE)

for vid in vids:
    ret = subprocess.check_output([HANDLE, vid], shell=True)

    pids = reg.findall(ret)
    if len(pids) > 0:
        for pid in pids:
            subprocess.call("taskkill /F /PID %d" % int(pid))

Nommez le “unlock.py” par exemple, et pour l’exécuter, faites simplment un clique droit dessus et “ouvrir avec…”, cherchez “python.exe” et le tour est joué.

Quand ma VM se trouve locké, je lance ce script, ça explose un vieux pet moisi devant le nez de McAfee qui fuit aux toilettes pour vomir. Le temps qu’il revienne, la VM peut démarrer.

Voilà pour le coté “vous devriez tous avoir python sur vos postes Windows 7” et la question “Mac et Linux incluent Python, pourquoi pas Windows ? ha oui c’est vrai… licence tout ça…”

La commande deux-points en Bash

Tue, 18 Nov 2014 18:49:28 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Que ce soit en bash, en sh, en ce que vous voulez, on trouve parfois des subtilités assez intéressantes pour peu qu’on se penche un peu sur les documentations. Une “commande” (oui s’en est une) que j’utilise souvent est “:”, c’est à dire “deux-point” ou en anglais “colon”. A quoi ça sert ? Je vous montre !

La commande “colon”, donc “:”, est extra, elle ne fait absolument rien ! Bon ok, en fait elle fait des choses, déjà elle retourne toujours “0” (zéro), donc elle réussit à tous les coups.

$ :
$ echo $?
0

La première chose à quoi m’a servi cette commande est simple, j’ai des scripts qui ne doivent pas planter, et ne doivent pas retourner autre chose qu’un succès, par exemple:

mkdir -p /tmp/test/machin || :

Quoiqu’il arrive, que la commande “mkdir” ait fonctionné ou pas, le retour est un EXIT_SUCCESS (donc zéro). C’est très utile par exemple dans des “entrypoint” de Docker.io

Mais si ça ne servait qu’à ça… autant utiliser la commande “true”. Sauf que “:” est vraiment un peu plus poussée, elle peut prendre des paramètres dont elle ne se sert pas. Du coup, on peut lui balancer une chaîne, ou une sortie de commande qu’elle n’affichera pas. Et du coup on commence à comprendre ce qu’on peut faire…

Je m’en sers pour taper un commentaire en plein milieu d’une commande:

command; command; : un commentaire rapide; command; command
# parce que la ligne suivante ne marche pas, le dièse commente la fin de ligne:
command; command; # un commentaire rapide; command; command

Ou alors, à faire un “while” rapidement

while :; do command; done

Une autre chose intéressante, remplacer une redirection de la sortie standard ! Je vous rappelle les faits: la commande prend en argument n’importe quoi, qu’elle n’affiche pas, donc:

# on peut faire
command | :

# equivalent à :
: `command`
: $(command)

Notez que ces commandes retournent toujours “0” même si la commande a planté ! C’est super intéressant pour lancer une commande dont on se fiche du résultat, et dont on se fiche de la sortie standard (STDERR continue à s’afficher)

Donc, que ce soit en conjonction avec un “&&” pour assurer un succès de sortie, pour commenter “en ligne” ou encore pour stripper la sortie standard, la commande “deux-points” (dites “colon” c’est plus pro :)) va vous faire plaisirs. A la longue, ça devient naturel.

Créer une API en GO avec Gorilla

Fri, 12 Sep 2014 10:55:34 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Bon, on va parler Go ou Golang (faudra me dire un jour quel est le bon nom) (en fait je sais, je vais le dire dans l’article tiens)… Après la naissance de mon outils “idok”, on discutait au boulot de la création d’une API et de savoir quelle techno utiliser. Vous me connaissez… j’ai répondu “Go”. Mais comment on fait ? Y’a des packages qui aident ? Hooo oui…

Bon en premier, on règle la question de suite:

Go = la technologie, c’est le compilo, les outils…
Golang = le langage

C’est réglé, on passe à la suite.

Commençons par le commencement

En premier lieu, on regarde la base d’un projet HTTP en Go. C’est finalement assez simple, on utilise le package “http” et on crée des handlers:

package main
import (
    "fmt"
    "net/http"
)

// Un handler qui répondrait à /api/v1/user

func GetUser(w http.ResponseWriter, r *http.Request) {
    // du blabla
    // et on répond
    w.Write("Un appel à GetUser...")
}

// la fonction principale (et pas de jeu de mot avec main et pied)
func main(){
    http.HandleFunc("/api/v1/user, GetUser)
    http.ListenAndServe(":8080", nil)
}

Pour l’exemple, je ne fais qu’écrire la réponse en texte. Vous pourrez utiliser le package “encoding/json” ou “encoding/xml” pour répondre comme il se doit en REST :)

Bon le “blabla” de la fonction GetUser est pas expliqué, tout va dépendre de votre API, de votre base de données et des traitements à effectuer.

Mais vous allez vite comprendre que tout ça c’est bien joli, mais ça reste limité. Pourquoi ?

Problème 1 - Le verbe HTTP

J’aimerai d’abord pouvoir répondre à un GET de “api/v1/user/12345”, “12345” étant un id d’utilisateur. Mais aussi à un PUT, ou PATCH sur la même URL… Sauf que là, la fonction GetUser(), mal nommée en plus, prend toutes les requêtes. Il faudrait alors tester “r.Method”, et pour chaque cas appeler d’autres fonctions.

Problème 2 - Les paramètre dans le path

Et en plus, récupérer le “12345” en fin d’URL, ça va qu’en on a que ça à récupérer, mais quand on commence à jouer un peu ça devient vite problématique.

On pourrait commencer à coder un autre Muxer et créer la méthode “ServeHTTP” comme le dit la doc. Mais honnêtement, on va réinventer une roue sans être sûr de bien l’avoir fait circulaire.

Conclusion, faut une surcouche…

Bref, pour quelque chose de très simple, ça suffit amplement. Mais un projet qui demande un peu plus de cuisine va vite vous condraindre à vous battre avec du code en veux tu en voilà. Le module HTTP de Go n’est pas fait pour proposer des règles d’écritures strictes. C’est un module simple pour faire des choses simples. Pour faire plus compliqué, il faut coder… ça vous ennui ? Heureusement il y a Gorilla.

Gorilla, le couteau suisse

Voyez la page: http://www.gorillatoolkit.org/

Gorilla est un ensemble de packages utltra intéressant qui rend un nombre de services vraiment conséquent. On va regarder gorilla/mux à la page: http://www.gorillatoolkit.org/pkg/mux

Ce muxer est vraiment cool et nous permet de faire:

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)

//... je vous passe les détail de fonctions, on va y revenir
func User(w http.ResponseWriter, r *http.Request) {
    // maintenant, je peux avoir:
    vars := mux.Vars(r) // récupère les valeurs d'url

    // vars["id"] contient l'id utilisateur... 
    fmt.Fprintf(w, "On demande l'utilisateur %s", vars["id"]) 

    // id => string, pas le choix, sinon on le converti avec strconv
}

func main(){
    // on crée un muxer
    r := mux.NewRouter() 

    // remarquez le "id" qu'on utilise dans User()...
    r.HandleFunc("/api/v1/user/{id:[0-9]*}", User)

    // cette fois on passe le muxer à ListenAndServe, et non pas "nil"
    http.ListenAndServe(":8080", r)
}

Maintenant, on peut faire joujou avec l’id, mais on ne sait pas encore faire un choix entre GET et PUT… Et bien c’est toujours aussi simple:

func main() {
    // on crée un muxer
    r := mux.NewRouter() 

    // on attache les fonctions en fonction des methodes HTTP
    r.HandleFunc("/api/v1/user/{id:[0-9]*}", GetUser).Methods("GET")
    r.HandleFunc("/api/v1/user/{id:[0-9]*}", PutUser).Methods("PUT")

    // cette fois on passe le muxer à ListenAndServe, et non pas "nil"
    http.ListenAndServe(":8080", r)

}

Reste alors à créer les deux fonctions GetUser() et PutUser(). En réalité il faut comprendre comment ça se passe:

r.HandleFunc() => enregistre la route (mux.Route) dans le muxer et retourne un mux.Route puis…
.Methods(…) => la route retournée par HandleFunc ne fonctionnera qu’avec la ou les méthodes spécifiées (on donner plusieurs verbes HTTP à Methods())

Il existe aussi des manières de gérer les domaines, des groupes de Routes, de nommer une route pour créer les urls… la doc est très complète et je vous invite à la lire.

Bon, c’est une introduction succinte, je sais, mais ça vous donne des billes pour commencer.

Si vous voulez non pas créer une API (qui répond en json ou xml par exemple) mais plutôt faire une des pages WEB (en html), il faudra vous pencher sur les packages “html/template” (dans le SDK de Go) ou sur d’autres moteurs comme Pongo2 (https://github.com/flosch/pongo2) semblable à Jinja (python) ou Twig (pour php).

Et coté ORM, base données… on en reparlera… J’utilise “mgo” le paquet pour MongoDB (https://labix.org/mgo) et j’ai beaucoup aimé l’ORM (“O” étant sujet à discussion puisque Go n’a pas d’objet…) nommé “gorm” (https://github.com/jinzhu/gorm) que j’intègre à mon framework.

En bref, ne venez pas me dire que Go est “pauvre en package pour se simplifier le travail”, parce que là… franchement…

Dans le prochain épisode, je vous montrerai comment on peu “packager” nos handlers, et faire un fichier de configuration pour mapper les requêtes. Avec ça, on peut rendre sympathique la configuration de notre API.

Et rien ne vous empêche de créer un service qui crée automatiquement l’API… en fait tout est possible :)

Serveur RSTP avec gstreamer et python

Tue, 02 Sep 2014 18:15:42 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Avec mon petit raspberry-pi je me suis lancé le défit de streamer mon bureau sur la télé sans avoir à installer quoique ce soit sur la framboise. Utiliser gstreamer sur mon pc et hop… quelle idée… en fait, c’est pas simple du tout, mais j’ai trouvé la ruse du sioux. Python, gstreamer, et un peu de recherche, voilà ma solution.

Je vous préviens, c’est clairement améliorable. Ce billet de blog va juste vous servir à capter le principe. Et puis ça fait une bonne entrée en matière pour le RSTP via gstreamer :)

Bon, l’idée c’est que la capture du bureau est un flux “temps réel”. Si le client ne lit pas le flux, on a pas envie de garder le tampon. Ca parait bête comme ça, mais c’est pourtant tout le problème. Heureusement pour nous, il existe des protocoles de communication qui servent à ça. Un d’entre eux, assez connu, est le RTP (Real Time Protocol). Et vous savez quoi, avec gstreamer c’est pas si compliqué. Sauf que…

J’ai l’habitude de “gstreamer”, et je me suis dit (connement) qu’un flux via le protocole RTP suffirait. Que nenni mon garçon, c’est pas si simple !

On commence d’abord par le début, comment faire ouvrir une adresse de media au XBMC (ici sur raspberry pi).

La solution la plus “simple” si je puis dire est de créer un répertoire contenant un fichier avec l’extension “strm”. C’est un simple fichier texte qui contien une addresse de flux. Et, pas de bol, xbmc ne connait que 3 protocoles (à ce que je sais…):

http - on oublie, pas de flux temps réel
mms - mais bien sûr…
rtsp - c’est quoi ce “s” en trop ?

On va revenir à ce “S” de RSTP après… d’abord parlons du raspberry (ou tout xbmc…)

J’ai donc créé dans le “home” de mon utilisateur “pi” sur le raspberry, un répertoire “mes_streams”, et un fichier “test.strm” contenant l’adresse d’une vidéo (http). J’ai ajouté la source dans l’interface (le répertoire) et en ouvrant le fichier, Xbmc va bel et bien lire la vidéo.

Donc le fichier “test.strm” contient:

http://une.adresse.vers/un.fichier.avi

Hop, je lance ce fichier strm sur le raspberry et miracle, ça marche.

Maintenant on va parler de RTSP…

Bon je vous l’ai dit, j’ai été idiot de croire que faire du RTSP était facile. RTSP est un protocole de streaming (Real Time Streaming Protocol) qui utilise RTP (Real Time Protocol). Sauf que voilà, ajouter un “S” à RTP ne suffit pas :)

On va détailler, c’est le but de ce ticket.

RTP c’est le protocole qui encapsule les trames de media.

Gstreamer a une chiée de plugins pour créer des “payloads” RTP. Un Payload est un contenu formaté correctement pour définir les type de media transférés et comment les lire. Bref, un gros bouzin compliqué qu’on ne va pas creuser en détail.

Ainsi, pour créer un payload h264, on peut faire ça:

gst-launch videotestsrc ! x26enc ! rtph264pay ! ...

Ce qui va vous intéresser, c’est ce qui suit (les trois petits points que j’ai laissé). Car en définitive, là on crée bien un payload, mais on l’envoit nulle part.

Et c’est là que j’ai déchanté… en fait il n’existe pas de (librement) de plugin RTSP. J’avais commencé à tenter de balancer le payload dans un “udpsink” mais sans succés. Non monsieur, RTSP c’est pas si simple.

Parce que moi, je me suis dit “allez te prend pas la tête, balance ça en udp…”:

gst-launch videotestsrc ! x264enc ! rtph264pay ! udp host=127.0.0.1 port=1234

et je l’ouvrai avec:

gst-launch udpsrc port=1234 ! rtph264depay ! decodebin ! autovideosink

Tu parles ! déjà ça marche pas, car il faut définir le “caps” à lire, en plus le raspberry il comprend rien à “udp://”

Et oui, en fait, le RTSP est un protocole de serveur spécifique qui sert justement à tout ça. M’a fallu un moment pour comprendre…

J’ai donc passé des heures à chercher, lire des docs, et je suis tombé sur des exemples en C. C’est donc avec dépis que je me dis “ok, on ne peut pas le faire avec gst-launch, mais on va se le faire en python”

Effectivement, il faut une librairie spécifique pour créer un serveur rtsp. Et heureusement pour nous, c’est en général packagé pour python, C/C++, et autres. Alors comme moi j’adore le python, on va pas se priver.

On commence par installer les packages, sur fedora ça donne:

sudo yum install gstreamer-python gstreamer-rtsp-python

Petite remarque… pas de possibilité avec gstreamer-1.0 apparement, à ce jour.

Bon, on y va… on crée le fichier “rtsp_test.py”

import pygst

pygst.require("0.10")

import gst
import gobject
import sys

from gst import rtspserver

server=rtspserver.Server()

factory = rtspserver.MediaFactory()
factory.set_launch(" videotestsrc ! ffmpegcolorspace ! x264enc ! rtph264pay name=pay0 pt=96 ")

server.get_media_mapping().add_factory('/test', factory)
server.attach()

try:
    gobject.MainLoop().run()
except KeyboardInterrupt :
    print "bye !"
    sys.exit()

J’explique. RTSP nécessiste une factory, c’est une usine à stream. Au moment où un client se connecte, il lance si besoin la création du stream. Ensuite on ajoute cette factory au serveur en lui spécifiant le chemin. Ainsi “/test” correspond au “test vidéo” que je fais (avec la mire videotestsrc)

Si je lance ce script, et que je vais ouvrir (avec vlc, totem, au choix) rtsp://127.0.0.1:8554/test alors je vois cette fameuse mire !

En mettant ce chemin dans le fichier test.strm de mon raspberry:

rtsp://192.168.1.29:8554/test

et bien ça fonctionne ! (192.168.1.29 est l’ip de mon pc, et j’ai ouvert le port 8554).

Ha au fait, pour ouvrir rapidos le port sur le pc:

firewall-cmd --add-port=8554/tcp --zone=public
firewall-cmd --add-port=8554/udp --zone=public

Quand le service de firewall se rechargera (avec reload…) ou au redémarrage du pc, ce port sera fermé. Si vous voulez garder la conf, ajoutez “–permanent” aux deux commandes précédentes.

Rest à ajouter un autre chemin, celui qui capture le bureau.

Ajoutez, juste après la création de la factory de test:

factorydesktop = rtspserver.MediaFactory()
factorydesktop.set_launch(" ximagesrc ! ffmpegcolorspace ! x264enc ! rtph264pay name=pay0 pt=96 ")
server.get_media_mapping().add_factory('/desktop', factorydesktop)

Et relancez le script.

Vous avez donc 2 chemins:

rtsp://192.168.1.29:8554/test qui montre une mire
rtsp://192.168.1.29:8554/desktop qui montre votre bureau

Reste à créer un autre fichier strm sur le raspberry-pi (ou votre XBMC encore une fois) et d’ouvrir ce dernier… attendez quelques secondes (la latence, j’ai pas trouvé comment la réduire) et hop voilà votre bureau sur votre télé :)

Bon voilà, le résultat est sympa, ça ne permet pas de faire grand-chose mais c’est intéressant de comprendre le principe.

Sachez que vous pouvez y mettre ce que vous voulez dans le flux RTP, là on a mis de la vidéo (la capture de bureau ou la mire de test), mais les “payloader” RTP de gstreamer sont nombreux. On peut donc streamer la musique, le son du pc, des images, etc… Il suffit de savoir faire un pipeline gstreamer. J’ai traité ça ici http://metal3d.org/ticket/2012/08/13/didacticiel-gstreamer et là http://metal3d.org/ticket/2012/08/14/gstreamer-la-suite

Installer localement Golang

Thu, 31 Jul 2014 13:33:48 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Toujours en cours d’écriture d’un livre sur le langage Go, ou du moins sur la pratique de ce langage, je mets de temps à autres des petits articles sur mon blog pour vous donner quelques points clefs. Et aujourd’hui, je vais vous montrer comment installer “localement” le compilateur et mettre les variables d’environnement au clair.

Go (http://golang.org) est un langage, mais il vient avec sa suite d’outils et une gestion de package téléchargeables depuis le net. Les paquets (packages) s’installent dans un répertoire et sont directement importé à la demande lors de la compilation… à condition de dire au compilateur où ils se trouvent. C’est le travail de la variable d’environnement GOPATH

GOROOT quant à elle, est utilisé pour savoir où trouver les outils (gotest, govet, gofmt…) et autres joyeusetés. Depuis la version 1.1, il est nécessaire de séparer les deux répertoires, ce qui (à mon goût) n’est pas super pratique au premier abord, car malheureusement Go ne donne pas de chemin par défaut pour GOPATH qui soit viable. En d’autres termes, quand vous allez utiliser “go install XXX”, vous allez vous prendre une belle erreur qui vous dit que vous devez fournir un chemin pour les packages externes.

Pour ma part, j’ai pas mal d’autres applications non packagées que j’ai installé “localement”. Quand je parle de “local”, je parle en fait de mon répertoire utilisateur. Et comme je n’aime pas attendre 6 mois pour avoir un paquet de Go mis à jour dans les paquets de ma distributions, y’a des choses que j’installe à la mimine.

Bref, dans notre exemple, on parle de Go.

Personnellement, j’utilise une configuration d’installation qui me permet de ne pas me mélanger les paluches:

la distro de Go dans ~/.go
le reste dans ~/Projets/goprojects

Pourquoi ?

Le répertoire de distribution de Go, normalement, vous n’avez pas à y toucher. Donc on se fiche de le voir apparaître dans le “home” directement. Je rappelle que sous Linux/Unix un point devant un nom de fichier sert à cacher le fichier (ou le répertoire)

Par contre, il est conseillé de développer dans le GOPATH/src afin de ne pas se battre avec les répertoires lors des instruction d’import de vos programmes. Comme je ne code pas que en Go, j’ai un répertoire Projets dans mon home, et tout ce qui est “externes à la distributions de go” va être placée dans ce répertoire.

Voilà comment ça se passe.

wget http://golang.org/dl/go1.3.linux-amd64.tar.gz
tar xf go1.3.linux-amd64.tar.gz
mv go ~/.go

Donc, là, on vient de télécharger le paquet de Go, on a décompressé le répertoire qui a créé ~/go. Je le déplace en “~/.go” pour le cacher de ma vue.

On crée maintenant le répertoire pour installer les paquets externes et développer nos propre packages:

mkdir -p ~/Projets/goprojects

Reste plus qu’à changer les variables qui vont bien dans ~/.bashrc:

export GOROOT=~/.go
export GOPATH=~/Projets/goprojects
export PATH=$GOROOT/bin:$GOPATH/bin:$PATH

La variable PATH comprend donc le répertoire ~/.go/bin (qui contient les commandes go) et le répertoire ~/Projets/gprojects/bin où seront ajoutés les programmes externes (comme par exemple godev, gocode…).

Reste plus qu’à essayer, soit vous faites:

source ~/.bashrc

Soit vous vous reloguez, ou vous ouvrez un autre terminal. Si vous tapez:

go --version

Ca doit bien se passer…

Installez un paquet, genre gocode (dont je suis fan, je l’utilise à foison via vim):

go get -u github.com/nsf/gocode
gocode -h

Ca marche, la commande gocode est bien accessible.

Voilà, de cette manière vous avez un bon contrôle sur votre installation locale de Go, et en plus c’est facile à virer… le jour où vous voulez tout supprimer:

rm -rf ~/.go ~/Projets/goprojects

et le tour est joué.

Le modèle CSS3 flex-box

Sun, 13 Jul 2014 13:37:37 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Que ce soit sur téléphone, tablette ou bureau, un des casse-têtes quotidiens des intégrateurs HTML est la position des boites et leur étirement. En gros, on cherche toujours à ce qu’une image soit positionné à coté d’un bloc de texte, le tout dans un conteneur qui s’étire de la même manière que le reste… basé sur le contenu de ce qui l’entoure. En bref, l’arrachage de cheveux dans les règles. Mais en fait, il existe une série de directives CSS3 qui soulage fortement le monteur, bien que mal connue, le système de “flex”.

Flex, comme flexible, étirable. A ne pas confondre avec Flex pour Flash. Ainsi, au lieu de parler de “flex” qui, dans Google, remonte des articles parlant de cette techno Flash, il vaut mieux parler de “flex-boxes CSS3”.

Ce qu’il y a de sympa avec ces directives, c’est qu’elle marche presque partout. De IE à Chrome en passant par Firefox… ça se passe pas mal. Bon ok, souvent il faudra préfixer la directive pour les version un peu anciennes et permettre d’avoir le comportement attendu. Si vous utilisez Less ou Sass, ça ira très vite.

Je ne vais pas vous faire un cours magistral sur toutes les possibilités des flex boxes, mais vous montrer deux ou trois exemples qui m’ont permis de monter une interface HTML qui tourne sur pratiquement toutes les plateformes que je cible. A savoir, une interface simple sur Android, Firefox et Chrome. Je n’ai pas testé sur IE, mais je pense que ça se passera bien.

Avant tout, c’est quoi le système de flex ?

Des boites élastiques

Les flex boxes permettent de faire en sorte qu’un conteneur (div, main, body…) s’étire et place son contenu en fonction du reste. Pour que votre boite gère le principe flexible, il suffit de donner donner la valeur “flex” à la directive “display”. Ca donne ça:

div {
    display: flex;
}

Me dites pas que c’était compliqué ! Bon ok, là on a fait que le début.

Ensuit va venir les attributs de flexibilité, on va permettre à une boite de gérer son contenu en colonne, en ligne, de se placer avant ou après le reste, et surtout de savoir combien de place par rapport au reste elle va prendre.

Les directives:

display: flex; avec des prefix -ms -webkit -moz… pour les vieux navigateurs, ça se passera bien.
flex: G S B; G et S => flex-grow (entier), S => flex-shrink (entier) et B => flex-basis (auto, ou taille), par défaut la valeur est “0 1 auto”
flex-direction: column|row|row-reverse…; y’en a plein
order: N; Ordre d’affichage. Permet de placer une boite avant un autre, sans bouger le DOM (ça c’est cool hein)

Pour clarifier:

flex-grow: force l’espacement par rapport aux autres élément dans le conteneur. Si vous avez 3 boites, et que vous donner la valeur 1 à deux boites, et 3 à une boite, cette dernière sera 3 fois plus grande que les deux autres…
flex-shrink: par défaut à 1, permet de réduire la taille de la boite si nécessaire
flex-basis: défini la taille avant que l’espacement soit distribué aux boites. “auto” par défaut.

Ça peut paraître un peu compliqué comme ça, mais en fait c’est super simple… surtout quand on le met en pratique. Et on va le faire :)

Mise en pratique: le layout cardinal

Le layout cardinal est simple. On veut 5 boites:

une entête (bannière, titre…)
3 colonnes pour la navigation, le contenu principal et une barre d’info à droite
un footer.

Le DOM va être bêtement:

<header>HEADER</header>
<div id="content">
    <main>MAIN CONTENT</main>
    <nav>NAV LEFT</nav>
    <aside>ASIDE RIGHT</aside>
</div>
<footer>FOOTER</footer>

Vous remarquez que j’ai placé le bloc “main” avant la navigation et le bloc aside, alors qu’on veut l’avoir visuellement après la navigation. On va gérer ça facilement avec la directive “order”.

Ce qu’on va faire, pour commencer, c’est définir que nous gérons le mode “flex” pour tout nos blocs définis. Allez c’est pas compliqué (et je le fais en pur CSS):

header, #content, footer {
    display: -webkit-box;
    display: -moz-box;
    display: -ms-flexbox;
    display: -webkit-flex;
    display: flex;
}

Ca c’est fait… Ca donne ça:

Bon j'ai ajouté de la couleur et une marge pour qu'on se rendre mieux compte des boites.

On remarque donc, d’entrée de jeu, que les boites contenu “#content” se trouvent en ligne, côte à côte, mais jusque là, rien d’impressionnant. On pourrait le faire à base de float ou de “inline-block”. Voyons la suite.

Ce qu’on doit faire, maintenant, c’est forcer le fait que le bloc “main” s’étire. On ajoute simplement “flex: 1”:

main {
    flex: 1
}

Et ça donne:

Bon, pas mal :), le bloc main est bien étiré, quelque soit le padding, le margin des conteneurs, tout se cale correctement et c'est déjà un grand pas !

Mais je sais ce que vous allez me dire… oui, ok mais si on met du contenu dans “main”, ça étire pas les bloc de navigation et aside dans la hauteur. La preuve que si:

Avouez le, ça vous éclate :) Et on a presque pas codé de CSS, on a pas une ligne de JS.

Reste le dernier point, le truc qui fâche, comment faire pour que la taille totale colle à 100% de la hauteur de la page ? Ou d’un conteneur qui l’englobe.

Et bien c’est super simple. On va juste forcer le fait que “body” soit un model de boite, on lui donne une taille de 100% en hauteur. Ensuite on demande à ce que “#content” fasse aussi 100% de la hauteur. Là où ça devient intéressant, c’est que le modèle de boite se débrouille pour que “100%” ne soit pas destructif. Il calcule son espace par rapport aux autres boites. Et du coup, ça colle parfaitement, quelque soit la taille de la fenêtre, quelque soit le contenu…

Comme on fait des lignes (header au dessus de #content qui est au dessus de footer), le body est une grosse colonne.

On va donc faire ça (j’ai viré les valeurs préfixées sinon ça fait trop de choses à lire):

/* On force la taille de la page... et on modèle de boite global */
body, html {
    display: flex;
    flex-direction: column;
    height: 100%
}

/* et on s'arrange pour que le contenu (ligne 2) prenne toute la place */
#content {
    height: 100%
}

J’ai ajouté aussi un overflox pour la balise “main” car le texte peut déborder si vous réduisez la fenêtre. Bref, sans trop forcer, j’arrive à ça:

Notez bien que j'ai enlevé des paragraphes pour vous prouver que la taille des blocs s'étirent en hauteur.

Aucun calcul, pas de JS, tout s’automatise… si c’est pas génial ça !

Et le responsive dans tout ça ?

Ce qui est sidérant, c’est que ce modèle de boite permet de faire des trucs vraiment puissant. Et quand on parle de responsive design on se rend compte que tout est là pour nous rendre la vie douce est mélodieuse.

Reprenons, on a “aside”, “main” et “nav” cote à cote. Mais quand on va descendre en résolution, on va avoir bobo… Il suffit simplement de dire à notre modèle qu’en dessous de 600px de largeur, notre bloc “#content” est un modèle en colonnes. Comment ? simplement:

@media all and (max-width: 600px) {
    #content {
        flex-flow: column
    }
}

Mais en plus, pour l’exemple, je veux que le bloc “nav” apparaisse après le bloc main. Avant on devait se taper un JS terrible de déplacement d’objet dans le DOM. Avec CSS et le modèle de boite… comment dire… c’est d’un con…

@media all and (max-width: 600px) {
    #content {
        flex-flow: column
    }

    nav, aside {
        order: 2
    }
    main {
        order: 1
    }
}

Et là, la magie:

Je vous laisse tenter le coup, ouvrez cet exemple: et amusez vous à redimensionner la fenêtre. Vous allez voir les boites bouger en fonction de la taille du navigateur. C'est tout simplement pratique, facile, clair et efficace.

Alors, pourquoi personne n’y pense ?

Honnêtement, je ne sais pas pourquoi la communication est mal passée sur ce principe de boite. Je l’ai découvert il y a peu de temps et j’ai l’impression qu’on est encore peu nombreux à avoir analysé et testé ce modèle CSS.

Pourtant, il répond pratiquement à tous les soucis existants. Il permet de caler parfaitement du contenu en bas de bloc (par exemple un bloc de produit donc le prix doit apparaître en bas de div), de faire des colonne flexibles, de résoudre des problèmes de largeur et de hauteurs. Ca marche bien sur mobile et les prefix vendor sont apparemment présents de puis des années…

Aujourd’hui, le mode boite est validée, et je suis persuadé qu’on va en entendre parler, et surtout qu’il va être fortement utilisé par la suite. Fini les table-cell et autre calc() CSS, terminé les padding avec des bloc flottants là où on en a pas besoin. Le modèle flexbox va fleurir.

Je ne vous ai montré qu’un infime partie de ce que permet ce modèle, je vous conseille d’aller voir deux trois pages que j’ai trouvé intéressantes:

http://www.w3.org/TR/css3-flexbox/ => la référence avec des exemples de bloc produit
http://www.alsacreations.com/tuto/lire/1493-css3-flexbox-layout-module.html => très bien expliqué de la part de alsacréation
http://css-tricks.com/snippets/css/a-guide-to-flexbox/ => page avec des exemples et pas mal de simplifications

Voilà pour aujourd’hui :)

Générateur de tests Python pour nose

Wed, 18 Jun 2014 22:39:24 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Python, j’en parle beaucoup, mais je l’utilise aussi pas mal. Faut dire, je bosse à 99% du temps sur ce langage. Et aujourd’hui, avec mon acolyte Jonathan Dray, on a réalisé un module qui nous a fait un peu plancher, mais qui apporte beaucoup à notre projet: des tests automatiques, c’est-à-dire générés. Ca peut paraitre touchy, overkill ou tout les mots à la mode que vous voulez, je vous assure (et vous allez le voir) que ça peut vous apporter beaucoup…

Au début, il y’a avait un beau foutoir

Je vous passe les détails. On a un module qui demande des tests hebdomadaires (parce que c’est un peu long à traiter). Pour simplifier l’explication: on parle des données sur le web, pour s’assurer que nos règles de parsing restent valables j’avais imaginé ce genre d’archi:

expected/
    siteA.py
    siteB.py
    siteC.py
    ...
test_SiteA.py
test_SiteB.py
test_SiteC.py
...

Dans “expected.siteA” on a un truc du genre:

data = {'un titre de test'; {
        'url' : 'http://...',
        'expected' : {
            # ... des datas traitées depuis cet url
        }
    },
    {'un autre titre': {
        #idem qu'au dessue, une url, des expected
        }
    }
}

La raison pour laquelle j’avais sorti les “expected” (données attendues) c’est que les données à tester sont relativement lourdes… Du coup, dans les tests unutaire on avait (en résumé):

from expected import siteA
# un truc de base qui gère des trucs redondants
from tests import testbase

# la class de test...
class TestSiteA(testbase):

    def test_url1(self):
        parsed = self.parse(siteA.data['un titre de test']['url'])
        self.assertEquals(parsed, siteA.data['un titre de test']['expected'])

Et ce, répété pour chaque site, pour chaque url du dictionnaire “data” contenu dans les module… bref, imbuvable même sous la contrainte. Jonathan pète un câble et me dit “non mais c’est complètement con, on copie colle là”. Et hors de question de faire une boucle… pouquoi ? c’est simple comme choux: on utilise nose, on va perdre des options cool.

Pas de boucle, et pour cause

Je reviens à la dernière remarque. Si Jonathan n’avait pas été là, j’aurais bêtement fait un truc qui charge toutes les données “expected”, et puis roulez jeunesse. Mais si un test foire, chaque appel à “nosetests” m’aurait rejoué toute la séquence.

Parce que voilà, nose est cool, il permet de faire ce genre de chose:

nosetests -sv test:TestSiteA.test_url1

Alors le truc à faire, c’est donc de savoir générer les tests… mais vous l’aurez compris, on ne va pas réellement les générer en tant que fichier, non, car Python est une tuerie en terme de réflexion et metaclasse. On va lire de la doc et créer un truc qui fait ça à la mode bourinnasse.

Faut que vous rencontriez ce type()

Vous me comprennez, je veux pouvoir utiliser “nose” comme si j’avais créé les classes nécessaires, sachant qu’elles font toutes à peu près la même chose. Le tout, c’est d’avoir un nom de classe consistant, et des méthodes de tests qui correspondent à peu près au titre des données attendues.

Générer une classe est ultra simple:

cl = type(nom, (parent1,...), {propriétés...})

“cl” sera la classe elle-même, et je dis bien “la classe”, et non un objet. Ca sent bon ça, mais le souci, c’est que je dois l’assigner au module courant. Toujours aussi simple, on utilise le module “sys” qui fourni la liste des modules chargés, y compris celui en cours. Et comment on connait le nom du module courrant ? Bha oui: __name__

Voyons voir:

import sys
import unitest

class BaseTest(unittest.TestCase)
    """ Classe de base, on y reviendra """
    pass

def init():
    # hop une référence au module en cours
    current = sys.modules[__name__]

    # génère une classe pour faire mumuse
    cl = type("Classe1", (BaseTest,), {})

    # on l'assigne au module en cours
    setattr(current, cl.__name__, cl)

init()
import pdb; pdb.set_trace()

Si vous sauvez ça dans “./tests/__init__.py” et que vous exécutez:

nosetests -sv tests

Vous vous retrouvez dans une console pdb, tapez simplement:

dir(sys.modules[__name__])

et là, miracle, vous voyez bien que votre module a une classe nommée “Classe1”. Bha on continue !

OK, mais pour les expected là…

Bon c’est cool mais on va passer aux choses sérieuses. Je veux générer:

une classe par module expected
une méthode pour chaque url

Avoir la liste des modules a été le plus tordu… c’est pkgutil. Et pour m’assurer d’avoir bien le chemin du module expected, j’ai usé de ruse:

# on prend le chemin exact
pkgpath = os.path.dirname(expected.__file__) 

# et on a la liste des modules
for mod in pkgutil.iter_modules([pkgpath]):
    # on prend juste le nom:
    modname = mod[1]

Donc là, en visitant https://docs.python.org/2/library/pkgutil.html#pkgutil.iter_modules vous verrez que le nom du module est le second élément du tuple retourné par “iter_modules”, c’est pourquoi j’ai récupéré le nom dans “mod[1]”.

Va pour générer le nom de classe…

# on prend le chemin exact
pkgpath = os.path.dirname(expected.__file__) 

# et on a la liste des modules
for mod in pkgutil.iter_modules([pkgpath]):
    # on prend juste le nom:
    modname = mod[1]
    cl = type("Test%s" % modname, (BaseTest,), {}

    # par exemple, on aura TestSiteA pour le module expected.SiteA
    # etc...

Ok… on va générer les méthodes, on s’y prend un peu comme pour la classe. Seule problème, la méthode doit faire des trucs hein… et surtout utiliser les méthodes d’assertion. Et là, vous remerciez le ciel que Python demande de passer explicitement la référence de la classe à ces méthodes. Car de cette manière, on peut déclarer une fonction hors classe qui prend en argument un paramètre “self”, puis l’attacher à une classe. Du coup, “self” sera bel et bien défini à la déclaration, et utilisée par la classe. Haaaa douce mélodie qu’est le code Python.

On se lance.

# un générateur de méthode, c'est cool ça
def _method(data):
    # on défini la méthode qui gère "data"
    def the_method(self):
        # oui, python est magique, on a un self là
        # donc là, vous pouvez créer votre test générique, nous
        # on utilise notre parser
        parsed = self.parse(data['url'])
        self.assertEquals(parsed, data['expected'])
    return the_method

Donc, si j’appelle:

method = _method(data)

la variable “method” sera une instance “the_method” qui peut utiliser les “data”. Et quant à “self”, il sera refourgué par l’appel à la méthode au travers de la classe. Voilà une raison toute bête de l’utilité de déclarer explicitement le mot clef “self” dans les méthodes de classe en Python, c’est simplement parce que vous pouvez générer des méthodes en dehors des classes, et par conséquent, la variable “self” doit exister dans le corps de la fonction. Donc, on la file en argument. C’est pas compliqué boudiou !!!

Et donc, là, on va l’utiliser. Après avoir généré la classe, on peut générer la méthode et l’accrocher à la classe (cherchez “==> LA” dans le code pour trouver où on génère la méthode):

# et on a la liste des modules
for mod in pkgutil.iter_modules([pkgpath]):
    # on prend juste le nom:
    modname = mod[1]

    # BaseTest c'est notre classe de base qui hérite de unittest.TestCase
    # Et donc là, on aura par exemple TestSiteA, classe qui hérite de notre
    # classe de base
    cl = type("Test%s" % modname, (BaseTest,), {}

    # on charge le module, on demande de charger "data" avec...
    module = __import__(modname, globals(), locals(), ["data"])

    # on itère sur les modules
    for key, val in module.data.items():

        # on génère le nom sans espace
        # par exemple "un titre de test" devient
        # un_titre_de_test (et je me fous des accents pour le moment)
        key = key.replace(" ","_") 

        # on récupère une méthode qui va utiliser
        # nos datas
        # ==> LA
        method = _method(val)

        # on génère le nom de la méthode
        # ce qui donnera "test_un_titre_de_test"
        method.__name__ = "test_%s" % key

        # hop, on assigne ça à la classe
        setattr(cl, method.__name__, method)

    #et voilà, on foure notre classe au module
    setattr(sys.module[__name__], cl.__name__, cl)

Si vous avez tout suivi:

on load expected
pour chaque module trouvé dans expected on récupère le nom et on génère une classe
on charge les données de test
pour chaque données de test, on génère une méthode qui utilise les assertions de unittest…

Donc, le code à peu près valide (oui là je le teste pas et comptez pas sur moi pour vous refourguer le code de mon client hein :p ):

import unittest
import sys
import pkgutil
import expected

class BaseTest(unittest.TestCase):
    """ Classe de base, elle peut faire un setUp, un tearDown
        et avoir des méthodes spécifique, comme "parse" dans notre
        cas... 
    """ 

    def parse(seld, data):
        # méthode à nous pour parser une url
        return {}

def init():
    """ Initialise les classes de test """

    # notre générateur de méthode
    def _method(data):

        def the_method(self):
            # le test en lui même
            # libre à vous de faire vos propres test ICI
            parsed = self.parse(data['url'])

            #assertion qui viendra de unittest.TestCase
            self.assertEquals(parsed, data['expected'])

        # retourne la fonction de test
        return the_method

    # on prend le chemin exact
    pkgpath = os.path.dirname(expected.__file__) 

    # et on a la liste des modules
    for mod in pkgutil.iter_modules([pkgpath]):

        # on prend juste le nom:
        modname = mod[1]

        # génération de la classe avec le nom du module
        cl = type("Test%s" % modname, (BaseTest,), {}

        # on charge le module, on demande de charger "data" avec...
        module = __import__(modname, globals(), locals(), ["data"])

        # pour chaque module expected
        for key, val in module.data.items():

            # on génère le nom sans espace
            key = key.replace(" ","_") 

            # génération de la méthode test_nom_du_test
            method = _method(val)
            method.__name__ = "test_%s" % key

            # assignation dans la classe
            setattr(cl, method.__name__, method)

        # déclaration de la méthode dans le module
        setattr(sys.module[__name__], cl.__name__, cl)

# initialisation
init()

Donc, là… on peut faire:

nosetests -sv tests

qui va lancer tous les tests générés.

Ou:

nosetests -sv tests:TestSiteA.test_un_titre_de_test

qui ne lancera que le test “un titre de test” choppé depuis le module expected.SiteA.py

Ou encore:

nosetests -sv tests:TestSiteB

qui lancera tous les tests de TestSiteB.

Heu… ok… mais du coup ?

Vous n’avez pas compris l’intérêt ? je vais vous faire un résumé.

Avant on devait:

Créer un module qui contenait des données attendue, non placées dans le test pour des raison de place, de lisibilité…
Créer une classe de test qui:
charge le module expected.ModuleATester
charge le parser
fait les asserts

Alors que maintenant, on ne fait que la première partie… on créer un module dans “expected”, formatté corretement, et c’est tout. Notre générateur va trouver le nouveau module, les données avec le titre, et générer un test à la volée. On peut invoquer un test par son nom logique, on peut même demander à nose de n’exécuter qu’une seule méthode. Car la méthode existera réellement, Python génère les classes comme si nous les avions réellement écrites.

Si ça vous parait étrange, trop “brutal”, demandez vous comment vous auriez fait pour réussir le même tour de force avec les même contraintes, à savoir pouvoir utiliser nose “comme si les classes existaient vraiement”.

Depuis, on ne tape pas un seul test, on ne génère que le module de données à tester.

On a amélioré le système en permattant au développeur de spécifier des assertions particulères dans les modules de “expected”, et même la gestion des “skip”… le temps de création et de maintenance de ces tests est tout simplement réduit par 10.

Python en mode one liner

Fri, 30 May 2014 14:11:36 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Python, c’est cool, c’est fun, c’est lisible et en plus c’est super bien intégré aux Unix. Alors quand on peut en plus s’en servir comme “one liner”…

Bon tout le monde connait sed, awk, perl etc… ils permettent d’être utilisés en “one liner” c’est-à-dire à traiter en une ligne des données injectées (généralement depuis un fichier ou une redirection dans STDIN). Sauf que Python n’est pas en reste… ou plutôt il l’est mais on peut rapidement se créer son petit outil qui avoir le même effet que sed, awk et consorts.

Non parce que bon, sérieusement, au taff on me sort souvent “pfff mais c’est quoi ce truc” en me montrant du doigt des instructions awk que j’ai tapé… ou encore “hey mais comment tu fais pour récupérer tel élément avec sed là ?”. Car voilà, au taff, on est surtout des Pythonistes… alors quand ils voient des variables avec un dolar devant ils sont perdus (si un collègue lis mon article: te vexe pas, je taquine :) )

Il existe un projet nommé Pyped que je trouve vraiment super, mais bon il demande pas mal de deps et pis bon hein… c’est du Python 2.7. Non pas que j’aime pas Python 2.7, mais faut commencer à utiliser Python 3 un jour…

Du coup je vous montre celui que j’ai codé, et dans la foulée ça fera un petit tuto. On commence, allons-y gaiement !

Lire STDIN, tout un programme

L’idée est de pouvoir injecter des lignes dans le STDIN du script, et ce depuis pas mal de sources possible (fichier, commande shell, …).

On va utiliser “sys.stdin” (quelle suprise !). Pour lire une ligne, on utilise “sys.stdin.readline()”.

Jusque là c’est facile. Mais j’aime les piments, alors on pimente un peu: je sais qu’un jour ou l’autre je vais me prendre plusieurs centaines de mega, voir des gigas de donnée dans STDIN… alors je vais “itérer” sur les lignes de données. Et devinez quoi, y’a un built-in Python génialissime pour ça: iter().

“iter” est un petit cachotier, car on le connait pour sa forme iter(list), mais bien moins pour sa forme “iter(callable, sentinel)”. C’est très simple il va retourner ce que le callable génère jusqu’à ce que la sentinel soit trouvée. En l’occurence, nous, on veut lire sys.stdin.readline jusqu’à ce qu’elle nous retourne plus rien… hahaha on tente ?

#!/usr/bin/python3 -u
import sys

for x in iter(sys.stdin.readline, ''):
    x = x.rstrip('\n')
    print(x)

Remarquez bien que j’utilise “python 3” et l’option “-u” pour utiliser STDIN et STDOUT en mode “non bufferisé”

Bon, vous rendez ce p’tit script exécutable et vous testez:

$ chmod +x pype.py
$ dmesg | tail | pype.py

Cool hein, on vient de faire un script qui affiche la sortie standard. Voilà c’est tout pour aujourd’hui… non je déconne, on va aller plus loin :)

Bon, on sait lire de manière propre une entrée standard. Reste maintenant à faire en sorte de traiter ces lignes.

Dans Python (version 3 pour l’heure) il existe la commande “exec”. Elle permet d’une part d’éxecuter du code python, mais prend en second et troisième paramètres des dictionnaires qui représentent respectivement les variables globales et locales. On appelle souvent ces attributs des “contextes” (ceux qui utilisent Jinja connaissent le principe). Chaque clef du dict contexte est le nom d’une variable accessible dans les instructions passées à “exec”.

Donc, on va permettre de prendre en argument un truc à exécuter. Vous avez compris… sys.argv va être notre allié.

#!/usr/bin/python3 -u
    # -*- encoding: utf-8 -*-

import sys

ctx = globales()
cmd = sys.argv[1]

for x in iter(sys.stdin.readline, ''):
            # on va donner une variable "x" qui est
            # la ligne STDIN récupérée
    ctx["x"] = x.rstrip('\n')
    exec(cmd, ctx)

On va donc s’amuser, par exemple lister le répertoire “/etc” et n’afficher que les fichiers qui ont “.conf” dans leur nom:

$ ls -1 /etc | pype.py 'if x.find(".conf"): print(x)'

Pas mal hein :) on va maintenant aller un peu plus loin. J’adore “enumerate” qui retourne l’index et l’entrée d’une liste. Allez, on y va.

#!/usr/bin/python3 -u
    # -*- encoding: utf-8 -*-

import sys

ctx = globales()
cmd = sys.argv[1]

for i, x in enumerate(iter(sys.stdin.readline, '')):
            # on va donner une variable "x" qui est
            # la ligne STDIN récupérée
            # et "i" est le numéro de ligne
    ctx["x"] = x.rstrip('\n')
    ctx["i"] = i
    exec(cmd, ctx)

On peut tester:

$ dmesg | tail | pype.py "print('%d -- %s' % (i, x))"

Si tout se passe bien, vous devez avoir le numéro de la ligne, puis deux tirets et le message récupéré dans STDIN, sinon c’est que j’ai foiré un truc dans mes exemples…

Bon reste un souci…

Si j’ai besoin d’un import “lourd”, et que je le met dans la ligne d’exécution, chaque ligne rencontrée va lancer l’import du module. C’est rageant. Le mieux, tout comme le propose awk, c’est d’avoir un block “begin” qui n’est exécuté qu’au début, et pourquoi pas un un block “end”. Et comme Python est founis en outils pour gérer facilement des trucs, on va utiliser “optparse”.

Le résultat est cool:

#!/usr/bin/python3
# -*- encoding: utf8 -*-

import optparse
import sys

# prepare options
parser = optparse.OptionParser()
parser.add_option('-e', '--end', 
            action="store", 
            dest="end", 
            help="end code", 
            default=None)
parser.add_option('-b', '--begin', 
            action="store", 
            dest="begin", 
            help="begin code", 
            default=None)

options, expr = parser.parse_args()

# now, save ctx (and get imports fro BEGIN if any)
ctx = globals()

#execute BEGIN block
if options.begin is not None:
    exec(options.begin, ctx)


#joining all commands
expr = "\n".join(expr)

# for each stdin line, stop if empty
for i, x in enumerate(iter(sys.stdin.readline, '')):
    ctx['x'] = x.rstrip('\n')
    ctx['i'] = i
    exec (expr, ctx)

# execute END code
if options.end is not None:
    exec (options.end, ctx)

Donc, là, pour tout vous expliquer:

On propose deux options, -b (–begin) et -e (–end) qui permettent de donner des instructions à exécuter au début et à la fin du travail (import, ouverture de fichier, etc…) les variables seront accessibles dans les block d’instructions
on récupère touts les autres paramètre qui sont les instructions à traiter. C’est une liste, donc je les join avec “n”.join(…)
on intègre dans le contexte deux variables: x => la ligne capturée dans STDIN et “i” qui est le numéro de la ligne à traiter (sympa pour compter)

Comprennez bien, j’utilise le contexte “ctx” dans les 3 “exec”, du coup les variables et import créés dans le block begin sont accessible dans les blocks d’instructions et le block “end”; et par conséquent une variable créée dans le block principal sera accessible dans le block “end”. Le context est clairement l’environnement de globales qui se promène partout.

Du coup, là, on peut faire:

$ ls -1 /etc | ./main.py \
-b "import re; counter = 0" \
-e "print('Founds: %d' % counter)" \
"if re.findall('.*.conf', x):
     print('found %s at %d' % (x, i))
     counter += 1
"

(les backslash sont là parce que dans mon blog ça déborde, ça permet de revenir à la ligne sans exécuter l’instruction… si vous le souhaitez, vous pouvez ne pas les mettre et tout faire en une ligne, d’où le nom “one liner” hein)

On charge “re” au début et on initialise un compteur “counter”, puis pour chaque ligne on utilise le module.

A la fin… on acffiche le compteur.

Bref, c’est pas idiot comme script, et ça peut être (pour les Pythonistes) plus agréable que awk ou sed.

Et un zeste de Cython

Allez, on va gagner le temps d’interprétation et (dans certains cas) accélerer un chouillat le tratement de notre script. Bon ok, c’est pas super avantageux mais juste pour l’amusement… on va compiler notre script pour en faire un binaire exécutable natif:

$ cython --embed pype.py
$ gcc pype.c -o pype -O9 $(pkg-config --libs --cflags python3)

Vous avez maintenant un binaire “pype” que vous pouvez copier dans un répertoire de votre $PATH, par exemple dans “~./local/bin”. Le binaire doit faire dans les 40ko.

Alors oui, on peut améliorer le truc, on peut utiliser le projet Pyped (su-cité), mais bon sang… que c’est cool de le faire soi-même !

Un mot pour la fin

De mon coté, mon script est à peine différent que celui que je vous propse; en fait j’ai juste ajouté des “import” pour que le contexte ait accès à des modules que je trouve indispensable:

import re -> pour les expressions régulières, je m’en sers tout le temps
import json -> on ne le présente plus
import os -> parfois utile pour la résolution de path

Tout ce que vous avez à faire, c’est de les mettre dans pype.py au début du script. Comme nous initialisons le contexte avec “globales()”, ces modules sont accessible dans les block d’instructions. Vous pouvez le recompiler avec cython, et le tour est joué.

A vous de vous amuser, de mettre les modules qui vous intéressent, d’adapter mon script (qui est libre), de l’améliorer. Il est clair que je le fais ici en Python, mais les PHPistes pourront le faire en PHP, les Javaistes ne pourront pas (oui bha une boutade de temps en temps hein…), et je suis sûr que c’est faisable en NodeJS.

Allez à vous !

Règles de base iptables

Fri, 01 Nov 2013 14:07:10 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

J’ai dut changé de serveur il y a 2 jours et face à une nouvelle installation, je me suis retrouvé confronté à une configuration de base iptables ésotérique. Après plusieurs tentatives de modifications “nouvelle mode”, j’en suis revenu à ma méthode favorite, l’ancienne, celle qui marche. Ainsi, si vous voulez régler un firewall “basique” (assez fiable), vous pouvez suivre ma méthode. Elle n’est pas nouvelle ni révolutionnaire, mais elle est maîtrisable.

Tout d’abord, la fameuse commande “iptables -L” me donnait des règles difficilement compréhensibles. Etant donné que je voulais au moins arriver à ouvrir quelques ports, et sans entrer dans une configuration compliquée, j’ai décidé de faire un “flush”. Erreur !!! trop pressé, j’ai simplement laissé les règles par défaut en “DROP”, je n’avais plus qu’à relancer le serveur pour m’en sortir.

Bref, pour éviter tout problème, voici les commandes de base à effectuer:

iptables -P INPUT ACCEPT
iptables -F
iptables -X
iptables -t mangle -F
iptables -t nat -X

Ce qui fait que toutes les règles de bases sont supprimées. Mais ne perd pas la connexion en cours car nous avons demandé d’accepter toutes les connexions par défaut (le temps de configurer le par-feu).

Mainentant, on va configurer un peu notre par-feu pour n’ouvrir que ce dont nous avons vraiment besoin, à savoir:

ssh (port 22)
http, https et http-alt (ports 80, 443 et 8080)

Il faut aussi:

accepter les connexions sur le rebouclage locale (connexions internes)
accepter les connexions déjà en cours vers la sortie, si une connexion entrante à été acceptée, il faut pouvoir lui répondre
accepter tout en sortie (pour mon cas, vous pouvez ne pas le vouloir)

On va donc commencer par le plus simple,

iptables -A INPUT -i lo -j ACCEPT

Donc, sur l’interface “lo”, on accept tout. On continue sur notre lancée, on accepte les connexions établies

iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

Et enfin, les connexions venant de l’extérieure sont acceptées seulement sur les ports que nous désirons. L’interface “eth0” est, sur mon serveur, la carte qui est utilisé pour l’accès depuis l’extérieure, vérifiez avec “ifconfig” le nom de votre interface réseau.

Donc pour mes ports à ouvrir (tcp uniquement):

iptables -A INPUT -i eth0 -p tcp -m tcp --dport 22 -j ACCEPT
iptables -A INPUT -i eth0 -p tcp -m tcp --dport 80 -j ACCEPT
iptables -A INPUT -i eth0 -p tcp -m tcp --dport 443 -j ACCEPT
iptables -A INPUT -i eth0 -p tcp -m tcp --dport 8080 -j ACCEPT

Pour des raisons pratique, je veux que mon serveur accpete aussi de répondre au “ping”, vous pouvez utiliser cette règle:

iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT

Et enfin, je “DROP” (laisse tomber, c’est-à-dire refuser…) le reste par défaut:

iptables -P INPUT DROP

Un coup de “iptables -L” vous donne la liste effective des règles de votre firewall:

Chain INPUT (policy DROP)
target     prot opt source               destination         
ACCEPT     all  --  anywhere             anywhere            
ACCEPT     all  --  anywhere             anywhere             state RELATED,ESTABLISHED
ACCEPT     tcp  --  anywhere             anywhere             tcp dpt:ssh
ACCEPT     tcp  --  anywhere             anywhere             tcp dpt:http
ACCEPT     tcp  --  anywhere             anywhere             tcp dpt:https
ACCEPT     tcp  --  anywhere             anywhere             tcp dpt:http-alt
ACCEPT     icmp --  anywhere             anywhere             icmp echo-request

Chain FORWARD (policy DROP)
target     prot opt source               destination         


Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination

Ce qui compte ici, c’est de voir que la politique par défaut (policy) est à DROP pour les entrées (INPUT) et traduction ip (FORWARD, utile dans mon cas car j’installe libvirt pour faire tourner des LXC, à savoir que libvirt installe des règles iptables au lancement, donc je ne m’en occupe pas pour le moment).

Pour des raisons pratique, je veux que mon serveur accpete aussi de répondre au “ping”, vous pouvez utiliser cette règle:

iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT

L’autre commande utile est “iptables-save”:

*filter
:INPUT DROP [7:614]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [414:373999]
-A INPUT -i lo -j ACCEPT
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i eth0 -p tcp -m tcp --dport 22 -j ACCEPT
-A INPUT -i eth0 -p tcp -m tcp --dport 80 -j ACCEPT
-A INPUT -i eth0 -p tcp -m tcp --dport 443 -j ACCEPT
-A INPUT -i eth0 -p tcp -m tcp --dport 8080 -j ACCEPT
-A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT
COMMIT
# Completed on Fri Nov  1 01:02:47 2013
# Generated by iptables-save v1.4.14 on Fri Nov  1 01:02:47 2013
*mangle
:PREROUTING ACCEPT [720:485103]
:INPUT ACCEPT [716:484539]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [496:383895]
:POSTROUTING ACCEPT [496:383895]
COMMIT
# Completed on Fri Nov  1 01:02:47 2013
# Generated by iptables-save v1.4.14 on Fri Nov  1 01:02:47 2013
*nat
:PREROUTING ACCEPT [17:1894]
:INPUT ACCEPT [7:499]
:OUTPUT ACCEPT [15:900]
:POSTROUTING ACCEPT [15:900]
COMMIT

Maintenant, plusieurs solutions… Vous être sur Debian, vous devez installer le paquet “iptables-persistent” puis taper cette commande:

iptables-save > /etc/iptables/rules.v4

Lors du redémarrage serveur, “iptables-restore < /etc/iptables/rules.v4” sera effectuée.

Sinon, sur CentOS et RedHat, utilisez cette commande:

service iptables save

Cela a pour effet de sauver votre configuration dans “/etc/sysconfig/iptables”.

Quand tout est fini, essayez de vérifier si tout est ok vue de l’extérieur. La commande nmap peut vous aider:

nmap -v ip_de_votre_server

Evidemment, utilisez cette commande depuis un poste externe au réseau du serveur. Il faut que vous ne voyez que les ports que vous avez autorisé et pas un de plus.

Pour ma part:

nmap -v XXXXXX.org

Starting Nmap 6.40 ( http://nmap.org ) at 2013-11-01 15:02 CET
Initiating Ping Scan at 15:02
Scanning XXXX.org (XXXXX) [4 ports]
Completed Ping Scan at 15:02, 0.04s elapsed (1 total hosts)
Initiating Parallel DNS resolution of 1 host. at 15:02
Completed Parallel DNS resolution of 1 host. at 15:02, 0.00s elapsed
Initiating SYN Stealth Scan at 15:02
Scanning XXXXXX.org (XXXXXX) [1000 ports]
Discovered open port 22/tcp on XXXXXX
Discovered open port 80/tcp on XXXXXX
Discovered open port 443/tcp on XXXXXX
Discovered open port 8080/tcp on XXXXXX
Completed SYN Stealth Scan at 15:02, 4.39s elapsed (1000 total ports)
Nmap scan report for XXXXXX.org (XXXXXXXXX)
Host is up (0.029s latency).
rDNS record for XXXXX: XXXXXX
Not shown: 996 filtered ports
PORT     STATE SERVICE
22/tcp   open  ssh
80/tcp   open  http
443/tcp  open  https
8080/tcp open  http-proxy

Read data files from: /usr/bin/../share/nmap
Nmap done: 1 IP address (1 host up) scanned in 4.49 seconds
           Raw packets sent: 2002 (88.064KB) | Rcvd: 7 (292B)

Vous pourrez ensuite gérer d’autres aspects de sécurité, mais pour l’heure cette première version vous évitera d’être mangé par un méchant pirate amateur. J’insiste sur le fait que cet article ne vous permet pas une sécurité absolue, mais c’est un début pour ceux qui veulent s’atteler à iptables.

Les designs patterns une preuve de faiblesse du langage

Thu, 10 Oct 2013 11:26:08 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Le titre peut faire frémir et vous pensez que je vais lancer un troll bien dégoulinant sur cette page - non ce n’est pas le but. Vous allez voir que je n’ai rien contre les designs patterns mais qu’une réflexion sur leur existence peut vous amener à y réfléchir quand vous choisirez un langage pour implémenter vos projets. Si ce post vous offusque, ne le lisez pas…

Hier, je discute avec mes collègues ingénieurs en développement à propos des patterns existants nativement dans certains langages, et je ne sais pas pourquoi, je lance la phrase “Rob Pike disait dans une conférence que les design patterns sont la démonstration de la faiblesse d’un langage”. Je ne me souvenais plus exactement quelle conférence, mais je l’ai retrouvé, c’est “Public Static Void” à voir ici http://www.youtube.com/watch?v=5kj5ApnhPAE et là http://fr.slideshare.net/120bi/public-staticvoidrobpikeosconjuly2210 . En réalité, je me rend compte que cette phrase est d’un autre personnage cité dans la conférence, c’est Norvig qui raconté ceci.

Patterns are demonstration of weakness in a language P.Norvig

Il le démontre en réalité en parlant du pattern Iterator dans son article http://home.pipeline.com/~hbaker1/Iterator.html

Personnellement je me suis fais cette réflexion il y a bien longtemps. Lorsque je faisais parti de l’équipe de développement de Copix (http://www.copix.org) Gérald Croës donnait des conférences sur le sujet. Et je me disais en l’écoutant “ouais en gros les designs patterns ça sert à régler des problèmes récurrents quand on a pas la solution nativement”… J’étais pas loin de ce que raconte R.Pike et P.Norvig.

Prenons un exemple de pattern, le Thread Pool. L’idée est de définir une pile limitée en taille qui va accepter des threads à lancer. Quand un thread est terminé, il laisse la place à un autre, pendant que les autres threads déjà dans la pile continuent de tourner.

Vous vous dites que c’est simple, c’est vrai. Aujourd’hui Python, Java, Ruby, et autres langages haut niveau permettent de faire un “Pool” et des “Threads”. Mais le Thread Pool doit être implémenté, et ce pour une raison simple: ils n’existent pas nativement dans le langage.

Certains langages par contre ont des types permettant de gérer des tâches concurrentes (ou parallèles, cela dépend du langage et de l’implémentation) nativement sans avoir besoin d’une classe ou d’un type spécifique, et de même pour les “pool” qui sont gérés eux aussi par des types prévus à cet effet. Je pense à Go, Erlang…

Je ne suis pas en train de dire que Go et/ou Erlang sont plus puissant que Java ou Python, mais que leur force réside dans le fait que vous pouvez vous abstraire de beaucoup de patterns parce que le langage est prévu pour cela.

Je vais un peu plus loin dans mon idée. Les design patterns existent depuis des lustres, en fait on en entend parler depuis les années 80 en tant que tel mais des “patterns” existent depuis les années 50 à l’époque où l’on développait en assembleur. Le simple fait de pousser des valeurs dans un espace mémoire pour laisser la pile propre au “sous-routines” était une idée ingénieuse qui règle un souci récurrent dans les langages “Assembleur”.

Quand est né le C, ce problème de mémoire à gérer a disparut pour ce cas. Le langage a supprimé l’utilisation d’un pattern en le rendant transparent. On peut en déduire que la méthode de déplacement des registres en mémoire pour l’utilisation de sous-routines (en tant que pattern) était une faiblesse des langages Assembleur. Et là, je ne crache pas sur le langage, je ne fais que noter une complexité réduite par un langage dont le niveau d’abstraction est plus haut.

Aujourd’hui, dans la plupart des langages que j’utilise (PHP, Python, C/C++, Java, …) je vois des implémentations de design patterns quasi identiques: Iterator, Singleton, Factory… tous sont des implémentations non natives alors que le développeur en a besoin tous les jours.

Deux options se présentent:

avoir les implémentations existantes
utiliser un langage qui s’en abstrait

La première solution est celle que l’on empreinte finalement presque tout le temps, car changer de langage dans une infrastructure logiciel complexe est de l’ordre de l’impossible.

La seconde solution fonctionne dans le cas d’un nouveau projet et si vous êtes certain que l’impact ne sera pas conséquent dans une infrastructure. Cela dit, ces langages sont généralement relativement nouveaux et sont laissés de coté en faveur d’un langage plus répandu, et qui n’offre pas ces évolutions.

Donc, en en revient à mon plaidoyer, si tous les langages demandent une implémentation non native d’un pattern que le langage ne résous pas, alors que de nouveaux langages s’en abstraient, on en revient au pattern “sous-routine” réglé par le langage C face à l’assembleur. Vous ne pouvez pas ne pas admettre le fait: le langage que vous utilisez a une faiblesse, même si la solution existe le problème est bien là.

Lisez la page: http://en.wikipedia.org/wiki/Software_design_pattern, juste les premières lignes…

En informatique, et plus particulièrement en développement logiciel, un patron de conception (en anglais : « design pattern ») est un arrangement caractéristique de modules, reconnu comme bonne pratique en réponse à un problème de conception d’un logiciel. Il décrit une solution standard, utilisable dans la conception de différents logiciels.

Il n’y a pas d’équivoque, le design pattern est une réponse à un problème standard, mais il manque l’information , je complète la dernière phrase “Il décrit une solution standard, utilisable dans la conception de différents logiciels si le langage ne propose pas de solution native”

Et de plus, prenons une phrase dans le préambule de la page wikipedia: “Ils ont une influence sur l’architecture logicielle d’un système informatique.” C’est étonnamment vrai et invraisemblable, car un pattern “standard” c’est à dire une solution à un problème, va vous forcer d’une part à l’implémenter mais aussi va influer sur la manière dont vous développez votre logiciel.

Ainsi, je ne peux pas définir un “pattern” autrement que par “une faiblesse” car si le langage ne vous impose pas d’implémenter une batterie d’implémentations qui influent sur votre code, alors il vous affranchi d’un problème et rend votre développement plus libre tout en respectant le standard du langage lui-même; et non pas d’une “bonne pratique” en “add-on” de langage… D’ailleurs, je me rend compte qu’encore une fois je suis sur la voie de R.Pike, car dans la même page où il cite “Norvig”, je vois qu’il parle de “add-ons” en parlant des patterns.

Voilà, c’est à peu près le fond de ma pensé. Je continue à utiliser des patterns dans mes développements quand le langage ne me permet pas de gérer certains aspects de conceptions, et je ne dis pas non plus que ces langages sont désuets, vieillots ou à oublier. Simplement, j’estime que les langages évoluent, que certains nouveaux apparaissent et qu’il ont la force de me permettre de me passer de patterns et par conséquent réduisent mes efforts.

Montrer un message aux utilisateurs AdBlock

Tue, 24 Sep 2013 19:59:22 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

AdBlock… le cauchemars de ceux qui vivent des bannières de pubs sur leur site… On a des polémiques, on a des discussions houleuses, et en mélangeant un peu le tout, on peut trouver un arrangement. Je vous propose une solution qui peut plaire à presque tout le monde, techniquement simple, qui ne gène pas (ou peu) l’utilisateur AdBlock ou Freenaute et qui peut vous permettre de vous faire comprendre; mais avant cela je tiens à m’exprimer une fois pour toute sur le pourquoi du comment de l’utilisation de bannières de pubs sur différents sites que je maintiens.

Bon, soyons clairs, moi personnellement j’utilise des bannières de pubs sur mon site. Si j’avais un moyen simple de vous proposer des logiciels, des solutions, des services en ligne sans avoir à me ruiner avec des serveurs dédiés, je le ferai. Le souci, c’est qu’un serveur ça coûte bonbon.

Pour ma part, entre les noms de domaines, le serveur, et sans compter le courant à la maison pour alimenter les heures de boulot sur mes travaux, je tape dans les 100, voir 120 euros par mois. Et le souci, c’est que ces serveurs ne sont pas là pour héberger des solutions professionnelles. Oui je suis développeur, mais pour un patron qui n’a rien à voir avec ce que je propose en ligne.

OK, je ne suis pas du tout un grand blogueur. Mon audience se limite à 500 visites par jours, et encore je pense que certains se sont juste perdu et ont atterrit ici pour rien. Toujours est-il que voilà, à un moment donné je tente de proposer du contenu utile, par forcément grand publique j’en conviens. Mais pour être clair, j’ai besoin d’aide, financièrement parlant. Je suis pas riche, je suis juste passionné et je fais de mon mieux.

J’ai donc décidé de tenter, il y a déjà un long moment, de mettre des bannières de pubs sur mon site. Oui là en bas de l’article. Avouez qu’elle vous gène en rien là… si ? ha… c’est dommage. Dommage pour qui ? bah pour vous…

Pourquoi je dis ça ? C’est simple, moi elle me permet de financer un peu mes travaux, c’est à dire les logiciels libres que je développe et je donne sans demander quelque chose en retour, des services que je maintiens, et j’en passe. La totalité des revenus des bannières de pub que je mets me donne (allez… en voyant large) 5 euros dans les meilleurs mois. La faute à qui ? bah à moi là pour le coup! Et oui, parce que j’ai fais le choix idiot de ne pas polluer complètement mon site avec des bannières partout. Là où certains abusent largement des bannières de pubs alors qu’ils génèrent un trafic conséquent, moi et mes visites ridicules je ne fais pas le choix de compenser.

Sauf que justement, moi qui ne compense pas en vous polluant la vue sur tout l’écran, je me vois réduis à être classifié dans le même groupe que le “salop qui profite des visiteurs” à cause des abus… Du coup, l’autre là avec son site chargé comme une mule de pubs, il profite toujours des revenus de ceux qui n’ont pas de bloqueur de pubs, mais moi, par contre, ça me vautre littéralement alors que je pense être largement en dessous du seuil d’abus.

Alors que je tente de faire les choses bien, on me prive de plus en plus de mes revenus. Adblock Plus par exemple, et Free avec son système anti-pub, me virent près de 40% de ce que je pourrais gagner. Ce chiffre ne sort pas de nul part, il sort de mes rapports de stats. Je sais comment connaitre le ratio en regardant simplement sur mes sites le nombre d’impression de pubs par rapport à mes visites réelles.

Alors quelles sont les solutions ?

Solution 1, j’arrête tout.

Bah à un moment donné, à force d’en baver j’ai littéralement ralenti mon rythme de travail. J’ai arrêté de supporter mon serveur de dépôt Fedora de près de 40 paquets que je maintenais (qui ne pouvaient pas entrer dans rpmfusion et dans les dépôts officiels). Passer près de 4h par jour à développer Kwiscale, Knotter, Baboosh ou GoVerbalExpressions

10 autres projets… pour en plus payer tout ça (serveur d’appli, noms de domaines…) avouez que ça décourage.

J’ai donc arrêté et je ne maintiens plus que deux ou trois projets… et encore… je vous assure que je pense de plus en plus à tout couper.

A ceux qui vont me répondre: t’as des services gratuit pour avoir un blog etc… je répond de suite: non. Enfin oui… je peux très bien avoir un site sur BlogSpot par exemple, mais le but est tout de même de faire tourner mes outils. Là par exemple, c’est Knotter qui répond. Un outil que je développe pour le moment dans mon coin mais qui permet de faire des sites comme ce blog. Le souci c’est que tous les serveurs qu’on me propose gratuitement ne me permettent pas de faire tourner mon framework node. J’attends pas la gloire, mais de faire tourner en production un outil qui, à terme, peut servir à d’autres que mon misérable blog. Donc, je répète, NON je ne peux pas aller sur un service gratuit.

Et encore, je parle pour le moment très peu de mon autre projet sous Go (Golang), nommé Kwiscale, pourtant j’ai un autre blog qui tourne dessus, mais comme je ne connais pas encore sa limite en sécurité, je dois le faire tourner sur mon serveur et vérifier tout ça. Je prends des heures à développer tout ce petit monde, en espérant qu’un jour des gens l’utilisent.

Solution 2, j’arrête le libre

Bah à un moment donné, la lâcheté me pendait au nez. Retourner sur Windows et faire un gros projet pour les mecs prêt à payer 15€ par copie, je me suis posé la question. Même en ne vendant que 10-15 produits par mois, ça arrondissait largement les angles pour mon banquier. Sauf que voilà, moi j’aime pas le fait de fermer la connaissance. J’ai toujours soutenu le libre et je ne vois pas trop comment l’argent pourrait polluer à ce point cet engouement.

Ma vrai richesse c’est ma passion, et le fait de vouloir la partager. Donc non, hors de question de passer à cette solution.

Solution 3, je fais la manche

Pas si con en fait… Mettre un petit encart avec marqué “sivousplééééé” ou un truc du genre. Non, je suis bête… les gens ne veulent pas payer et moi le premier. Si je devais faire un don à tous les sites que je visite et que j’adore, je pense que mon banquier me pendrait. Même à un euro par mois et par site, je serai très mal.

Par contre j’ai fait pas mal de dons, Ardour, Blender,… je donne quand j’utilise, parce que ces mecs méritent d’être aidé. Mais moi, je suis pas Ton Roosendhal et j’ai pas le génie de Thorvalds. Bref, le don ça marche pas. Donc à la limite, un mec qui a des sous, si il met 1 euro dans mes projets, je suis preneur.

1 euro ça parait rien comme ça… mais c’est preque 1% de mes couts de maintenance…

Solution 4, je laisse la pub et je supplie les gens de me whitelister

Mhhhh pas bête ça ! A la limite, je vais pas interdire un mec de lire mes articles, de télécharger mes sources de logiciels etc… sous prétexte qu’il veut pas voir les pub de “meetruc” ou “comment blanchir ses dents avec de la javel alimentaire”… mais si je lui explique que ces pubs aussi grotesques soit-elles parfois (souvent) sont très importantes pour que je puisse continuer à lui fournir des outils, des articles, etc… Peut-être qu’il acceptera. Ou mieux, je lui propose de faire un don ou de désactiver le blocage de pub mais je lui laisse aussi le choix de ne rien faire. Y’a aussi des gens qui peuvent pas payer et qui ne veulent pas voir de pub. J’aurais beau tenter de lui expliquer que voir de la pub ne lui coute rien, que ça m’aide à payer mon serveur qu’il utilise pour lire mes déblatérations, et qu’en plus ça lui permet de pouvoir jouer avec mes outils sans rien payer, si il veut pas comprendre, je vais pas le blâmer… tant pis pour moi.

Donc la solution est pas si mal. Mais comment savoir si il a coupé mes pubs ?

Y’a un moyen simple, c’est de jouer avec le bloqueur lui même. Que fait le bloqueur ? il regarde le DNS utilisé, ou simplement le nom du ficher récupéré (c’est ce que fait AdBlock) pour aller chercher le javascript et/ou l’iframe de la pub, et il arrête le chargement avant affichage.

On peut alors imaginer simplement que le bloqueur cherche un truc simple dans le nom du ficher, par exemple “ads”. Je me suis alors adonné à une expérience. J’ai posé un fichier css nommé “myblogads.css” et (miracle ?) le bloqueur de pub refuse son chargement… L’idée est là !

Je pose un div qui contient un message explicatif, du genre “hey monsieur (ou madame) tu bloques mes pubs… machin… tout ça… aide moi, argent… bouton de don, bouton pour cacher le div”. ID du bloc: “soyezcool”

Ensuite, dans ce fameux CSS bloqué par AdBlock, je mets:

div#soyezcool { display: none }

Ce qui va se passer c’est que si le bloqueur refuse mon CSS (à cause de son nom qui contient “ads”) la div n’est plus cachée. Par contre, pour ceux qui se foutent de voir un petit encart de pub, rien ne se passe, car le CSS est chargé. Donc le bloc “soyezcool” est caché.

Reste à être sympa aussi avec celui qui veut pas de pub. J’ai personnellement eut l’idée (sur un autre site) de placer un cookie valable un an qui, s’il est présent, cache direct le div.

Le script qui fait tout le patacaisse

Dans un JS:

function createCookie(name,value,days) {
    if (days) {
        var date = new Date();
        date.setTime(date.getTime()+(days*24*60*60*1000));
        var expires = "; expires="+date.toGMTString();
    }
    else var expires = "";
    document.cookie = name+"="+value+expires+"; path=/";
}

function readCookie(name) {
    var nameEQ = name + "=";
    var ca = document.cookie.split(';');
    for(var i=0;i &lt; ca.length;i++) {
        var c = ca[i];
        while (c.charAt(0)==' ') c = c.substring(1,c.length);
        if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
    }
    return null;
}

function eraseCookie(name) {
    createCookie(name,"",-1);
}

// cache le message d'information et place un cookie
function hide(cookietime) {
    // on retient qu'on ne montera pas le message pendant X jours 
    createCookie("cool", "true", cookietime); 
    // on cache le message
    document.getElementById("soyezcool").style.display = "none";
}

// cas d'un retour de paiement, à paramétrer chez Paypal si vous mettez un bouton de don
// place le cookie, le mec a fait un don
if (location.hash === "#payed" && readCookie(cookiename) !== "true") {
    hide(356); // on laisse le visiteur 1 an tranquile
}

// Bon le visiteur là, il a déjà payé ou demandé de cacher le message, on 
// cache le message par défaut
if (readCookie(cookiename) === "true") {
    document.getElementById(divid).style.display = "none";
}

Voilà, c’est tout. Reste à faire une div dans votre HTML:

<div id="soyezcool">
<button onclick="hide(1)">Fermer</button>
<p>
    Soyez cool, coupez votre bloqueur de pub ou faire un don (mettre le bouton de don)... etc... 
    avec des explications claires et gentilles. 
    Si vous voulez pas vous pouvez continuer quand même... et bla bla bla
</p>
</div>

C’est tout… Si votre visiteur a déjà pris connaissance de votre quête ou qu’il a fait un petit don et qu’il a bien été redirigé sur votre page suivi d’un “#payed” dans l’URL, il ne verra ni la pub, ni votre div d’information.

Dans le cas d’un don, le message disparait 1 an, pour une personne qui cache juste le message, on le fait pour 1 jour. Oui là je le fais à la mode cookie ce qui veut dire que:

le payeur change de navigateur ou supprime les cookies, il verra de nouveau le message
en lisant le code, on peut facilement être tranquile 1 an sans payer…

Je sais tout ça… mais je suis pas là pour fliquer tout le monde… et puis encore une fois je suis désolé de me défausser mais si AdBlock n’était pas là il ne verrait qu’une pub en bas de page et pas un gros popup une fois par jours en haut de page… et je continue sur ma lancée, si les foutus sites remplis de bannières de pub n’avaient pas été aussi avide de pognon, vous ne seriez pas un utilsateur de AdBlock, et par conséquent moi j’aurai pas à ruser pour vous montrer un message. La faute est aux profiteurs, pas à vous chers lecteurs qui utilisez AdBlock ou qui êtes chez Free. Je tiens à être clair sur ce point !

Personnellement j’ai déjà utilisé cette méthode sur ma page http://asm.metal3d.org étant donné le temps que m’a pris ce petit émulateur d’assembleur…

Comprenez moi bien, je comprends largement le fait que la pub vous ennui, mais pensez à ceux qui posent des pubs avec parcimonie (tel que moi) et qui ne cherchent pas la richesse, mais la subsistance… je suis pas un Robin des bois, mais je donne pas mal de mon temps à des projets qui ne me rapportent rien, mis à part l’immense joie (et c’est énorme, croyez moi) d’avoir de temps à autre des commentaires par mail sur différents projets que je donne de bon cœur. Pensez juste au fait que tout cela me prend du temps, beaucoup de temps, et que ça me coute vraiment cher par mois pour maintenir le matériel en marche. Si ce que je donne vous aide:

faites un don sur la page de projet qui vous intéresse
ou whiltelistez mes pages de votre bloqueur de pub (si c’est Free je sais pas comment vous devez faire…)

En espérant que vous ne preniez pas comme une agression ce billet de site. Bonne soirée à tous !

Une ligne pour avoir un serveur HTTP de développement

Sun, 22 Sep 2013 09:37:05 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

En parcourant des pages de ci de là, j’ai découvert deux commandes qui permettent de développer rapidement des pages nécessitant des appels HTTPRequest,

Alors que je m’amusais à développer un émulateur d’Assembleur avec en prime quelques binding de AngularJS, il m’a fallut utiliser un serveur Web pour que les appels HTTPRequest (ce que beaucoup appellent à tort Ajax). De prime abord, on aurait le réflexe de se dire “ok, on a deux possibilités, je me configure mon serveur Web pour qu’il puisse servir mon dossier de travail, ou sinon je déplace le tout dans /var/www…” avec tout les soucis de droits qu’il faut gérer.

Arrêtez vous ! y’a plus simple ! Vous avez certainement Python installé sur votre poste ? Alors faites simplement cette opération :

cd /répertoire/à/utiliser
python -m SimpleHTTPServer

Et hop ! un serveur web qui tourne. Il écoute sur le port 8000 par défaut. Si ça vous plait pas, utilisez :

python -m SimpleHTTPServer 8082

A partir de maintenant il écoute le port 8082. C’est bête comme choux. Il écoute, de plus, sur toutes les interfaces. Du coup votre instance est accessible depuis le réseau.

Vous préférez PHP ? Pas de souci:

cd /répertoire/à/utiliser
php -S 0.0.0.0:8000

Pareil que plus haut, mais en prime un “log en couleur” qui vous permettra de mieux voir les erreurs 404 (not found).

Attention hein, ces lignes ne doivent servir que pour les développements locaux. Ne les utilisez pas en production, c’est juste pas fait pour ça, ce serait dangereux et pas efficace.

Petit edit de dernière minute, merci à Frédéric Thouin (sur Google+): Ces commandes permettent aussi de faire un partage réseau ponctuel. C’est super pratique, vous vous placez dans le répertoire, vous tapez la commande, et si aucun fichier “index.html” n’est présent, vous pouvez naviguer (via un navigateur internet) dans les répertoires et fichiers. C’est super pratique, et bien plus rapide que de créer un partage samba (ou sur Windows, partager un dossier en spécifiant que le partage est public).

Technique de masque binaire

Fri, 09 Aug 2013 13:55:16 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Une fois n’est pas coutume, j’ai décidé d’expliquer une technique courante mais souvent oubliée par les développeurs, cela sans aucune forme de critique. C’est le sytème de masque binaire pour créer des drapeaux (ou flag) d’option.

Ce post s’adresse surtout au développeurs qui débutent ou encore ceux qui ont perdu l’habitude de travailler avec des types primitifs. Si vous connaissez cette méthode je ne vous apprendrai rien.

L’idée d’écrire un post de blog sur le sujet me vient du fait que moi même j’ai commis l’erreur d’oublier d’utiliser cette méthode très propre lors de mon écriture d’implémentation de “VerbalExpression” en Go. C’est un certain surnommé “maurodec” qui m’a mis sur la voie avec son implémentation que je tente de fusionner à la mienne.

Le principe est connu, assez simple mais rarement utilisé si comme moi vous travaillez “trop vite” pour implémenter une librairie…

Je vais partir de mon implémentation de VerbalExpressions pour vous expliquer le principe.

VerbalExpression permet de construire des expressions régulières simplement. Elle permet d’utiliser des méthodes qui active ou non des options telles que:

ignorer la casse
capturer en multiligne
le caractère “.” prend aussi les n…

On ne va prendre que ces cas pour le moment.

Si on utilise la méthode ‘SearchOneLine(true)’ il faut ajouter “m” au modificateur d’expression régulière, si “WithCaseSensitive(true)’ on ajoute “i” au modificateur. Si on passe “false” à ces méthodes, on doit supprimer le modificateur associé. Pas d’inquiétude, je vais éclaircir tout ça.

Ma première idée était simple, avoir une “chaine” qui se concaténait avec les modificateurs… et supprimer la lettre correspondante via strings.Replace si on demandait la suppressions. C’est tout simplement pas du tout efficace.

Seconde idée, avoir un “slice” (genre de hash) qui avec pour chaque lettre “m” et “i” un booléen associé, puis concaténer selon le cas… encore une fois mauvais idée.

La troisième fut la bonne (merci à maurodec): utiliser les masques !

L’idée est simple: on crée des constante qui ont une valeur particulière. Ensuite je garde une variable qui opère de manière binaire, et enfin quand je veux vérifier les flags, je fais des masques.

Houlla je vous perds… on va y aller doucement.

D’abord, revenons à la base de nos vieux cours d’info.

Une variables est une valeur binaire, une représentation de 0 et de 1. Selon le type, le langage interprétera cette série pour l’utiliser de différente manière.

On lit de droite à gauche !

Prenons le nombre entier “1”, en binaire 4 bits c’est “0001”. Ok…
Le nombre entier 2 est “0010”
Pour le “3” : “0011”
etc…

Si l’on regarde ces nombres, plus on avance dans les nombres entiers, plus on assigne des “1” vers la gauche. Ainsi “8” est “1000”.

Bon, maintenant, regadons ces 4 représentations binaires:

0001 = 1
0010 = 2
0100 = 4
1000 = 8

Que des “0” + un “1” qui se décalle à gauche.

Le principe va être très simple, on regarde chaque bit du mot binaire, on imagine simplement que chaque bit est une colonne, ou une option, qui a une valeur 1 pour active, 0 pour inactive.

Les nombres 1, 2, 4, 8, 16… sont interssants car ils n’ont qu’un seul “1” dans leur représentation binaire. Du coup en les additionnant on a juste un “ou” binaire… et oui ! regardez 2+4 = 6


	1	0	=4
	0	1	=2
OR	1	1	=6

Bien… on continue.

Prenons ce fameux nombre “6” issue de notre opération. Il a deux “1”… un sur la colonne 2 (en partant de la droite) et un à la troisième…

Si on prend un à un ces nombres “1”, et qu’on élimine les autres, on trouve:

0010
0100

Tien donc ! c’est bien 2 et 4…

Et oui, on sait donc à partir d’un résultat retrouver les nombres qui ont servis.

Et bien maintenant, tout le problème est de savoir décomposer les nombres qui ont composé le résultat. Et pour cela, on va faire un masque. on y arrive.

L’idée est de voir si on arrive à retrouver la composition binaire.

On a une première méthode, faire un “&” (“et binaire”) avec 1, 2, 4, 8…

Avec 1


	1	1	0	=6
	0	0	1	=1
AND	0	0	0	=0

Avec 2


	1	1	=6
	0	1	=2
AND	0	1	=2

Avec 4


	1	1	=6
	1	0	=4
AND	1	0	=4

Et avec 8


	0	1	1	=6
	1	0	0	=8
AND	0	0	0	=0

Donc, ça fonctionne: l’opération binaire a retourné une valeur supérieure à 0 seulement pour les nombres binaires composés d’un seul “1” qui partagent un bit en commun. C’est à dire 4 et 2.

Donc, voilà une première idée, on teste avec “&” chaque valeur:

const (
    MULTILINE  = 1
    IGNORECASE = 2
    DOTALL     = 4
)

// ... plus loin

flags := MULTILINE | DOTALL // ça donne un 5
if ( flags & MULTILINE != 0 ){
    // oui, on a MULTILINE
}
if ( flags & IGNORECASE != 0 ){
    // oui, on a IGNORECASE
}
if ( flags & DOTALL != 0 ){
    // oui, on a DOTALL
}

Bon ça marche, mais on peut aller encore plus loin.

On reviens à VerbalExpression et le fameux “modificateur” à créer. Chaque option correspond à une lettre:

MULTILINE : m
DOTALL : s
IGNORECASE : i

Donc:

Si je fais “MULTILINE | DOTALL” je dois générer “ms”
Si je fais “IGNORECASE | DOTALL” je dois générer “is”

Ok, maintenant j’ai besoin de regarder les options enregistrées tour à tour… mais je dois compter non pas de 0 à 2 en décimale, mais de 1 à 4 de manière binaire (1,2,4,8…)

Pour compter de cette manière on va utiliser le décallage de bit.

Comme vous l’avez vu, les nombres 1,2,4,8,16… sont des représentation d’un seul 1 binaire qui se décalle à gauche. L’opérateur “<<” décale les bits vers la gauche (en assignant des 0 à droite)

Ainsi:

0001 = 1<<0 (1 décallé de 0 bit vers la gauche)
0010 = 1<<1 (1 décallé de 1 bit vers la gauche)
0100 = 1<<2 (1 décallé de 2 bits vers la gauche)
1000 = 1<<3 (1 décallé de 3 bits vers la gauche)

0, 1, 2, 3… donne 0, 1, 2, 4… c’est pas génial ça ?

Donc l’idée c’est que chaque itération, je décalle “1” de “i” vers la gauche, et j’ai bien 1 puis 2 puis 4…:

flags := MULTILINE | DOTALL
for i:=0; i<4; i++ {
    if flags & (1<< uint(i) ) != 0 {
        // tour à tour je teste MULTILINE 
        // (quand i=1 => 1<<1 = 0001 = 1)
        // puis IGNORECASE 
        // (quand i=2 => 1<<2 = 0010 = 2)
        // puis DOTALL 
        // (quand i=3 => 1<<3 = 0100 = 4)
    }
}

Alors voilà comment on peut procéder:

const (
    MULTILINE  = 1
    IGNORECASE = 2
    DOTALL     = 4
)

// ... plus loin

flags := MULTILINE | DOTALL //on demande à avoir "m" et "s"

// rune correspond à un caractère, c'est plus simple
// en Go pour indexer les lettres, on transforme en string à la fin
totests := []rune("mis") // dans l'ordre exact de mes constantes

modifiers := []rune{} // on stoquera là dedans les caractères m, i, s...
for i, flag := range totests {
    // on le fait pour chaque lettre de totests
    if flags & (1 << uint(i) ) != 0 {
        modifiers = append(modifiers, flag) // on ajoute la lettre associée            
    }
}

fmt.Println(string(modifiers)) // affiche "ms"

Vous pouvez aller voir l’exemple http://play.golang.org/p/8J_tYrhUgq et changez la valeur de “flags”

Et pour les connaisseurs de Go, on peut déclarer nos constante via “iota”, c’est moins ennuyeux que de compter en binaire, surtout quand on commence à avoir un paquet de constantes…:

const {
    MULTILINE  = 1<<iota
    IGNORECASE = 1<<iota
    DOTALL     = 1<<iota
}

Reste un dernier point… il faut des méthodes pour ajouter les constantes ou les retirer. Rappelez vous: ajouter = faire un “ou”, retirer c’est faire un “bitclear” (l’un et pas l’autre) soit “&^”, cela ne perd pas les autres bits…

Exemple, j’ai DOTALL et j’ajoute IGNORECASE

0100 => DOTALL, 4
0010 => ajout de IGNORECASE, 2
0110 => donne 6 (4+2) par opération “ou”

On retire IGNORECASE

0110 => DOTALL | IGNORECASE = 4+2 = 6
0010 => on retire IGNORECASE
0100 => bitclear, il faut un seul 1 dans la colonne, on revient à “4” soit DOTALL

Donc voilà une méthode d’exemple :

var flags unint = 0
func IgnoreCase(stat bool) {
        if stat {
            flags = flags | MULTILINE
        } else {
            flags = flags &^ MULTILINE
        }
}

Selon si on active ou non un mode, on ajoute ou retranche la valeur… on aurait put le faire avec “+” et “-” mais bien souvent on préfère retyper les constantes… du coup prenez l’habitude de la faire de manière binaire.

Voici un exemple avec les méthodes appliquées : http://play.golang.org/p/OICDEDceWN

Voilà, j’ai peut-être pas été super clair, mais les exemples peuvent vous donner de la lumière.

En espérant que je vous ai donné des billes…

Réactiver le mass storage sur Android

Mon, 29 Jul 2013 11:30:03 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vous l’avez certainement remarqué. Android a supprimé le fameux mass storage depuis les versions 4.x. Au lieu de cela, nous avons droit à un protocole soit disant pratique, le MTP, mais qui engendre un certain nombre de frustrations. Cela dit il existe un moyen de réactiver rapidement le mode “par défaut” qu’on aimait tant.

Depuis les versions 4.x, et y compris sur Cyanogen, brancher un téléphone ou une tablette sur PC active un protocole “mtp” (multimedia transfert protocol) et non plus un simple support USB de stockage appelé communément “mass storage”. Outre les soucis de protocoles, il arrive que certains bugs vous gênent, par exemple dans mon cas un répertoire de 17 éléments sur mon téléphone n’affiche que 14 éléments sur le PC. Moi personnellement ça m’énerve.

Rage, énervements… je me suis mis à utiliser SSHDroid pour communiquer avec mon téléphone.

Mais en réalité il existe un moyen simple pour réactiver le mass storage: activer le mode développeur. Et comment on fait ? Simple ! ou du moins… quand on sait comment faire.

Allez dans les paramètres (touche menu depuis l’accueil ou “Paramètres” dans la liste des applications)

En bas de l’écran vous devez voir “A propos du téléphone”, cliquez dessus…

Au prochain écran, en bas, il doit y avoir une case “Numéro de build”

Pressez 7 fois cette case, théoriquement un “popup” apparait et décompte le nombre de fois que vous devez encore presser la case pour activer le mode “développeur”

Ok, après ces 7 touches, vous devez avoir dans les paramètres (écran précédent) une case d’options pour le mode développeur

En pressant cette entrée, vous allez avoir des options:

Activez le mode “Débogage USB” va réactiver le “mass storage”. De ce fait, en connectant votre téléphone sur la prise USB de votre ordinateur, vous aurez monté le téléphone comme une “clef usb” ou un “disque dur amovible”.

En haut de l’écran se trouve un bouton pour désactiver le mode “Développeur” au cas où vous ne voudriez plus avoir cette option.

Voilà… Pour ma part, plus besoin de SSHDroid et plus d’utilisation du mode “mtp”… On se demande bien pourquoi un mode aussi simple et efficace que le mass storage a été désactivé, mais surtout pourquoi cacher ce mode dans un menu caché…

Reading some lines from a file in terminal

Mon, 22 Jul 2013 09:42:32 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

At work, I am often asked to find commands that meet specific needs. One of them recurs: how to make selections of lines in a file?

The question is very simple, some of you have got the answer. But when you’re not a “frequent terminal user” you can realize that it’s not as simple.

There are 4 commands to use:

head: get firsts lines of a file
tail: get last lines of a file
cat: get the whole content of a file
sed: to manipulate specific lines

“head” and “tail” commands have got an option to get a specific number of lines: “-n”

Let’s create a file to test:

my line 1 for foo
bar line 2
baz line 3
and another line 4
one more for 5
and the last 6

Save the content in “/tmp/example.txt”.

Ok now let’s test:

$ cat /tmp/example.txt
my line 1 for foo
bar line 2
baz line 3
and another line 4
one more for 5
and the last 6

$ head -n2 /tmp/example.txt
my line 1 for foo
bar line 2

$ tail -n3 /tmp/example.txt
and another line 4
one more for 5
and the last 6

Ok, but how to get line 4 of a file ? You can do it with head and tail… But the problem is that you will run 2 commands + an output redirection:

$ head -n 4 /tmp/example.txt | tail -n1
and another line 4

So, the “good” answer can be “use sed”, it will open file only one time:

$ sed -n "4p" /tmp/example.txt
and another line 4

How to read the command ?

sed -n => “-n” means “do not print anything”
“4p” => when line is number 4, “print” (command “p”)

“sed” can return a lineset, for example from line 3 to 5:

$ sed -n "3,5p" /tmp/example.txt
baz line 3
and another line 4
one more for 5

“head tail” (bad answer) equivalent, that runs 2 commands:

head -n 5 /tmp/example.txt | tail -n 2

You can get several lines, for example the line 2 and 4:

$ sed -n "2p; 4p" /tmp/example.txt
bar line 2
and another line 4

And for this example, there is no “head tail” equivalence that is easilly usable ;)

Vim for Golang

Sun, 07 Jul 2013 13:02:27 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Developping with Go is easy, a simple text editor and you’re ready to work. But it’s very confortable to have syntax highlight, checker and outline view. There are lot of possible configurations for a lot of editors. My preference is Vim + some plugins. Let me show you how I configured my “Go vim IDE”

At first, be sure you’ve installed a recent Go implementation. My configuration works with Go version > 1.x.

I’m working on Fedora (18) with a vim version 7.3.

What we will do:

install pathogen (or Vundle)
install syntastic
install gocode
install tagbar + configuration
install nerdtree (optional)

Pathogen

Pathogen is like Vundle, it allows you to install plugins inside a deported directory that is easier to manage. To install pathogen:

mkdir -p ~/.vim/autoload ~/.vim/bundle; \
curl -Sso ~/.vim/autoload/pathogen.vim \
https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim

Then, in your ~/.vimrc, append this line before any “filetype” directive or “syntax”:

execute pathogen#infect()

You’ll see my own vimrc plugin at the end of post.

Ok, you’re done, now to install plugins, you just have to put it in ~/.vim/bundle - this is what we will do.

Syntastic

I will be honest, I don’t know if syntastic is required, but if you develop with other langages (as Python, C, Java…) with vim, you will love this plugin.

Syntastic is a vim plugin that is very powerfull. It will show you errors and warnings for a large variety of langage when you save your vim buffer. TO install this plugin, now you’ve got pathogen installed, is easy:

cd ~/.vim/bundle
git clone https://github.com/scrooloose/syntastic.git

That’s all

Vim for go

Before installing Gocode, let’s install the given vim configuration from your Go installation.

Be sure that your environment variable contains somthing:

$ echo $GOROOT 
/home/patachou/src/go

Then type:

ln -s $GOROOT/misc/vim ~/.vim/bundle/go-vim

That link configuration to the “bundle” directory for vim.

Now, the entire vim configuration is ready to use (thanks again to pathogen)

Gocode

Now, let’s install the Go part. Gocode is a “service” that will be connected to your vim instance. It will add lot of very interessing functionnalities as:

code check
code completion

In your terminal, execute this:

go get -u github.com/nsf/gocode

This add the “gocode” command. Vim will use if needed. The deamon will start at time.

Some vim configuration

We will need some additional vim configuration. Open your ~/.vimrc and append:

set omnifunc=syntaxcomplete#Complete

This activate “omnifunc” for the whole possible languages that implement completion.

So to conclude, this is my (cleaned for the article) vimrc file:

execute pathogen#infect()
set modeline
set number
syntax on
set omnifunc=syntaxcomplete#Complete
set mouse=a
set autoindent
set ts=4 sts=4 sw=4 expandtab
filetype plugin indent on     " required! 
filetype plugin on

With this lines, I’ve got:

pathogen that checks my ~/.vim/bundle directory
modeline that can read some “vim directives in comments” (optionnal)
line number
syntax is on
completion ok
mouse that can be used to navigate in NerdTree, and Tagbar (after the test, be patient ;) )
indentation auto
tab makes 4 spaces
plugin for indentation + autocommand (required by gocode)

Ok, make a test now

Testing installation

Before to try, keep the shortcuts in mind: CTRL+x - o ==> autocompletion from “omnifunc”

Now, go to a temporary directory, for example /tmp and make a test directory:

cd /tmp; mkdir testgo; cd testgo

And try:

vim main.go

You will have vim opened, append this lines:

package main

import "fmt"

func main() {
     // place your cursor after the "."
     fmt.
}

After dot (.) press “CTRL+x” then “o”, and you will see a menu that lets you choose the method to use.

This works with any variables, package, builtins…

Append 2 plugins that will change your life

There are 2 plugins that can be very cool to use: Nerdtree and tagbar.

Nerdtree is a directory viewer that shows you your project directory. There are a lot of options, but you can use “as is”. NERDTree is made by the same author that syntastic.

Let’s install:

cd ~/.vim/bundle
git clone https://github.com/scrooloose/nerdtree.git

Now install the second plugin, tagbar that is an outline viewer that works with a lot of languages (excpeting go… buuuuuuut):

cd ~/.vim/bundle
git clone git://github.com/majutsushi/tagbar

To let tagbar useable with Go, we need to install “gotags” and append a vim configuration…:

go get -u github.com/jstemmer/gotags

And append this to the file ~/.vim/ftplugin/go.vim (theorically, gocode has created this file and append a omnifunc method on top, don’t remove this line, append this after):

" gotags
let g:tagbar_type_go = {
    \ 'ctagstype' : 'go',
    \ 'kinds'     : [
        \ 'p:package',
        \ 'i:imports:1',
        \ 'c:constants',
        \ 'v:variables',
        \ 't:types',
        \ 'n:interfaces',
        \ 'w:fields',
        \ 'e:embedded',
        \ 'm:methods',
        \ 'r:constructor',
        \ 'f:functions'
    \ ],
    \ 'sro' : '.',
    \ 'kind2scope' : {
        \ 't' : 'ctype',
        \ 'n' : 'ntype'
    \ },
    \ 'scope2kind' : {
        \ 'ctype' : 't',
        \ 'ntype' : 'n'
    \ },
    \ 'ctagsbin'  : 'gotags',
    \ 'ctagsargs' : '-sort -silent'
\ }

Right ok !

Test tagbar and NERDTree

You can do:

type :NERDTree in vim
open vim with +NERDTree argument

To open Tagbar, type :TagbarOpen

This is what I’ve got:

One shot

Let’s resume what we’ve made:

mkdir -p ~/.vim/autoload ~/.vim/bundle; \
curl -Sso ~/.vim/autoload/pathogen.vim \
https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim

ln -s $GOROOT/misc/vim ~/.vim/bundle/go-vim

cd ~/.vim/bundle
git clone https://github.com/scrooloose/syntastic.git
git clone https://github.com/scrooloose/nerdtree.git
git clone git://github.com/majutsushi/tagbar

go get -u github.com/nsf/gocode
go get -u github.com/jstemmer/gotags

In ~/.vimrc:

execute pathogen#infect()
set modeline
set number
syntax on
set omnifunc=syntaxcomplete#Complete
set mouse=a
set autoindent
set ts=4 sts=4 sw=4 expandtab
filetype plugin indent on     " required! 
filetype plugin on

Open one time a gocode, use completion, that creates ~/.vim/ftplugin/go.vim

Then append to ~/.vim/ftplugin/go.vim:

" gotags
let g:tagbar_type_go = {
    \ 'ctagstype' : 'go',
    \ 'kinds'     : [
        \ 'p:package',
        \ 'i:imports:1',
        \ 'c:constants',
        \ 'v:variables',
        \ 't:types',
        \ 'n:interfaces',
        \ 'w:fields',
        \ 'e:embedded',
        \ 'm:methods',
        \ 'r:constructor',
        \ 'f:functions'
    \ ],
    \ 'sro' : '.',
    \ 'kind2scope' : {
        \ 't' : 'ctype',
        \ 'n' : 'ntype'
    \ },
    \ 'scope2kind' : {
        \ 'ctype' : 't',
        \ 'ntype' : 'n'
    \ },
    \ 'ctagsbin'  : 'gotags',
    \ 'ctagsargs' : '-sort -silent'
\ }

That’s all folks

Utiliser la reconnaissance vocale de Google

Sat, 18 May 2013 13:27:49 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Et si on se faisait une petit application de reconnaissance vocale maison qui marche sur le desktop ? Je recherche depuis des mois, voir des années, une solution sous Linux qui me permettrait de faire correctement de la reconnaissance vocale proprement. Mais mes recherches n’ont jamais été fructueuses, que ce soit du coté de CMU Sphinx ou je ne sais quel “Perlbox”… Mais voilà, Google propose sur Android, et depuis peu (quelques mois en fait) une api sur Chromium/Chrome qui fonctionne vraiment bien.

Alors avant toutes choses: très important, utiliser l’api de Google hors Android et hors navigateur semble ne pas être autorisé. Si vous utilisez mes exemples, vous êtes responsables de vos actes en cas de souci avec la loi. Je ne vous propose cet article qu’à des fins de recherche.

Relisez bien ce que je viens de taper… qu’on soit bien clair, ce que je vous propose est utile à des fins de tests jusqu’à ce que Google nous autorise un jour (on y croit…) à faire mumuse sans restriction avec leur API… ou (rêvons un peu) qu’il rende tout ça publique.

On passe à la suite. Comment ça fonctionne ?

Si vous visitez http://translate.google.com vous remarquerez une icone de micro en bas du textarea de texte à traduire. C’est une nouvelle implémentation qui permet de proposer de dicter le texte via le micro plutôt que de taper à la main le texte. Ceci est possible depuis l’introduction d’un attribut “x-speech” dans les inputs et textareas. Une très bonne explication se trouve sur la page: http://tilap.net/champs-de-saisie-vocale-en-html5-x-webkit-speech/

Lorsque vous pressez le bouton, le navigateur enregistre votre voix. L’encodage est FLAC (voilà une idée géniale) à 16kHz. Puis il le poste sur la page:

https://www.google.com/speech-api/v1/recognize

Ne cherchez pas à ouvrir la page depuis votre navigateur, cette adresse n’accèpte pas les requêtes GET. Bref, cette adresse prend aussi des arguments, comme la langue source, le nombre de résultats attendus, etc…

Pour préparer notre petit programme de reconnaissance, on va utiliser:

Gstreamer pour capturer votre voix
curl pour poster tout ça à Google

Gstreamer n’est pas plus simple, mais il a le mérite de ne pas me prendre la tête pour le choix de la source d’enregistrement.

Pour le pipe Gstreamer, on va utiliser:

autoaudiosrc pour laisser pulse nous donner la source (donc vérifiez vos paramètres pour vérifier que votre micro fonctionne)
audioresample pour rééchantillonner le fichier proprement
utiliser la capacité audio/x-raw-int pour demander un “rate” de 16kHz (16000 hz)
pour le moment: envoyer ça dans un fichier .flac

C’est parti, dans un terminal:

gst-launch autoaudiosrc ! audioresample ! audio/x-raw-int,rate=16000 ! \
flacenc ! filesink location=/tmp/voice.flac

Dites quelques mots, pas trop long, puis presssez CTRL+C. Vérifiez votre fichier en l’écoutant avec mplayer, vlc, ou la commande “play” pour vous assurer que vous êtes audible et qu’il n’y a pas trop de bruit.

Maintenant, on va l’envoyer à Google pour voir si il reconnait correctement la voix.

L’idée c’est qu’il faut envoyer les informations nécessaires pour construire une requête POST bien propre. A savoir donc:

le Content-Type qui est un audio/x-flac; rate=16000
les données binaires (le fichier de son)
un argument pour lui dire qui est le client, je vais mettre chromium
un argument pour lui dire que je veux au pire 10 résultats de reconnaissance

Donc la commande “curl” est la suivante:

curl -X POST --data-binary @/tmp/voice.flac \
--header 'Content-type: audio/x-flac; rate=16000' \
'https://www.google.com/speech-api/v1/recognize?client=chromium&lang=fr-FR&maxresults=10'

Cela me retourne (j’ai reformaté pour plus de lisibilité):

{
"status": 0,
"id": "cf3c79ce01920853aedc0825f33ac0ea-1",
"hypotheses": [
    {
        "utterance": "bonjour et bienvenue",
        "confidence": 0.7474387
    },
    {
        "utterance": "bonjour et bienvenu"
    },
    {
        "utterance": "bonjour bienvenue"
    },
    {
        "utterance": "bonjour et bienvenue à"
    },
    {
        "utterance": "bonjour et bienvenue chez"
    },
    {
        "utterance": "bonjour et bienvenue au"
    }
    ]
}

C’est donc au format JSON que la réponse est faite (plutôt pratique). Vous remarquez que ce sont les “hypothèses” de reconnaissance qui vont nous intéresser et que nous avons quelques possibilité avec des points (confidence) qui oscillent de 0.0 à 1.0. Si vous tentiez sans le “maxresults”, vous n’auriez en réponse que l’hypothèse la plus haute:

curl -X POST --data-binary @/tmp/voice.flac \
--header 'Content-Type: audio/x-flac; rate=16000;' \
'https://www.google.com/speech-api/v1/recognize?client=chromium&lang=fr-FR'

{
"status": 0,
"id": "06eee2607513b6f23081891d051736bc-1",
"hypotheses": [
    {
        "utterance": "bonjour et bienvenue",
        "confidence": 0.7474387
    }
    ]
}

Bon me reste une ou deux choses à faire, notamment faire en sorte que l’enregistrement de ma voix s’arrête quand je ne parle plus… ha ça c’est un truc que j’ai gratté un moment, mais j’ai fini par trouver !

Il existe un pad gstreamer nommé “vader”. Ce pad est magique, il déclenche la lecture du pipeline gstreamer quand le niveau d’enregistrement monte, puis il met en pause quand vous ne parlez plus. Pour tester, voici ce que vous pouvez faire:

gst-launch autoaudiosrc ! vader auto_threshold=true ! audioconvert ! \
audioresample ! audio/x-raw-int,rate=16000 ! \
flacenc ! filesink location=/tmp/tmpaudio.flac

Alors, attendez… pour couper le pipeline vous allez devoir presser CTRL+C… sauf que vader va peut-être l’entendre donc faites doucement.

Commencez à parler, dites “un deux trois” par exemple. Attendez une dizaine de secondes puis dites “quatre cinq”. Pesses calmement CTRL+C et écoutez le fichier /tmp/tmpaudio.flac. Vous allez vous rendre compte que la dizaine de secondes de pause a disparue. C’est tout le but, l’encodage ne s’est fait que lorque vous parliez.

Voilà, on approche du but:

on sait enregistrer des phrases au moment où on parle
on sait envoyer un fichier à Google qui peut être utilisé pour de la reconnaissance

Hé, dites… ça vous dirait de faire un petit programme qui écrit ce que vous dites ? Python est un petit bijou pour ça.

Je vous explique pas à pas.

On va utiliser le module “gst” qui est le module gstreamer de python. Ce module a une méthode bien pratique qui permet de donner le pipeline à la manière de gst-launch plutôt que de s’entêter à faire les pad un à un et de les raccorder.

Petit rappel, les pads, ainsi que le pipeline gstreamer, envoit des évènements. On regarde ce que donne le pad “vader”:

gst-inspect vader
...
Element Signals:
   "vader-start" :  void user_function (GstElement* object,
                                   guint64 arg0,
                                   gpointer user_data);
   "vader-stop" :  void user_function (GstElement* object,
                                  guint64 arg0,
                                  gpointer user_data);

Deux évènements à retenir: vader-start et vader-stop… inutile de vous dire à quoi il servent.

Ensuite, en ce qui concerne python et gst, on peut mettre en pause ou en état de démarrage le pipeline via la méthode set_state() en lui donnant en argument gst.STATE_PAUSED ou gst.STATE_PLAYING

On va utiliser urllib2 pour envoyer les données à Google.

Et enfin, pour que le programme écoute en continue sans couper le script, on va utiliser le module gtk pour utiliser la boucle itérative “gtk.main()”

L’algo est le suivant:

on crée le pipeline en nommant le pad vader "vad" (afin de le récupérer)
on écoute les évènement du pad vader
quand vader stop son écoute:
    on met en pause tout le pipeline pour ne pas relancer l'écoute tout de suite
    on copie le fichier flac en mémoire
    on vide le fichier flac pour ne pas cumuler nos phrases
    on remet le pipeline en écoute
    on envoit la requête à Google
    si ça a marché, on affiche la meilleures hypothèse de reconnaissance

Voilà… et bien lisez un peu le source:

import gst
import gtk
import urllib2
import json
import logging
import os

# file where we record our voice (removed at end)
FLACFILE='/tmp/tmpvoice.flac'

#to be clean on logs
logging.getLogger().setLevel(logging.DEBUG)

def on_vader_start(ob, message):
    """ Just to be sure that vader has reconnized that you're speaking
    we set a trace """
    logging.debug("Listening...")

def on_vader_stop(ob, message):
    """ This function is launched when vader stopped to listen
    That happend when you stop to talk """

    logging.debug("Processing...")

    # pause pipeline to not break our file
    pipe.set_state(gst.STATE_PAUSED)

    # get content of the file
    flacfile = open(FLACFILE, 'r').read()

    # empty file, to not reprocess
    # next time
    open(FLACFILE, 'w').write('')

    #file is empty, continue to listen
    pipe.set_state(gst.STATE_PLAYING)

    try:
        # hey, Google ! what did I said ?
        req = urllib2.Request('https://www.google.com/speech-api/v1/'
                              'recognize?client=chromium&lang=fr-FR&maxresults=10',
                flacfile, {'Content-Type': 'audio/x-flac; rate=16000'})
        res = urllib2.urlopen(req)
        # thanks google...
        resp = res.read()
        resp = json.loads(resp)
        print resp['hypotheses'][0]['utterance']
    except:
        logging.error("An error occured...")



#the main pipeline
pipe = gst.parse_launch('autoaudiosrc ! vader auto_threshold=true name=vad '
                        '! audioconvert ! audioresample ! '
                        'audio/x-raw-int,rate=16000 ! flacenc ! '
                        'filesink location=%s' % FLACFILE)

bus = pipe.get_bus()
bus.add_signal_watch()

vader = pipe.get_by_name('vad')
vader.connect('vader-start', on_vader_start)
vader.connect('vader-stop', on_vader_stop)

try:
    # start the pipeline now
    pipe.set_state(gst.STATE_PLAYING)
    logging.info("Press CTRL+C to stop")
    gtk.main()

except KeyboardInterrupt:
    # stop pipeline 
    pipe.set_state(gst.STATE_NULL)
    # remove our flac file
    os.remove(FLACFILE)

Voici un exemple de choses que j’ai put voir en lançant mon script python:

$ python voice.py 
** Message: pygobject_register_sinkfunc is deprecated (GstObject)
INFO:root:Press CTRL+C to stop
DEBUG:root:Listening...
DEBUG:root:Processing...
ceci est un exemple de reconnaissance vocale
DEBUG:root:Listening...
DEBUG:root:Processing...
comme vous pouvez voir cela fonctionne plutôt pas mal

Bon il est clair qu’il faudra certainement régler le niveau du micro pour pas tout enregistrer tout le temps, voir créer un raccourcis qui lance cette reconnaissance one shot… et puis pourquoi pas se faire des jeux de commandes qui peuvent executer des actions…

En gros, tout est possible, mais encore une fois: Google n’a pas donné explicitement son accord pour utiliser leur outil de reconnaissance vocale comme ça… alors allez-y molo avec ce jouet - c’est purement un exemple à titre de recherche !

Petite parenthèse: j’ai pas mal testé pocketsphinx, y’a bien un moment où je vais réussir à en tirer un truc plus propre… mais rien n’a égalé ce que j’ai réussi à faire via Google…

Les closures javascript et la notion de classe

Fri, 17 May 2013 11:50:04 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

NodeJS, JQuery, Mootools, HTML5… le javascript s’est imposé. Mais un sujet encore mal compris par beaucoup de développeurs JS me saute aux yeux. Depuis que je développe Knotter et que j’ai l’occasion d’en discuter, la tendance se creuse: beaucoup n’ont pas bien assimilé le concept de closure. Alors faisons un point sur les closures JS.

Les closures ne sont pas nouvelles et Javascript n’est pas le seul à les implémenter. Go par exemple implémente le concept de “full closure”, et PHP entre dans la danse. Mais il y a aussi C#, Perl, Python… tous utilisent le principe de closure.

Si il y a bien un chose qui est mal écrit dans Javascript, c’est ce fichu mot clef “function”. Car en réalité, une fonction Javascript n’est pas réellement une fonction.

Alors c’est quoi une closure ? Et bien simplement, c’est une notion de fonction qui peut garder son contexte actif et faire référence à des variables libres.

Bon, prenons un exemple de “fonction”, elle peut prendre en argument des valeurs (ou pas) et retourner une valeur (ou pas…)

function Add(a, b) {
    var c= a+b;
    return c;
}

C’est simple, c’est basique, c’est une fonction ! Sauf que je peux très bien écrire la même chose de cette manière:

var Add = function (a, b){
    var c = a+b;
    return c;
};

Etonnant ? je peux assigner une fonction à une variable. La variable “Add” contient la fonction. “Contient” ? et oui, car une fonction est un genre d’objet qu’on peut assigner quelque part, ce genre d’objet s’appelle une closure (le terme “fermeture” en français existe)

Alors si je peux l’assigner, au même titre que la variable “c” dans mon exemple, je peux faire une fonction qui retourne une fonction ! On tente:

function createAddFunction(){
    var add = function (a, b){
        var c = a+b;
        return c;
    };

    return add;
}

var myadd = createAddFunction();

console.log( myadd(4, 5) ); //=> retourne 9

Pour le moment l’utilité n’est pas probante, mais vous comprennez aisément ce qu’il se passe. La variable “myadd” se voit assignée de la fonction retournée par createAddFunction. Par conséquent elle contient la fonction “add” qui va être créée seulement au moment de l’appel “createAddFunction”.

Si c’est pas génial ça ?

Mais là où la closure prend tout son sens et son intérêt, c’est qu’elle capture le contexte dans lequelle elle est créée.

Je vais être plus clair: la fonction “add” retournée est créée dans une fonction nommé “createAddFunction”. Mais cette seconde fonction, c’est aussi une closure ! Si je créee une closure à l’intérieur d’un autre, les variables de la closure parente sont accessibles dans la descendante tant qu’elle s’en sert.

Voici un exemple simple:

function getCounter() {
    var c = 0;
    return function (){
        return c++;
    }
}

var counter1 = getCounter();
var counter2 = getCounter();

// on utilise le premier compteur
console.log( counter1() ); // 1
console.log( counter1() ); // 2

// on passe au seconde compteur
console.log( counter2() ); // 1
console.log( counter2() ); // 2

// on revient au premier compteur
console.log( counter1() ); // 3
console.log( counter1() ); // 4

Voilà ce qu’est une closure que l’on appelle “full closure”. Le contexte parent est assigné à ses descendants. Ainsi, “counter1” contient la fonction qui retourne “c++”. Mais comme cette variable “c” est initialisée dans la closure “getCounter” elle a accès à la variable “c” qui a été créée au moment de l’appel à getCounter. Je vous rappelle au passage que chaque appel à getCounter est séparé, on parle de contexte, et par conséquent la variable “c” n’est pas partagé à tous les compteurs. Ce ne sont pas des singletons et c’est tant mieux.

Ce concept est très utile car il permet de ne pas garder globalement des variables, et surtout il permet de controller la mémoire aisément.

Mais ce qui est fabuleux en JS, c’est qu’en plus d’être “full closure”, les fonctions peuvent avoir un prototype. Du coup, on peut instancier une fonction dont on aura accès à des méthodes, des propriétés… ha mais oui ! on dirait bien une classe ! Sauf qu’il faut garder à l’esprit que ce ne sont pas des classes !

Tout comme en Go qui utilise un principe de structures et d’interfaces permettant de “simuler” des classes, gardez à l’esprit que JS n’a pas de classe réelle mais des closures avec un prototype.

Voici une classe simple:

function Animal() {
    console.log("Naissance de l'animal");
}
Animal.prototype.name = null ;

Animal.prototype.getName = function (){
    return this.name;
}

Ce mot clef “prototype” est une quelque sorte un “objet” qui contient des propriétés et fonctions.

Vous avez remarqué le mot “this” dans la méthode “getName”. Elle fera référence à l’animal en cours. Sauf que voilà… pour que “this” soit une référence à un animal (et pas tous les animaux qu’on créera) il faut “instancier” la closure. C’est le rôle du mot clef “new”.

var tom = new Animal()
tom.name = "Tom le chat"
console.log( tom.getName() ); //=> Tom le chat

Et voilà, on a l’impression d’utiliser une classe qui s’instancie dans un objet nommé “tom”. En réalité, on a instancié le prototpye initialisé. En passant, l’appel à “new Animal()” a appelé la fonction “Animal” que l’ont peut voir comme un “constructeur”.

Et donc, si un prototype est un objet… rien ne nous empêche de l’initialiser avec un autre objet. Par exemple, un chat :

function Chat() {

}

Chat.prototype = new Animal();

Chat.prototype.classification = "chat";

var hercule = new Chat();
hercule.name = "Hercule le copain de Pif";
console.log( hercule.getName() ); // appelle getName de "Animal"
console.log( hercule.classification ); // => chat

Cela fonctionne pour une simple et bonne raison. Le prototype de “Chat” est un objet, auquel on a assigné une instance de “Animal”. Ainsi, Chat.prototype.getName existe tout comme Chat.prototype.name

Ensuite on a ajouté au prototype une nouvelle propriété, nommée “classification”.

Notez au passage, il fait bien construire le prorotype après avoir assigné le prototype parent. Sinon vous allez écraser ce que vous avez assigné.

C’est typiquement une façon de faire de l’héritage. Même si au final, c’est de la composition…

Par contre, vous avez remarqué que “new Chat()” n’a pas appelé le constructeur parent. Encore une fois, comprennez bien que nous ne faisons pas ici de classes, mais des closures !

La méthode pour forcer l’appel au parent est la suivante, appeler une fonction qui existe dans toutes les closures: “call()”. Cette méthode prend en argument un objet et va appeler la méthode en prenant un contexte donné. En clar, modifiez la closure:

function Chat() {
    Animal.call(this); // on envoit le chat dans Animal
}

Cela va appeler le constructeur “Animal” avec le contexte du “Chat”. Pour aller plus loin, regardez cet exemple:

function Animal(name) {
    this.name = name;
    console.log("Nom assigné !");
}

Animal.prototype.name = null;
Animal.prorotype.getName = function (){
    return this.name;
}

function Chat(name){
    Animal.call(this, name); // on appelle le constructeur
}

// on hérite... mais le souci c'est que là on 
// ne donne pas "name" en paramètre...
// Dans tous les cas, Chat() sera appelé, donc on aura
// quand même un appel à Animal() avec le nom...
Chat.prototype = new Animal();
Chat.prototype.classification = "chat";

var grosminet = new Chat("Sylvestre");

Là on a bien appelé la construction parente… 2 fois ??? et oui… le prorotype est initialisé avec “new Animal()” puis on appelle “Animal.call(this, name)” depuis le constructeur de Chat… Ralalala c’est gênant !

Il existe heureusement d’autres méthodes pour ça. Mais avant de lire la suite, assurez vous d’avoir tout compris à ce que je raconte au dessus.

C’est bon ? on continue. Le but du jeu c’est d’initialiser le prorotype de la closure “Chat” avec celui de “Animal”, c’est tout simple. Alors pourquoi ne pas copier le prototype de “Animal” ?

function Chat(name) {
    console.log("Constructeur de chat");
    Animal.call(this, name);
}

Chat.prototype = Animal.proyotype;
// etc...

var c = new Chat("Choupette");

Et là… désespoir… vous n’avez pas vu passer “Constructeur de chat”. Car en réalité, vous avez assigné tout le prototype de Animal à Chat. Y compris le constructeur !

La solution est de remettre le constructeur à sa place:

//...
Chat.prototype = Animal.prototype;
Chat.prorotype.constructor = Chat;

//...

Et là, ça marche !

Bon on va récapituler:

une closure c’est une fonction qui a un prototype, on peut l’assigner à une variable et par conséquent la retourner depuis une fonction
une classe en JS n’existe pas, c’est une closure (fonction) dont on a initialisé un prototype
on peut copier le prototype d’une closure dans une autre closure, du coup on compose la closure avec une autre => simili d’héritage de classe

Du coup c’est relativement simple de créer des factories. Voici un exemple simplifié de ce que j’utilise dans mes helpers de Knotter :

function createClass(proto, parentClass) {

    var f = null;

    if (parentClass) {
        // le constructeur appellera le constructeur parent
        f = function (){
            parentClass.call(this);
        };

        // on copie le prototype parent
        f.prototype = parentClass.prototype;

        //on remet le constructeur enfant
        f.prototype.constructor = f;

    }
    else {
        // pas d'héritage, donc une simple closure
        // suffit
        f = function (){};
    }

    //assigne le prototype sans écraser
    //le prototype parent (on garde le constructeur, etc...)
    for (var p in proto) {
        f.prototype[p] = proto[p];
    }

    return f;
}

Ce qui permet de faire joliement:

var MaClass = createClass({
    name : "",
    //fonction parente, retourne le nom tel quel
    getName : function (){
        return this.name;
    }
});

var ChildClass = createClass({
    // on fait pareil que le le parent
    // mais en lowercase
    getName : function () {
        return this.name.toLowerCase()
    }
}, MaClass);


var c = new ChildClass();
c.name = "Foo Bar";

//affiche "foo bar"
console.log(c.getName());

C’est assez propre, joli, facile à utiliser…

Bref, j’espère voir avoir éclairé un peu plus sur ce qu’est une closure JS, et sur le principe même des classes Javascript.

Le futur du web m'inquiète

Fri, 03 May 2013 06:17:28 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Il fut un temps pas si lointain où créer un site web entrait dans une logique saine de construction de pages. Chaque contenu était bien défini et les applications étaient un jeu de question-réponses entre le client et le serveur. Je me souviens que le plus dur était de passer la validation xhtml et de ne pas passer par des tableaux pour toute la mise en page. HTML5 est arrivé et tout à coup, c’est comme si tout le monde se foutait de l’accessibilité…

Avant que vous me pourrissiez en me disant que je suis anti “nouvelles technologies”, sachez que j’utilise avec plaisirs les dernières technologies du web, que ce soit les websockets, les canvas, les tags video et audio, le CSS3, et le HTML5. Mais mon analyse qui suit est une interrogation suite à quelques années de développement dans le Web. Je ne cherche en aucun cas à faire boycotter les technologies dont je vais parler. Je cherche simplement à donner matière à réflexion.

Revenons quelques années en arrière, voir même seulement quelques mois. Quand l’annonce de Adobe fait mouche auprès de la communauté des développeurs de sites en spécifiant que leur technologie “Flash” n’allait plus être supportée sur Android (alors que Apple ne l’a jamais supporté), cela donnait du sourire à pas mal d’entre nous. Car si les deux monstres du web mobile ne supportent pas Flash, alors il est clair que cette technologie n’allait pas suivre longtemps sur les navigateurs de bureau. Pourquoi ? tout simplement parce qu’aujourd’hui les mobiles affichent le même site que celui que vous voyez sur votre ordinateur. Cela pose donc un problème si vous utilisez Flash sur votre site. Car un utilisateur visionnant votre site sur ton téléphone ou sa tablette allait avoir un sacré problème.

Flash, c’est la techno anti-accessibilité au possible. De vrais soucis pour le référencment… et j’en passe. Les derniers bastions de cette technologie reste la possibilité d’utiliser aisément la webcam et le micro. Seulement voilà… même sur ce terrain les navigateur modernes (donc tout sauf Internet Explorer) peuvent commencer à utiliser ce matériel via “getUserMedia”. Ce n’est donc pratiquement plus un problème.

Il y a donc quelques mois encore, l’un des problèmes majeurs du corps de métier du web était de faire un site viable, lisible, accessible.

Mais HTML5 approchait. Petit à petit j’ai vu des dizaines de sites utiliser cette technologie pour ne plus être un site, mais une application Web. Il y a une grande différence entre un site de contenu et une application web. L’un donne du contenu, l’autre vous fait interagir avec du contenu qui apparaît et disparaît selon vos actions.

La complexité de créer ce genre de site, le rendre accessible et surtout qu’il puisse être correctement référencé par les moteurs de recherche fait doubler voir tripler le temps de développement. Car si vous faites les choses correctement, il faut pour chaque actions de l’utilisateur qui donne du contenu via des requêtes HTTP javascript, permettre un affichage statique… imaginez un peu si vous n’y avez pas pensé dés le départ…

Il existe une méthodologie que je vous conseille d’utiliser: le “progressive enhancement” ou en français “Amélioration Progressive”. Cette technique consiste à créer votre page en éliminant un maximum de fioritures (Javascript, canvas…) puis quand votre page est correctement affichée, que les liens répondent de manière traditionnelle, vous ajoutez la couche interactive: les liens peuvent utiliser des requêtes XHR etc…

Ce qui m’inquiète, c’est que de plus en plus de site web se fichent de cela. Google Plus, que j’utilise à foison, ne fonctionne pas du tout avec les navigateurs type Uzbl. Et je sais que beaucoup de non voyant n’on pas accès à ce genre de site de part le fait que les navigateur Braille n’arrive pas à afficher les contenus.

Mettre le Web et ses services à la disposition de tous les individus, quel que soit leur matériel ou logiciel, leur infrastructure réseau, leur langue maternelle, leur culture, leur localisation géographique ou leurs aptitudes physiques ou mentales.

–Tim Berners-Lee, Inventeur de l’internet

Une chose est vraie, je pense aussi que nous ne devons pas limiter la technologie pour qu’elle soit accessible, mais plutôt faire évoluer l’accessibilité (ses outils et ses intégrations) pour que tout le monde puisse en profiter.

Alors quel avenir pour le Web ? Allons nous perdre ces règles que nous chérissions il y a peu de temps ? N’allons nous pas trop loin avec nos navigateurs ? Nous sommes en train de passer sur du “tout web”, pratiquement toutes les applications que nous utilisions en “client lourd” deviennent des application web… nos mails, édition de document, visio conférence, édition de vidéo… notre navigateur internet devient notre bureau. C’était d’ailleurs l’un des paris de Google avec ChomeOS. Un webstore propose des jeux, des outils, des applications bureautique qui tournent toutes dans le navigateur.

Le WebGL apporte en plus la partie accélération 3D, ce qui fait qu’aujourd’hui le navigateur est capable de faire absolument tout ce qu’un gestionnaire de fenêtre peut faire. Et même si je suis franchement impressionné par la puissance de Chrome, de Firefox ou de Opera, je n’en reste pas moins inquiet pour nos technologies de bureau… et je vous avoues que j’ai peur de voir disparaître beaucoup d’applications client lourd et les voir se transformer en applications Web, ouvrant ainsi la porte à des failles de sécurité et des inaccessibilités grandissante. Il suffira que le site qui propose l’application soit indisponible, et vous voilà dans le brouillard.

Sortie de Knotter

Mon, 29 Apr 2013 23:46:11 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Et bien on y est. Je me suis lancé un défis il y a quelques semaines et il est réalisé en quelques temps. Knotter, mon microframework NodeJS passe en version 0.1.1. Et comme je pense que personne ne le connais, je vais vous le présenter avec des exemples à l’appui. Knotter, c’est simple un framework NodeJS basé sur un principe prototypé simple, rapide et malléable.

Knotter est né lors d’une étude comparative que je devais faire entre une solution Python WSGI (webapp2) et NodeJS. Comme je devais réaliser à peu de chose près la même structure de code, j’ai créé un tout petit middleware en quelques lignes pour simuler le même fonctionnement. J’aurais put utiliser Connect mais il ne collait pas exactement à mon attention. En quelques minutes j’avais la base, et j’ai réalisé mon étude. Et puis… l’idée à pris son chemin…

Les jours passaient, et dans ma tête se peaufinais l’idée. Oui j’adore Connect. Mais j’aime le pattern composite des closures pour créer des pseudo classes. Le mode Objet de Javascript n’est pas réputé, mais il faut dire que la plupart des développeurs oubli que Javascript n’a pas de classes, ni même de fonctions… Il a des “closures”. Du moment où vous acceptez cette idée, que vous la comprenez, alors le langage devient limpide.

Je ferai un billet de blog à ce sujet, passons au coeur de l’idée.

Mon blog tombait, je ne le maintenait plus et après plusieurs années de bons et loyaux services, Copix 3 sous PHP 5.2 n’y arrivait plus. Depuis des mois je n’ai pas touché à PHP, je code en Python et JS à longueur de journée… et voilà alors le projet qui nait. Je me décide, je fais mon framework sur mesure pour gérer mon blog.

Plus de MySQL, on passe à MongoDB et je me lance dans le code.

Knotter commence à naitre, au départ avec des erreurs monumentales de conception: les “handlers” sont des objets non prototypés, les cookies sont mal gérés, et surtout pas moyen de faire passer des sessions d’un worker à l’autre. Mais outre cela, le modèle était pas mauvais, il fallait juste une refonte, repenser le core.

La version 0.1.1 devait faire sauter le bouchon, et voici comment vous pouvez créer un petit projet avec Knotter, Petit car, mis à part mon site, je ne sais pas à quel point cela est viable. Mais mes benchmarks sont assez encourageant.

Installation

On va commencer par créer notre dossier de travail. Nous allons le créer dans “~/Dev/knotter-example”. Au final, vous aurez cette structure de répertoire:

~/Dev/knotter-example/
                     |_ index.js
                     |_ templates/
                     |      |_example.html
                     |
                     |_ handlers/
                     |      |_page.js
                     |
                     |_ statics/
                               |_ css/
                               |     |_base.css
                               |_ images/
                                     |_test.png

Ce n’est pas compliqué, tapez dans un terminal:

mkdir -p ~/Dev/knotter-example/{handlers,statics,statics/css,static/images,templates}
cd ~/Dev/knotter-example

Installez knotter via “npm”:

npm install knotter

Inutile de l’installer globalement, knotter s’installe localement. Du coup, vous allez avoir un répertoire “node_modules” qui va apparaitre, avec à l’intérieur une installation toute prête de knotter.

Puisqu’on va faire les choses bien, on va utiliser un moteur de template. Knotter est agnostique au moteur de templates car il utilise le génial module “consolidate”. Mon moteur de templates préféré étant “swig”, on passe par la commande:

npm install swig

Swig a l’avantage de ressembler fortement à Twig ou Jinja et me permet de ne pas me mélanger les pinceaux. Bref, passons au code.

Premier handler

Un handler est une closure prototypée (oui, une classe allez…) qui hérite (se compose en réalité) de knotter.Handler. Afin d’assurer l’héritage, il faut respecter une syntaxe simple:

// fichier ~/Dev/knotter-example/handlers/page.js

var knotter = require('knotter'),
    util    = require('util');

//on crée notre classe PageHandler, le nom est arbitraire
PageHandler(){
    // on appelle le constructeur parent
    knotter.Handler.call(this);
}
//on fait hériter la classe
util.inherits(PageHandler, knotter.Handler)

Et c’est tout… enfin presque. Là nous avons un handler, mais il doit répondre à une url et surtout à une méthode HTTP précise, continuez:

// l'expression régulière pour répondre
// la route *doit* faire parti du prototype
PageHandler.prototype.route = "^/page/example";

// le handler "get" 
PageHandler.prototype.get = function () {
    this.end("Coucou")
};

// on exporte le handler
module.exports = PageHandler;

Voilà pour le handler, on passe au serveur

Le serveur

Comme la plupart des nouvelles technologies de service Web, c’est l’outil qui sert les réponses depuis sont propre mécanisme de serveur. Ainsi, votre application Web répond elle-même aux clients. On aime passer par un proxy frontal type nginx pour simplifier une partie du travail, mais dans l’ensemble le serveur HTTP intégré de Node s’en sort bien.

Mais knotter fourni une classe qui va permettre de définir la configuration, savoir quels handlers utiliser, etc…

// fichier ~/Dev/knotter-example/index.js

var knotter = require('knotter'),
    PageHandler = require('./handlers/page.js');

var server = new knotter.Server({
    handlers : [ PageHandler ]
})
// on lance le serveur
server.start();

Voilà, rien de bien compliqué ici. Pour le moment notez simplement que nous n’avons qu’un handler dans la liste (n’oubliez pas que “handlers” est un tableau). Il suffit alors de lancer:

node index.js

Et de se rendre sur http://127.0.0.1:8000/page/example

Un fabuleux “Coucou” apparait, c’est gagné :)

Gérer les arguments et utiliser un moteur de template

Nous avons installé un moteur de template, alors utilison le ! Mais pour rendre l’exemple plus sexy, on va utiliser les arguments passés à la route.

Reprenons handler/page.js et modifions la route et le handler “get”.

// la regexp qui prend deux arguments
// le "?" permet de ne pas capturer de "/" dans la première
// capture.
PageHandler.prototype.route = "^/page/example/(.*?)/(.*)";

// on va utiliser un template
PageHandler.prototype.get = function () {

    var firstname = this.params.args[1];
    var lastname = this.params.args[2];


    // on appelle le template example.html à la racine de "templates"
    // La racine sera déclaré dans la configuration serveur, lisez la suite...
    // Le second argument est le contexte envoyé au template, les 
    // propriétés seront des variables de template
    this.render('/example.html', {
        lastname: lastname,
        firstname : firstname
    });

};

Dans le fichier “templates/example.html” on va juste faire simple:

Bonjour {{firstname}} {{lastname}}

On passe à “index.js”, on y configure l’utilisation de swig

var server = new knotter.Server({
    handlers : [ PageHandler ],
    engine   : "swig",
    templates : __dirname + "/templates",
    engineOptions: {
        root: __dirname +"/templates",
        allowErrors : true,
        autoescape : false,
        cache : false
    }
});

Il faut malheureusement bel et bien répéter les deux options de “templates” et “root”. Je n’ai pas encore trouvé de palliatif…

Bref, coupez le serveur si ce n’est pas déjà fait, et relancez le. Puis allez vois les pages:

Les arguments passés à l’url apparaissent bien, c’est encore gagné !

Sessions

Les sessions fonctionnent correctement depuis la version 0.0.5 mais la version 0.1.1 permet désormais de les partager entre clusters (voir section suivante).

Pour utiliser des variables de sessions, il suffit, dans un handler, d’utiliser l’objet “this.sessions”.

this.sessions.get('key'); // retourne la valeur de session utilisateur pour la clef "key"
this.sessions.set('key', 'une valeur'); // assigne la valeur à une clef

Les valeurs sont sérialisée via JSON, ce qui induit que vous ne pouvez pas garder une classe complexe en session, mais un objet simple sera correctement récupéré.

Les sessions restent en mémoire, elles ont un TTL de 15 minutes d’inactivité. Je vais régler d’ici la version 0.1.2 le fait de pouvoir changer ce TTL.

Cluster, et sessions

L’un des mes soucis majeurs était de réussir à faire tourner plusieurs “workers” en parallèle tout en pouvant gérer des variables de sessions. Car vous le savez certainement, Node est “monoprocess”. Cela signifie que pour pouvoir répondre en même temps à plusieurs clients, il faut jongler avec le module “cluster”.

Mais le passage de valeurs a été une bataille sans nom… Knotter fourni une classe pour simplifier le travail. Voici comment vous pouvez procéder.

Coupez les serveur (CTRL+C) et modifiez les fichier index.js:

var cluster = require('cluster'),
    numCPUs = require('os').cpus().length,
    knotter = require('knotter');

if (cluster.isMaster) {
    var n = cluster.fork();
    knotter.Cluster.addWorker(n);

} else {
    // dans le worker, on lance le serveur

    var server = new knotter.Server({
        handlers : [ PageHandler ],
        engine   : "swig",
        templates : __dirname + "/templates",
        engineOptions: {
            root: __dirname +"/templates",
            allowErrors : true,
            autoescape : false,
            cache : false
        }
    });

    server.start();

}

Le sous-module “Cluster” de Knotter permet d’envoyer les sessions lors des modifications de valeurs. Tout est fait automatiquement.

A terme, le système de sessions sera paramétrable pour pouvoir utiliser un memcache ou redis… pour le moment c’est amplement suffisant pour mon cas personnel.

Fichiers statiques

Vous allez avoir besoin de servir des fichiers statiques, ne serait-ce que des images ou des feuilles de styles. Ici nous utilisons le répertoire “statics”. Pour décorèler un peu et que vous comprenniez bien comment cela fonctionne, je fais en sorte de créer deux routes spécifiques pour les images et le css. Voici la configuration à donner au serveur:

var server = new knotter.Server({
    handlers : [ PageHandler ],
    engine   : "swig",
    templates : __dirname + "/templates",
    engineOptions: {
        root: __dirname +"/templates",
        allowErrors : true,
        autoescape : false,
        cache : false
    },
    // deux points pour les fichiers statiques
    statics: {
        'styles': __dirname + '/statics/css/',
        'img' : __diranme + '/statics/images/'
    }
});

Ainsi:

http://127.0.0.1:8000/styles/base.css sert statics/css/base.css
http://127.0.0.1:8000/img/test.png sert statics/images/test.png

Concrètement

Concrètement mon blog tourne sur Knotter. J’ai créé deux ou trois modules pour gérer les tickets, le flux RSS ou les sitemaps. Cela ne m’a pas pris longtemps, mais je maitrise mon outil… Je vais vraiment devoir documenter Knotter sérieusement si vous êtes intéressés par mon projet. Dans tous les cas, celui-ci ne mourra pas. Le simple fait de l’utiliser ici pour mon blog va me pousser à le maintenir. Mais je vous avoues qu’un peu d’aide ou ne serait-ce que quelques personnes me faisant un retour serait un bon carburant.

Pour aller plus loin

Lisez la documentation de swig, notamment en ce qui concerne “extends” dans l’API. Cela va vous permettre de faire des templates “globaux” dans lesquels vous injecterez des blocks.

L’utilisation d’une base de données sera vraiment un plus, MongoDB est en quelques sorte la panacée puisque la syntaxe est aussi en Javascript… mais n’importe quelle base de données fera l’affaire.

Je pense avoir fait un tour assez clair… à moins que vous ayez des questions ?

Reprise du blog avec NodeJS

Sun, 21 Apr 2013 16:26:28 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vous avez remarqué ? nouveau blog, nouveau design, et surtout nouveau langage: NodeJS (javascript) avec une base mongo. Le tout avec mon middleware nommé Knotter. Je me permet donc de vous présenter le renouveau et certainement un peu plus de contenu puisque de désormais je pense qu’il va bien mieux marcher. Laissez moi vous expliquer…

Cela faisait des mois, que je ne touchais plus mon blog. Il faut dire que j’ai pas eut le temps, d’une part, mais aussi que ce vieux coucou tourne depuis presque 6 ans sur un Copix 3 (vous vous souvenez ?) en PHP. J’avais beau avoir fait le maximum à l’époque, les méchants spammeurs ont pris le dessus et m’ont pollué mon site de commentaires bien dégueulasses… En plus de ça, le conteneur qui était là pour tenir le site en éveil s’en prend plein la poire (d’ailleurs ça j’ai pas encore tout réglé). Mais depuis quelques jours, je me suis relancé sur le projet. D’abord parce que je développe depuis quelques temps un middleware (un genre de microframework) nommé Knotter

. But de la manœuvre: avoir un truc qui fasse un peu comme le WSGI via Python, mais en Javascript.

Le projet lancé, je me suis attelé à reprendre mon blog… pas mal d’étapes ont dut être effectuées pour remettre au propre le site.

En premier lieu, virer le spam ! Tenez vous bien: 97% des commentaires sur le site était du spam. Dingue non ? Alors j’ai commencé par:

passer un export de la base MySQL dans MongoDB (avec un script python qui sérialisait mes tickets + commentaires en un document JSON)
faire un module de calcul “Bayesien”, un coup d’apprentissage et il a pas mal classé le bordel
nettoyer un peu mes billets qui étaient écrit en “wiki” => or voilà, node n’a rien pour ça, je me suis donc tapé un module à la main qui fait tout ça

Ensuite, j’ai recherché les modules qui pouvaient me rendre service:

“feed” pour créer un fil RSS propre
“swig” pour le moteur de template (vraiment génial, proche de Twig pour PHP ou Jinja2 pour Python)
“emailjs” pour ajouter (enfin !) un système de notification email en cas de réponse à un commentaire
“sitemap” pour créer un bon sitemap rapidement

et j’en passe…

Je me suis dit aussi: “rendons le site responsive”, et j’ai beau aimer le bon vieux Twitter Bootstrap, j’ai préféré épurer mon travail en utilisant “Skeleton”, un outil généralissime qui est “style agnostique”, ce qui veut dire qu’il ne me donne que la partie intéressante: les layouts.

J’ai calculé, pour créer le site, à savoir:

3h pour les modules (ticket, page statique, rss, sitemap, connexion à la base mongo…)
1h pour le montage HTML et styles (oui je sais ça se voit…)
2h pour le classement des spams

Reste que je vois encore des spammeurs me faire chier… je vais vérifier si mon filtre auto fonctionne. Et au fur et à mesure je vais améliorer tout ça. J’espère que cette fois-ci le site arrêtera de se planter misérablement tous les jours (parfois pendant plusieurs heures) et que je pourrais vous délivrer rapidement tous mes modules.

A savoir que désormais, le site tourne entièrement en Javascript (ou simili):

nodejs coté serveur
mongodb pour les datas
un peu de js brut pour le site

Du coup, un seul langage pour un site, je vous assure que ça le fait. Niveau perf je suis pas mal non plus… Voilà pour l’info.

Vendre de la musique libre

Sat, 12 Jan 2013 14:38:42 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Voilà des années que je propose ma musique sous une licence libre. En l’occurrence, sous Creative Commons. Vous pouvez la télécharger, la distribuer, l’utiliser… aucun souci. La liberté d’écouter et partager est et reste au centre de ma philosophie. Alors quand je vous dis que mon album est en vente sur Google Play, vous pouvez avoir un sentiment étrange.

Effectivement, l’album “Ayen Bowen No” est en vente sur la page Arkyne sur Google Play pour 0.99€ , le prix n’est pas élevé, mais en même ce n’est ni la gloire ni l’enrichissement que je cherche. Non… vraiment, vous pouvez me croire. La musique, pour moi, est une forme d’échange, un message, un exutoire dont j’ai besoin. Partager mes compositions avec les gens qui veulent m’entendre n’est pas une envie de reconnaissance. C’est une chance pour moi, simplement. Car vous me faites des retours, des critiques, et je les entends.

Mais le problème dans ce principe d’échange, c’est que l’on veut en avoir encore plus. Et pour en vouloir plus, il faut proposer plus. Et dans notre monde, même la création coûte cher; car voilà, proposer un album, même libre, même si je le produit moi même depuis mon petit bureau, j’ai besoin de matériel, de payer un serveur, d’avoir une carte son digne de ce nom, de nouvelles cordes de violon, de réparer quelques instruments.

Et qui plus est, certains m’ont demandé une version vinyle, et en ce qui concerne le son, j’aimerai qu’un ingénieur me fasse un mastering en studio… Bref, tout cela n’est pas gratuit.

Oui, j’aimerai avoir un peu plus de fans, non pas par reconnaissance (je l’ai déjà dit) mais pour proposer plus rapidement et de meilleur qualité de nouveaux morceaux.

Voilà pourquoi je propose une version payante de l’album. Tout comme sur Jamendo (qui va pas aimer que je propose mon album ailleurs, mais en même temps… ils m’ont pas beaucoup aidé jusque là), les fonds que je pourrais engendrer seront gage de nouvelle création.

Vivre de ma musique est hors de propos. Je n’ai ni la capacité financière, ni le talent de certain pour avoir assez de fans pour vivre de mes créations. Mais si je peux toucher ne serait-ce que quelques personnes, que ces personnes en veulent davantage, et que je peux enfin leur proposer d’autres albums sans passer 3 ans à corriger avec peu de matériel… alors je serai comblé.

C’est pourquoi il faut voir cette version comme une version de “don”. Si vous voulez m’aider à promouvoir un peu ce que je fais, n’hésitez pas à partager le lien de l’album, en expliquant bien que la musique proposée est libre, et que tout le monde peut l’écouter et la récupérer gratuitement ailleurs. Mais que la version payante est une aide précieuse pour continuer à faire vivre le projet.

Merci à vous.

Google vs la presse qui veut taxer

Wed, 24 Oct 2012 11:58:43 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

La menace de voir Google bannir les médias français se fait sentir, même si ce ne sont que des paroles visant à appeurer le monde internet. Que Google le fasse ou non, le problème est bien levé. Les éditeurs de presses demandent à ce que la “Lex Google” (loi Google en allemand) soit appliquée aussi en France. Grosso-modo, on demande à Google de reverser des “taxes” aux éditeurs de presse français car il gagne de l’argent sur la pub en affichant du contenu des sites de presse. Dans le fond, c’est pas idiot, dans la forme il y a un souci…

Soyons pragmatique, à quoi sert Google (en tant que moteur de recherche) ? Il référence les sites qui lui permettent de le faire sur sa base de données, permettant aux internautes qui utilisent ce moteur de recherche à trouver des sites en relation avec leur recherche. Comme l’une des grandes sources d’information se base sur la presse, il est évident qu’une recherche sur un évènement d’actualité vous retourne un résultat qui se situe sur un site de presse (le monde, le point, figaro…)

Bref, en soit, Google est un service de référencement. Dans la forme, Google génère son contenu à partir du contenu des sites qu’il référence. Mais il reste un service qui permet aux sites référencés de voir leur trafic augmenter. Car si Google ne retourne pas de résultat pointant sur votre site, vous pouvez être sûr que vous n’allez pas avoir un trafic phénoménal.

Google fait apparaitre de la publicité sur sa page de résultat. Car oui, Google est une entreprise… et par ailleurs, les sites de presse eux même ont en général des espaces de publicité qui leur rapport un peu de sous.

L’hopital se fout de la charité, et voilà que “comme la bête est grasse” on va pas se gêner. En plus de fournir des visites aux site de presse, Google devrait reverser un pourcentage de ses révenus publicitaires aux dits sites de presse.

Bha voyons…

Donc, réaction de Google, faire une menace impossible à tenir: on va donc bannir les sites de presse du moteur de recherche. Google ne peut évidamment pas se le permettre, car effectivement les sites de presses fournissent un contenu à Google. Mais en contre parti, la visibilité du site de presse est largement accrus.

Alors deux questions me tarodent. D’abord: est-ce que **tous les moteurs de recherches** vont être visés ? et secondo, si les éditeurs de sites de presse sont pas content que Google gagne de l’argent en référençant leur site, je leur rappelle qu’il peuvent se faire déréférencer hein, un vieux fichier “robots.txt” avec un Disallow *" et on en parle plus. Alors la seconde question: si les éditeurs se croient si indispensables à Google et qu’ils sont pas content que Google gange des pépètes, pourquoi laissent-ils leur site se faire référencer ?

Oui… je connais les réponses à ces questions, mais j’ai l’impression que les acteurs de ce mouvement n’ont pas conscience qu’on est pas dupes…

Alors messieurs les éditeurs de presse qui demande encore de la tune, vous pouvez nous donner honnêtement une réponse claire ?

JQuery toujours pas pour moi

Wed, 05 Sep 2012 20:15:22 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Suite à un vieux post qui s’est terminé par une horde de pas mal de fans de jQuery insultants, j’ai évité de continuer à commenter et je décide de refaire un article. Deux ans se sont écoulés, et ma vision de jQuery se déteriore de plus en plus… J’ai admis certaines critiques, mes exemples n’étaient pas forcément les plus adéquats et mon entrain à défendre un point de vue n’a pas été suivi par une explication claire. Du coup, voici un point de vue plus “technique” et plus poussé sur le “pourquoi je n’aime pas du tout jQuery”

Pour appuyer mes remarques et mon avis, je vais me baser sur des discussions que j’ai eut depuis 2 ans. Que ce soit après ma conférence donnée sur JS ou avec des collègues, j’ai noté les remarques, et je vous redonne texto ce que j’ai répondu ou ce que j’ai tenté d’expliquer.

En plus de ces remarques, je vais vous montrer aussi les points principaux qui me font vraiment une poussée allergique à ce “framework” Javascript.

Sémantique

Commençons par ce qui m’orifie le plus, à savoir cette sémantique qui me fait palir.

Prenons un exemple tout bête: $('#element').load(handler)

Non mais vous plaisantez ? quand je lis ça je me dis que “load” ça charge un truc. Bha non ! là c’est l’évènement “onload” qui appelle le handler. Une sémantique pareille me choque vraiment, surtout que:

//pris de la doc... $('#result').load('ajax/test.html');

Ce coup-ci load charge bien un truc… la page “ajax/test.html” est récupéré via un XHR (XHttpRequest, et pas “Ajax”, on va y venir…) et le contenu est inséré dans l’élement…

Vous pouvez me dire ce que vous voulez, utiliser un nom de méthode pour deux opérations qui n’ont rien à voir, c’est absurde et pas propre. Vous en voulez un autre, bougez pas.

La méthode “click” par exemple. En premier lieu, moi quand je lis ce nom, je me dis “tiens c’est cool, une fonction qui simule un click”. Et j’ai pas tort en fait. Car si je fais:

$('#toto').click()

alors je simule un click. Je ne fais que répéter la doc:

“In the third variation, when .click() is called without arguments, it is a shortcut for .trigger(“click”).”

Mais si je mets un handler en paramètre, alors tout le comportement est différent, car dans ce cas la fonction “click” enregistre un “event listener”.

Deux comportements purement éloignés, qui sont bien séparés dans tous les autres framework JS. On définis plutôt une méthode “onclick” et “click” qui font deux choses bien distinctes.

Terminologie hasardeuse

jQuery a vraiment un souci avec les termes. Quand je lis le code qu’on pond, j’ai l’impression de parler comme un petit débutant qui connait rien au HTTP, HTML, CSS et JS… je vous explique.

Savez-vous ce qu’est un CSS ? Cascading StyleSheet, ce qui signifie “Feuille de style en cascade”. Autrement dit, une CSS est une arborescence qui définit des styles pour des éléments dissociés par des attributs (class, type…), des identifiants (id), des états (active, hover, visited…) et en les repérant par leur hiérarchie dans le DOM. C’est un standard clair, qui évolue.

Chaque propriété d’un élément repéré est un **style**. On est d’accord ? je l’espère… parce que les auteurs de jQuery ont une autre définition. Pour eux, un CSS est un style… Si si…

Je vous montre:

$('.class-element').css('color','red')

Vous me direz “ouais tu pousses, en fait on change la CSS pour les éléments de classe classe-element “. Non ! car:

$(this).css('border','1px solid black')

ce code change le **style d’un élément unique**, et si ça suffit pas, regardez avec Firebug ou la console de Chrome/Chromium pour vous rendre compte que l’attribut touché est “style” et **non pas la feuille de style**. Je chipotte ? si aujourd’hui vous voyez un framework dans un autre langage, pour une autre technologie que le web, je vous assure que vous seriez choqué.

Ici, on dit que “CSS” permet de modifier le style de l’élément. C’est juste une erreur me diriez-vous. Et bien non. Les auteurs de jQuery ont vraiment du mal avec les terminologies, car pour eux on peut faire du “Ajax synchrone” avec du JSON.

Rappel: Ajax = Asynchroneous Javascript And Xml

Dire que vous faite de l’Ajax synchrone, c’est comme dire que vous faites de la photo avec une toile, des peinceaux et de la peinture… c’est vrai quoi, la photo et la peinture c’est exactement pareil, on ne va pas chipoter hein !

Alors pour reprendre les choses clairement, si vous faite un appel HTTP en javascript, que ce soit synchrone ou non, avec du JSON ou non… c’est ce que nous appelons une “requête HTTP”, ou “Http Request”. C’est d’ailleurs pour cela que l’objet standard JS se nomme XHttpRequest (on dit aussi XHR), et que les autres frameworks JS l’appellent de la même manière… Mais apparement, jQuery veut se démarquer avec des termes erronnés. Ou alors, ce que je pense fortement, c’est qu’à la base jQuery faisait du HTTPRequest en mode asynchrone par défaut, et qu’un jour les développeurs se sont rendu compte qu’on pouvait faire des appels synchrones. Comme pour “css”, ils ne se sont pas posé la question et ont ajouté l’option “synchrone” à une terminologie qui veut dire “asynchrone”: Ajax.

Ce qui me choque, c’est que jQuery est arrivé après Prototype et Mootools, et eux ont fait cette distinction. Sauf qu’au lieu de respecter un standard de dénomination, les auteurs de JQuery ont décidé de prendre des termes “bateaux” pour monsieur Michu qui décide de développer sans connaître Javascript à la base. On y reviendra après.

Vous me trouvez sarcastique, je ne m’en cache pas. C’est pas aggressif, c’est juste que je tente de défendre ces idées depuis des années et que je reste dépité à entendre des gens défendre des erreurs pareils. Bref, continuons.

Sélecteurs illogiques

J’adore les selecteurs. Non là je ne suis pas ironique ! Que ce soit sur Prototype, jQuery, Mootools, etc. l’utilisation des sélecteurs me plait.

Mais… là où jQuery m’enrage, c’est cette utilisation de “$” pour tout et n’importe quoi. Et surtout qu’il fait une chose infâme quand on bosse sur du DOM, laissez-moi vous expliquer.

On m’a par ailleurs sorti: “attend mais Xpath tu n’aimes pas ?” Mais bien sûr que si ! Je me répète, j’adore les selecteurs, mais encore faut-il que le framework sache les utiliser dans les règles. Je vous donne un exemple tout bête. Un élément peut avoir un “id” (identifiant) qui **doit être unique**. En JS pure, on utilise alors la fonction “getElementById” qui récupère **un et un seul élément**, c’est-à-dire l’élement qui a cet ID.

Avant de passer à la suite: oui merci je connais querySelector et querySelectorAll qui utilisent la même syntaxe que jQuery pour les sélecteurs, et je n’aime pas…

Revenons à mon souci: Si deux éléments ont le même ID, alors c’est une erreur de votre part. Vous devez corriger le DOM.

Sauf que voilà… JQuery ne sait pas ce que c’est que de retourner un seul élément. Il retourne toujours une collection, que l’élément soit unique (via un id) ou pas.

Alors comparer cela au comportement de Xpath, excusez-moi mais ça me fait mal ! Car Xpath retourne un élement unique et non une collection si vous sélectionnez un élément qui doit l’être. Point barre. Et querySelectorAll fait pas mieux là dessus… Cherchez pas à me vendre que le code suivant est normal:

var uid = $('#id-unique')

Ici, “uid” est une collection, avec un seul élément à l’intérieur. Inutile de me retourner une collection.

Tiens je reviens sur ce que j’ai dit, finalement querySelector est pas bête, car lui il me retourne un seul élément, et querySelectorAll me retourne une collection, je sais donc choisir entre deux cas. Ho mais attendez…

Prototype et Mootools (pour ne citer que ceux ci) font une distinction importante entre une collection et un élément, ils ont utilisé une fonction séparée pour cela:

-$ pour un élément identifié par un id -$$ pour une collection, sélectionnée via des selecteurs CSS

Marrant hein, 7 ans plus tard les moteurs JS récents utilisent aussi deux méthodes de sélections: querySelector et querySelectorAll.

Mais attendez la suite, vous allez voir que pour jQuery, un élément ayant un id n’est pas forcément unique, selon le cas. C’est juste la section suivante.

4 méthodes, 2 comportements, aucune logique DOM

Qu’est ce qui est passé par la tête des développeurs de JQuery quand ils ont développé les méthodes “find”, “children”, “parent” et “parents” ?

Tout d’abord, le truc qui me choque: find et children. Le premier trouve tous les déscendants d’un élément selon un sélecteur, alors que children fait pareil mais pour **seulement le premier niveau**. Admettons, ça ne me choque pas trop jusque-là. Mais par conséquence, pourquoi “parents” peut remonter de plusieurs niveaux ? On a deux méthodes inversement liées (parents, enfants) qui n’ont pas la même logique de sélection.

Et toujours avec cette fichue collection par défant, parent() vous retourne un seul élément (normal hein) mais dans une collection…

Si ça n’était que cela, je dirai “ok, pourquoi pas, après tout c’est une dénomination”. Mais là où ça marche plus, c’est quand je vois ça:

<!-- on fait n'importe quoi -->
<span id="foo">
    <div id="toto">toto 1</div>
    <div id="toto">toto 2</div>
    <div id="toto">toto 3</div>
    <div>
         <span id="toto">un span toto 4</span>
    </div>
</span>

On est d’accord que c’est une erreur, on a 3 fois le même “id”. JQuery est pas trop débile et sait que “$(’#toto’)” retournera un seul élément, en l’occurence le premier, et à la limite ça me convient.

Mais par contre, avec children, on en a 3 !

Testez: alert($("#toto").length) alert($("#foo").children("#toto").length) alert($("#foo").find("#toto").length)

Vous pouvez voir ici: http://jsfiddle.net/metal3d/9KDA4/1/

C’est quoi cette implémentation ? trois cas possibles ?

On se retrouve avec des comportements illogiques.

Tout passe par $, merci la POO

Et pour revenir au cas du fameux “$”, on va prendre un exemple de handler de click. Dans cette méthode, “this” correspond bien à l’élément cliqué, mais pas “$(this)” qui lui est une collection contenant un seul élément (celui qui est cliqué)… Cela a une impacte sur la logique: puisque le handler est appelé par jQuery, il y a peu de raison (perso j’en vois pas) pour que “this” ne soit pas au moins l’objet jQuery contenant l’élément. Parce que forcer l’utilisateur à taper “$(this)” pour avoir les méthodes spécifiques au framework… je ne vois pas l’intérêt.

Et en en vient à ce qui me dépite le plus…

Ce fichu “$” sert à tout dans jQuery: sélecteur, espace de nom, bind d’évent du document… tout y passe. Du coup, quoique vous fassiez, créer un XHR, une collection, une collection, c’est un objet “jQuery” (mapé en $).

Impossible de faire des classes, et ne venez pas me parler de $.extend parce que tout développeur qui a bossé avec des langages objets ne peut honnêtement me dire que cette méthode est digne de ce nom.

Alors que Prototype, Mootools, Dojo, etc, vous permettent de bosser avec des classes, jQuery vous demande de faire du code pas beau pour tenter de faire des héritages, des proxy et on oublie l’implementation. Impossible de classifier des objets par classe. Et c’est là que le “code less, do more” me fait sourire, car pour faire du code un peu sérieux, on est obligé de coder beaucoup plus pour contrôler tout le code, alors que JS est un langage Objet et qu’on pourrait faire du code plus propre, plus pro, et maintenable.

Franchement, regardez du code dans d’autres framework, par exemple en Mootools (que j’aime beaucoup):

$("element").addEvent('click', function (){ this.setStyle('color','red') });

Comprennez bien que dans Mootools, Prototype, etc. la fonction “$” ne sert que de sélecteur ! l’espace de nom est un élément du document. Cela permet de faire des classes, des implémentations, sans avoir des “$” partout.

Masquage du JS

Je reviens à M. Michu qui code en JQuery sans connaitre le javascript. D’une, **non je ne critique pas tous les utilisateurs de jQuery en pensant que ce sont des débiles**. Que ce soit bien clair, jamais je n’ai pensé cela ! On me l’a ressorti ce matin, ça commence sérieusement à m’aggacer que “du moment où on a une vue critique d’un framework” (surtout que, désolé, mais je connais très bien JS et d’autres frameworks) alors ses utilisateurs se voient automatiquement pris pour des cons.

Ce que je critique, ce n’est pas le fait de ne pas connaître JS. C’est le fait que le framework masque fortement le langage. C’est le cas pour beaucoup de frameworks de pas mal de langages. Je vise particulièrement PHP et eZ Publish qui ont vraiment tendance à sucrer le langage et forcer les intégrateurs à coder dans les templates.

Le vrai souci ici, c’est que la puissance du langage est littéralement court-circuitée par le framework. C’est beaucoup moins le cas pour Prototype par exemple qui a gardé (justement) les notions de prototypage de classe. Mootools a une syntaxe très claire de création de classe et garde ses méthodes proches du langage d’origine.

Or, avec jQuery, vous ne faites pas de JS, mais du jQuery. Et c’est selon moi très dommage.

Une note positive quand même ?

Mais évidemment ! Si je suis aussi “agressif” envers jQuery c’est surtout parce que beaucoup de projets pro utilisent ce framework sans avoir de réflexion a priori. jQuery est un excelent framework pour des interfacages rapides, monter un ou deux caroussels et utiliser des systèmes “basiques”. C’est parfait pour un blog, un site non complexe et ne demandant pas beaucoup d’interactions. Parfait parce que **simple** et ne demandant pas beaucoup de code pour une utilisation standard.

Mais si votre interface a besoin d’évolutivité, de maintenance, demande beaucoup de code pour interfacer dynamiquement le site, alors utilisez un framework plus orienté POO, plus professionnel et moins gadget.

jQuery a eut le mérite de proposer une implémentation vraiment facile à utiliser, rapide à mettre en oeuvre et ne demandant pas de lire de la doc constamment. Mais avant de choisir par défaut jQuery parce que “vous le connaissez bien”, testez d’autres frameworks et faites-vous une idée.

Le bilan de 7 ans à utiliser 5 frameworks m’a donné cette vision:

-jquery != js, = gadget super simple et efficace en mode standard -prototype, mootools = POO, fiable, propre et modulaire -dojo = implémentation supra modulaire, proche de JS standard (oui, innerHTML ça marche hein) -extJS = on se tape des UI pour faire une application, pas un site

Mais:

-tous les frameworks ont tendance à faire oublier la puissance de JS et du DOM -trop de développeurs oublient que la plupart des UI qu’ils font sont faisables en CSS + un JS basique simple -un framework JS ne doit être utilisé que si, et seulement si vous perdez du temps à le faire en JS simple

Maintenant, vous pouvez penser ce que vous voulez, j’en ai discuté lors des conférences que j’ai données, et je sais que je ne suis pas du tout le seul à penser que jQuery devrait franchement être utilisé à moindre mesure… et que trop de développeurs ne s’intéressent pas assez aux autres technologies. C’est mon opinion, voilà tout.

Apple vs Samsung ou comment tromper le monde

Sat, 25 Aug 2012 11:39:59 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Apple a gagné… ils ont tous les droits ! le droit de se proclamer maitre de technologies qu’ils n’ont pas inventé, que des standards soient leur propriété, qu’il puissent vous demander de payer pour ça.

Vous ne me croyez pas ? Regardez un peu cette image… elle parle d’elle même. Et non, ce n’est pas une blague, un fake ou quoique ce soit, mais une pièce à conviction présentée au procés.

Non mais rien ne vous choque là ? Des brevets sur des “icones au coins arrondis” ??? je rêve pas ? Le “multitouch” ? non toujours pas ?

Samsung se défend avec les même armes, et c’est une erreur malheureusement. Et oui, on est au pays du MacDo là. La boite américaine a forcément gain de cause face à un géant asiatique. Mais que ce soit au dépit de tout bon sens me rend fou…

Comment un jury a put permettre une firme milliardaire s’approprier des droits sur des technologies qu’elle n’a pas inventé, et pire: sur des idées qui n’ont rien d’innovantes !!!

Comment un tel enjeu liberticide a put être voté ? mais comment des humains peuvent avoir l’audace de délibérer un jugement qui prône l’absence total d’innovation !

Apple peut donc acheter un brevet, même à son créateur, et interdire à tout le monde de l’utiliser. Voilà ce que veut dire ce procès, voilà ce que veut dire le jugement donné chez nos copains les ricains.

Bravo… car un pays qui se veut tellement ouvert et exemplaire en terme de liberté vient de faire un procès inversant tout fondement de leur belle Amérique.

Non messieurs les fansboys de Apple, on ne vous appréciera pas davantage si vous défendez un tel acte d’injustice. Non, Apple n’a jamais inventé le multitouch, les icones au bord arrondis, ou encore de pouvoir écouter de la musique en utilisant une autre application… Non, Apple n’a pas le droit de se prétendre garante de cela, surtout pour l’interdire. Non, ce n’était pas du vol !!! l’innovation passe par le fait qu’une technologie soit utilisée en de multiple situation. Enfermer une techno (qui en plus, je le répète, n’a pas été inventée par APPLE !!!) à un usage strict ne fait qu’une chose: enrichir le dirigeant. Vous, vous n’y gagnez rien… au contraire.

Vous, utilisateur, vous allez devoir attendre des années avant d’avoir mieux, tout simplement parce que la boite qui a désormais le droit d’interdire une utilisation va pouvoir prendre tout son temps pour élaborer un produit encore plus cher, dans un temps qu’elle va maîtriser, en étant sûr que personne ne puisse faire mieux, plus rapidement, moins cher. Donc vous, Apple Addict, vous acceptez cela sans broncher, vous payez, vous être content d’avoir un produit “hype” mais dénué de qualité techniques avancées. Ça vous fait plaisirs de savoir que votre bonne boite Apple vous a vendu un appareil 5 fois plus cher que ce que ça lui coûte, que la techno qu’elle vous vend est dépassée mais que personne n’ait le droit de vous proposer **mieux et moins cher** ?

Donc si demain votre boulanger à tous les droits sur le pain, qu’il a réussit à interdire la vente de baguette dans tout le pays, et qu’il en profite pour monter le prix tout en prenant de la farine moisie, ça vous dérange pas ?

Bravo… je ne peux qu’applaudir ce comportement, parce que je pensais qu’il avait disparut au début du 19ième siècle…

Amis Apple Addicts: Vous vous rendez compte au moins que défendre un tel acte est grave ? Vous avez au moins écouté les autres qui vous expliquait le danger ? Vous avez essayé de comprendre ?

La suite c’est quoi ? on interdit les téléphones portables parce que Apple aura un brevet sur “les appareils sans fil permettant une télécommunication” ? Accorchez vous bien parce que ça va arriver là… on est à deux doigts de ça !

Cette politique me dégoute sérieusement. Là vraiment, plus rien ne me fera acheter un produit Apple. J’avais déjà pas envie question techno… alors là…

Gstreamer la suite

Tue, 14 Aug 2012 21:29:48 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Toujours envie de faire du gstreamer ? Et si on s’amusait un petit peu avec quelques plugins ? Genre des visualisations graphiques de sons… et appréhender un souci simple de gstreamer qui ne peut pas raccorder une sortie sur deux entrées. Et de trouver la solution.

Je vous fais un petit rappel vite fait. Gstreamer est un framework utilisable en bash, python, C, Vala, Java, Ruby, etc. Ce framework permet de manipuler des flux audio et vidéo au travers de plugins. L’ensemble des liaisons de plugins se nomme un “pipeline”.

Chaque plugins peut être nommé, un peu comme une variable dans un script. On fait un lien entre deux plugins entre des “src” et des “sink” avec un point d’exclamation (!). Le flux va de gauche à droite.

Le plugin “decodebin” est un bonheur magique qui permet de décoder un flux sans avoir à chercher constamment quel démultiplexeur et décodeur utiliser.

On utilise gst-inspect pour trouver un plugin et/ou savoir comment il fonctionne, par exemple pour les “caps” qui sont des options.

On teste un pipeline avec gst-launch.

Un exemple de pipeline:

gst-launch filesrc location="monfichier.ogg" ! decodebin ! \
audioconvert ! audioresample ! autoaudiosink

Ici le flux part d’une source fichier, on utilise le “caps” location qui définit le chemin du fichier. Le flux est envoyé vers decodebin, puis dans audioconvert, puis audioresample et enfin dans un plugin qui va trouver la sortie sonore adéquate (en général c’est pulseaudio, donc on entend le son).

On prend l’habitude de resampler le son, de le convertir etc. Avec l’habitude ça va tout seul.

Quand on a besoin de manipuler deux flux en même temps, par exemple une vidéo avec du son, on fait deux pipes et on les place dans une queue pour avoir deux threads en parallèle. On prend soin de nommer quel plugin réutiliser pour récupérer les “src” dans les pipes qui composent le pipeline. Exemple:

gst-launch filesrc location="mavideo.mp4" ! decodebin name=foo \
foo. ! queue ! ffmpegcolorspace ! videoscale ! autovideosink \
foo. ! queue ! audioconvert ! audioresample ! autoaudiosink

Ici, “foo” est le nom que je donne à “decodebin”. On utilise un point pour récupérer le plugin qui porte ce nom (sinon gstreamer cherchait un plugin “foo”) et je le place dans une queue. Gstreamer se débrouille pour raccoder les src de bon type aux sink qui peuvent supporter le flux. Ici la vidéo est traitée par ffmpegcolorspace, puis videoscale et arrive sur mon écran. Le son part en queue et va dans audioconvert, puis audioresample, puis mes enceintes.

Faites attention de ne pas mettre de “!” partout, il ne sert que de lien quand on en a besoin. Par exemple dans le pipeline précédent, on ne fait pas de lien entre autovideosink et “foo.”

Bon, et bien jouons un peu. J’avais envie d’utiliser un visualisateur de son, vous savez… le truc graphique qui bouge avec le son, c’est joli en plus ! Il existe des plugins gstreamer qui le permettent. Ils se trouvent dans l’ensemble “audiovisualizer”:

gst-inspect | grep -i audiovisual
audiovisualizers:  wavescope: Waveform oscilloscope
audiovisualizers:  synaescope: Synaescope
audiovisualizers:  spectrascope: Frequency spectrum scope
audiovisualizers:  spacescope: Stereo visualizer

Si je vais vous parler de ces outils, c’est surtout pour vous montrer un problème qu’on peut résoudre aisément. Ce problème est simplement de pouvoir réutiliser le même flux dans deux “sink”. **Car gstreamer ne peut pas raccorder une src à deux sink.** Mais il existe un plugin qui va nous permettre de le faire :)

Je vous prépare à un autre problème … ces visualisateurs ne sortent pas une vidéo, mais des images. Du coup “autovideosink” ne fonctionnera pas, il faudra utiliser “ximagesink” ou xvimagesink" selon certains cas.

Ici, ce sont des images brutes… on va utiliser ximagesink comme fenêtre de visualisation.

gst-launch filesrc location="Musique/good_night_moon-shivare_e.ogg" ! decodebin !\
audioconvert ! audioresample ! wavescope ! ximagesink

Ok, cool hein :) c’est joli, on voit la courbe… mais on entend rien ! Alors voilà le souci, on se dit “bha ok, simple, je vais nommer decodebin, et réutiliser la sortie pour la mettre dans autoaudiosink”… Pas bête… mais ça marchera pas. On tente (en utilisant des queues hein, pour faire tourner le son en même temps que le visualisteur):

gst-launch filesrc location="Musique/good_night_moon-shivare_e.ogg" ! decodebin name=d \
d. ! queue ! audioconvert ! audioresample ! wavescope ! ximagesink \
d. ! queue ! audioconvert ! audioresample ! autoaudiosink

Bon, ça bloque… effectivement “decodebin” n’a qu’un flux de sortie, un seul “src” donc… il se raccorde à la queue, et on a plus d’autre src à raccorder à l’autre queue. Ce serait donc cool de pouvoir démultiplier le flux pour l’envoyer dans les deux plugins.

Il existe un plugin qui va faire cela avec une facilité déconcertante: tee. Oui, comme un “T” qu’on utilise pour dériver des câbles d’antennes. Notez aussi que “tee” est une commande linux qui fait pareil en shell: sortir un contenu à deux endroits différents.

Bref, “tee” fait à peu près cela:

        +-------------+
        |    Tee      |
----> (sink)         (src0) -> plugin
        |            (src1) -> plugin
        |            (...)
        |            (srcN) -> plugin...
        |             |
        +-------------+

Il sort un src à la demande, sitôt qu’on tente de le connecter à un autre plugin. “Magique” est encore le mot qui me vient à l’esprit.

Bref, dans notre cas:

gst-launch filesrc location="Musique/good_night_moon-shivare_e.ogg" ! decodebin ! \
audioconvert ! audioresample ! tee name=T \
T. ! queue ! wavescope ! ximagesink \
T. ! queue ! autoaudiosink

Je vous fait un petit asciart pour comprendre:

filesrc >-+
          |
      decodebin ---> audioconvert --+
                                    |
          +------------------------+
          |
          +--->audioresample -------+
                                    |
    +-------------------------------+
    |
    |    +------------------+
    |    |    tee T         >> queue ---> wavescope -> ximagesink
    +--->>                  |
         |                  |
         |                  >> queue --> autoaudiosink
         +------------------+

Le flux sortant de audioresample est dédoublé en deux via le “tee”. On place chaque sortie en queue, et ça tourne nickel !

Ce genre de tee peut justement vous permettre de “voir” une vidéo en l’encodant et l’enregistrant dans un fichier.

Ou alors, pour le fun, raccorder plusieur visualisteur de son, de ce genre:

filesrc >-+
          |
      decodebin ---> audioconvert --+
                                    |
          +------------------------+
          |
          +--->audioresample -------+
                                    |
    +-------------------------------+
    |
    |    +------------------+
    |    |    tee T         >> queue ---> wavescope -> ximagesink
    +--->>                  |
         |                  |
         |                  >> queue --> spacescope -> ximagesink
         |                  |
         |                  >> queue --> autoaudiosink
         +------------------+

En tapant ce pipeline:

gst-launch filesrc location="Musique/good_night_moon-shivare_e.ogg" ! decodebin ! \
audioconvert ! audioresample ! tee name=T \
T. ! queue ! wavescope ! ximagesink \
T. ! queue ! spacescope ! ximagesink \
T. ! queue ! autoaudiosink

Je sais que parfois la lecture d’un pipeline peut paraître un peu ostère, mais à la longue, en quelques heures, vous prendrez le coup.

Didacticiel GStreamer

Mon, 13 Aug 2012 11:35:11 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Gstreamer est un framework extrêmement puissant, bien pensé et vraiment utile permettant de travailler avec des flux audio et vidéo. Decodage, encodage, streaming, effets, et j’en passe… Il est impressionnant de simplicité à condition d’avoir des bases de connaissance sur les méthodes. C’est donc avec plaisirs que je vous propose une montée en compétence sur ce système de “pipeline”.

J’ai certainement beaucoup de retard pour créer un tel didacticiel, mais je ne peux pas tout faire à temps. J’ai eut envie de me pencher sur Gstreamer pour gérer une lecture de vidéo dans une application. J’ai tellement aimé gstreamer que j’ai décidé de vous proposer ce didacticiel.

D’abord, qui a besoin de gstreamer ?

Gstreamer est utilisé dans la plupart des applications utilisant des flux vidéo et audio. Totem, le lecteur inclu dans Gnome, KDE, Empathy pour les vidéo conférences, Web le navigateur Gnome pour la gestion des médias HTML5… La liste est longue. De ce fait, l’utilisateur final a besoin des plugins intégrés en général nativement par les distributions GNU/Linux ou BSD.

Mais si en plus vous avez envie de créer un outil que ce soit en script Bash ou via C, Java, Python ou je ne sais quel langage, GStreamer va vous soulager de la plupart des tâches complexes de gestion de flux (stream). En effet, il va vous permettre de lire des médias en tant que source, de l’envoyer dans des encodeurs, des décodeurs, des effets, puis d’aller directement se brancher sur le serveur de son (pulse, jack…) ou X pour la vidéo. Et ce avec un minimum d’effort.

Donc, clairement, les “utilisateurs” des pipeline gstreamer sont surtout les développeurs ou au moins des utilisateurs avertis qui veulent se créer des outils, des script ou les utiliser par curiosité.

Avant de savoir utiliser Gstreamer, il faut appréhender le fonctionnement de flux, de multiplexage et de “pipeline”.

Prenons un exemple relativement général: une vidéo avec du son. Nous allons prendre le cas où vous voulez lire un fichier avi qui contient un film complet.

Le principe est de récupérer deux flux: la vidéo et la bande son. C’est ce que nous appelons le démultiplexage. Le fichier conteneur sort une source binaire que nous devons découper en deux flux distincts.

Ces flux ont un format d’encodage (mp3, mp4, vorbis…) il faut donc les décoder afin de les utiliser. Et enfin il faut envoyer le flux décodé dans les sorties adéquates: la vidéo sur l’écran via le serveur graphique, et le son sur le serveur sonore qui envoit le tout dans les enceintes.

Ça en fait un paquet d’opérations n’est-ce pas ?

vidéo avec du son
       |
       |
+--------------------+
|   démultiplexage   |- flux de son -> décodage -> ... -> pulseaudio (sortie sonore) 
+--------------------+
          |
          +- flux vidéo -> décodage -> callage de taille -> ... -> Affichage

Gstreamer va vous permettre de faire ces opérations via une ligne de connexion appelée “pipeline”. C’est le même principe que les redirections de sortie de commandes en shell.

Petit rappel:

echo "coucou vous" | rev

la commande “echo” fait sortir “coucou vous”, puis le pipe “|” redirrige cette chaine dans la command “rev” (reverse, retourne le texte), ce qui sort “suov uocuoc”

Avec Gstreamer on utilisera non pas “|” mais “!” pour ne pas interférer avec le shell.

Chaque plugin GStreamer peut avoir ces “PADS” qui représentent des entrées/sorties:

des sorties: src
des entrées : sink

En plus de ces PADS, on peut utiliser des options, nommées “caps”, par exemple pour manipuler la qualité d’un encodage ou donner un nom à un plugin qu’on va réutiliser plusieurs fois.

Par conséquent, un pipeline gstreamer va être une simple série de branchements entre des “src” et des “sink”. Notez que le mot “sink” veut dire “lavabo”, l’idée étant de déverser un flux dans le lavabo qui se rempli, le plugin se débrouillera tout seul pour le vider à son rythme.

+----------+         +-----------+
|   pad    |         |   pad 2   |
|        (src) -> (sink)       (src) -> ... 
|          |         |           |
|        (src) -> (sink)         |
|          |         |           |
+----------+         +-----------+

Les bases sont en place, on entre dans le vif du sujet.

Afin de tester un pipeline, on peut utiliser la commande “gst-launch”.

Utilisons un fichier de son, disons “hello.ogg”. Je vous montrerai après comment on peut trouver quel plugin utiliser. Pour le moment faites moi simplement confiance.

On va :

Utiliser une source de type fichier: filesrc
demultiplexer de fichier oggvorbis pour avoir une sortie : oggdemux
on l’envoit ensuite dans le décodeur vorbis: vorbisdec
on l’envoit dans pulseaudio: pulsesink

L’idée est donc de raccorder un pipeline de ce type:

filesrc -> oggdemux -> vorbisdec -> pulsesink

Le plugin filesrc a une option nommée “location” qui permet de donner le chemin du fichier à utiliser. Voici la commande de lecture:

gst-launch filesrc location="hello.ogg" ! oggdemux ! vorbisdec ! pulsesink

Vous comprenez, on lit de gauche à droite, de sortie en entrée. Les “caps” (option de plugin) sont déposés à coté du nom du plugin, et on utilise “=” pour donner une valeur. Ainsi, le plugin filesrc à un caps “location” que j’utilise. C’est assez simple.

Vous allez me dire “ok, pour coder un truc qui fait de la lecture c’est cool, mais c’est pas drôle de devoir chercher constamment quel demultiplexeur et décodeur utiliser”. Et ce à quoi je vous répond que si je vous dis que gstreamer est vraiment bien pensé, c’est qu’il existe des méthodes qui ressemblent à de la magie.

En effet, il existe des plugins qui vous font gagner un temps fou. L’un d’entre eux est “decodebin” qui est un décodeur générique sortant du “raw”. Il fait office de proxy et se débrouille comme un chef pour trouver quel décodeur utiliser. Testons-le:

gst-launch filesrc location="hello.ogg" ! decodebin ! pulsesink

Magique non ?

Et là je vous vois venir: “oui, et si j’utilise pas pulseaudio ? Comment je sais quel sink final utiliser ?”. C’est là qu’intervient “autoaudiosink”. On teste:

gst-launch filesrc location="hello.ogg" ! decodebin ! autoaudiosink

“autoaudiosink” trouve quelle sortie sonore utiliser… Et tout seul en plus !

Dans le cas où on doit être générique, pour créer un petit lecteur par exemple, c’est simplement (je me répète) magique.

Important

Il faudra tout de même prendre quelques habitudes. Il est toujours intéressant de rééchantillonner le son avant de le faire sortir afin de soulager le calcul. En effet un son à un bitrate de 192khz pour une simple écoute de musique n’est pas forcément nécessaire, l’oreille humaine ne pourra pas entendre les hautes fréquences. D’autre part, envoyer un flux trop gros à un décodeur ou un lecteur peut avoir un véritable impact sur les performances, et certain encodeur n’accèpte pas certaines fréquences. Donc pour rester dans un seuil correct, on “resample” le son:

Ce sera aussi le cas avec les vidéo, il est recommandé de passer par les plugins ffmpegcolorspace et videoscale lors des traitements. Si je ne les mets pas dans mes exemples, pensez à le faire…

gst-launch filesrc location="hello.ogg" ! decodebin ! audioresample ! autoaudiosink

On fait compliqué, et on simplifira après

Cette partie va vous faire peur… alors avant de la lire en vous disant “ouais bha c’est le foutoir pour trouver quel decodeur, encodeur etc…” rapellez vous qu’on utilisera “decodebin” par la suite, et que par conséquent vous n’aurez pas à vous arracher les cheveux. Ici je vais simplement vous présenter comment on peut traiter deux flux en même temps. C’est **primordial** car sans cela vous ne saurez jamais lire/encoder une vidéo avec du son.

Ok pour le son. On va passer par la partie “vidéo” puis “audio/vidéo” mais avant tout il faut que je vous montre les outils qui permettent d’avoir des informations sur les plugins. Deux sont vraiment utiles dans tous les cas:

gst-inspect
gst-typefind

Le premier sert à inspecter les capacités d’un plugins. Sans argument vous allez lister tous les plugins installés. En utilisant “grep” vous pourrez alors trouver votre bonheur. Par exemple, pour trouver un plugin qui traite du mp3:

gst-inspect | grep mp3
typefindfunctions: application/x-id3v2: mp3, mp2, mp1, mpga, ogg, flac, tta
typefindfunctions: application/x-id3v1: mp3, mp2, mp1, mpga, ogg, flac, tta
typefindfunctions: application/x-apetag: mp3, ape, mpc, wv
typefindfunctions: audio/mpeg: mp3, mp2, mp1, mpga
mad:  mad: mad mp3 decoder
mpegaudioparse:  mp3parse: MPEG1 Audio Parser
ffmpeg:  ffmux_mp3: FFmpeg MPEG audio layer 3 formatter (not recommended, use id3v2mux instead)
ffmpeg:  ffdec_mp3on4float: FFmpeg MP3onMP4 decoder
ffmpeg:  ffdec_mp3on4: FFmpeg MP3onMP4 decoder
ffmpeg:  ffdec_mp3adufloat: FFmpeg ADU (Application Data Unit) MP3 (MPEG audio layer 3) decoder
ffmpeg:  ffdec_mp3adu: FFmpeg ADU (Application Data Unit) MP3 (MPEG audio layer 3) decoder
ffmpeg:  ffdec_mp3float: FFmpeg MP3 (MPEG audio layer 3) decoder
ffmpeg:  ffdec_mp3: FFmpeg MP3 (MPEG audio layer 3) decoder
lame:  lame: L.A.M.E. mp3 encoder
lame:  lamemp3enc: L.A.M.E. mp3 encoder

Notez qu’on aime beaucoup utiliser “mad” pour décoder le mp3 sous gstreamer. Et pour connaitre les informations d’un plugins, ce qui vous permettra en plus d’avoir la liste de pads et de caps:

gst-inspect mad

Je ne vous colle pas la sortie complète, mais vous y trouverez les sections “Pad Templates” et “Element Properties”. Vous voyez donc quel sont les capacités d’un plugin, les entrées, les sorties et les options.

Pour vous amuser, on va ajouter un echoe au son. On cherche ça:

gst-inspect | grep echo

On trouve “audioecho”… on regarde les options:

gst-inspect audioecho

Je trouve 3 options intéressantes: delay, feedback et intensity. “delay” étant en nanoseconde, feedback entre 0 et 1 et intensity entre 0 et 1. Voici un réglage sympa:

gst filesrc location="hello.ogg" ! decodebin ! audioresample ! audioecho feedback=0.8 delay=1200000000 intensity=0.2 ! autoaudiosink

Quant à “gst-typefind” il vous donnera le type du fichier que vous voulez traiter, par exemple :

gst-typefind hello.ogg
hello.ogg - application/ogg

Je suis donc “sûr” que mon fichier est en oggvorbis je sais donc quel plugin chercher… ou presque…

Allez, on passe à la vidéo. On utilisera encore une fois “decodebin”, mais pour vous montrer comment on se sert des sources et sink, je commence par la partie compliquée.

Prenons une vidéo et regardons quel type est utilisé:

gst-typefind Portishead\ -\ Wandering\ Star.mp4 
Portishead - Wandering Star.mp4 - video/quicktime, variant=(string)iso

Ok… du quicktime… bon et bien cherchons un demuxer…

gst-inspect | grep -i quicktime
...
isomp4:  qtdemux: QuickTime demuxer

Ok, là on va utiliser qtdemux. Quels sont les pads à utiliser:

gst-inspect qtdemux
...
Pad Templates:
  SRC template: 'subtitle_%02d'
    Availability: Sometimes
    Capabilities:
      ANY

  SRC template: 'audio_%02d'
    Availability: Sometimes
    Capabilities:
      ANY

  SRC template: 'video_%02d'
    Availability: Sometimes
    Capabilities:
      ANY

  SINK template: 'sink'
    Availability: Always
    Capabilities:
      video/quicktime
      video/mj2
      audio/x-m4a
      application/x-3gp

Aïe… ça se complique… Plusieurs “src” à utiliser, et en plus ce sont des “template”. Car ce type de fichier peut contenir des sous-titres, plusieurs sources vidéos, plusieurs piste de sons. Mais ne prenons pas peur. En informatique “%02d” veut dire “deux chiffres de type double (entier) et si le nombre ne tient pas 2 caractère on lui met un 0 (zéro), par exemple 01”, donc en toutes logique on va utiliser la vidéo: “video_00” pour avoir la première piste vidéo, et “audio_00” pour la première piste audio.

Ne cherchez pas encore comment savoir quel décodeur utiliser, ici je vous le dit: ma vidéo est en “h264” et le son en “aac”. Si je vous dis de ne pas chercher trop longtemps c’est que vous pourrez vous en passer par la suite. Je veux juste vous montrer comment récupérer des sources dans un plugin.

Dans un premier lieu, on peut se passer de cette option. Gstreamer va trouver tout seule quoi raccorder à quoi. De ce fait:

gst-launch filesrc location=Portishead\ -\ Wandering\ Star.mp4 ! qtdemux ! ffdec_h264 ! autovideosink

et pour le son:

gst-launch filesrc location=Portishead\ -\ Wandering\ Star.mp4 ! qtdemux ! ffdec_aac ! autoaudiosink

Alors comment je vais faire pour récupérer les deux en même temps ?

Et voilà comment on en vient à donner un nom à un pipe ! Le “caps” “name” qui est utilisable par tous les plugins va nous permettre cette manipulation. Le but est de pouvoir réutiliser un plugin en cours d’utilisation pour récupérer d’autres “src” (ou d’autres sink).

C’est là qu’il faut y aller par étape:

-on donne un nom au plugin de démultiplexeur pour l’identifier (avec l’option “name”), ici on l’appelera “q” -on récupère la piste qu’on veutavec nom_plugin.nom_propiété, donc d’abord la vidéo “video_00”, puis l’audio “audio_00” (comme indiqué par gst-inspect), via q.video_00 et q.audio_00. -On dira quel “src” ira dans quel “sink”, donc q.video_00 dans ffdec_h264 et q.audio_00 dans ffdec_aac

Allons-y par étape, je commence par la vidéo:

gst-launch filesrc location=Portishead\ -\ Wandering\ Star.mp4 ! qtdemux name=q q.video_00 ! ffdec_h264 ! autovideosink

Etudiez la ligne:

filesrc est envoyé à qtdemux -on ne met pas de “!”, on repart avec un src
je pars de q.video_00 qui est une source, et je l’envois dans ffdec_h264

Cela fonctionne donc comme les lignes précédentes.

J’insiste sur l’absence de “!” entre “name=q” et “q.video_00”. Pour être plus clair, cette commande se découpe en deux pipes:

file -> qtmux nommé “q”
q.video_00 -> ffdec -> sortie vidéo

Pour ajouter le pipe de son, on va donc mettre un nouveau pipe qui réutilise “q”:

q.audio_00 -> ffdec -> sortie sonore

C’est à dire:

... q.audio_00 ! ffdec_aac ! autoaudiosink

et voici la ligne de commande (qui ne marchera pas encore… vous allez comprendre):

gst-launch  -v filesrc location=./Portishead\ -\ Wandering\ Star.mp4 ! qtdemux name=q \
q.video_00 ! ffdec_h264 ! autovideosink \
q.audio_00 ! ffdec_aac ! autoaudiosink

Vous voyez les 3 pipes:

filesrc -> qtdemux nommé “q”, “q” est donc le demultiplexeur
q.video_00 -> ffdec_h264 -> autovideosink
q.audio_00 -> ffdec_aac -> autoaudiosink

Important pour cette section

Avant de craquer, parce que d’une part vous n’avez peut-être pas compris la ligne, et que en plus ça marche toujours pas, lisez tout jusqu’au bout.

Alors pourquoi ça marche pas ? Et bien le problème c’est que là nous utilisons 2 flux. Il faut créer une file d’attente pour que gstreamer parse un peu les données et puisse gérer le tout en parallèle.

Explication: gstreamer a pris tout le pipeline et le passe comme on lui donne… du coup il tente de lire la vidéo mais l’audio est en pause dans un coin.

Ce n’est pas si compliqué, il faut mettre en “queue” les différentes parties du pipeline pour que tout parte en même temps, correctement callé. Et pour cela, on utiliser un plugin de base nommé “queue”. Il est super simple à utiliser, on le calle à des endroits stratégiques pour définir la mise en fil d’attente. On peut en utiliser autant qu’on veut.

Voici la commande que je vous propose:

gst-launch  -v filesrc location=./Portishead\ -\ Wandering\ Star.mp4 ! qtdemux name=q \
q.video_00 ! queue ! ffdec_h264 ! autovideosink \
q.audio_00 ! queue ! ffdec_aac ! autoaudiosink

Voilà, gstreamer sait maintenant qu’il faut travailler avec une mise en queue sur chaque src. Et du coup ça fonctionne.

Notez que là je mets en queue juste avant le décodage, on peut aussi lui demander de la faire après:

gst-launch  -v filesrc location=./Portishead\ -\ Wandering\ Star.mp4 ! qtdemux name=q \
q.video_00 ! ffdec_h264 ! queue ! autovideosink \
q.audio_00 ! ffdec_aac ! queue  ! autoaudiosink

Ou carrément avant et après:

gst-launch  -v filesrc location=./Portishead\ -\ Wandering\ Star.mp4 ! qtdemux name=q \
q.video_00 ! queue ! ffdec_h264 ! queue ! autovideosink \
q.audio_00 ! queue ! ffdec_aac ! queue  !  autoaudiosink

A vous d’optimiser, en testant, on plantant le stream comme une misérable pomme oubliée en fin de récolte…

Ne vous découragez pas… car là, vous allez adorer la suite: on va rendre tout ça très très simple !

On va tout simplifier !

Je vous ai parlé du magique “decodebin”, mais j’ai oublié de vous dire qu’en plus il évite les prises de tête pour des recherche de nom de source etc…

Et ajoutons un point encore plus sympa: pas la peine de donner les nom de sources, car GStreamer sait quel src doit se racorder au plugin.

Comme je vous le disais, “nom_du_plugin.nom_de_propriété” permet d’avoir la propriété nommée “nom_de_propriété” dans un plugin nommé “nom_du_plugin”. Mais ce que je ne vous ai pas dit, c’est qu’en fait “nom_du_plugin.” (n’oubliez pas le point) permet de récupérer le plugin complet. On utilise un point pour ne pas interférer avec les nom de plugin. Un point en fin de nom veut simplement dire “nom que j’ai donné”. Donc là, quand je tape “qtdemux name=q” je pourrais réutiliser ce demuxer en utilisant “q.” dans mon pipline.

Comme gstreamer est cool, qu’il sait quoi raccorder en src dans un sink selon le type de flux, on va simplement donner le nom du demuxer, ça sera bien plus simple.

Ce que je vous dit là, c’est que le pipeline qu’on a créé plus haut pour demultiplexer un fichier quicktime, trouver les “src” qui vont bien, les raccorder à decodeur… peuvent simplement se faire via:

decodebin qui va démultiplexer et décoder
q. pour raccorder les pads au bon endroit

Laissez-moi vous montrer:

gst-launch  -v filesrc location=./Portishead\ -\ Wandering\ Star.mp4 ! decodebin name=q \
q. ! queue !  autoaudiosink \ 
q. ! queue ! autovideosink

Et oui, gstreamer sait quel pad utiliser, le met en queue, et le branche à la sortie. Mais attendez, on peut simplifier:

gst-launch  -v filesrc location=./Portishead\ -\ Wandering\ Star.mp4 ! decodebin name=q \ 
! queue !  autoaudiosink \ 
q. ! queue ! autovideosink

Pas la peine de donner “q.” au premier branchement, puisque le plugin (decodebin ici) a des sorties. Inutile de le donner explicitement, le pipe “!” branche la sortie de decodebin sur la queue.

Par contre pour le second branchement (vers l’audio) je dois le donner car autoaudiosink n’a pas de sortie (c’est un sink).

Et il existe encore plus simple ! Le plugin “playbin” qui prend directement toutes les sorties et les plug dans les sorties audio et vidéo automatiquement.

Autre plugin intéressant: uridecodebin. Il permet de récupérer un stream depuis le disque dur, le net, un périphérique, etc. Exemple:

gst-launch uridecodebin uri="http://mirrorblender.top-ix.org/peach/bigbuckbunny_movies/big_buck_bunny_720p_surround.avi" name=u ! autovideosink u. ! autoaudiosink

Ce plugin a d’autant plus des options pour régler la taille de tampon, le déclenchement de mise en buffer, etc.

On a parlé de décodeur, parlons maintenant d’encodage.

L’idée est la même, mais au lieu de brancher la sortie sur la carte son ou vidéo, on va l’envoyer dans un fichier. Il faut donc encoder les éléments puis les multiplexer pour en faire un seul élément.

On commence encore une fois par un truc simple, on va encoder un wav en oggvorbis, la chaine sera:

filesrc -> decode -> conversion + resample -> encode en vorbis -> écriture dans un fichier (filesink)

On va utiliser les éléments simples, j’entends par là que j’utiliserai “decodebin” pour avoir le flux décodé de mon fichier source afin d’éviter de vous mettre une chaine de décodage complexe. Par contre pour la sortie en oggvorbis, il est logique de devoir spécifier l’encodeur… Puisque c’est le but.

filesrc monfichier mp3 -decodebin pour avoir un flux raw
audioconvert pour avoir un flux converti
audioresample pour rééchantillonner
vorbisenc pour encoder au format vorbis
oggmux pour en faire un fichier au format .ogg -filesink pour écrire

Pas mal de plugins, mais c’est logique.

gst-launch -v filesrc location="Portishead - Roads.mp3" ! decodebin ! \
audioconvert ! \
audioresample ! \
vorbisenc ! \
oggmux ! \
filesink location=out.ogg

C’est très rapide. Testez le fichier out.ogg et vous verrez que ça fonctionne bien.

Bon et bien encodons une vidéo au format ogv ! On va utiliser la même méthode, c’est-à-dire récupérer les sources, encoder, multiplexer le tout dans un seul fichier, et enfin le déposer dans un fichier.

Ça va ressembler à ça:

   filesrc (fichier d'entrée)
     |
     |     -(vidéo) -> queue -------> theoraenc --------
     |    /                                             \
 decodebin                                               -> oggmux --+ 
     d.   \                                             /    mux.    |
           -(audio) -> queue -> resample -> vorbisenc --             |
                                                                     |
                                                                     |
+--------------------------------------------------------------------+
|
+---> filesink (fichier de sortie)

Avant de lire la commande ci dessous, prenez le temps de comprendre. On va ouvrir un décodeur qu’on nomme “d”, chaque fois que je vais appeler “d.” je récupère un flux que j’envois dans un plugin.

Un multiplexeur (muxer) nommé “mux” va récupérer les deux sorties, la vidéo et l’audio. On redirige enfin les muxer dans un sink fichier pour sauver le résultat.

Je vous le fait pas à pas:

je décode la source

gst-lauch filesrc location="video.mp4" decodebin name=d

je récupère la sortie son, on la place en queue, on resample, on encode en vorbis et j’envois ça dans un muxer ogg

d. ! queue ! audioconvert ! audioresample ! vorbisenc ! oggmux name=mux

on reprend le flux decodé (d), cette fois la vidéo, on la place en queue, dans theoraenc, puis envoyée dans le muxer ogg déclaré plus haut

d. ! queue ! theoraenc ! mux.

je reprend le muxer, j’envoi le tout dans un fichier

mux. ! filesink location="out.ogv"

En une ligne:

gst-lauch filesrc location="video.mp4" decodebin name=d \
d. ! queue ! audioconvert ! audioresample ! vorbisenc ! oggmux name=mux \
d. ! queue ! theoraenc ! mux. \
mux. ! filesink location="out.ogv"

Et sans le “d.” implicite en seconde ligne:

gst-lauch filesrc location="video.mp4" ! decodebin name=d \
! queue !audioconvert ! audioresample ! vorbisenc ! oggmux name=mux \
d. ! queue ! theoraenc ! mux. \
mux. ! filesink location="out.ogv"

Petit conseil: utiliser ffmpegcolorspace pour permettre à Gstreamer de récuperer le bon espace de couleur avant d’encoder, ou décoder une vidéo… vous savez, l’hitoire des vidéo en RGB, YUV, etc.

Donc, plus proprement:

gst-lauch filesrc location="video.mp4" ! decodebin name=d \
! queue ! audioconvert ! audioresample ! vorbisenc ! oggmux name=mux \
d. ! queue ! ffmpegcolorspace ! theoraenc ! mux. \
mux. ! filesink location="out.ogv"

Bon, ça va servir à quoi tout ça ?

Ce que je me suis efforcé de vous montrer, ce n’est pas “comment lire/encoder un fichier audio/vidéo” car pour cela vous avez des lecteurs bien plus simples. L’idée et de vous montrer comment fonctionne un pipeline gstreamer pour s’en servir dans du code. Python, C, Java, etc. Car désormais vous savez sortir un flux vidéo ou audio, et par conséquent vous allez pouvoir l’utiliser. L’idée principale étant d’intégrer une vidéo dans un programme.

Il sera effectivement simple d’utiliser un effet vidéo, de le placer après un stream, d’encoder dans différent format, simplement en créant un pipeline gstreamer.

Je pense créer un didacticiel python très prochainement pour vous montrer comment on peut utiliser gstreamer dans un programme Gtk. Mais pour l’heure, essayez de créer des pipeline, regardez du coté du plugin “v4l2src” pour capter la caméra (petit conseil, utilisez ximagesink pour la sortie plutôt que autovideosink), tenter des encodages, revoyez comment on utilise les nom assigné au plugins (le nom avec un point) etc. Ne paniquez pas si ça passe pas du premier coup, je passe parfois un peu de temps à trouver le bon pipeline, je m’y reprend à plusieurs fois, mais à la fin vous serez heureux d’avoir un bon pipeline qui vous permette de faire exactement ce que vous voulez.

Notez bien que que c’est vraiment simple:

sink = entrée
src = sortie source.

C’est tout !

Gnome 3 est pourtant meilleur

Sat, 11 Aug 2012 08:03:16 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Voilà des années que j’utilisais Xmonad, un tiling desktop très intéressant vous permettant l’utilisations de terminaux avec aisance. J’étais passé sur cet environnement de fenêtre pour deux raisons: mémoire mangée par Gnome 2 ou KDE et parce que l’interface de Gnome, XFCE ou encore KDE était lourde visuellement (bureau, icones, barres de menus, etc. ça m’agace moi). Et me revoilà sur Gnome 3 par hasard… et je vais me permettre de m’opposer aux détracteurs de cet environnement, car personnellement (et ce contrairement au maître Linus Thorvalds) moi je trouve Gnome 3 vraiment excellent.

Voilà l’histoire. Je travaille donc sur Xmonad et pour des raisons de mauvaise gestion de ma carte graphique, je passe d’une version ma Fedora (donc je passe de Fedora 16 à 17). Arrivé sur Xmonad, je lance deux ou trois softs 3D… et catastrophe: rien ne passe. Ce n’est pas la faute de Xmonad, loin de là. Une configuration mal passée, je décide de m’en retourner sur une interface plus “user friendly” pour voir si au moins Blender ou MakeHuman (dernière version) veulent bien démarrer. Comme je déteste KDE… et que Gnome 3 est présent (j’avais oublié de l’enlever ??) je me retrouve sur ce dernier.

Tiens donc… Blender démarre, MakeHuman aussi… cool ! bon bha je vais rester sur Gnome 3 (gnome-shell hein) pour bosser un peu, le temps de chercher pourquoi mon Xmonad a des soucis.

Quelques jours passent. J’ai découvert comment on installait des extensions sur Gnome 3, je teste Epiphany (le navigateur web de gnome), j’enregistre mes comptes en ligne et je peux chatter directement depuis des notifications… attendez mais c’est pas mal du tout en fait.

En plus, Gnome 3 m’offre exactement ce que j’aime, l’inverse de ce que je retrouve dans les autre environnements: une interface épurée ! Une barre, une seule, en haut de l’écran. Pas de menu, pas de double barre. L’écran “Activités” est bien pensée (en pressant la super touche du clavier, ou en posant la souris en haut à gauche de l’écran…). Et des extensions offre même la possibilité d’avoir du “tilling desktop”.

Je commence à me dire que les détracteurs y sont allé un peu fort sur Gnome 3… Il est vraiment simple, utile, ergonomique, facile à appréhender. Et comme le dit ce bloggeur Gnome 3 prend peu de mémoire finalement. Oui… 120mo c’est pas non plus super léger… mais ça l’est bien plus que Gnome 2 (je me souviens de 200Mo de RAM utilisé par Gnome 2 en me débrouillant un peu). Alors dire que Gnome 3 est plus lourd me surprend.

Loin de moi l’idée de comparer Xmonad et Gnome 3. La seule chose que je veux souligner est l’utilisation que j’attends d’un environnement de travail. Je déteste littéralement que mon bureau soit surchargé de fenêtres, de menus, d’icones en tout genre. J’aime avoir une seule barre, avec des infos rapides dedans (température du CPU, état de la batterie du portable, un ou deux raccourcis à la limite…, date, heure). Et là, Gnome 3 me donne exactement ça. C’est même étonnant à quel point ma barre Gnome 3 resseble à celle de mon Xmonad :)

Vraiment, les nostalgiques de Gnome 2 je peux les comprendre. Quand on aime une interface, on a du mal à passer à autre chose. Mais la découverte d’une autre manière de travailler, sur un environnement (ne vous en déplaise) plus léger en terme visuel et mémoire, doit tout de même être étudié. J’estime pour ma part que Gnome 3 est bien meilleurs que XFCE (qui soyez honnête n’apporte rien de spécial…) KDE, Gnome 2 (forké ou non)… c’est un avis personnel. Vous avez entièrement le droit de me contredire !

Arkyne le site

Fri, 27 Jul 2012 10:21:41 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Cela faisait des mois que je n’avais pas pu travailler sur mon projet musical. L’heure est à la composition, mais aussi à la création du site. Voici donc http://arkyne.net réalisé en HTML5.

Internet Explorer pourra pleurer, tant pis si je perds des “visiteurs” sur le site, mais clairement je ne pouvais pas me passer d’animation sur le site. Mettre une vidéo en fond de page et jouer avec les “keyframes”… impossible pour le moment sur les versions “répandues” de IE.

Donc voilà, je me suis lancé sur Blender, et j’ai commencé à faire ce que je voulais. Un arbre qui a un mouvement un peu “tordu”. Non pas comme si le vent le poussait, mais comme si il cherchait à s’étirer, puis se relache.

Quelques nuages, réalisés sur Gimp, puis placé en deux divs animées.

Ce qui est le plus étonnant dans l’histoire, c’est que j’ai codé ça en quelques heures, sans vraiment chercher à faire en sorte que ça passe sur Chromium et Firefox. Je travaillais sur mon vieux vim et je testais sur Chromium. Puis j’ai simplement ajouté les keyframes et transition en remplaçant les “-webkit” en “-moz”… et ça a marché du premier coup…

Ce que j’en retiens, c’est que Firefox et les navigateurs Webkit ont des comportement très proches, et par conséquent permettent au développeur ou designer de se concentrer seulement sur la créa, et non pas sur les “workaround”.

Reste que je en sais pas ce que ça rend sur Opera, j’ai ajouté les mots clefs utiles, mais pas encore testé.

Parlons du projet musique, le prochain album arrive à grands pas. Les compos se peaufinent, l’enregistrement prend un peu de temps, et j’ai encore des voix à replacer. Mais si vous suivez un peu les infos sur Google+, ou (mon dieu…) Facebook, ou encore Twitter… alors vous aurez la primeur de la nouvelle :)

Voilà, ce message est certes peu utile, mais comme c’est un blog perso, je dis ce que je veux hein ;)

Outrepasser un proxy

Thu, 12 Jul 2012 10:15:31 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Me voilà sur un projet Python qui demande une installation via le fameux bootstrap.py assez intéressant pour automatiser une installation complète du projet. Or, je me retrouve derrière un proxy http très restrictif, et python a beaucoup de mal à passer outre. Voici la méthode qui m’a permis de faire mon installation.

Les prérequis sont:

-avoir un serveur externe qui permette une connexion SSH -les outils corkscrew et proxychains -un peu d’aspirine

On commence par configurer le client SSH pour qu’il puisse se connecter en SSH à un serveur externe dont vous avez le contrôle. Ici, on appellera le serveur externe “extserv”.

Le serveur proxy HTTP sera nommé ici “httpprox” et utilise le port 8080.

Sur le client, donc votre poste, vous devez installer corkscrew et proxychains:

su -c "yum install corkscrew proxychains"
ou bien sur ubuntu, parce qu'il y en a plein hein...
sudo aptitude install corkscrew proxychains

Ensuite, vous allez éditer le fichier ~/.ssh/config, le but est de dire que toutes connexion ssh passera par corkscrew via le proxy http.

#fichier ~/.ssh/config
ProxyCommand corkscrew httpprox 8080 %h %p ~/.ssh/auth

Le fichier ~/.ssh/auth doit contenir les informations de connexion au proxy http:

#fichier ~/.ssh/auth
VotreLoginProxy:VotreMotDePasseProxy

Voilà, tentons une connexion au serveur SSH:

ssh user@extserv

Parfait, je suis connecté à mon serveur ssh. Je modifie deux options sur le serveur, dans le fichier /etc/ssh/sshd_config:

AllowTcpForwarding yes
PermitTunnel yes

Si les options n’existent pas dans le fichier, ajoutez les simplement… Redémarrez le service sshd du serveur:

/etc/init.d/sshd restart
ou sur debian, ubuntu...
/etc/init.d/ssh restart

Désormais, on peut créer un tunnel vers notre serveur.

Créons maintenant un proxy SOCK5 sur le client. Donc fermez votre connexion SSH au serveur et tapez simplement:

ssh -N -D 8888 user@extserv

La commande se bloque après demande du mot de passe (si vous n’avez pas utilisé d’authentification par clefs). Le port 8888 local écoute gentillement.

Gardez ce terminal dans un coin, ne le fermez pas, et ouvrez un autre terminal.

Dans ce second terminal, paramétrons proxychains. Editez /etc/proxychains.conf. Vous devez trouver deux options. La première est proxy_dns. Mettez la en commentaire:

#proxy_dns

Puis, normalement en bas du fichier, vous trouverez une ligne “sock4 …” supprimez la, et mettez à la place:

sock5  127.0.0.1 8888

Voilà, vous sauvez le fichier, vous quitter et vous tentez:

#plus besoin du proxy http
unset http_proxy https_proxy

#on essait de lire une page web
proxychains wget -q http://www.google.fr -O -

si tout se passe bien, vous aurez sur le terminal la sortie HTML de google.fr, sinon, vérifiez vos paramètres de proxy, de ssh, etc…

Vous l’avez compris, en préfixant la commande par “proxychains” vous forcez les connexions à passer par le proxy local “127.0.0.1:8888” qui passe ensuite par corkscrew, puis le proxy http, enfin vers votre serveur SSH qui redirige tout vers le serveur demandé. En gros:

connexion A ==> proxychains => 127.0.0.1:8888 => httpprox => extserv => A
            <==             <=               <=           <=         <=

Voilà… et bien lançons simplement la commande, en ayant pris soin de supprimer les variables d’environnement “http_proxy” et “https_proxy” via la commande unset

unset http_proxy https_proxy
proxychains python bootstrap.py
proxychains ./bin/buildout

toutes les commandes nécessitant une connexion devront être préfixées par proxychains.

Notez enfin que git utilise SSH, et que par conséquent vous pouvez désormais l’utiliser avec une configuration remote “ssh” et non plus “https”… Bref, proxychains + corkscrew, ça peut vraiment vous aider :)

Certificat SSL et Chrome ou Chromium

Thu, 21 Jun 2012 07:43:29 +0000

Si vous aimez mon contenu, vous pouvez me fournir un peu de calcul en lançant le conteneur
docker run --rm -it metal3d/xmrig
Cela lance un conteneur de minage léger, qui ne consomme que 50% de CPU non utilisé.
CTRL+C pour stopper.
Faites cela le temps de lire l'article, c'est un genre de don, mais pour geeks 😇

Vous devez avoir cherché pendant des lustres la manière de faire en sorte d’éviter un écran rouge sur les page SSL (HTTPS) en enregistrant le certificat dans votre navigateur… Voici une méthode assez simple…

Parce que franchement, la méthode “certutils” proposé sur différents sites me parait assez complexe, j’ai cherché une autre méthode en grattant un peu partout dans la configuration.

L’idée est simple… on enregistre le certificat en partant de l’autorité de contrôle, puis on l’installe dans les paramètres. En fait ça parait simple, mais fallait juste le savoir

Je vous propose une vidéo (sans son) qui vous montre la méthode. Retenez juste:

séléctionnez bien l’entrée qui est défini comme CA (Control Authority)
le fichier enregistré pourra être supprimé après insertion dans Chrome
dans les paramètres, insérez l’autorité dans l’onglet “autorités” et non “serveur”

Cette méthode marche très bien pour ma part… si vous avez des remarques… n’hésitez pas.