Petit rappel évident mais il faut bien garder en tête à quoi servent les logs. Généralement, il s'agit de traces techniques qui vous serviront à cerner plus rapidement un problème (fonctionnel, technique, de performance...) de votre service ou application. Il ne faut pas logger d'informations fonctionnelles ni personnelles.

En natif en go

Par défaut le langages offre au moins 2 possibilités pour ajouter des logs :

1. utiliser le package "fmt" et printX comme par exemple fmt.Printf("erreur de chargement de %s", maVariable)
   Il est évident que cela n'est pas tenable sur le long terme au fur et à mesure que la base de code augmente, mais qui ne l'a jamais fait... ;-)
2. utiliser le package "log" et printX. Le package log natif est déjà très riche comme beaucoup d'autres packages natifs et évitent de se charger en dépendances externes.

package main

import (
	"fmt"
	"log"
)

func main() {
	fmt.Printf("Exemple pour logger :\n")
	log.Printf("mon premier log")
}

Le package log vous permet également de spécifier la sortie avec la méthode SetOutput(w io.Writer) et vous pouvez définir aussi votre propre logger avec func New(out io.Writer, prefix string, flag int) *Logger.

et le fichier logs.txt :

2022/06/20 12:06:51 mon premier log dans le fichier
INFO : 2022/06/20 12:06:51.716196 main.go:21: un log personnalisé

Vous pouvez aussi ajouter l'initialisation de votre système de log dans un répertoire utils  et une fonction init() par exemple :

package logging

import (
	"log"
	"os"
)

var (
	Info     *log.Logger
	Warning  *log.Logger
	Error    *log.Logger
	Critical *log.Logger
)

func init() {

	Info = log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
	Warning = log.New(os.Stdout, "WARNING: ", log.Ldate|log.Ltime|log.Lshortfile)
	Error = log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)
	Critical = log.New(os.Stderr, "CRITICAL: ", log.Ldate|log.Ltime|log.Lshortfile)
}

Cela reste intéressant pour des petits services ou utilitaires mais très vite il va manquer une rotation des fichiers, de la distribution pour un usage multi services...

Avec des librairies externes

Une des plus connues est certainement logrus. Seulement elle est passée en mode maintenance. Cela n'empêche pas de l'utiliser ni qu'elle soit utilisée dans de gros projets tel que Docker :

moby/health.go at 7b9275c0da707b030e62c96b679a976f31f929d3 · moby/moby

Moby Project - a collaborative project for the container ecosystem to assemble container-based systems - moby/health.go at 7b9275c0da707b030e62c96b679a976f31f929d3 · moby/moby

GitHubmoby

ou encore si vous utilisez datadog, ils privilégient logrus.

glog n'est également plus vraiment maintenue. C'est pourquoi les équipes de Kubernetees ont fait un fork pour leur projet :

kubernetes/vendor/k8s.io/klog/v2 at 609db7ed0b1f2839e414c17d29fe4d76edc994bd · kubernetes/kubernetes

Production-Grade Container Scheduling and Management - kubernetes/vendor/k8s.io/klog/v2 at 609db7ed0b1f2839e414c17d29fe4d76edc994bd · kubernetes/kubernetes

GitHubkubernetes

Dans un projet interne, j'ai implémenté zerolog. Cela permet de bien structurer ses logs mais on arrive très vite à beaucoup de code et de verbosité. IMHO, il devient intéressant à utiliser dans des projets de monitoring et donc couplé à des outils de visualisation de logs (Grafana, Kibana...)

Il y a beaucoup d'autres librairies mais le point important est de bien déterminer ce que l'on veut de ses logs...

Note du 28/12/2022 :

Un nouveau package est en cours et fera peut être son entrée dans une version future de go:

https://pkg.go.dev/golang.org/x/exp/slog

Avec ce package, vous pouvez directement écrire un :

slog.Info("une info en stdout")

# ou bien en declarant un text handler ou json handler :

textHandler := slog.NewTextHandler(os.Stdout)
logger := slog.New(textHandler)
logger.Info("une info supplémentaire", slog.Int("compteur", 10))

et il semble que les perfs soient bonnes (mais non vérifié).

Installation de sa première instance d'Odoo version communautaire avec Docker. Cela a été testé avec docker-compose et Odoo v14 et Odoo v15.

A priori vous avez une petite idée de ce qu'est Odoo. Si ce n'est pas le cas, vous pouvez toujours consulter la page Wikipedia ou leur site web.

Maintenant si vous souhaitez l'installer sur votre serveur, vous pouvez reprendre le fichier docker compose fourni par la page Odoo du docker hub : https://hub.docker.com/_/odoo.

Il y a d'autres façon de l'installer et cela est bien documenté.

Voici le contenue du fichier "docker-compose.yml" :

version: '3.1'
services:
  web:
    image: odoo:15.0
    depends_on:
      - db
    ports:
      - "8069:8069"
    volumes:
      - odoo-web-data:/var/lib/odoo
        # - ./config:/etc/odoo
      - ./addons:/mnt/extra-addons
    environment:
      - PASSWORD_FILE=/run/secrets/postgresql_password
      - USER=odoo
    secrets:
      - postgresql_password
  db:
    image: postgres:13
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_PASSWORD_FILE=/run/secrets/postgresql_password
      - POSTGRES_USER=odoo
      - PGDATA=/var/lib/postgresql/data/pgdata
    volumes:
      - odoo-db-data:/var/lib/postgresql/data/pgdata
      # - ./pg_hba.conf:/var/lib/postgresql/data/pgdata/pg_hba.conf
    secrets:
      - postgresql_password
volumes:
  odoo-web-data:
  odoo-db-data:

secrets:
  postgresql_password:
    file: odoo_pg_pass

Le mot de passe de la DB n'est pas passé en tant que variable d'environnement mais par un fichier ce qui évite de le stocker dans le fichier compose et de se retrouver dans un source control par exemple...

Ajoutez donc un fichier "odoo_pg_pass" avec le mot de passe de la base de donnée.

Il faut bien garder la db à postgres qui est la base de donnée par defaut. En réalité la vraie db de Odoo sera créée à la première connexion avec le nom voulu. Il vaut donc mieux éviter de la changer.

Il est aussi possible d'utiliser les credentials de postgres qui sont stockés dans un fichier de type pgpass. Il faut donc ajouter au meme niveau que votre fichier compose, un fichier "odoo_pg_pass" qui contient une ligne avec les informations suivantes "nom_hote:port:database:nomutilisateur:motdepasse" :

db:5432:postgres:odoo:password1234

Vous pouvez faire votre docker compose up (avec -d si vous le voulez en mode daemon) et si tout va bien vous avez une ligne avec odoo.service.server: HTTP service (werkzeug) running on

Cool, je me connecte et...

Internal Server Error... On remonte à la première ligne en erreur et on trouve ERROR odoodb odoo.modules.loading: Database odoodb not initialized, you can force it with -i base

A noter que cela n'arrive pas tout le temps et qu'en réalité, si vous partez bien d'un répertoire vide, pas de réseau ni de volume docker et que vous avez bien suivi les instructions au dessus, vous devriez avoir une instance qui fonctionne directement.

A la première installation, il faut initialiser la base de donnée. L'usage de "secrets" n'est pas à ce jour possible dans un container standalone.

Une façon de faire est de se connecter directement dans le container docker exec -it odoo-web-1 bash et d'executer cette commande :

# Pour initialiser la base de donnée depuis le container :
$ odoo -i base -d odoo --stop-after-init --db_host=db -r odoo -w odoo

 A la suite de cela, vous devriez avoir votre instance prête. Vous pouvez vous connecter sur localhost:8069 et vous devriez avoir la page de creation de base de donnée :

Il existe déjà beaucoup de littérature de présentation à la fois d'Apache Spark et aussi de Scala.

Juste en quelques mots, les points clés qu'il faut retenir:

• Apache Spark est un framework conçu pour la manipulation de gros volumes de données, et très versatile, et est généralement distribués sur une plateforme Hadoop, mais pas que.
• Dans Spark, on manipule un ensemble de données que l'on appelle Datasets, qui se basent sur la notion principale de RDD : Resilient Distributed Datasets. Ce sont des blocks de données distribuées sur le cluster, généralement stockées en mémoire, permettant un traitement très rapide.
• Scala est un langage de programmation basé sur la JVM et qui présente l’intérêt d'être moins verbeux que Java.
• Apache Spark est développé en Scala, mais on peut aussi utiliser Spark avec Java, Python, R et SQL.

Dans le reste de l'article nous allons installer Spark 3 et utiliser le shell pour analyser des données. En général, nous n'utilisons pas le shell en production, mais c'est un outil très utile pour analyser un petit ensemble de données avant de passer à plus grand échelle ou bien pour faire des pocs. Le REPL spark (Read Eval Print Loop), comme dans beaucoup d'autres langages, y compris Java, permet de rapidement taper des lignes de codes en ligne de commande sans passer par un éditeur ni la phase de compilation.

Dans un autre article nous mettrons en place un projet Apache Spark dans Intellij et nous ferons des tests sur un cluster spark.

Télécharger la librairie Apache Spark

Allez sur la site d'Apache Spark sur la page de téléchargement et téléchargez une version récente de spark. Au moment d'écrire cet article nous téléchargeons spark 3.0.1

Une fois le ficher tgz télécharger, le dézipper où vous voulez sur votre disque. Puis créer une variable d'environnement SPARK_HOME vers ce répertoire et ajouter le bin dans le path export PATH="$PATH:$SPARK_HOME/bin" pour pouvoir démarrer le shell de n'importe quel répertoire.

Télécharger un jeu de données à analyser

Nous allons utiliser un jeu de données des valeurs foncières du site : https://www.data.gouv.fr/fr/datasets/demandes-de-valeurs-foncieres-geolocalisees/

Voici le lien de téléchargement du jeu de données en question: https://cadastre.data.gouv.fr/data/etalab-dvf/latest/csv/2020/full.csv.gz

Téléchargez le fichier et le dézipper. Il s'agit d'un CSV de 136M dont les colonnes sont:

• id_mutation : Identifiant de mutation (non stable, sert à grouper les lignes)
• date_mutation : Date de la mutation au format ISO-8601 (YYYY-MM-DD)
• numero_disposition : Numéro de disposition
• valeur_fonciere : Valeur foncière (séparateur décimal = point)
• adresse_numero : Numéro de l'adresse
• adresse_suffixe : Suffixe du numéro de l'adresse (B, T, Q)
• adresse_code_voie : Code FANTOIR de la voie (4 caractères)
• adresse_nom_voie : Nom de la voie de l'adresse
• code_postal : Code postal (5 caractères)
• code_commune : Code commune INSEE (5 caractères)
• nom_commune : Nom de la commune (accentué)
• ancien_code_commune : Ancien code commune INSEE (si différent lors de la mutation)
• ancien_nom_commune : Ancien nom de la commune (si différent lors de la mutation)
• code_departement : Code département INSEE (2 ou 3 caractères)
• id_parcelle : Identifiant de parcelle (14 caractères)
• ancien_id_parcelle : Ancien identifiant de parcelle (si différent lors de la mutation)
• numero_volume : Numéro de volume
• lot_1_numero : Numéro du lot 1
• lot_1_surface_carrez : Surface Carrez du lot 1
• lot_2_numero : Numéro du lot 2
• lot_2_surface_carrez : Surface Carrez du lot 2
• lot_3_numero : Numéro du lot 3
• lot_3_surface_carrez : Surface Carrez du lot 3
• lot_4_numero : Numéro du lot 4
• lot_4_surface_carrez : Surface Carrez du lot 4
• lot_5_numero : Numéro du lot 5
• lot_5_surface_carrez : Surface Carrez du lot 5
• nombre_lots : Nombre de lots
• code_type_local : Code de type de local
• type_local : Libellé du type de local
• surface_reelle_bati : Surface réelle du bâti
• nombre_pieces_principales : Nombre de pièces principales
• code_nature_culture : Code de nature de culture
• nature_culture : Libellé de nature de culture
• code_nature_culture_speciale : Code de nature de culture spéciale
• nature_culture_speciale : Libellé de nature de culture spéciale
• surface_terrain : Surface du terrain
• longitude : Longitude du centre de la parcelle concernée (WGS-84)
• latitude : Latitude du centre de la parcelle concernée (WGS-84)

Utiliser spark-shell

Dans cet article nous allons lancer spark sans cluster, juste en local. Pour cela créer une variable d'environnement SPARK_LOCAL comme suit.

export SPARK_LOCAL_IP="127.0.0.1"

Lancer spark-shell

Soit depuis le répertoire de spark : ./bin/spark-shell soit spark-shell si vous avez ajouté les variables d'environnement SPARK_HOME dans votre path.

Charger un fichier text

scala> val donnees_brutes = spark.read.textFile("full.csv")

donnees_brutes: org.apache.spark.sql.Dataset[String] = [value: string]

Nous avons instancié un Dataset dont le contenu sera le contenu du fichier full.csv. Chaque ligne du fichier peut-être traitée.

A ce point, rien n'a été chargé. Seule une action "finale" lancera un traitement. Par exemple, compter le nombre de ligne du Dataset lance le chargement du fichier et effectuer l'action de comptage:

scala> donnees_brutes.count
res0: Long = 827106

Voyons maintenant un échantillon du fichier pour voir de quoi il est fait.

scala> donnees_brutes.show(3, false)

+------------+
|value       |
+------------+
|id_mutation,date_mutation,numero_disposition,nature_mutation,valeur_fonciere,adresse_numero,adresse_suffixe,adresse_nom_voie,adresse_code_voie,code_postal,code_commune,nom_commune,code_departement,ancien_code_commune,ancien_nom_commune,id_parcelle,ancien_id_parcelle,numero_volume,lot1_numero,lot1_surface_carrez,lot2_numero,lot2_surface_carrez,lot3_numero,lot3_surface_carrez,lot4_numero,lot4_surface_carrez,lot5_numero,lot5_surface_carrez,nombre_lots,code_type_local,type_local,surface_reelle_bati,nombre_pieces_principales,code_nature_culture,nature_culture,code_nature_culture_speciale,nature_culture_speciale,surface_terrain,longitude,latitude|
|2020-1,2020-01-07,000001,Vente,8000,,,FORTUNAT,B063,01250,01072,Ceyzériat,01,,,01072000AK0216,,,,,,,,,,,,,0,,,,,T,terres,,,1061,5.323522,46.171899                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|2020-2,2020-01-07,000001,Vente,75000,,,RUE DE LA CHARTREUSE,0064,01960,01289,Péronnas,01,,,01289000AI0210,,,,,,,,,,,,,0,,,,,AB,terrains a bâtir,,,610,5.226197,46.184538                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+----------+
only showing top 3 rows

Nous voyons de longues lignes dont la première est le header du fichier csv puis deux autres lignes.

Nous pouvons filtrer par exemple la colonne 32 qui est 'nombre_pieces_principales'

scala> val col32 = donnees_brutes.map(li => li.split(",")(32))
col32: org.apache.spark.sql.Dataset[String] = [value: string]

Nous utilisons ici le dataset initial et ajoutons un map. A ce stade aucun traitement ne se fait car il ne s'agit pas d'une action finale.

Le map prend une fonction lambda où li est une ligne et l'action sera de spliter la ligne avec le séparateur ',' et extraire la colonne 32.

scala> col32.show(10)

col32.show(10)
+--------------------+
|               value|
+--------------------+
|nombre_pieces_pri...|
|                    |
|                    |
|                    |
|                    |
|                   5|
|                    |
|                    |
|                    |
|                    |
+--------------------+
only showing top 10 rows

On constate que toutes les entrées ne renseignent pas forcément le nombre de pièce. Essayons de montrer plus de lignes :

scala> col32.show(1000)

Caused by: java.lang.ArrayIndexOutOfBoundsException: Index 32 out of bounds for length 29

Nous constatons que la fonction qui split les lignes n'obtient pas 32 valeurs pour certaines lignes.

En effet nous ne parsons pas le fichier très proprement dans le cas où le fichier est mal formaté. Chaque ligne devrait avoir 40 colonnes. Comptons le nombre de colonnes par ligne et montrons le nombre de ligne par taille

scala> val colsCount = donnees_brutes.map(l => l.split(",").length)
colsCount: org.apache.spark.sql.Dataset[Int] = [value: int]

scala> colsCount.groupByKey(identity).count().orderBy("key").show
+---+--------+
|key|count(1)|
+---+--------+
| 31|       3|
| 40|  780120|
| 41|      12|
| 35|       4|
| 38|   39465|
| 29|    4948|
| 33|    2554|
+---+--------+

groupByKey et count nous permettent de calculer le nombre d’occurrences de colsCount.
groupByKey traite chaque entrée, qui dans notre cas, est simplement un Integer. Nous utilisons la fonction 'identité' pour utiliser cette valeur comme clé. La fonction count() compte le nombre d'occurence.

Les Dataset nous permettent de faire des choses plus puissantes que cet exemple. Voyons plus loin.

Autres manipulations du fichier de données csv

Vous pouvez spécifier plus de paramètres au chargement d'un fichier csv que dans l'exemple ci-dessus.

Nous demandons à scala de passer en "paste mode" pour pouvoir coller la section suivante sur plusieurs lignes.

scala> :paste
// Entering paste mode (ctrl-D to finish)

val donnees_brutes = spark.read.format("csv")
  .option("locale", "France")
  .option("sep", ",")
  .option("inferSchema", "true")
  .option("header", "true")
  .load("full.csv")

Une fois collé tapez Ctrl-D.

Spark a parsé le fichier csv avec les options fournies et à identifié les colonnes du fichier. Ce qui est puissant dans ce cas est que Spark peut identifier automatiquement le schema.

scala> donnees_brutes.printSchema
root
 |-- id_mutation: string (nullable = true)
 |-- date_mutation: string (nullable = true)
 |-- numero_disposition: integer (nullable = true)
 |-- nature_mutation: string (nullable = true)
 |-- valeur_fonciere: double (nullable = true)
 |-- adresse_numero: integer (nullable = true)
 |-- adresse_suffixe: string (nullable = true)
 |-- adresse_nom_voie: string (nullable = true)
 |-- adresse_code_voie: string (nullable = true)
 |-- code_postal: integer (nullable = true)
 |-- code_commune: string (nullable = true)
 |-- nom_commune: string (nullable = true)
 |-- code_departement: string (nullable = true)
 |-- ancien_code_commune: string (nullable = true)
 |-- ancien_nom_commune: string (nullable = true)
 |-- id_parcelle: string (nullable = true)
 |-- ancien_id_parcelle: string (nullable = true)
 |-- numero_volume: string (nullable = true)
 |-- lot1_numero: string (nullable = true)
 |-- lot1_surface_carrez: double (nullable = true)
 |-- lot2_numero: string (nullable = true)
 |-- lot2_surface_carrez: double (nullable = true)
 |-- lot3_numero: string (nullable = true)
 |-- lot3_surface_carrez: double (nullable = true)
 |-- lot4_numero: integer (nullable = true)
 |-- lot4_surface_carrez: double (nullable = true)
 |-- lot5_numero: integer (nullable = true)
 |-- lot5_surface_carrez: double (nullable = true)
 |-- nombre_lots: integer (nullable = true)
 |-- code_type_local: integer (nullable = true)
 |-- type_local: string (nullable = true)
 |-- surface_reelle_bati: integer (nullable = true)
 |-- nombre_pieces_principales: integer (nullable = true)
 |-- code_nature_culture: string (nullable = true)
 |-- nature_culture: string (nullable = true)
 |-- code_nature_culture_speciale: string (nullable = true)
 |-- nature_culture_speciale: string (nullable = true)
 |-- surface_terrain: integer (nullable = true)
 |-- longitude: double (nullable = true)
 |-- latitude: double (nullable = true)

Notez qu'il est aussi possible de spécifier le schema à spark si on connait des particularités.

Remarquez également que 'nombre_pieces_principales' est bien un integer.

Si on regarde les données ça ressemble fortement à une requête SQL

scala> donnees_brutes.show(3)
+---------+
|id_mutation|date_mutation|numero_disposition|nature_mutation|valeur_fonciere|adresse_numero|adresse_suffixe|    adresse_nom_voie|adresse_code_voie|code_postal|code_commune|nom_commune|code_departement|ancien_code_commune|ancien_nom_commune|   id_parcelle|ancien_id_parcelle|numero_volume|lot1_numero|lot1_surface_carrez|lot2_numero|lot2_surface_carrez|lot3_numero|lot3_surface_carrez|lot4_numero|lot4_surface_carrez|lot5_numero|lot5_surface_carrez|nombre_lots|code_type_local|type_local|surface_reelle_bati|nombre_pieces_principales|code_nature_culture|  nature_culture|code_nature_culture_speciale|nature_culture_speciale|surface_terrain|longitude| latitude|
+---------+
|     2020-1|   2020-01-07|                 1|          Vente|         8000.0|          null|           null|            FORTUNAT|             B063|       1250|       01072|  Ceyzériat|              01|               null|              null|01072000AK0216|              null|         null|       null|               null|       null|               null|       null|               null|       null|               null|       null|               null|          0|           null|      null|               null|                     null|                  T|          terres|                        null|                   null|           1061| 5.323522|46.171899|
|     2020-2|   2020-01-07|                 1|          Vente|        75000.0|          null|           null|RUE DE LA CHARTREUSE|             0064|       1960|       01289|   Péronnas|              01|               null|              null|01289000AI0210|              null|         null|       null|               null|       null|               null|       null|               null|       null|               null|       null|               null|          0|           null|      null|               null|                     null|                 AB|terrains a bâtir|                        null|                   null|            610| 5.226197|46.184538|
|     2020-3|   2020-01-14|                 1|          Vente|        89000.0|          null|           null|           VACAGNOLE|             B112|       1340|       01024|   Attignat|              01|               null|              null|01024000AL0120|              null|         null|       null|               null|       null|               null|       null|               null|       null|               null|       null|               null|          0|           null|      null|               null|                     null|                 AB|terrains a bâtir|                        null|                   null|            600|     null|     null|
+---------+
only showing top 3 rows

On peut même sélectionner une colonne qui nous intéresse

scala> donnees_brutes.select("nombre_pieces_principales").show
+-------------------------+
|nombre_pieces_principales|
+-------------------------+
|                     null|
|                     null|
|                     null|
|                     null|
|                        5|
|                     null|
|                     null|
|                     null|
|                     null|
|                        4|
|                     null|
|                        4|
|                        0|
|                     null|
|                     null|
|                     null|
|                     null|
|                     null|
|                        7|
|                     null|
+-------------------------+
only showing top 20 rows

Nombre de propriétés vendues par nombre de pièces :

scala> donnees_brutes.groupBy(col("nombre_pieces_principales")).count().sort(col("nombre_pieces_principales")).show(100)
+-------------------------+------+
|nombre_pieces_principales| count|
+-------------------------+------+
|                     null|364129|
|                        0|137414|
|                        1| 33767|
|                        2| 58112|
|                        3| 77281|
|                        4| 78304|
|                        5| 47759|
|                        6| 18971|
|                        7|  6853|
|                        8|  2635|
|                        9|   960|
|                       10|   460|
|                       11|   227|
|                       12|    96|
|                       13|    42|
|                       14|    32|
|                       15|    15|
|                       16|    13|
|                       17|     7|
|                       18|     3|
|                       19|     1|
|                       20|     8|
|                       21|     2|
|                       22|     3|
|                       23|     3|
|                       25|     2|
|                       28|     2|
|                       30|     1|
|                       41|     1|
|                       55|     1|
|                       70|     1|
+-------------------------+------+

Nombre de propriétés vendues par département :

scala> donnees_brutes.groupBy("code_departement").count.orderBy("code_departement").show(100)
+----------------+-----+
|code_departement|count|
+----------------+-----+
|              01| 6314|
|              02| 9217|
|              03| 1832|
|              04| 2550|
|              05|  677|
|              06|18859|
|              07| 6165|
|              08| 5256|
|              09|  563|
|              10| 4662|
|              11| 6473|
|              12|  149|
|              13| 9435|
|              14| 5474|
|              15|   81|
|              16| 3848|
|              17| 3857|
|              18| 6185|
|              19| 6346|
|              21|   23|
|              22|12335|
|              23| 5686|
|              24|11069|
|              25| 2419|
|              26| 4990|
|              27| 4136|
|              28| 9412|
|              29| 5251|
|              2A| 1983|
|              2B|   43|
|              30|18654|
|              31| 4439|
|              32| 1942|
|              33|36966|
|              34|13716|
|              35|22680|
|              36| 1096|
|              37| 6864|
|              38| 8015|
|              39| 2817|
|              40| 6351|
|              41|10449|
|              42|11995|
|              43| 4703|
|              44|34684|
|              45|13716|
|              46|  401|
|              47|10392|
|              48| 2941|
|              49|20213|
|              50|13129|
|              51|11161|
|              52|  989|
|              53| 6139|
|              54| 9418|
|              55|  119|
|              56|15274|
|              58| 4529|
|              59|29203|
|              60|13304|
|              61|  940|
|              62|14243|
|              63| 4073|
|              64| 2536|
|              65| 1289|
|              66| 1681|
|              69|16265|
|              70| 4078|
|              71| 3743|
|              72|12665|
|              73| 1118|
|              74| 6771|
|              75|23498|
|              76|12723|
|              77|24965|
|              78|23371|
|              79| 9289|
|              80| 7674|
|              81| 1137|
|              82| 5257|
|              83|11189|
|              84| 4262|
|              85|18288|
|              86| 6425|
|              87|10147|
|              88|10698|
|              89| 6259|
|              90|  383|
|              91|17785|
|              92|14624|
|              93|15855|
|              94|19177|
|              95|19635|
|             971|   31|
|             972| 1241|
|             973| 1236|
|             974|  965|
+----------------+-----+

Notez que l'utilisation de col() dans les cas simples n'est pas obligatoire.

On peut aussi ajouter des colonnes :

scala> donnees_brutes.groupBy("code_departement").agg(count("code_departement"), sum("valeur_fonciere")).orderBy("code_departement").show(20)
+----------------+-----------------------+--------------------+
|code_departement|count(code_departement)|sum(valeur_fonciere)|
+----------------+-----------------------+--------------------+
|              01|                   6314| 1.742594188399994E9|
|              02|                   9217|1.3345704534799988E9|
|              03|                   1832|2.7055697240999997E8|
|              04|                   2550|3.8006166279999995E8|
|              05|                    677|       1.128379445E8|
|              06|                  18859|1.205845898618000...|
|              07|                   6165|      8.0660834657E8|
|              08|                   5256| 5.004314756300006E8|
|              09|                    563|1.3252729695000008E8|
|              10|                   4662| 8.730233068700001E8|
|              11|                   6473|1.1661764984500015E9|
|              12|                    149|       5.617143578E7|
|              13|                   9435|     3.72011788628E9|
|              14|                   5474|1.5801534871200008E9|
|              15|                     81|          4574032.25|
|              16|                   3848| 5.387546528899996E8|
|              17|                   3857| 7.421604203099996E8|
|              18|                   6185| 9.852137856099991E8|
|              19|                   6346| 5.676203941399999E8|
|              21|                     23|           2601610.0|
+----------------+-----------------------+--------------------+
only showing top 20 rows

Autres requêtes sur les données

• filtrer les données pour un code postal particulier :

scala> val data1 = donnees_brutes.filter("code_postal == 79000")
data1: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [id_mutation: string, date_mutation: string ... 38 more fields]

• comme il peut y avoir plusieurs communes pour un même code postal, nous filtrons en plus par nom de commune, qui est typée donc on met entre simple quote. Et nous mettons en cache ce qui permet de ne pas relancer les traitements à chaque opération :

scala> data1.groupBy("nom_commune").count.show
+-----------+-----+                                                             
|nom_commune|count|
+-----------+-----+
|     Sciecq|   15|
|      Niort| 1199|
|   Bessines|   36|
+-----------+-----+

scala> val data2 = data1.filter("nom_commune == 'Niort'").cache
data2: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [id_mutation: string, date_mutation: string ... 38 more fields]

• nous regroupons ensuite par adresse et nous affichons les valeurs foncières. Le booleen dans la fonction show permet de ne pas tronquer les noms de rues :

scala> val data3 = data2.groupBy("valeur_fonciere").agg(collect_set("adresse_numero"),collect_set("adresse_nom_voie"))
data3: org.apache.spark.sql.DataFrame = [valeur_fonciere: double, collect_set(adresse_numero): array<int> ... 1 more field]

scala> data3.show(3, false)
+---------------+---------------------------+-----------------------------------------+
|valeur_fonciere|collect_set(adresse_numero)|collect_set(adresse_nom_voie)            |
+---------------+---------------------------+-----------------------------------------+
|181400.0       |[219]                      |[RUE JEAN JAURES]                        |
|300000.0       |[65]                       |[LA JEUNE NOEMIE, RUE LOUISE MICHEL]     |
|330000.0       |[133, 47]                  |[AV DE LA VENISE VERTE, RUE DE FLEURELLE]|
+---------------+---------------------------+-----------------------------------------+
only showing top 3 rows

Utiliser SparkSQL

scala> donnees_brute.createTempView("valeurs")
scala> spark.sql("SELECT code_departement, count(code_departement), format_number(sum(valeur_fonciere),2) as val from valeurs group by code_departement").show
+----------------+-----------------------+----------------+                     
|code_departement|count(code_departement)|             val|
+----------------+-----------------------+----------------+
|              07|                   6165|  806,608,346.57|
|              51|                  11161|2,602,674,825.81|
|              15|                     81|    4,574,032.25|
|              54|                   9418|3,584,392,751.82|
|              11|                   6473|1,166,176,498.45|
|              29|                   5251|  924,555,519.99|
|              69|                  16265|6,919,943,214.33|
|              42|                  11995|2,150,156,062.88|
|              73|                   1118|  322,142,860.18|
|              87|                  10147|1,252,443,498.36|
|             974|                    965|  915,366,405.44|
|              64|                   2536|  469,110,158.79|
|              30|                  18654|5,146,175,384.62|
|              34|                  13716|2,900,615,804.92|
|              59|                  29203|9,800,705,395.83|
|              01|                   6314|1,742,594,188.40|
|              22|                  12335|1,780,289,300.53|
|              28|                   9412|2,595,710,151.61|
|              85|                  18288|2,669,234,383.54|
|              16|                   3848|  538,754,652.89|
+----------------+-----------------------+----------------+
only showing top 20 rows

Beaucoup de sources de données disponibles

Apache spark sait lire des tas de sources de données en natif et avec des modules open source. En voici une liste à titre d'exemple, mais en général n'importe quelle source est possible

• CSV
• JSON
• Parquet
• ORC
• JDBC/ODBC connections
• Plain-text files
• Cassandra
• HBase
• MongoDB
• AWS Redshift
• XML
• Kafka
• etc...

Exemple : Lire un fichier JSON

Spark ne va pas lire directement un fichier JSON, mais attend un object JSON par ligne, par example

{"nom":"Garcia","prenom":"Denis"}
{"nom":"Colin","prenom":"Gérald"}

Vous pouvez préparer votre fichier JSON avec un simple commande jq

cat data.json | jq -c '.' > data-ready.json

Maintenant, il nous suffit de faire comme suit avec spark :

scala> val fichier = "data-ready.json"
scala> val personnes = spark.read.json(fichier)

scala> personnes.printSchema()
root
 |-- firstname: string (nullable = true)
 |-- name: string (nullable = true)
 
scala> personnes.show()
+------+------+
|prenom|  nom |
+------+------+
| Denis|Garcia|
|Gérald| Colin|
+------+------+

Voilà pour cette mise en bouche rapide pour l'utilisation d'Apache Spark et le traitement rapide et éphémère de données.

Nous avons un serveur qui héberge plusieurs services liés à des sous-domaines différents et qui doivent tous avoir un certificat.

En prérequis, les entrées DNS des sous-domaines pointent toutes sur le même serveur.

Sur un serveur qui héberge plusieurs services en https sur des sous-domaines différents, voici une méthode (parmi d'autres) pour configurer HAProxy avec des certificats LetsEncrypt qui se renouvellent automatiquement.

• Reprendre le fichier /etc/haproxy/haproxy.cfg ci-dessous et compléter avec votre domaine et services :

global
	log /dev/log	local0
	log /dev/log	local1 notice
	chroot /var/lib/haproxy
	stats socket /run/haproxy/admin.sock mode 660 level admin expose-fd listeners
	stats timeout 30s
	user haproxy
	group haproxy
	daemon

	# Default SSL material locations
	ca-base /etc/ssl/certs
	crt-base /etc/ssl/private
	tune.ssl.default-dh-param 2048 

	# Default ciphers to use on SSL-enabled listening sockets.
	# For more information, see ciphers(1SSL). This list is from:
	#  https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
	# An alternative list with additional directives can be obtained from
	#  https://mozilla.github.io/server-side-tls/ssl-config-generator/?server=haproxy
	ssl-default-bind-ciphers ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:RSA+AESGCM:RSA+AES:!aNULL:!MD5:!DSS
	ssl-default-bind-options no-sslv3

defaults
	log	global
	mode	http
	option	httplog
	option	dontlognull
        timeout connect 5000
        timeout client  50000
        timeout server  50000
	errorfile 400 /etc/haproxy/errors/400.http
	errorfile 403 /etc/haproxy/errors/403.http
	errorfile 408 /etc/haproxy/errors/408.http
	errorfile 500 /etc/haproxy/errors/500.http
	errorfile 502 /etc/haproxy/errors/502.http
	errorfile 503 /etc/haproxy/errors/503.http
	errorfile 504 /etc/haproxy/errors/504.http

frontend http-in
	bind *:80

	acl http ssl_fc,not
	http-request redirect scheme https if http

frontend https-in
	bind *:443 ssl crt-list /etc/haproxy/certs/domains_list.txt

	option forwardfor
	option forwardfor header X-Real-IP
	http-request add-header X-Real-IP %[src]
	reqadd X-Forwarded-Proto:\ https

	acl letsencrypt-acl path_beg /.well-known/acme-challenge/
	use_backend letsencrypt-back if letsencrypt-acl

	acl host_dom1 hdr_end(host) -i subd1.mydomain.com
	acl host_dom2 hdr_end(host) -i subd2.mydomain.com

	use_backend dom1-back if host_dom1
	use_backend dom2-back if host_dom2

	default_backend dom1-back

backend dom1-back
	redirect scheme https if !{ ssl_fc }
	server dom1 127.0.0.1:8080 check

backend dom2-back
	redirect scheme https if ! { ssl_fc }
	server dom2 127.0.0.1:9980 check

backend letsencrypt-back
	server letsencrypt 127.0.0.1:8888

• Pour créer un certificat la première fois, exécutez la commande :

certbot certonly --standalone -d subd2.mydomain.com --email me@email.com --agree-tos --non-interactive --http-01-port=8888

• Concaténez les fichiers de certificats en un seul fichier pour haproxy :

cat /etc/letsencrypt/live/subd2.domain.com/fullchain.pem /etc/letsencrypt/live/subd2.domain.com/privkey.pem | tee /etc/haproxy/certs/subd2.domain.com.pem

• Créez ou complétez le fichier /etc/haproxy/certs/domains_list.txt :

/etc/haproxy/certs/subd1.domain.com.pem subd1.domain.com
/etc/haproxy/certs/subd2.domain.com.pem subd2.domain.com

• Redémarrez haproxy pour prendre en compte les ajouts sudo haproxy reload
• Pour le renouvellement, copiez le script ci-dessous dans /opt/certif-renewal.sh et ajoutez le en crontab :

#!/bin/sh

certbot renew --force-renewal --tls-sni-01-port=8888

cat /etc/letsencrypt/live/subd1.domain.com/fullchain.pem /etc/letsencrypt/live/subd1.domain.com/privkey.pem | tee /etc/haproxy/certs/subd1.domain.com.pem
cat /etc/letsencrypt/live/subd2.domain.com/fullchain.pem /etc/letsencrypt/live/subd2.domain.com/privkey.pem | tee /etc/haproxy/certs/subd2.domain.com.pem

service haproxy reload

echo `date +'%F %T'` " ---- Certificat renewal done ----"

Et voilà...

Explications

HAProxy est un load balancer très performant et simple de mise en oeuvre.

Dans ce mode de fonctionnement, les appels vers le serveur et les sous-domaines sont forcés en https par haproxy et c'est lui qui gère les certificats. Les appels aux services backend sont alors fait en http. Cela facilite leur mise en oeuvre car vous évite de gérer des certificats, surtout quand ces services sont des containers docker.

Le problème général est que haproxy écoute sur le port 80 et 443 de votre serveur et que certbot a besoin de ces ports pour créer les certificats ou les renouveler. Vous pourriez stopper haproxy le temps de faire le renouvellement mais ici nous préférons utiliser certbot sur un port dédié (8888 par exemple) et donner l'instruction à HAProxy de l'utiliser quand il détecte l'appel à l'URL de LetsEncrypt.

Du coup, pour les commandes certbot, il faut ajouter l'attribut --http-01-port=8888 pour préciser sur quel port se connecter. Celui-ci correspond à ce que vous paramétrez dans la configuration du backend de HAProxy.

Dans la section global, l'instruction tune.ssl.default-dh-param 2048 augmente la sécurité lors de l'échange de clés (1024 par défaut).

Dans le domaine de la Business Intelligence ou créations de dashboard métiers, il existe beaucoup d'outils payants et quelques uns open-source. Nous allons vous présenter Metabase qui à l'avantage de proposer leur outil avec les principales fonctionnalités en open source et gratuitement. Cette version est à héberger soi-même (exemple ci-dessous). Sinon ils proposent une version avec plus de sécurité et d'audit mais la marche est haute en terme de prix. Ils ont aussi des offres en mode SAAS.

Installation

Prérequis : base de donnée PostgreSQL

Cette base de donnée sera utilisée pour la configuration de Metabase. Voici un exemple de commandes et script :

# Ajout d'un utilisateur systeme postgres sur le host et creation du repertoire des données de la base
$ sudo useradd -r postgres
$ mkdir data
$ sudo chown postgres:postgres

# Ajout du reseaux docker dédié
$ docker network create MB_NET

# Execution du script start.sh ci-dessous
$ ./start.sh

avec le script start.sh suivant :

docker run -d --name metabaseDB \
	--restart unless-stopped \
	--network MB_NET \
	--user 999:998 \
	-v /etc/passwd:/etc/passwd:ro \
	-v $PWD/data:/var/lib/postgresql/data \
	-e POSTGRES_PASSWORD=metabasedemo \
	-e POSTGRES_USER=metabasedemo \
	-e POSTGRES_DB=metabase \
	-p 15432:5432 \
	postgres:12.4

Image docker de Metabase

Nous utilisons l'image Docker officielle avec le script suivant :

#!/bin/sh

docker run -d -p 3000:3000 \
	--network MB_NET \
	-e "MB_DB_TYPE=postgres" \
	-e "MB_DB_DBNAME=metabase" \
	-e "MB_SB_PORT=5432" \
	-e "MB_DB_USER=metabasedemo" \
	-e "MB_DB_PASS=metabasedemo" \
	-e "MB_DB_HOST=metabaseDB" \
	-e "JAVA_TIMEZONE=Europe/Paris" \
	--name metabase metabase/metabase:latest

et après exécution de ces scripts vous pouvez aller sur localhost:3000 et vous obtenez l’assistant de première configuration :

Vous avez le choix de plusieurs sources de données :

Overview

La prise en main est plutôt intuitive et simple et orienté utilisateur (et non pas informaticien comme dans beaucoup d'outils BI).

Une base de donnée de démo est fournie ce qui permet de jouer avec l'outil sans ajouter de sources externes.

Metabase vous présente une radiographie de vos données : il a scanné les tables et construit pour vous des premiers tableaux de bords plus ou moins pertinents en fonction de votre modèle.

En plus de la radiographie, vous avez 3 notions essentielles :

• les requêtes que vous pouvez construire de 3 manière différentes, de la question simple à la requête SQL
• les dashboards qui sera une composition de vos requêtes
• les pulses qui sont des rapports automatiques que vous pouvez envoyer sur Slack ou par mail.

Pour requeter les données, vous avez donc 3 niveaux en fonction de votre appétence technique :

• La question simple va lire le contenu d'une table choisie. Metabase fonctionnera mieux si votre modèle de donnée source est déjà bien structuré. Il ne vous permet pas de transformation intermédiaires et de préparation de données comme d'autres outils de BI plus évolués.

• La question personnalisée permettra les jointures avec d'autres tables, l'ajout de colonnes calculées, le tout de façon graphique
  

• La requête native permet de taper ses propres requêtes SQL. Vous avez la possibilité d'ajouter des clauses where optionnelles (entre [[ et ]] ) et aussi des variables qui pourront être utilisées dans les dashboards.
  

Comparaisons entre périodes

Un cas classique est de présenter des données sur une période comparées à une autre période.

Une façon de faire est d'utiliser la question personnalisée. Dans la partie "Résumer", choisir une expression personnalisée au lieu d'une colonne existante et utiliser un opérateur conditionnel tel que sumif ou countif. Par exemple : SumIf([Quantity], between([Created at],"2020-01-01","2020-12-31")).

Notes et écueils

Alias et variables

Dans les requêtes SQL, le système n'aime pas l'utilisation des alias avec les variables. Un exemple qui ne fonctionne pas :

select p.nom, p.race 
from pet as p
where 1=1
[[ and {{ color }} ]];

Explications :

• nous utilisons ici une clause optionnelle délimitée entre crochet. Si celle-ci n'est pas présente, la clause where se retrouve vide et la requête n'est plus valide, d'ou l'ajout du 1=1.
• la variable "color" rattachée à la colonne du même nom ne passera pas ensuite dans la requête générée par Metabase et vous donnera une erreur.

Notre conseil est d'enlever les alias pour les tables sur lesquelles vous avez des variables.

Notes sur outils de BI

Nous ne ferons pas de comparaisons poussées avec les gros de la BI tels que Qlik ou Tableau Software, mais le principal avantage de Metabase est sa prise main facile et rapide et son ergonomie orientée utilisateur final.

• Utiliser le SDK Dropbox
• Récupérer les méta données des fichiers et répertoires
• Utiliser le digest des fichiers (content_hash) pour identifier les doublons
• Générer une liste de doublons et calculer la taille qu'on pourrait gagner en supprimant les doublons

Avant de commencer

• Avoir node and npm installés
• Avoir un compte Dropbox

Préparation

• Création de l'espace de travail

$ mkdir espace_de_travail
$ cd espace_de_travail
$ npm init --yes

• installation des dépendances

$ npm install -s dropbox isomorphic-fetch lodash

• Génération du token Dropbox

Créer un compte sur https://www.dropbox.com/developers/apps

Créer une application

Récupérer le 'access_token'

• Ajouter le token  dans le fichier token.js

exports.TOKEN ='LE_TOKEN_GENERE';

Récupération des fichiers

Nous allons maintenant travailler dans le fichier recuperation-meta-donnees.js

• Imports

const fs = require('fs');
const fetch = require('isomorphic-fetch');
const Dropbox = require('dropbox').Dropbox;

• Activation du SDK Dropbox

const TOKEN = require('./token').TOKEN;
var dbx = new Dropbox({ fetch: fetch, accessToken: TOKEN });

• La fonction pour récupérer les fichiers

async function getFiles(path, process) {
  var response = await dbx.filesListFolder({
          path: path,
          recursive: true
      });
    
  processResponse(response);
  
  while(response.has_more) {
    try {
      response = await dbx.filesListFolderContinue({cursor: response.cursor});
      processResponse(response);
    }
    catch(e) {
      console.error('error', e);
      break;
    }
  }
}

• Préparation  de notre data store local

const entries = {};
// content_hash: Array<meta_donnees_fichier>

• Traitement des données

async function processResponse(response) {
    
  response.entries.forEach(processEntry);
  const currentSize = Object.keys(entries).length;
}

async function processEntry(entry) {
	entries[entry.id] = entry
}

• Action!

On lance maintenant le programme, on affiche le nombre de meta données et on sauvegarde le résultat dans un fichier json qu'on utilisera par la suite pour trouver les doublons.

const path = '/Caderias'; // Le chemin du répertoire Dropbox à scanner. Utiliser '' pour tout sinon '/le-chemin'
getFiles(path, processResponse)
  .then(() => {
    console.log('entries', Object.keys(entries).length);
    fs.writeFileSync('db.json', JSON.stringify(entries, null, 4));
  });

Trouver les doublons

• Les imports

const _ = require('lodash'); 
const fs = require('fs'); 

• Chargement de la base de données des metadata des fichiers de Dropbox

const fileContent = fs.readFileSync('db.json', {
  		encoding:'utf8',
   		flag:'r'
	}
);
const db = fileContent.length > 0 ? JSON.parse(fileContent) : {};

const entries = Object.values(db);
console.log('entries', entries.length);

• Maintenant le travail commence, nous allons d'abord filtrer les meta données pour ne garder que les fichiers, puis les grouper sur le champ 'content_hash' qui  représente  le digeste des fichiers. Si deux fichiers ont le même 'content_hash' alors on peut considérer qu'ils sont identiques.

// Filtrer les fichiers seulement
const files = entries.filter( e => e['.tag'] === 'file');
console.log('files', files.length);

// Grouper les fichiers par 'content_hash'
const grouped = _.groupBy(files, 'content_hash');
console.log('grouped', Object.keys(grouped).length);

• Afficher les doublons

A ce stade nous avons un Map dont la clé est le digest des fichiers ('hash_content') et la valeur est une liste de méta données des fichiers sur Dropbox

Nous allons simplement filtrer et conserver uniquement les digests qui ont une liste avec strictement plus d'un élément, car il s'agit de doublons

// ne conserver que les digestes avec doublons
const duplicates = Object.keys(grouped)
    .filter( k => grouped[k].length > 1);

// On map maintenant le nom des fichiers
const duplicatesFiles = duplicates.map(l => 
	l.map(e => e.path_display) // remplacer les méta données du fichier par le nom du fichier dans la liste
);
console.log('duplicatesFiles', duplicatesFiles);

• Calculer la taille des fichiers doublons

const duplicatedSize = duplicates
    .map(doublons => doublons[0].size * (doublons.length - 1))
    .reduce((a,b) => a + b);
console.log('Manque à gagner', duplicatedSize / 1000 / 1000, 'mb');

Nous avons maintenant une liste de doublons (donc une liste de liste).

Nous parcourons la liste des doublons, et pour chaque liste de doublons nous calculons la taille que l'on peut gagner en supprimant tous les doublons (en ne conservant qu'une version).

Récapitulatif

fichier get-files.js

const fs = require('fs');
const fetch = require('isomorphic-fetch');
const Dropbox = require('dropbox').Dropbox;

const TOKEN = require('./token').TOKEN;
const dbx = new Dropbox({ fetch: fetch, accessToken: TOKEN });

async function getFiles(path, process) {
  var response = await dbx.filesListFolder({
          path: path,
          recursive: true
      });
    
  processResponse(response);
  
  while(response.has_more) {
    try {
      response = await dbx.filesListFolderContinue({cursor: response.cursor});
      processResponse(response);
    }
    catch(e) {
      console.error('error', e);
      break;
    }
  }
}

const entries = {};
// content_hash: Array<meta_donnees_fichier>

async function processResponse(response) {
    
  response.entries.forEach(processEntry);
  const currentSize = Object.keys(entries).length;
}

async function processEntry(entry) {
	entries[entry.id] = entry
}

function saveDB(entries) {
  fs.writeFileSync('db.json', JSON.stringify(entries, null, 4));
}

const path = '/Caderias'; // Le chemin du répertoire Dropbox à scanner. Utiliser '' pour tout sinon '/le-chemin'
getFiles(path, processResponse)
  .then(() => {
    saveDB(entries);
    console.log('entries', Object.keys(entries).length);
  });

fichier analyse-files.js

const _ = require('lodash'); 
const fs = require('fs'); 

const fileContent = fs.readFileSync('db.json', {encoding:'utf8', flag:'r'});
const db = fileContent.length > 0 ? JSON.parse(fileContent) : {};

const entries = Object.values(db);
console.log('entries', entries.length);

const files = entries.filter( e => e['.tag'] === 'file');
console.log('files', files.length);

const grouped = _.groupBy(files, 'content_hash');
console.log('grouped', Object.keys(grouped).length);

const duplicates = Object.values(grouped)
    .filter( l => l.length > 1);
console.log('duplicates', duplicates.length);

const duplicatesFiles = duplicates.map(l => l.map(e => e.path_display))
console.log('duplicatesFiles', duplicatesFiles);

const duplicatedSize = duplicates
    .map(l => l[0].size * (l.length - 1))
    .reduce((a,b) => a + b);
    // .reduce((a,b) => a.b);
console.log('duplicatedSize', duplicatedSize / 1000 / 1000, 'mb');

console.log('DONE');

Prérequis : vous devez avoir au moins Go v1.13 (avant je n'ai pas testé).

Commencez par installer cobra:

go get -u github.com/spf13/cobra/cobra

Créez votre répertoire de travail (en dehors du Gopath)

$ cd maCli
$ go mod init maCli
$ git init
$ cobra init --pkg-name maCli

Pour utiliser votre programme, vous allez l'appeler, puis y ajouter une commande et enfin des arguments.

Ajoutez une nouvelle commande :

$ cobra add maCommande

Votre projet contient alors un main.go avec juste un point d'entrée qui va executer vos commandes. Vos commandes sont dans le répertoire "cmd". Vous avez "root.go" qui contient la commande par defaut et l'appel à votre programme sans commande. Vous pouvez y personnaliser votre message principal.

Dans chaque commande, vous retrouvez dans la fonction "init()" la gestion de vos arguments, avec 2 types : les persistens qui sont disponibles dans la commande en cours et les sous-commandes et la locale uniquement pour la commande en cours.

// Here you will define your flags and configuration settings.
// Cobra supports persistent flags, which, if defined here,
// will be global for your application.

rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.maCli.yaml)")

Par exemple, dans "maCommande.go" vous pouvez définir dans la fonction init()

func init() {
	rootCmd.AddCommand(maCommandeCmd)

	// Here you will define your flags and configuration settings.

	// Cobra supports Persistent Flags which will work for this command
	// and all subcommands, e.g.:
	foo = maCommandeCmd.PersistentFlags().String("foo", "", "A help for foo")
}

et dans la commande :

Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("maCommande called")
		if foo!=nil {
			fmt.Printf("with foo value : %s\n", *foo)
		}
	},

Si vous souhaitez voir certains projets qui utilisent cela:

• https://github.com/docker/cli
• https://github.com/kubernetes/kubernetes
• https://github.com/gohugoio/hugo

Les meetups Golang Paris sont un moment privilégiés pour faire du code, avoir du retour d'expérience bref monter en compétence et rencontrer des gens sympas. N'hésitez pas à vous inscrire et à venir:

https://www.meetup.com/fr-FR/Golang-Paris/

et aussi  à consulter la page github également:

Golang Paris interest group

Gophers from the greater Paris area (you know... the place with that tall metal thingy) - Golang Paris interest group

GitHub

Utilisation de Go routines et assignation de variables

Nous allons montrer un piège qui est arrivé sur un exemple plus complexe à la base mais qui peut se résumer ainsi:

• Nous partons d'un bout de code simple qui boucle et affiche le contenu de la variable "i" dans une Go routine

package main

import (
	"fmt"
)

func main() {
	fmt.Println("Demo on goroutines seq")

	for i := 0; i < 10; i++ {
		go func() {
			fmt.Println("Val i: %d", i)
		}()
	}
}

Si vous executez ce code : https://play.golang.org/p/PyMsrChN-ZD
vous verrez uniquement `Demo on goroutines seq` d'affiché : le programme effectue la boucle et sort avant qu'il n'ait le temps de lancer les routines.

• Ajoutons un sleep à la fin.

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("Demo on goroutines seq")

	for i := 0; i < 10; i++ {
		go func() {
			fmt.Printf("Val i: %d\n", i)
		}()
	}

	time.Sleep(500 * time.Millisecond)
}

et maintenant, que devons nous voir: 10 lignes avec ` Val i: 10 `.
Encore une fois, les routines sont lancées une fois que la boucle est terminée. Les routines sont créées avec une référence sur la variable "i" et non pas une copie.

• Une façon de corriger cela est de passer en paramètre la variable "i" à la routine:
  https://play.golang.org/p/BiSCQtXQ6wl

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("Demo on goroutines seq")

	for i := 0; i < 10; i++ {
		go func(cpt int) {
			fmt.Printf("Val i: %d\n", cpt)
		}(i)
	}

	time.Sleep(500 * time.Millisecond)
}

et vous voila avec une boucle qui affiche les chiffres de 0 à 9, mais en parallèle!

Les slices et leur valeur sous-jacente

Regardez l'exemple de code disponible sur le repo de Meetup Golang Paris:

GolangParis/dont-panic

Du fait des dérèglements climatiques affectant le taux de reproduction de l’espèce : l’état d’urgence a été décrété. Ne pas céder à la panic. - GolangParis/dont-panic

GitHubGolangParis

Sans revenir sur une description poussée des slices, ceux-ci peuvent être liés à un tableau sous-jacent. Si vous ne changez pas la capacité du slice, il y a la même référence que le tableau mais dans le cas d'une nouvelle allocation, vous changez d'emplacement.

Ce cas est à garder en tête car il peut être difficile à débugger et se comporter comme "un bug aléatoire".

Vous trouverez dans cet article un ensemble de bouts de code, trucs et astuces et retours d'expérience sur l'utilisation d'Apache Spark en Scala.

Créer un objet exécutable comme une app

object MyApp {
  def main(args: Array[String]) {
    // Le code ici sera exécuté
  }
}

ou

object MyApp extends App {
 // le code ici sera exécuté
}

Créer un contexte spark

  def getSC(appName: String , master: String = "local"): SparkContext = {
    val conf = new SparkConf()
      .setAppName(appName)
      .setMaster(master)
      .set("spark.hadoop.validateOutputSpecs", "false")
    new SparkContext(conf)
  }

Créer une session Spark

  def getSS(appName: String , master: String = "local"): SparkSession = {
    SparkSession
      .builder
      .appName(appName)
      .master(master)
      .config("spark.sql.warehouse.dir", "file:///tmp") // A utiliser pour contourner un bug de Spark 2.0.0 sous Windows
      .getOrCreate()
  }

Créer un streaming context

 def getStreamingContext(appName: String, duration: Duration, master: String = "local"): StreamingContext = {

    val conf = new SparkConf()
      .setAppName(appName)
      .setMaster(master)
    new StreamingContext(conf, duration)
 }

Note : Spark Streaming ne fait pas du vrai streaming, mais plutôt regroupe des événements dans de micro-batch. Duration est l'intervalle entre deux batches

Créer un RDD à partir d'un objet scala (pour tester mon algo)

object MyApp extends App {
  val sc = SparkUtils.getSC("CountByValue")
  
  val list = List("value1", "value2", "value3", "value4", "value4")
  
  val rdd: RDD[String] = sc.parallelize(list)
}

Le parallelize crée un RDD qui sera distribué dans Spark (si vous lancez le job sur un cluster). Bien sûr en général on travaille sur de très grosses quantité de données que l'on charge ou reçoit d'une source de données externes à l'application.

Parrallelize est très utile pendant le développement pour tester notre algo dans une session "local".

Charger des données à partir d'un fichier

object WordCountReduceByKey extends App {
  val sc = SparkUtils.getSC(this.getClass.getName)
  val lines: RDD[String] = sc.textFile("hdfs://spark/my-data/ddh.txt")
  // It could have been "file://spark/my-data/ddh.txt"
  
  println(lines.count)
}

Note 1 : le fichier texte est en général placé sur un stockage distribué, type Hadoop HDFS

Note 2 : c'est un super outil pour le développement pour charger des données d'un fichier local aussi

countByValue

object MyApp extends App {
  val sc = SparkUtils.getSC("CountByValue")
  
  val list = List("value1", "value2", "value3", "value4", "value4")
  val rdd = sc.parallelize(list)
  
  val countedByValue = rdd.countByValue
  countedByValue.print()
  
}

Note 1 : take et collect sont de très bons outils pour le développement, et sont moins souvent utilisés en production (ça dépend des cas) car ils ramènent tous les éléments du RDD dans le process courant. Si la collection est trop grosse Spark ne pourra pas allouer assez de mémoire.

Note 2 : On préfère en général utiliser reduceByValue

PairRDDs

Un PairRDD est un RDD  de paires. Certaines fonctions sont proposées pour la manipulation des paires qui va vous simplifier la vie et améliorer les performances des traitements.

object MyApp extends App {
  val sc.SparkUtils.getSC(this.getClass.getName)
  
  val lines = sc.textFile("/path/to/my/file.txt")
  val words: RDD[String] = lines.flatMap( l => l.split(" "))
  
  val pairRDD: RDD[(String, Int)] = words.map((word: String) => (word, 1))
  
  pairRDD.collect.foreach(println)
}

groupByKey

object MyApp extends App {
  val sc.SparkUtils.getSC(this.getClass.getName)
  
  val lines = sc.textFile("/path/to/my/file.txt")
  val words: RDD[String] = lines.flatMap( l => l.split(" "))
  val pairs: RDD[(String, Int)] = words.map((word: String) => (word, 1))
  
  val groupedByKey = pairs.groupByKey()
  
  groupedByKey.collect.foreach(println)
}

// --- output ---
// [...]
// (privé,,CompactBuffer(1))
// (inquiété,CompactBuffer(1))
// (ou,CompactBuffer(1, 1, 1, 1, 1))
// (consentir,CompactBuffer(1))
// [...]

Note : On préfère en général reduceByKey qui réduit le volume de données échangées pendant le shuffle.

reduceByKey

object MyApp extends App {
  val sc = SparkUtils.getSC(this.getClass.getName)
  val words = List("value1", "value2", "value3", "value4", "value4")
  val wordsPairs = words.map(word => (word.toLowerCase, 1))
  
  val wordCounts = wordsPairs.reduceByKey((c1: Int, c2: Int) => c1 + c2)
    .sortByKey()
    
  wordCounts.collect.foreach(println)
}

// --- output ---
// [...]
// (ordres,1)
// (expressément.,1)
// (privé,,1)
// (inquiété,1)
// [...]

map/filter sur RDD

Si vous êtes familier avec map et filter dans n'importe quel langage, par exemple avec les collections Java ou Scala, c'est essentiellement la même chose d'un point de vu programmatique. Prenons un exemple simple, qu'on ne devrait pas trouver un production, mais qui donne une idée:

• Nous chargeons un fichier csv de liste d'aéroports et on split les colonnes sur ","
• Nous allons filtrer les aéroports qui ont une altitude supérieure à 1500m et ne retourner que le nom et altitude des aéroports en question.

Vous noterez que comme on ne charge pas le csv très proprement en considérant les chaines de caractères incluant le séparateur, etc... On filtrera la première ligne en éliminant la chaîne qui commence par Airport (pas propre, mais suffisant pour notre exemple).

D'autre part, le nom de l'aéroport est la première colonne de notre fichier csv et l'altitude est à la colonne 4

object AirportsByAltitude extends App {

  val sc = SparkUtils.getSC(this.getClass.getName)

  val maxAltitude = 1500
  val airports = sc.textFile(raw"C:\MyData\spark\data\airports.dat.txt")
    .filter(l => !l.startsWith("Airport")) // pas propre

    val data1 = airports
      .map(l => {
        val s = l.split(",")
        val airportName = s(1)
        val altitude = s(4)
        (airportName, altitude.toDouble)
      })

  val data2 = data1.filter(t => t._2 > maxAltitude)

  data2.take(2).foreach(println)

  println("airpots above 1500m: " + data2.count())
}

Note : faire les filtres sur les données le plus tôt possible pour réduire la taille des données lors des opérations lourdes, surtout lorsqu'un shuffle va être nécessaire. Les données filtrées ne sont jamais ajoutées dans le RDD.

Sauvegarder un RDD

On peut sauvegarder un RDD dans un fichier text (qui peut-être distribué en étant sauvegarder sur HDFS par exemple) ou dans d'autres format éventuellement plus efficace comme les séquences files

[...]

  // On parse un fichier de log apache par exemple
  val logParserRegex = raw"([^\:]+)[^\/]+([^\s\?]+).*".r
  def matchLog(logLine: String): (String, String) = logLine match {
    case logParserRegex(date, url) => (date, url)
    case _ => ("", "")
  }
  val tuples = logs.map(matchLog).distinct

  tuples.saveAsTextFile("hdfs://mon/chemin/tuples.txt")
  
[...]

Il pourra être rechargé plus tard avec :

[...]
  val sc = SparkUtils.getSC(this.getClass.getName)
  val logs = sc.textFile("hdfs://mon/chemin/tuples.txt")

[...]

Note : selon le besoin il est utile d'utiliser un format spécifique pour sauvegarder le RDD, par exemple un format de fichier colonnaire permet de pouvoir accéder de façon très efficace à un colonne entière sans avoir avec lire la totalité du fichier comme c'est le cas avec un fichier plat CSV.
Regardez SequenceFile, RC (Row Colomnar), ORC (Optimized Row Columnar) Avro, Parquet.

Mettre un RDD en cache et le réutiliser

Quand un RDD est créé vous pouvez vous en servir pour faire d'autres opérations dessus. Si vous avez plusieurs opérations à faire il est important de considérer mettre en cache le RDD, c'est à dire qu'il sera conservé en mémoire. Sinon la chaîne complète sera réexécutée lors des opérations suivantes.

Par exemple :

object AnalyseLogs extends App {
  val sc = SparkUtils.getSC(this.getClass.getName)
  val logs = sc.textFile("hdfs://mon/chemin/tuples.txt").cache // on met en cache
  
  val countSite1 = logs.filter(t => t._2.startsWith("https://monsite1.com/")).count

  val countSite2 = logs.filter(t => t._2.startsWith("https://monsite2.com/")).count

  println("count site1 " + countSite1)
  println("count site2 " + countSite2)
  
}

Note : sans l'instruction .cache de la troisième ligne, le fichier text serait parsé 2 fois.

map et flatMap

map  transforme chaque élément de la collection en un autre élément avec éventuellement un type différent

map[U: ClassTag](f: T => U): RDD[U]

flatMap transforme chaque élémenet de la collection en un collection (éventuellement vide) qui est ensuite applitie pour donner une collection entière

flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

# exemple : tous les mots d'un texte

val text = sc.textFile("/path/to/mon_text.txt")
val listOfWords = text.flatMap( line => line.split(" ")) // on retourne bien une collection de mots pour chaque ligne du fichier. Le resultat du flatMap est une collection de mots de tout le fichier

val wordCount = listOfWords.count

GroupByKey vs ReduceByKey

On compte le nomber de mots d'un fichier

object WordCountGroupByKey extends App {

  val sc = SparkUtils.getSC(this.getClass.getName)
  val lines = sc.textFile("/path/to/my_big_text.txt")
  val words = lines.flatMap( l => l.split(" "))
    .map(w => (w, 1) // on crée un tuple2 dans la clé est le mot
    .cache

  # groupBy
  val groupByCount = words.groupByKey()
  groupByCount.take(10).foreach(println)
  
  # reduceByKey
  val reduceByKeyCount = pairs.reduceByKey((count1, count2) => count1 + count2 )
  // pour chaque clé, on fait un reduce de la valeur
  reduceByKeyCount.collect.foreach(println)
}

On obtient le même résultat dans les deux cas, mais le reduceByKey est préféré car le réduce est d'abord fait par partition (sans shuffle / sans échange réseau) alors que le reduce qui est fait par le groupBy et groupByKey est fait dans un reduce job, donc toutes les données de la collection sont échangées via un shuffle

Fusionner deux RDDs

  val rdd1: RDD[Int] = sc.parallelize(List(1,2,3))
  val rdd2: RDD[Int] = sc.parallelize(List(4,5,6))

  val merged = rdd1.union(rdd2)
  merged.collect.foreach(println)

Réduction des logs Apache Spark

Utiliser la configuration de votre logger ou bien en développement faites :

Logger.getLogger("org").setLevel(Level.ERROR)

Ne pas faire ça!

Pourquoi cela ne fonctionne-t-il pas en Prod ?

let monRDD = ... // on charge un RDD
monRdd.foreach(println)

En fait le code compile, et j'arrive même à l'exécuter sur mon cluster, mais les println sont exécutés sur les workers dans spark, dans un sous job. Je ne vais pas les voir apparaître dans le driver (mon application spark).

Ce qu'il faut faire si on veut récupérer un résultat dans notre driver :

let monRDD = ... // on charge un RDD
monRdd.collect.foreach(println)

Le collect est une action finale qui ramène tous les éléments du RDD dans une collection scala dans la JVM courante

Bien pour le développement et prod

• rdd.take(num: Int): Array[T]
  Pour récupérer des éléments dans une collection du driver
• rdd.first()
  Pour récupérer le premier élément de la collection
• rdd.top(num: Int): Array[T]
  par défaut, comme take mais après classement de la collection avec un "ordering" implcit
  
  On peut surcharger le triage comme suit :

  val customOrdering = new Ordering[Int] {
    override def compare(a: Int, b: Int) = {
      b - a
    }
  }
  rdd.top(10)(customOrdering).foreach(println)

• rdd.sample(
     withReplacement: Boolean, // accepte-t-on plusieurs fois le même élément
     fraction: Double, // fraction de la collection
     seed: Long = Utils.random.nextLong // initialization du générateur aléatoire
  ): RDD[T] = { // note on reçoit un RDD
• un peu avec le même principe, mais pour pour récupérer en local dans le driver
  rdd.takeSample(
     withReplacement: Boolean,
     num: Int,
     seed: Long = Utils.random.nextLong): Array[T] // on reçoit bien un Array, qui est une instance de collection dans la JVM du driver
• rdd.randomSplit(
     weights: Array[Double],
     seed: Long = Utils.random.nextLong
  ) : Array[RDD[T]]

Vocabulaire

• RDD : Resilient Distributed Dataset
• RC : Row Colomnar
• ORC : Optimized Row Columnar

Ceci est un bout de code qui permet de lire les préférences du poste utilisateur sous Windows et de trouver les paramètres d'affichage des nombres décimaux.

Évidemment, cela ne fonctionne que sous windows.

Listons d’abord les propriétés systèmes disponibles par défaut :

System.getProperties().forEach(
	(o, o2) -> System.out.printf("Prop : %s / %s\n", o, o2)
);

et vous obtenez :

Nous voyons que nous accédons facilement à la propriété user.language. Seulement cette propriété donne la langue du poste mais sous windows, il est possible de changer des paramètres avancés tel que les formats des dates ou des nombres décimaux :

Si on veut afficher des nombres décimaux, nous pouvons simplement utiliser les locales default et nous obtenons:

System.out.println("Locale: " + Locale.getDefault().toString());
NumberFormat nf = NumberFormat.getNumberInstance(Locale.getDefault());
DecimalFormat df = (DecimalFormat)nf;
System.out.println("Locale default : " + df.format(123456.789));

et on obtient un résultat qui ne prend pas en compte notre paramétrage du poste :

Du coup si vous souhaitez exporter des nombres décimaux selon la préférence de l’utilisateur, un moyen de faire est d'aller lire ces données via le Kernel32 (cette méthode est très fortement inspirée de ce qui est fait dans IntelliJ)

import com.sun.jna.Native;

(...)

private interface Kernel32 extends com.sun.jna.win32.StdCallLibrary {
        int LOCALE_SDECIMAL = 0x0000000E;
        int LOCALE_STHOUSAND = 0x0000000F;

        int GetLocaleInfoEx(String localeName, int lcType, char[] lcData, int dataSize);
        int GetLastError();
}

static void getNbFormat() {
        Kernel32 kernel32 = (Kernel32) Native.loadLibrary("Kernel32", Kernel32.class);
        int bufferSize = 128, rv;
        char[] buffer = new char[bufferSize];

        rv = kernel32.GetLocaleInfoEx(null, Kernel32.LOCALE_SDECIMAL, buffer, bufferSize);
        if (rv < 2) throw new IllegalStateException("GetLocaleInfoEx: " + kernel32.GetLastError());
        System.out.println("Decimal sep: " + new String(buffer, 0, rv - 1));

        rv = kernel32.GetLocaleInfoEx(null, Kernel32.LOCALE_STHOUSAND, buffer, bufferSize);
        if (rv < 2) throw new IllegalStateException("GetLocaleInfoEx: " + kernel32.GetLastError());
        System.out.println("Thousands sep: " + new String(buffer, 0, rv - 1));
}

Il faut surement rajouter dans votre pom.xml :

<dependency>
    <groupId>com.sun.jna</groupId>
    <artifactId>jna</artifactId>
    <version>3.0.9</version>
</dependency>

et vous obtenez

à partir desquelles vous pouvez redéfinir le pattern d'affichage de vos nombres décimaux qui prendra bien en compte les paramètres du poste utilisateur (comme le fait Excel par exemple).

Ressources :

- Cover photo by Bruno Martins

Nous allons présenter une découverte des APIs Matrix pour communiquer dans un salon.

Matrix est un système de communication distribué et crypté. Il vient d'être implémenté par l'état français comme système de messagerie interne. Le server principal (Synapse) peut-etre auto-hébergé ou bien publique. Il existe de nombreux clients et le plus connu est riot, sur lequel vous pouvez créer un compte. Cette plateforme est ouverte, modulaire et pensée comme un socle pour éventuellement bien plus que de la simple communication de messages (ils ont l'intention de réinventer le web, rien que ça).

Prérequis

Il faut un compte sur un server Matrix. Allez sur riot et vous pouvez créer un compte gratuit.

Dans le cadre de cet article, nous avons créé un salon dédié.

Et il faut ensuite Go > 1.11 installé pour pouvoir utiliser les modules.

Le code

Vous pouvez simplement cloner le repo du projet depuis mon compte github. Vous devez ajouter un fichier riot.pass contenant le mot de passe de votre compte (à éviter de le publier sur un compte git publique...).

Pour simplifier le code, plusieurs variables sont directement dans le code:

1. La base_url : est l'addresse du serveur Matrix sur lequel vous vous connectez. Attention, ici le seveur est matrix.org et le client est riot.

2. L'id du salon (ou room en anglais) est donc l'identifiant du salon que vous retrouvez à la fin de l'adresse ci-dessus.

1) La connexion au server

Le serveur Matrix met à disposition des API avec leur documentation via swagger. Tous les échanges se feront donc en API REST Json avec un échange de token JWT que nous récupérons à l'authentification.

Pour se connecter:

// nous lisons le mot de passe depuis le fichier riot.pass à la racine du projet
pwd := getPasswordFromFile()

// nous préparons une requete post avec en body un json contenant le login et mot de passse
	resp, err := resty.R().
		SetHeader("Content-Type", "application/json").
		SetBody([]byte(`{
		"identifier": {
		  "type": "m.id.user",
		  "user": "` + user + `"
		},
		"initial_device_display_name": "Jungle Phone",
		"password": "` + pwd + `",
		"type": "m.login.password"
	  }`)).
		// SetResult(&AuthSuccess{}).
		Post("https://" + BaseURL + "/_matrix/client/r0/login")

	checkErr(err, "Could not authenticate")
	// fmt.Println(resp, err)

// nous deserialisons la réponse
	var lr loginResponse
	err = json.Unmarshal(resp.Body(), &lr)
	checkErr(err, "Could not decode json of authentication")

	// fmt.Println(lr.Access_token)
	return lr.AccessToken

2) Lecture des 10 derniers messages du salon

Pour lire les messages, il faut envoyer une requete GET au serveur en passant le token et l'identifiant du salon. On limite le nombre de messages directement dans la requête:

// Point d'entrée pour la récupération des messages
respMsg, err := resty.R().Get("https://" + BaseURL + "/_matrix/client/api/v1/rooms/" + RoomID + "/messages?access_token=" + token + "&from=END&dir=b&limit=10")
checkErr(err, "Could not get the messages from matrix API")
// fmt.Printf("%s\n\n---------------\n", respMsg)

// On parse le message reçu à l'aide fastjson
var p fastjson.Parser
m, err := p.Parse(string(respMsg.Body()))
checkErr(err, "Could not decode json of messages")
vals := m.GetArray("chunk")
for _, val := range vals {
fmt.Printf("  (%s) > %s\n", val.GetStringBytes("sender"), val.GetStringBytes("content", "body"))
}

et en l'executant go run main.go on obtient les messages (en fait ici il n'y a en a eu qu'un seul):

3) Envoie de messages dans le salon

Comme c'est un peu vide, nous allons envoyer des messages dans le salon. On reprend la doc des APIs et cette fois on envoie une requete en POST avec le contenu du message dans le body:

respMsg, err := resty.R().
		SetHeader("Content-Type", "application/json").
		SetBody([]byte(`{"msgtype":"m.text", "body":"` + msg + `"}`)).
		Post("https://" + BaseURL + "/_matrix/client/r0/rooms/" + RoomID + "/send/m.room.message?access_token=" + token)

	checkErr(err, "Could not post the message")
	fmt.Println(respMsg)

et nous ajoutons les appels dans le main

Voici 2 exemples d'utilisation des APIs matrix en GO mais n'hésitez pas à consulter la doc swaggers pour découvrir toutes les autres possibilités.

Une liste de resources, articles, librairies pour le développement en Go. Nous les avons testés et implémentés et avons validé leur intérêt. Ce post sera mis à jour au fur et à mesure.

[NDLR] Quand on aborde une problématique (parsing de json, sécurité...) il y a plusieurs approches possibles qui dépendent du contexte :

• vous codez directement la solution, si possible en s'appuyant sur des patterns de programmation : cela à l'avantage de garder votre code concis et minime en ne répondant qu'à votre problématique et vous facilite les optimisations éventuelles; à contrario vous réinventez la roue et pour des algos plus complexes peut être moins optimal qu'une lib développée par une équipe le ferait.
• vous utilisez une librairie externe : cela à l'avantage de traiter plus de cas d'usages en une fois (quand la lib a été éprouvée) mais à l'inconvénient d'ajouter des dépendances et augmente la taille de vos projets.

Lib pour gérer les paramètres de ligne de commande mais oblige à suivre leur paradigme. De nombreux gros projets l'utilisent (docker, kubernetes, istio...)
- https://github.com/spf13/cobra

Lib pour charger facilement des paramètres d'un fichier de config
- https://github.com/joho/godotenv

Lib pour traiter le JSon plus facilement et sans créer de struc:
- https://github.com/valyala/fastjson

Lib pour consommer des APIs REST, resty :
- https://github.com/go-resty/resty

Lib qui implemente les principaux patterns de messaging (pub/sub, req/rep, push/pull...):
- https://github.com/nanomsg/mangos

Lib pour implémenter un réseau P2P:
- https://github.com/libp2p/go-libp2p

Lib pour construire des microservices (ou de jolis monoliths) :
- https://gokit.io/

Framework de site web en go :
- https://gobuffalo.io/fr

Framework de tests de validation :
- https://agouti.org/

Vous aimez bien les pages github qui permettent d'avoir des sites static (ie. sans techno server) pour de la présentation de projet ou de la documentation. Seulement vous souhaitez les garder sur un réseaux privé. Nous vous présentons ici une solution en installant Jekyll, un thème sympa, la génération de la doc en PDF et un exemple de workflow pour la mise à jour de la doc.

1/ Installation de Jekyll

Jekyll est un moteur de site statique qui permet d'écrire ses pages en Markdown. C'est aussi le moteur sous le capot des github pages.

Sur votre serveur de publication, nous construisons une image Docker à partir de celle disponible sur le hub et ce afin d'y ajouter quelques libs :

FROM jekyll/jekyll:3.8.5

RUN echo "Install extra libs" \
&& apk --update add build-base ruby-dev \
&& gem install bundler \
&& gem install jekyll-paginate \
&& gem install jekyll-gist \
&& gem install redcarpet

Puis nous lançons l'image construite avec la commande docker build -t goovy/jekyll:1.0 . par ce script:

docker run -d \
	    	--restart=unless-stopped \
  	    	--volume="$PWD/doc-site:/srv/jekyll" \
	    	-e "JEKYLL_ENV=prodcution" \
	    	-p 80:4000 \
		--name doc-site \
  	    	goovy/jekyll:1.0 \
	    	jekyll serve --watch

Testez votre déploiement en allant sur localhost et vous devriez avoir ceci:

2/ Utilisation d'un thème sympa

Il existe plein de thèmes mais celui de idratherbewriting.com est plutôt pas mal et complet: Une topnav pour une navigation principale, un second menu contextuel sur le côté et le contenu au centre. Il explique bien l'installation donc pour faire simple:

• clonez (ou downloadez) le thème et copiez l'intégralité dans le volume docker (doc-site)
• supprimez les 2 fichiers Gemfile et Gemfile.lock
• démarrez l'image docker

et vous devriez avoir ceci :

3/ Un exemple de workflow de travail

Maintenant que le site de la doc est en place, comment ajouter du contenu. L'idée est de maintenir sa doc comme son code (ie. versionné avec git). Dès que la documentation est validée (push dans le remote) nous souhaitons avoir le site à jour. Le problème est que le site est hébergé sur un serveur, que notre doc est écrite sur des postes de travail. C'est là que les git hooks viennent à notre secours (un hook est un crochet appelé par le système sous-jacent, ici git, à des étapes précises).

Résumé du workflow:

Commençons par la droite du schema ci-dessus en configurant la publication automatique. Sur le server d'hebergement de la doc, il faut d'abord créer un répertoire dédié pour le repo git qui contient les scripts des hooks.

// initialize the git repo folder
$ git init --bare doc-repo.git

et vous voila avec le répertoire ci-dessous:

Les hooks sont des scripts se trouvant dans le répertoire "hooks"... Celui qui nous intéresse est le post-receive. Il suffit d'avoir ce fichier ainsi nommé et après un push il sera automatiquement exécuté par git.

Nous copions le code mis à jour dans le répertoire de Jekyll et affichons un message de retour à la personne qui a pushé.

Contenu du fichier post-receive (remplacez les "xxx" par votre chemin) :

#!/bin/bash
#
# Script to copy the push received into the doc-site (production) folder

while read oldrev newrev ref
do
    if [[ $ref =~ .*/master$ ]];
    then
        echo -e "\nMaster ref received.  Deploying master branch to the website in production...i\n"

echo "      _                                _       _           _  "
echo "     | |                              | |     | |         | | "
echo "   __| | ___   ___     _   _ _ __   __| | __ _| |_ ___  __| | "
echo "  / _  |/ _ \ / __|   | | | | '_ \ / _  |/ _  | __/ _ \/ _  | "
echo " | (_| | (_) | (__    | |_| | |_) | (_| | (_| | ||  __/ (_| | "
echo "  \__,_|\___/ \___|    \__,_| .__/ \__,_|\__,_|\__\___|\__,_| "
echo "                            | |                               "
echo "                            |_|                               "


        git --work-tree=/home/xxx/Jekyll/doc-site --git-dir=/home/xxx/Jekyll/doc-repo checkout -f
    else
        echo "Ref $ref successfully received.  Doing nothing: only the master branch may be deployed on this server."
    fi
done

Coté client, il faut ajouter un git remote vers le serveur de publication. Ainsi, lors d'un git push, il va à la fois publier vers le repository central (un gitlag, github, bitbucket...) et vers le serveur Jekyll.

Dans votre répertoire de travail, vous devez avoir une copie du thème précédent. Initialisez git et ajoutez "_site" (version compilée du site) dans le fichier .gitignore.
Ajoutez le remote vers votre repository central. Vous devriez avoir ceci:

Ajoutez un remote vers votre serveur de documentation (localhost dans cet exemple) en push uniquement. On veut publier sur 2 serveurs en même temps mais faire un fetch que du repo central (gitlab dans l'exemple).

Pour ajouter le remote:

// ajoutez l'url déjà présente (bizarre mais sans cela git remplace malgré le --add)
# git remote set-url --add --push origin git@gitlab.com:user/doc-repo.git
// ajoutez la seconde url
# git remote set-url --add --push origin ssh://user@localhost/doc-repo.git

et vous pouvez vérifer avec git-remote -v :

Modifiez ensuite un fichier dans votre répertoire de travail (par exemple le fichier index.md), committez et pushez et vous obtiendrez ce message et le site sera également à jour !

4/ Génération de PDF

Nous utilisons Prince qui utilise des feuilles de styles CSS pour la mise en page et qui sont déjà prise en compte dans notre thème Jekyll.

Il y a aussi des scripts shell pour l'utilisation de Prince mais nous allons les adapter pour les utiliser avec le container. Nous générons le pdf dans un process à part avec une instance différente du site :

1. pour cela nous stoppons le site
2. nous démarrons une instance dédiée à la génération du PDF
3. nous lançons la génération du PDF
4. nous revenons ensuite sur le site de départ.

L'instance dédiée pour le PDF se lance avec le script suivant:

#!/bin/sh

docker run      -d \
                -v $PWD/doc-site:/srv/jekyll \
                -p 4010:4010 \
                --name doc-site-pdf \
                -e "JEKYLL_ENV=production" \
                goovy/jekyll:1.0 jekyll serve --config _config.yml,pdfconfigs/_config_mydoc_pdf.yml

Pour la génération via PrinceXML, nous devons créer une image docker avec ce Dockerfile

# Container for PrinceXML (tools to generate PDF file)
# Used with Jekyll for the documentation website
FROM ubuntu:16.04
VERSION=prince_12.5-1_ubuntu16.04_amd64.deb
RUN \
        DEBIAN_FRONTEND=noninteractive apt-get update && \
        apt-get install -y wget && \
        wget -q https://www.princexml.com/download/$VERSION && \
        dpkg -i --force-depends $VERSION && \
        apt-get install -yf

# Define default command.
CMD ["prince"]

que nous exécutons ensuite par ce script:

#!/bin/sh

docker run      -it --rm \
                -v $PWD/doc-site:/data \
                --link doc-site-pdf:localhost \
                goovy/princexml \
                prince --javascript --input-list=/data/_site/pdfconfigs/prince-list.txt -o /data/pdf/mydoc.pdf

N'oubliez pas de stopper l'instance dédiée au PDF et de redémarrer celle normale. Il doit être possible de lancer les 2 en même temps et d'automatiser mieux cette partie, ce qui vous fera un bon exercice.

Voici un petit docker-compose que j'utilise régulièrement en développement pour importer des données dans un MySQL local pour faire une analyse rapide des données ou plus.

Il vous faudra préalablement avoir installé docker et docker-compose

Le docker compose crée un volume persistent docker pour MySQL, ce qui permet de pouvoir redémarrer le docker compose tout en ayant conservé les données.

Puis le script démarre 3 composants :

• MySQL
• Adminer
• PHPMyAdmin
  mais vous devrez choisir si vous voulez utiliser AdMiner (petit utilitaire très simple pour voir la base de données et faire des requêtes) ou PHPMyAdmin. On vous rappelle que pour des raisons évidentes de sécurité, il ne faut pas avoir de PHPMyAdmin en prod!

# mysql-stack.yml

version: '3.7'

services:

  db:
    image: mysql
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_DATABASE: testDB
      MYSQL_USER: testDB
      MYSQL_PASSWORD: testDB
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - testDB:/var/lib/mysql
    ports:
      - 3306:3306

  adminer:
    image: adminer
    restart: always
    ports:
      - 8085:8080
      
  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    restart: always
    ports:
      - 8086:80

volumes:
  testDB:

Pour lancer les composants

docker-compose -f mysql-stack.yml up -d

Pour arrêter les composants

docker-compose -f mysql-stack.yml down

Note 1

J'expose le port 3306 de MySQL localement pour pouvoir m'y connecter avec mon code en développement

Note 2

Lorsque vous supprimez le container, si vous voulez supprimer les données aussi n'oubliez pas de supprimer le volume. Dans notre cas d'exemple :

docker volume rm testDB

Puis pour vérifier

docker volume ls