dimanche 31 décembre 2023

Multi cloud data & apps: snowflake

 Snowflake est une plate-forme data s'adossant sur les trois clouds les plus utilisés: aws, azure et gcp. C'est désormais un produit abouti en termes d'instanciation data du multi-cloud. Il dispose aussi de fonctionnalités data sharing très avancées pour partager la donnée entre différents comptes cloud à travers le monde.

Cette première étape achevée, il se lance désormais dans la construction d'un écosystème équivalent pour les apps en s'appuyant sans surprise sur les container services ou les native apps. Cette deuxième étape si elle réussit sera très fructueuse car le marché des apps offre bien plus d'opportunités que la distribution de la data.

Les container services sont désormais disponibles en public preview.

Pour découvrir Snowflake, une série de liens:

- doc Snowflake

- blog Snowflake

- handlab Snowflake

vendredi 10 mars 2023

Observabilité

Un outil intéressant à étudier pour l'observabilité d'un système IT est Prometheus.

Schéma d'archi générale: 


Par l'intermédiaire d'exporters, il permet de regrouper les métriques de plusieurs systèmes ( bases de données, hardware, systèmes de messages, stockage de données, API, ... ) dans une TSDB ( Time Series DataBase ) pour ensuite les diffuser vers des outils d'alertes ou des outils de visualisation, en particulier Grafana, lui-même disposant d'un alert manager pour info.

Comme l'indique cette best practise, éviter d'utiliser le module Pushgateway. En particulier, si l'exporter n'existe pas pour le système à monitorer, soit vous pouvez créer en un, soit vous pouvez utiliser l'option textfile Collector du node exporter.

Elle permet de récupérer les métriques d'un système tiers, ces dernières étant créées par batch. Elles doivent respecter le format d'exposition de Prometheus.

Pour illustrer ce dernier point, voici un exemple de génération de métriques de type CPU:

!/bin/bash
# mpstat 15 >> mpstat.stat
MPSTAT_FILE=./mpstat.stat

DATE_FILE=`date +%F-%T`
METRIC_FILE=./metric.prom.${DATE_FILE}
> ${METRIC_FILE}

# Déclaration des métriques de type cpu
echo '# HELP node_cpu_user node cpu user' >> ${METRIC_FILE}
echo '# TYPE node_cpu_user gauge' >> ${METRIC_FILE}
echo '# HELP node_cpu_sys node cpu user' >> ${METRIC_FILE}
echo '# TYPE node_cpu_sys gauge' >> ${METRIC_FILE}
echo '# HELP node_cpu_idle node cpu user' >> ${METRIC_FILE}
echo '# TYPE node_cpu_idle gauge' >> ${METRIC_FILE}
echo '# HELP node_cpu_wait node cpu user' >> ${METRIC_FILE}
echo '# TYPE node_cpu_wait gauge' >> ${METRIC_FILE}

LAST_LINE=`cat ${MPSTAT_FILE} | tail -n 1 | tr -s ' '`

CPU_USER=`echo ${LAST_LINE} | cut -d ' ' -f 3 | sed 's/,/./'` 
CPU_SYS=`echo ${LAST_LINE} | cut -d ' ' -f 5 | sed 's/,/./'`
CPU_IDLE=`echo ${LAST_LINE} | cut -d ' ' -f 12 | sed 's/,/./'`
CPU_WAIT=`echo ${LAST_LINE} | cut -d ' ' -f 6 | sed 's/,/./' `
 
# Valeur des métriques de type cpu   
echo "node_cpu_user ${CPU_USER}" >> ${METRIC_FILE}
echo "node_cpu_sys ${CPU_SYS}" >> ${METRIC_FILE}
echo "node_cpu_idle ${CPU_IDLE}" >> ${METRIC_FILE} 
echo "node_cpu_wait ${CPU_WAIT}" >> ${METRIC_FILE}

# Copie du fichier des métriques dans le répertoire du node exporter 
PROM_FILE=~/metrics/metric.prom
> ${PROM_FILE}
cp ${METRIC_FILE} ${PROM_FILE}

Pour stresser une VM sur différents aspects ( CPU, mémoire, disque, socket, ... ), il existe deux outils stress et stress-ng pour le faire.

vendredi 3 mars 2023

Kafka

 Sur le sujet, un livre:

Kafka: The Definitive Guide

Real-Time Data and Stream Processing at Scale

Gwen Shapira, Todd Palino,Rajini Sivaram & Krit Petty

et un site didactique: https://www.conduktor.io/kafka/

jeudi 20 octobre 2022

Création d'un usage dans le cloud

Je vais tenter d'apporter quelques éléments de réflexion sur le sujet après deux ans d'expérience.

Tout d'abord, le contexte, cet usage est critique car il permet le financement de commerçants à travers l'Europe ce qui leur permet de disposer d'une réserve de trésorerie au quotidien. On n'est plus sur un usage analytique souvent mis en place sur le cloud mais sur une application critique de type batch.

Cet usage s'appuie sur une plate-forme data hébergée par Google ( gcp ). Elle a été construite les précédentes années à partir d'outils comme Terraform et Ansible. 

Elle s'appuie sur un modèle en trois couches:

- une infrastructure commune à tous les usages;

- un socle technique délivrant des composants techniques génériques multi-usages ( ingestion de fichiers ou de messages, transformation et calcul de la donnée, export de données ... )

- une couche usage utilisant les composant techniques pour instancier des usages définis par le métier

Cette séparation entre la couche technique et la couche usage est intéressante car elle permet d'isoler le code métier du code technique et d'enrichir les composants techniques au-fur-et-à-mesure de l'ajout d'usages tout en assurant l'unicité de la couche technique.

De plus, on peut alors distinguer deux types de développeur, les développeurs du socle technique, des profils plus pointus des développeurs de la couche usage, des personnes technico-fonctionnelles pouvant développer des usages dans un canevas préétabli et nécessitant moins de connaissances techniques.

Pour illustrer mes propos, sur le projet où je travaillais, les développeurs du socle technique codent et testent unitairement des composants écrits en Java sur un poste de dev, puis déploient les composants dans des pods kubernetes.

Les développeurs usage codent des dags Airflow qui se résument à des séquences d'appels aux composants du socle technique, il ne reste plus qu'à gérer les paramètres en fonction du contexte métier. Les traitements métiers sont, quant à eux, écrits dans un langage SQL enrichi avec des tags. Les tags permettent d'avoir des traitements métiers multi-usages, par exemple gérer une problématique multi-pays.

Ce type d'architecture permet d'avoir certes un pool restreint de développeurs pointus, mais surtout permet le développement rapide d'usages en se consacrant uniquement aux règles métiers à traduire sans se préoccuper des problématiques techniques sous-jacentes.

On pourrait même envisager d'aller plus loin en proposant une interface de règles métier dans la mesure où les règles métier sont traduites dans un langage déclaratif paramétré. On aurait ainsi un usage qui est capable de se modifier en temps réel ( pas de compilation, pas de déploiement, ... ). Une forme de nocode directement accessible aux équipes métier 😉


dimanche 29 mai 2022

Data & Distributed systems

 Best ressources to learn about data and distributed systems

Data & distributed systems

JVM dans container

Une vidéo très détaillée sur le fonctionnement des JVM dans un container avec un focus sur la gestion de la mémoire.

JVM & container 

jeudi 11 novembre 2021

Apache Beam: traitement unifié de la donnée en mode batch et streaming

 Une présentation claire de Frances Perry sur Apache Beam: Apache Beam: Portable and Parallel Data Processing (Google Cloud Next 17)

L'implémentation Google du modèle Beam toujours présentée par Frances Perry: Dataflow: A Unified Model for Batch and Streaming Data Processing