Skip to content

Blogs de Développeurs: Aggrégateur de Blogs d'Informatique sur .NET, Java, PHP, Ruby, Agile, Gestion de Projet

Forum Logiciel

Forum Logiciel : diffusion de connaissance et d’informations sur toutes les activitĂ©s liĂ©es au dĂ©veloppement d’applications informatiques en entreprise.

Agrégateur de flux

What’s the fuss about FaaS?

ekito people - il y a 12 heures 5 min

The recent blog post about Serverless Architectures by Mike Roberts caught my attention. Furthermore, ekito recently developed, a video on demand service whose technical architecture is serverless. Consequently I decided to have my own take on Serverless Architectures based on FaaS (Functions as a Service).

In this blog post I will demonstrate how to develop a simple FaaS that is triggered by a REST API. I will show how to define an API using a description in a contract first approach. Then, the API will be deployed to Amazon’s API Gateway. In the gateway, I will configure a mapping that extracts data from API requests and transforms them to event objects. Those event objects are then passed to Amazon Lambda.

In the second part I will provide some feedback on load testing the service I developed. You will get some insights to observed round trip latencies and API Gateway rate limiting behaviour.

But first what’s all that fuss about FaaS?


A Function as a Service (FaaS) is some stateless business logic that is triggered by a stimulus. The logic of the function is applied to its inputs; the result is returned. A FaaS can have side effects. For example, it can trigger another function or communicate with third party services.

For FaaS to execute, they are bound to triggers. Therefore they become versatile building blocks that can act as a stored procedure on database tables, be triggered on file system changes, act as workers on messaging queues or act as controllers behind a REST API.

FaaS are packaged and deployed to a cloud provider. FaaS usage is generally billed by the number of invocations and by the amount of computing resources consumed during the execution of a function call.

What makes FaaS so attractive is their simple programming, packaging and deployment model. Their capacity of being natively elastic, resulting in linear scalability in terms of performance and operational costs makes them outstanding. Furthermore, the FaaS deployment model does not require any execution platform, middleware, container or virtual machine. Operational maintenance is completely outsourced to cloud providers (NoOps).

Building the HelloWorld function

Amazon Lambda accepts functions implemented in JavaScript (Node.js), Python and Java 8. By consequence, it is also possible to write a function in Scala or any other programming language based on Java 8.

Willing to write a little bit of Scala, I decided to follow this blog post for implementing my function.

Project Initialization

First, let’s initialize a Scala project with the following build.sbt file at the project root:

name := "AWSLambdaTest"
version := "1.0"
scalaVersion := "2.11.8"
libraryDependencies += "com.amazonaws" % "aws-lambda-java-core" % "1.1.0"
libraryDependencies += "com.fasterxml.jackson.module" % "jackson-module-scala_2.11" % "2.7.5"
javacOptions ++= Seq("-source", "1.8", "-target", "1.8", "-Xlint")
assemblyMergeStrategy in assembly := {
  case PathList("META-INF", xs@_*) => MergeStrategy.discard
  case x => MergeStrategy.first

Note that we instruct sbt expressively to build Java 8 byte code. The build script also contains the assembly strategy of the SBT assembly plugin.

The assembly plugin is configured in LambdaTest/project/plugins.sbt as follows:

addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.3")

In order to build and package the project, use the command sbt assembly. The resulting jar resides at LambdaTest/target/scala-2.11/AWSLambdaTest-assembly-1.0.jar.

What struck me was the size of the jar file (12.4MB) given that we are writing a mere hello world function. It turns out that all Scala byte code classes are included in the jar. In practical terms, this size can have an impact on the upload time to AWS (timeout after 61s) and the number of functions one can deploy per user account and region (max. storage space for all lambdas in one region is 1.5GB). Should this really become an issue, consider spreading your deployments across different regions, consider using directly Java 8 or an interpreted language with a smaller footprint (Node.js or Python).

Programming model

We implement functions within a handler with a name of your choice. The function signature can take several forms, always defining an input and an output. Amazon Lambda accepts the following input and output types:

  • Simple Java types (AWS Lambda supports the String, Integer, Boolean, Map, and List types)
  • POJO (Plain Old Java Object) type
  • Stream types (InputStream / OutputStream)

Amazon Lambda ignores return value of asynchronously invoked functions. In this case, do consider using the void return type instead.

When using POJOs, Amazon Lambda serializes and deserializes based on standard bean naming conventions. One must use Mutable POJOs with public getters and setters. Annotations are ignored.

When developing AWS Lambdas in Scala, type conversions between Scalaisms and Javaisms must be implemented for non-primitive types. Alternatively, stream types for inputs and outputs can be used. In that case, it is the responsibility of the function handler to marshall and unmarshall inputs and outputs. At a first look this approach seems a little cumbersome. However, it is in my opinion the most stable strategy when opting for Scala. I am not inventing anything here. It is coming straight from this tutorial I was following.

package io.ekito.lambdaTest
case class NameInfo(firstName: String, lastName: String)
class Main {
  import{InputStream, OutputStream}
  val scalaMapper = {
    import com.fasterxml.jackson.databind.ObjectMapper
    import com.fasterxml.jackson.module.scala.DefaultScalaModule
    new ObjectMapper().registerModule(new DefaultScalaModule)
  def hello(input: InputStream, output: OutputStream): Unit = {
    val name = scalaMapper.readValue(input, classOf[NameInfo])
    val result = s"Greetings ${name.firstName} ${name.lastName}."

The complete source code is available on Github.


With the code in place, call:

$> sbt assemby

Now lets deploy the artifact. You can do this via the CLI or the console; below I’ve illustrated what it looks like in the AWS console. Skip the steps ‘Select BluePrint’ and ‘Configure Triggers’ to arrive at the following screen:


I am using the default suggestions for memory, duration, and role (basic execution). Note the handler: io.ekito.lambdaTest.Main::hello. Click ‘Create Lambda function’ and you should be ready to test.


At this point the function should be fully operational. First configure a JSON object of the test event:


Now you can test it by sending a JSON event object as illustrated here:


As you can see, valuable information about execution duration, billed duration the used memory is displayed. Based on those values, we can reduce the amount of configured memory from 512MB to 128MB. Interesting is also that an initial invocation can take up to 2 seconds. There is somewhat of a warmup taking place. Execution times upon subsequent invocations are pretty short: ~ 0.6ms. However, the smallest billing period being 100ms, Amazon bills us for resources that we are actually not using

Catégories: Blog Société

Kafka Streams : encore un framework de stream processing ?

Dans les papiers des ingĂ©nieurs de depuis 2015, Kafka 0.10 est sorti en mai 2016. Peu aprĂšs la sortie de la version 0.9 qui introduisait principalement l’API Kafka Connect, la version 0.10 apporte elle un composant majeur : Kafka Streams.

Encore un autre framework de stream processing ?

Il faut dire que depuis quelques annĂ©es, de nombreux frameworks de stream processing orientĂ©s “big data” ont Ă©mergĂ©. Capables d’évoluer dans l’écosystĂšme Hadoop comme dans des environnements plus divers, les principaux “open-source” sont Samza, Storm, Spark, Flink ou encore plus rĂ©cemment HĂ©ron. Bien souvent, ces frameworks Ă©voluent de deux façons : soit ils montent en flĂšche, soit ils stagnent puis pĂ©rissent, Ă©crasĂ©s par d’autres moteurs dĂ©livrant des meilleures performances, une meilleure API, ou bien une meilleure stabilitĂ©. La concurrence est fĂ©roce, alors pourquoi ajouter sa pierre ?


Google trends

Tendances Google Trends de 2005 Ă  2016 : Storm s’essouffle, Spark et Flink s’envolent, Kafka Streams dĂ©marre


Les cas d’usage streaming sont nombreux. Dans certains cas, utiliser un framework de stream processing peut ĂȘtre exagĂ©rĂ©, car sa mise en place est synonyme d’un ou plusieurs middlewares de plus (habituellement un systĂšme master/slave), d’un gestionnaire de ressources, d’un grand nombre de dĂ©pendances, d’une nouvelle API Ă  maĂźtriser, de complexitĂ© opĂ©rationnelle

À l’inverse, utiliser les librairies clientes de Kafka et traiter les donnĂ©es « Ă  la main » en dĂ©veloppant sa propre application peut ĂȘtre fastidieux. GĂ©rer la distribution, le sharding, l’ajout ou le retrait de ressources Ă  chaud, la reprise sur erreur ou le redĂ©ploiement applicatif sont des vrais sujets.

Kafka Streams se positionne au juste milieu en venant proposer une librairie ultra-lĂ©gĂšre, complĂštement basĂ©e sur les clients Kafka, ainsi qu’une API, Kafka Streams DSL qui permet Ă  l’utilisateur de dĂ©crire d’une maniĂšre fonctionnelle les opĂ©rations Ă  effectuer sur les flux, tout en abstrayant la maniĂšre dont cela est rĂ©alisĂ©. L’API en Java 8 permet un code Ă©lĂ©gant et lĂ©ger, notamment grĂące aux lambdas.

Exemple de code

Avant de dĂ©tailler les possibilitĂ©s offertes par l’API, prenons un exemple. Nous avons en entrĂ©e un flux Kafka d’évĂšnements dĂ©crivant des achats, contenant un identifiant de produit et le prix d’achat de ce produit. Une table rĂ©fĂ©rentiel permet d’associer le libellĂ© d’un produit Ă  son identifiant. Nous voulons en sortie un flux enrichi du libellĂ© produit, c’est Ă  dire un flux dĂ©normalisĂ© contenant l’identifiant produit, le libellĂ© correspondant Ă  ce produit et son prix d’achat. Voici un exemple de code pour rĂ©pondre Ă  ce problĂšme :

// Initialisation des ser/déserialiseurs pour lire et écrire dans les topics
Serde<ProduitBrut> produitBrutSerde = Serdes.serdeFrom(new JsonSerializer<>(), new JsonDeserializer<>(ProduitBrut.class));
Serde<ProduitEnrichi> produitEnrichiSerde = Serdes.serdeFrom(new JsonSerializer<>(), new JsonDeserializer<>(ProduitEnrichi.class));
Serde<Referentiel> referentielSerde = Serdes.serdeFrom(new JsonSerializer<>(), new JsonDeserializer<>(Referentiel.class));

// Création d'un KStream (flux) à partir du topic "achats"
KStream<String, ProduitBrut> achats =, produitBrutSerde, "achats");

// Création d'une KTable (table) à partir du topic "referentiel"
KTable<String, Referentiel> referentiel = builder.table(Serdes.String(), referentielSerde, "referentiel");
KStream<String, ProduitEnrichi> enriched = achats
    // Re-partitionnement du flux avec la nouvelle clé qui nous permettra de faire une jointure
    .map((k, v) -> new KeyValue<>(v.getId().toString(), v))
    // Jointure du flux d'achats avec le rĂ©fĂ©rentiel
    .leftJoin(referentiel, (achat, ref) -> {
        if (ref == null) return new ProduitEnrichi(achat.getId(), "REF INCONNUE", achat.getPrice());
        else return new ProduitEnrichi(achat.getId(), ref.getName(), achat.getPrice());

// On publie le flux dans un topic "achats-enrichis", produitEnrichiSerde, "achats-enrichis");

// Enfin, on démarre l'application
KafkaStreams streams = new KafkaStreams(builder, streamsConfiguration);

Avant de rentrer dans les dĂ©tails, oĂč est-ce que ce morceau de code va-t-il ĂȘtre exĂ©cutĂ© ?

Le cluster le plus simple du monde

À premiĂšre vue, ce n’est pas trĂšs clair, on se demande si la version 0.10 de Kafka inclut dans chacun des brokers des exĂ©cuteurs permettant de traiter les streams. Cela serait pratique du point de vue opĂ©rationnel, mais douteux car les performances des brokers pourraient ĂȘtre dĂ©gradĂ©es par les exĂ©cuteurs co-localisĂ©s.

Et bien, non ! Les brokers n’embarquent pas d’exĂ©cuteurs. Les applications KStreams sont en fait standalones : ce sont de simples programmes Java pouvant ĂȘtre dĂ©ployĂ©s en parallĂšle sur plusieurs machines. Chaque application KStreams est donc un ensemble de JVMs qui elles mĂȘmes contiennent un ou plusieurs “stream threads” : ce sont les threads qui sont en charge d’exĂ©cuter les diffĂ©rentes tĂąches de la topologie dĂ©finie par l’utilisateur. Les diffĂ©rentes JVMs d’une mĂȘme application KStreams (et mĂȘme les stream threads d’une mĂȘme JVM) ne communiquent pas entre eux ! Chaque stream thread fonctionne de maniĂšre indĂ©pendante vis Ă  vis des autres stream threads. Pour des raisons de simplification, nous appellerons un stream thread “exĂ©cuteur”. Nous pouvons alors dire qu’une application est constituĂ©e d’un ensemble d’exĂ©cuteurs rĂ©partis sur une ou plusieurs JVMs.


RĂ©partition de deux applications KStream entre plusieurs machines

Comment ça marche, « under the hood » ?

Kafka est un systĂšme dont les Ă©tudes montrent qu’il est capable d’absorber de grandes quantitĂ©s de messages en peu de temps par rapport Ă  d’autres messagers. Mais c’est aussi un systĂšme dont il faut tirer parti du design pour ne pas plomber ses performances. Nous allons prendre le simple exemple d’une jointure pour dĂ©crire le cheminement de la donnĂ©e et comprendre comment un tel systĂšme peut « scaler » quasi linĂ©airement.

Partons de la base. La plus petite unité de parallélisme dans un topic Kafka est la partition. Le nombre de partitions représente le potentiel de parallélisme. Chaque partition est possédée par un seul broker Kafka, et un Broker Kafka peut posséder plusieurs partitions. 

Partitions-brokers (1)

RĂ©partition partitions-brokers

Le partitionnement est régi ainsi :

  • C’est le producteur d’un message qui, via la clĂ© du message et un partitionneur dĂ©termine dans quelle partition le message va ĂȘtre envoyĂ©. Nous utiliserons le partitionneur par dĂ©faut pour tous nos producteurs, pour tous les topics.
  • Deux topics ayant le mĂȘme nombre de partitions sont partitionnĂ©s identiquement. C’est Ă  dire que si deux messages dans deux topics A et B ont la mĂȘme clĂ©, alors le numĂ©ro de la partition du topic A contenant le premier message est le mĂȘme que celui de la partition du topic B contenant le deuxiĂšme message.
kafka-meme-clé-meme-partition (1)

MĂȘme partitionnement pour deux topics = les mĂȘmes clĂ©s se retrouvent dans les mĂȘmes numĂ©ros de partition

L’opĂ©ration de jointure est une opĂ©ration par clĂ©. Dans ce cas, le partitionnement garantit que joindre deux flux revient Ă  joindre une Ă  une chacune des partitions de ces flux entre elles. Si les flux ont chacun n partitions, la jointure peut alors s’effectuer avec un degrĂ© de parallĂ©lisme de n. En revanche, si les flux n’ont pas le mĂȘme nombre de partitions, il sera impossible de faire la jointure ! Et c’est sur ce principe que repose la puissance de Kafka Streams : les partitions Ă  traiter sont distribuĂ©es Ă©quitablement entre les exĂ©cuteurs. Ainsi, une partition est traitĂ©e par un seul exĂ©cuteur, et un exĂ©cuteur peut traiter une ou plusieurs partitions.

La rĂ©partition des consommateurs d’une mĂȘme application s’effectue par le partage d’un associĂ© au nom de l’application. Tous les consommateurs (issus des exĂ©cuteurs) possĂ©dant le mĂȘme se verront rĂ©partir dynamiquement les partitions afin de garantir que chaque partition ne possĂšde qu’un seul consommateur (exĂ©cuteur) et que toutes les partitions soient traitĂ©es. Ce mĂ©canisme de rĂ©partition est gĂ©rĂ© par les brokers Kafka.

Par exemple, si un topic possĂšde 4 partitions et que l’on dĂ©marre deux instances de l’application, la premiĂšre instance se verra attribuer les partitions 1 et 3, alors que la deuxiĂšme instance consommera les partitions 2 et 4.

KStreams et KTables

Deux types de streams existent dans l’API : les KStreams et les KTables. Les KTables sont des Streams « finis », ou encore selon la nomenclature de Kafka : « compactĂ©s ». Alors qu’un KStream reprĂ©sente un topic Kafka « infini », une KTable est un topic pour lequel chaque nouveau message clĂ©/valeur Ă©crase l’ancien message avec la mĂȘme clĂ©, ou insĂšre le message si la clĂ© est nouvelle. Ce n’est finalement qu’une simple Map <clĂ©,valeur>.


Mapping topic-KStream et topic-KTable

Dans notre exemple, le rĂ©fĂ©rentiel des mappings entre les identifiants produit et les libellĂ©s associĂ©s peut parfaitement ĂȘtre reprĂ©sentĂ© par une KTable. Si l’on dĂ©cide de mettre Ă  jour le libellĂ© d’un produit du rĂ©fĂ©rentiel, l’injection d’un nouveau message Ă©crasera l’ancien ! La politique de log compaction de Kafka nous garantit que nos tuples ne seront pas effacĂ©s, contrairement Ă  un topic non compactĂ© qui voit ses messages effacĂ©s aprĂšs 7 jours, par dĂ©faut.

Lorsqu’une application travaillant avec des KTables dĂ©marre, elle lit entiĂšrement le topic depuis l’offset oĂč elle s’était arrĂȘtĂ©e (de la fin par dĂ©faut, si elle dĂ©marre pour la premiĂšre fois), puis stocke les messages dans une instance RocksDB qui est un cache persistĂ© et local Ă  chaque JVM. Elle reste ensuite Ă  l’écoute du topic pour insĂ©rer tout nouveau message dans son cache.

Pour une instance d’une application KStreams, joindre un KStream(topic achats) et une KTable(topic referentiel) revient donc à :

  • lire et mĂ©moriser dans un cache l’ensemble des partitions assignĂ©es du topic « rĂ©ferentiel ».
  • joindre chaque tuple provenant des partitions assignĂ©es du topic « achats » Ă  la volĂ©e avec un tuple de la KTable rĂ©fĂ©rentiel.

Cas pratique : retour sur l’exemple de code

Reprenons l’exemple d’enrichissement du flux d’achats :

// Création d'un KStream (flux) à partir du topic "achats"
KStream<String, ProduitBrut> achats =, produitBrutSerde, "achats");

// Création d'une KTable (table) à partir du topic "referentiel"
KTable<String, Referentiel> referentiel = builder.table(Serdes.String(), referentielSerde, "referentiel");
KStream<String, ProduitEnrichi> enriched = achats
    // Re-partitionnement du flux avec la nouvelle clé qui nous permettra de faire une jointure
    .map((k, v) -> new KeyValue<>(v.getId().toString(), v))
    // Jointure du flux d'achats avec le rĂ©fĂ©rentiel
    .leftJoin(referentiel, (achat, ref) -> {
        if (ref == null) return new ProduitEnrichi(achat.getId(), "REF INCONNUE", achat.getPrice());
        else return new ProduitEnrichi(achat.getId(), ref.getName(), achat.getPrice());

// On publie le flux dans un topic "achats-enrichis", produitEnrichiSerde, "achats-enrichis");

// Enfin, on démarre l'application
KafkaStreams streams = new KafkaStreams(builder, streamsConfiguration);

Supposons que le flux d’entrĂ©e est constituĂ© ainsi : <id_transaction; produitBrut>. id_achat est le numĂ©ro du ticket. produitBrut possĂšde un attribut id_produit avec la rĂ©fĂ©rence du produit. Nous souhaitons joindre ce flux avec la KTable rĂ©fĂ©rentiel en utilisant comme clĂ© id_produit. Nous devons donc transformer le flux et Ă©mettre le mĂȘme message avec la clĂ© id_produit extrait de ProduitBrut plutĂŽt que id_achat. Or cette opĂ©ration perturbe le partitionnement : un message sur une partition donnĂ©e voit sa clĂ© changer, ce qui l’amĂšne trĂšs probablement Ă  devoir ĂȘtre gĂ©rĂ© par une autre partition ! La jointure ne peut plus avoir lieu. Essayez vous-mĂȘme, vous obtiendrez le message d’erreur suivant:

Invalid topology building: KSTREAM-MAP-0000000003 and KTABLE-SOURCE-0000000002 are not joinable.

Comment faire alors ? Comme dans tout systĂšme distribuĂ©, il faut Ă  un moment ou Ă   un autre avoir recours Ă  un « shuffle », c’est Ă  dire une re-distribution des donnĂ©es entre les exĂ©cuteurs. Or nos exĂ©cuteurs ne communiquent pas entre eux. Le shuffle doit donc ĂȘtre indirect : il faut tout simplement rĂ©-Ă©mettre chaque message avec sa nouvelle clĂ© sur un tout nouveau topic, et consommer de ce nouveau topic pour effectuer la jointure. Le morceau de code devient :

// Création d'un KStream (flux) à partir du topic "achats"
KStream<String, ProduitBrut> achats =, produitBrutSerde, "achats");

// Création d'une KTable (table) à partir du topic "referentiel"
KTable<String, Referentiel> referentiel = builder.table(Serdes.String(), referentielSerde, "referentiel");
KStream<String, ProduitEnrichi> enriched = achats
    // Re-partitionnement du flux avec la nouvelle clé qui nous permettra de faire une jointure
    .map((k, v) -> new KeyValue<>(v.getId().toString(), v))
    // Copie du flux vers un nouveau topic, avec la nouvelle clé
    .through(Serdes.String(), produitBrutSerde, "achats-by-product-id")
    // Jointure du flux d'achats avec le rĂ©fĂ©rentiel
    .leftJoin(referentiel, (achat, ref) -> {
        if (ref == null) return new ProduitEnrichi(achat.getId(), "REF INCONNUE", achat.getPrice());
        else return new ProduitEnrichi(achat.getId(), ref.getName(), achat.getPrice());

// On publie le flux dans un topic "achats-enrichis", produitEnrichiSerde, "achats-enrichis");

// Enfin, on démarre l'application
KafkaStreams streams = new KafkaStreams(builder, streamsConfiguration);

La mĂ©thode « through » revient Ă  forcer l’opĂ©ration de « shuffle » en utilisant un topic Kafka intermĂ©diaire pour re-partitionner le flux. Et maintenant, ça fonctionne !


Workflow de l’application

En bonus
  • Les KStreams permettent aussi d’effectuer des opĂ©rations fenĂȘtrĂ©es sur des flux en gĂ©rant plusieurs types de fenĂȘtres, avec trois systĂšmes d’extraction de timestamps pour couvrir un maximum de cas d’usages.
  • Il est possible de travailler avec des Ă©tats (stateful processing).
  • La sĂ©mantique par dĂ©faut est “at least once”.
  • En cas de panne d’un des exĂ©cuteurs, un mĂ©canisme de reprise intrinsĂšque au consommateur Kafka se met en place automatiquement. Ce mĂȘme mĂ©canisme permet l’ajout ou retrait de ressources Ă  chaud.
  • Les KTables sont “backĂ©es” par RocksDB par dĂ©faut, mais cela peut ĂȘtre remplacĂ© par toute autre implĂ©mentation de org.apache.kafka.streams.state.KeyValueStore.
  • Plusieurs stratĂ©gies existent pour crĂ©er les topics Kafka nĂ©cessaires au fonctionnement de l’application. Je prĂ©conise de le faire au moment du dĂ©ploiement de l’application.

Les dĂ©veloppeurs de Confluent n’ont pas rĂ©inventĂ© la roue : l’API KStreams est un moyen simple de faire du streaming, en s’appuyant le plus possible sur les composants et concepts existants dans Kafka. De ce fait, le projet ne contient en fait que quelques milliers de lignes de code !

DĂ©velopper et faire tourner son application de streaming ne nĂ©cessite pas d’ajout de middleware en plus. La gestion du cluster d’exĂ©cuteurs Java de votre application est cependant entre vos mains. Les cas d’usage plus complexes nĂ©cessitant par exemple de l’apprentissage pour un modĂšle de machine learning ne pourront certainement pas s’appuyer sur cette API, car trop lĂ©gĂšre.

Retrouvez le code source de l’exemple utilisĂ© sur ce Github pour pouvoir le faire tourner chez vous en quelques minutes, avec ou sans Docker.

Merci Sebastiån pour ton coup de pouce Docker, et bien sûr merci les Octos pour vos précieuses relectures !

Articles suggested :

  1. Collecte de tickets de caisse : vue sur l’architecture
  2. Rejoignez-nous au Datastax Day le mardi 14 juin Ă  Paris

Catégories: Blog Société

Installer une chaĂźne SSL avec dovecot

Barre Verte ! - jeu, 07/21/2016 - 23:00

Nous avons entamé avec quelques amis développeurs notre cure de dégooglelisation il y a quelques années. Pour le mail, nous avons choisi, aussi pour notre apprentissage, de monter notre serveur postfix/dovecot. Pour ceux que ça intéresse, mais qui ne veulent pas mettre les mains dans le cambouis, il y a des infos chez Framasoft.

Afin de pouvoir utiliser le service de messagerie avec la couche SSL, il nous a fallu acheter un certificat SSL et l’installer. La semaine derniĂšre, le certificat arrivait en fin de validitĂ©, j’ai du le changer. Manque de chance, le certificat “intermĂ©daire”, celui de Gandi avait changĂ© aussi, et nous n’avions pas documentĂ© l’installation d’origine. Comme j’ai un peu galĂ©rĂ©, alors que c’est trĂšs simple, je mets pour mĂ©moire les Ă©tapes ici.

Le problÚme du certificat intermédiaire

Je vais voir dans notre fichier de configuration /etc/dovecot/dovecot.conf comment sont configurés les certificats. Je trouve :

ssl_cert = </etc/ssl/certs/monServeur.crt
ssl_key = </etc/ssl/private/monServeur.key

OK donc j’achĂšte et je tĂ©lĂ©charge notre nouveau certificat chez Gandi. Je me dis qu’il suffit de le copier Ă  la place de l’ancien, avec le mĂȘme nom, et je recharge dovecot au cas oĂč il le monte en mĂ©moire.

$ cp /etc/ssl/certs/monServeur.crt monServeur.crt.old && cp monServeur.crt /etc/ssl/certs/
$ service dovecot restart

J’essaye de rĂ©cupĂ©rer mes messages depuis mon Thunderbird, j’ai une erreur SSL identitĂ© inconnue. Je vais voir les logs dovecot et je vois :

Jul 18 11:36:46 monServeur dovecot: imap-login: Disconnected (no auth attempts in 0 secs): user=<>, rip=xx.xx.xx.xx, lip=yy.yy.yy.yy, TLS handshaking: SSL_accept() failed: error:14094416:SSL routines:SSL3_READ_BYTES:sslv3 alert certificate unknown: SSL alert number 46, session=<w/nxtOU3RwBOwT0M>

Le certificat de notre fournisseur n’est pas le bon, puisque le mien est neuf, fraĂźchement installĂ©. Alors je vĂ©rifie le certificat. Je trouve dans notre rĂ©pertoire /etc/ssl/certs/ un certificat intermĂ©diaire Gandi. J’essaye :

$ openssl verify -CAfile /etc/ssl/certs/GandiStandardSSLCA.pem monServeur.crt
monServeur.crt: OU = Domain Control Validated, OU = Gandi Standard Wildcard SSL, CN = *
error 20 at 0 depth lookup:unable to get local issuer certificate

Sur le site de notre fournisseur de certificat, lorsque nous le tĂ©lĂ©chargeons, il propose aussi de tĂ©lĂ©charger le certificat “intermĂ©diaire”. Surprise ! Il s’appelle GandiStandardSSLCA2.pem. Je le copie dans /etc/ssl/certs/ et Ă  prĂ©sent :

$ openssl verify -CAfile /etc/ssl/certs/GandiStandardSSLCA2.pem monServeur.crt
monServeur.crt: OK
Installation manuelle dans le client mail

J’essaye de rĂ©cupĂ©rer mes mails dans Thunderbird. Toujours la mĂȘme alerte Impossible de vĂ©rifier ce certificat car l'Ă©metteur est inconnu. L’erreur est diffĂ©rente cĂŽtĂ© dovecot :

Jul 18 11:45:15 monServeur dovecot: imap-login: Disconnected (no auth attempts in 0 secs): user=<>, rip=xx.xx.xx.xx, lip=yy.yy.yy.yy, TLS: SSL_read() failed: error:14094418:SSL routines:SSL3_READ_BYTES:tlsv1 alert unknown ca: SSL alert number 48, session=<qcIvFiY4rABOwT0M>

Dans l’état du certificat sur thunderbird, il est indiquĂ© Ce site essaie de s'identifier lui-mĂȘme avec des informations invalides. Quand je clique sur le bouton “Voir” je vois la ligne

Organisation (O) <Ne fait pas partie du certificat>

Je comprends que le certificat de Gandi n’est pas envoyĂ© par dovecot. Alors je vais dans Edition > PrĂ©fĂ©rences > AvancĂ© > Certificats de thunderbird et je clique sur Voir les certificats puis j’importe manuellement mon certificat GandiStandardSSLCA2.pem. Maintenant sur mon thunderbird, ça fonctionne. Sur mon mobile ça ne fonctionne pas. On ne va pas importer ce certificat dans tous nos clients mail ?

Utilisation de la chaĂźne SSL

Heureusement, grĂące Ă  la chaine SSL, ce n’est pas nĂ©cessaire.

Quand je vĂ©rifie par ligne de commande l’état de mon certificat imap j’obtiens :

$ openssl s_client -crlf  -connect
depth=0 OU = Domain Control Validated, OU = Gandi Standard Wildcard SSL, CN = *
verify error:num=20:unable to get local issuer certificate
verify return:1
depth=0 OU = Domain Control Validated, OU = Gandi Standard Wildcard SSL, CN = *
verify error:num=27:certificate not trusted
verify return:1
depth=0 OU = Domain Control Validated, OU = Gandi Standard Wildcard SSL, CN = *
verify error:num=21:unable to verify the first certificate
verify return:1
Certificate chain
0 s:/OU=Domain Control Validated/OU=Gandi Standard Wildcard SSL/CN=*
i:/C=FR/ST=Paris/L=Paris/O=Gandi/CN=Gandi Standard SSL CA 2
Server certificate

On constate l’absence de chaĂźne car Gandi Standard SSL CA 2 a certifiĂ© monServeur, mais la vĂ©rification s’arrĂȘte lĂ . La profondeur (depth) est de 1 (ou zero si on compte comme un informaticien). Je crĂ©e alors la chaĂźne de monServeur : monServeur -> gandi -> USERTrust en concatĂ©nant les certificats (USERTrust Ă©tait dĂ©jĂ  dans le fichier pem de Gandi) :

$ cat monServeur.crt GandiStandardSSLCA2.pem  > monServeur-chain.crt
$ cp monServeur-chain.crt /etc/ssl/certs/monServeur.crt

Je redémarre dovecot. Je relance ma commande :

$ openssl s_client  -crlf  -connect
depth=2 C = US, ST = New Jersey, L = Jersey City, O = The USERTRUST Network, CN = USERTrust RSA Certification Authority
verify error:num=20:unable to get local issuer certificate
verify return:0
Certificate chain
0 s:/OU=Domain Control Validated/OU=Gandi Standard Wildcard SSL/CN=*
i:/C=FR/ST=Paris/L=Paris/O=Gandi/CN=Gandi Standard SSL CA 2
1 s:/C=FR/ST=Paris/L=Paris/O=Gandi/CN=Gandi Standard SSL CA 2
i:/C=US/ST=New Jersey/L=Jersey City/O=The USERTRUST Network/CN=USERTrust RSA Certification Authority
2 s:/C=US/ST=New Jersey/L=Jersey City/O=The USERTRUST Network/CN=USERTrust RSA Certification Authority
i:/C=SE/O=AddTrust AB/OU=AddTrust External TTP Network/CN=AddTrust External CA Root
Server certificate

Il y a toujours une erreur mais la chaĂźne monServeur -> gandi -> USERTrust est lĂ  (depth=2).

Indication du chemin des certificats racines

Il ne trouve pas USERTrust. C’est la racine, et elle est dĂ©jĂ  installĂ©e dans les clients mails. Donc ici, c’est juste l’exĂ©cution de la commande openssl qui est incorrecte, mais la configuration SSL est bonne cĂŽtĂ© serveur. J’essaye sur mon mobile, ça fonctionne. Et sur tous les autres clients jusqu’à prĂ©sent.

Pour avoir une vraie barreverte(©) dans notre ligne de commande, il faut ajouter -CApath pour indiquer Ă  openssl oĂč se trouvent les certificats racine :

$ openssl s_client -CApath /etc/ssl/certs/ -crlf  -connect
depth=3 C = SE, O = AddTrust AB, OU = AddTrust External TTP Network, CN = AddTrust External CA Root
verify return:1
depth=2 C = US, ST = New Jersey, L = Jersey City, O = The USERTRUST Network, CN = USERTrust RSA Certification Authority
verify return:1
depth=1 C = FR, ST = Paris, L = Paris, O = Gandi, CN = Gandi Standard SSL CA 2
verify return:1
depth=0 OU = Domain Control Validated, OU = Gandi Standard Wildcard SSL, CN = *
verify return:1
Certificate chain
0 s:/OU=Domain Control Validated/OU=Gandi Standard Wildcard SSL/CN=*
i:/C=FR/ST=Paris/L=Paris/O=Gandi/CN=Gandi Standard SSL CA 2
1 s:/C=FR/ST=Paris/L=Paris/O=Gandi/CN=Gandi Standard SSL CA 2
i:/C=US/ST=New Jersey/L=Jersey City/O=The USERTRUST Network/CN=USERTrust RSA Certification Authority
2 s:/C=US/ST=New Jersey/L=Jersey City/O=The USERTRUST Network/CN=USERTrust RSA Certification Authority
i:/C=SE/O=AddTrust AB/OU=AddTrust External TTP Network/CN=AddTrust External CA Root
Server certificate

Tout est ok cette fois.

A noter que l’organisation va ĂȘtre cachĂ©e par thunderbird et les clients mails. Une fois que je me suis connectĂ© une fois sur notre serveur mail, je retrouve USERTRUST -> Gandi CA 2 dans les certificats. Si vous remettez le certificat seul, sans la chaĂźne, ça fonctionnera sur les clients s’étant dĂ©jĂ  connectĂ©s une fois.

Catégories: Blog Individuel

Les chatbots

les botsParmi les sujets techno tendance, les bots font beaucoup parler d’eux depuis cette annĂ©e.
Mais pourquoi ce sujet revient Ă  la mode alors qu’ils existent depuis les annĂ©es 60 ?
La façon dont nous interagissions avec les machines Ă©voluent d’annĂ©es en annĂ©es de maniĂšre Ă  cela soit le plus naturel et facile pour nous humain. Le dialogue est certainement un des moyens les plus naturel pour nous de communiquer avec la machine.

Qu’est-ce qu’un bot ?

Un bot est un logiciel qui permet d’interagir avec un systĂšme gĂ©nĂ©ralement sous forme d’une conversation. D’autres formes de bots existent, bien que ceux ne sont pas eux que nous traiterons ici :

  • spider bots : ils scannent le web (comme ceux de Google)
  • trading bots : ils recherchent les meilleurs offrent commerciales sur internet
  • media bots : ils fournissent des updates sur des Ă©vĂ©nements comme la mĂ©tĂ©o, des news, la bourse…

Les bots permettent d’automatiser des problĂ©matiques rĂ©pĂ©titives.
Il existe 3 catégories principales de bots :

  • Les bots textuels ou conversationnels : ils n’ont pas d’interface et sont intĂ©grĂ©s dans des applications de messagerie
  • Les bots visuels : ils sont prĂ©sents dans les chats ayant une interface plus Ă©voluĂ©e. Ils nĂ©cessitent une Web View pour afficher plus de contenu et peuvent ĂȘtre comparĂ©s Ă  des applications.
  • Les bots audio : ils sont basĂ©s sur la voix. Quelques exemples sont Siri d’Apple, Cortana de Microsoft, Google Now, Viv et Alexa d’Amazon

On les retrouve donc dans les applications de messagerie comme Slack, Facebook Messenger, Kik ou Skype…

Si on devait décomposer un bot, on y trouverait quatre grandes parties :

  • l’interface de communication permettant d’envoyer les demandes et restituer le rĂ©sultat
  • l’analyseur de langage (NLP : voir la dĂ©finition ci-dessous) capable de comprendre la demande de l’utilisateur
  • le workflow conversationnel permettant crĂ©er et suivre la conversation
  • la partie mĂ©tier appelant les APIs correspondant aux besoins de l’utilisateur
NLP : Natural Language Processing

On ne peut pas parler de bots sans introduire la notion de Natural Language Processing (NLP). C’est une discipline Ă  la frontiĂšre de la linguistique, de l’informatique et de l’intelligence artificielle, qui concerne l’application de programmes et techniques informatiques Ă  tous les aspects du langage humain (voir dĂ©finition dans wikipedia). Le langage naturel est le moyen de rentrer des inputs (textuel ou vocal) vers la machine. Mais afin que celle-ci comprenne ce que l’on souhaite, il est nĂ©cessaire que cet input brut soit processĂ© pour en dĂ©duire l’intention et des mots clĂ©s.
Prenons l’exemple courant d’un bot mĂ©tĂ©o. Lorsqu’on demande « quel temps fait-il Ă  Paris ? », il faut que la machine comprenne que l’intention de l’utilisateur et d’obtenir la mĂ©tĂ©o. Le contexte de Paris doit ĂȘtre aussi pris en compte afin qu’elle puisse rĂ©pondre de maniĂšre pertinente et ne donne pas une rĂ©ponse ne concernant pas la capitale française.

Pourquoi parle-t-on autant de bots en ce moment ?

Plusieurs raisons expliquent l’engouement autour des bots cette annĂ©e. Tout d’abord l’intelligence artificielle a Ă©normĂ©ment progressĂ© ces derniĂšres annĂ©es (big data, machine learning…). Les systĂšmes peuvent dĂ©sormais processer le langage naturel beaucoup plus efficacement via des rĂ©seaux de neurones permettant de concevoir des algorithmes plus complexes. Les intentions de l’utilisateur sont maintenant beaucoup mieux comprises et offrent une bien meilleure interaction.

Ensuite, les applications de messagerie sont dĂ©sormais rentrĂ©es dans notre vie privĂ©e et professionnelle. Facebook revendique plus d’un milliard d’utilisateurs sur chacune de ses applications FB Messenger et WhatsApp !  De son cĂŽtĂ©, Slack annonce plus de 3 millions d’utilisateurs uniques journalier. Les bots s’intĂ©grant dans ces applications, elles arrivent alors simplement dans nos conversations.

Qui sont les grands acteurs ?

Plusieurs acteurs prennent place autours des bots. Il y a ceux qui permettent de créer des bots, ceux qui proposent des moteurs de NLP et ceux qui héberge des plateformes dans lesquels seront intégrés les bots.

Les frameworks de bots

Plusieurs frameworks pour développer des bots existent :

  • Microsoft propose son botframework permettant de dĂ©velopper des bots qui seront ensuite publiables dans un « bot directory ». Ils seront intĂ©grables dans des emails, FB Messenger, Kik, Skype, Slack, SMS….
  • Lita est un framework open source en Ruby qui accompagnĂ© de plugins s’intĂšgre Ă  FB Messenger, Twitter, Slack, HipChat…
  • Errbot est un framework en Python qui possĂšde aussi ses plugins pour s’installer sur Slack, HipChat, Skype…
  • Hubot est un framework  open source en CoffeeScript compatible avec de trĂšs nombreuses plateforme de chat.

Facebook a lancé sa propre plateforme de bots lors de la derniÚre conférence F8.

Les moteurs NLP

Microsoft dĂ©veloppe aussi en beta son moteur NLP LUIS (Language Understanging Intelligence Service). Cette API hĂ©bergĂ©e dans le cloud permet donc de rĂ©pondre au besoin de comprĂ©hension des requĂȘtes dans un langage naturel.

IBM Watson propose un framework offrant une plateforme cognitive. Elle permet d’interprĂ©ter le langage naturel, la vision, les discours, les data.

Les plateformes intégrant des bots

Presque toutes les applications de chat proposent d’intĂ©grer des bots : Slack, Facebook Messenger, WhatsApp, Kik Messenger, Twitter, WeChat, Line, Skype, Telegram…

chatbot value

Bots VS App

On entend souvent la question suivante : « est-ce que les bots ne vont pas remplacer les applications mobiles ? ». La rĂ©ponse est clairement non. Les bots vont rajouter des fonctionnalitĂ©s ou rendre plus accessibles des donnĂ©es (dans une application), mais elles ne feront pas faire disparaĂźtre les apps.
En revanche, les bots transcendent la question de plateforme car n’ayant pas d’interface Ă  proprement parler, ils vont pouvoir s’intĂ©grer aux applications dĂ©jĂ  existantes.
Alors qu’il existe dĂ©jĂ  plus de 3 millions d’applications tout stores confondus, seulement 11.000 bots ont Ă©tĂ© publiĂ©s pour le moment. La compĂ©tition pour faire connaitre son bot est plus facile que celle pour rentrer dans le top des applications de l’AppStore ou de GooglePlay. En effet, rechercher un bot en filtrant seulement par une plateforme de chat et un domaine, ne retourne que peu de rĂ©sultat.

Si on compare le prix du dĂ©veloppement d’une application mobile (en natif et sur iOS et Android), cela coĂ»tera entre plusieurs dizaines et plusieurs centaines de milliers d’euros. Un bot pouvant s’intĂ©grer Ă  plusieurs plateformes de chats (quel que soit le device) coĂ»tera beaucoup moins cher.

Les cas d’usages

Dans le milieu professionnel, les bots peuvent rĂ©pondre Ă  plusieurs besoins comme devenir assistants, pour rĂ©pondre Ă  des emails, programmer votre agenda… Les bots peuvent aussi remplir un premier niveau d’assistance en ligne disponible 24h/7.

CĂŽtĂ© grand public, les bots peuvent remplacer un concierge et faire toutes vos rĂ©servations, commander sur internet… Plusieurs bots donnant la mĂ©tĂ©o ou permettant de trouver un restaurant apparaissent sur les stores de bots.

  • Taco bell a crĂ©e un bot permettant de passer une commande
  • Domino’s permet de commander un pizza sur twitter
  • Booking a prototypĂ© un bot pour faire des rĂ©servations
  • CĂŽtĂ© retail, Sephora et H&M ont dĂ©veloppĂ© leur bots sur Kik

Disney a investi dans Imperson afin de personnifier ses personnages et leur permettant de dialoguer avec leur fans renforçant son image de marque.

Que ce soit pour un usage professionnel ou personnel, les bots permettent d’accĂ©der Ă  de l’information de façon plus directe que parcourir des menus.

Faut-il avoir peur des bots ?

MS Tay bot

On se rappelle Tay dĂ©veloppĂ© par Microsoft qui est devenu raciste en moins de 24 heures sur Twitter. Ce bot d’intelligence artificielle Ă©tait un projet de machine learning sensĂ© communiquer avec les humains et favoriser la comprĂ©hension du langage naturel. Malheureusement, aucune rĂšgle limitant l’apprentissage de message nazi ou mettant de barriĂšre Ă©thique n’avait Ă©tĂ© implĂ©mentĂ©e.

Cette expĂ©rience montre Ă  quel point l’intelligence artificielle est capable d’apprendre rapidement ce qu’on lui apprend. Les bots sont gĂ©nĂ©ralement entraĂźnĂ©s avant d’ĂȘtre mis en production et disponible pour les utilisateurs ce qui Ă©vite ce genre de dĂ©rapage. De plus, d’un point de vue UX / marketing, les bots tendent Ă  avoir une « personnalitĂ© » ayant un ton correspondant Ă  la cible des utilisateurs.

Pour aller plus loin

Les bots sont dĂ©sormais arrivĂ©s Ă  un niveau de maturitĂ© qui permet de dialoguer naturellement avec la machine. Ils ont l’avantage d’ĂȘtre plateforme agnostiques et moins coĂ»teux en termes de dĂ©veloppement qu’une application mobile.

On imagine alors facilement la dĂ©multiplication des bots sur nos canaux de communications de type chat. Plusieurs plateformes / stores de bots commencent Ă  voir le jour. Y-aura-t’il une uniformisation de ces plateformes comme l’AppStore ou le GooglePlay ?

Bien souvent, la conversation que l’on souhaite avoir avec un bot concerne plusieurs sujets. Par exemple, pour planifier des vacances, il faudra rĂ©server l’avion, l’hĂŽtel, la voiture, les restaurants et vĂ©rifier la mĂ©tĂ©o. Comment passer de maniĂšre fluide Ă  chacun de ces informations lors de la conversation ? Faudrait-il un master bot coordonnant d’autres bots spĂ©cialisĂ©s ? Une standardisation des APIs de bots serait-elle nĂ©cessaire pour qu’ils puissent communiquer entre eux ?

Des problĂ©matiques de sĂ©curitĂ©s se posent car les bots peuvent avoir accĂšs Ă  des donnĂ©es sensibles et l’authentification de la personne dialoguant sera critique. S’interfaçant dans des conversations, il faudra s’assurer que les bots n’affichent pas des informations personnelles dans le flux d’une conversation Ă  plusieurs personnes.

De plus, les bots peuvent ressembler Ă  des attaques de type « man in the middle ». Il faudra alors s’assurer qu’ils ont bien le droit d’interroger les APIs back-end fournissant les donnĂ©es et services.

Pour le moment, les bots ne remplaceront pas les humains car mĂȘme si les progrĂšs en IA sont fulgurant ces derniĂšres annĂ©es, elle a encore beaucoup de progrĂšs Ă  faire pour des requĂȘtes complexes. De nombreux tests de Turing font encore Ă©chouer la majoritĂ© des NLP. Mais l’utilisation massive des applications de chat et l’usage naturel du chat permet dĂšs aujourd’hui d’implĂ©menter des fonctionnalitĂ©s rapidement et facilement accessible Ă  tous.

Articles suggested :

  1. Chronique de la réalité virtuelle: quels usages en 2016 ?
  2. Améliorer sa productivité avec les expériences immersives

Catégories: Blog Société

Revue de Presse Xebia

revue de presse XebiaLa revue de presse hebdomadaire des technologies Big Data, DevOps et Web, architectures Java et mobilité dans des environnements agiles, proposée par Xebia.

MobilitĂ© Kotlin 1.1 – Yeld, Type alias et plus Benjamin Lacroix

Jetbrains continue Ă  travailler sur son langage maison : Kotlin. Pour rappel, Kotlin peut ĂȘtre utilisĂ© sur des projets existants Java, des nouveaux projets 100% Kotlin et des projets Android. Avec Kotlin 1.1, ses crĂ©ateurs nous proposent une syntaxe dĂ©diĂ©e aux exĂ©cutions asynchrones : Coroutines. Async/await permet d’Ă©crire du code qui peut s’arrĂȘter (traitement long) sans bloquer le processus d’exĂ©cution courant, malgrĂ© tout, le code ressemble Ă  du code sĂ©quentiel :

fun main(args: Array&lt;String&gt;) {
    val future = async&lt;String&gt; {
        (1..5).map {
            await(startLongAsyncOperation(it)) // suspend while the long method is running

DeuxiÚme nouveauté de Kotlin 1.1 : les alias sur les types. Dorénavant nous pourrons remplacer un type avec une signature complexe par un nom de type plus simple ou qui a plus de sens.

typealias Length = Double
typealias Weight = Double

De nombreuses nouveautĂ©s restent Ă  dĂ©couvrir dans l’article First glimpse of Kotlin 1.1

DevOps LambCI: Une usine logicielle serverless pour votre intégration continue Philippe Antoine

LambCI est une usine logicielle serverless qui s’exĂ©cute grĂące Ă  des Lambda dans AWS et des templates CloudFormation. On notera l’intĂ©gration facilitĂ©e avec slack, et les travaux en cours pour assurer une future compatibilitĂ© avec les services Google et en particulier les Google Cloud Functions. 


DependencyCI: l’outil pour tester vos dĂ©pendances dans votre usine logicielle Philippe Antoine

Dependency CI est un outil, disponible en SaaS, de test de vos dĂ©pendances. Il supporte un grand nombre de package manager (npm, Maven, Swift, Go …) et permet de lancer une sĂ©rie de vĂ©rification Ă  chacun de vos commits:

  • DĂ©prĂ©ciation
  • DĂ©pendances non maintenues
  • DĂ©pendances supprimĂ©e
  • Absence de licence

Et bientĂŽt d’autres tests seront bientĂŽt ajoutĂ©s:

  • Failles de sĂ©curitĂ©
  • Utilisation d’une ancienne version de la dĂ©pendances
  • DĂ©pendances sujettes au « Bus factor« 
  • Conflits entre licences
Catégories: Blog Société

Leveraging Atlassian tools in enterprise-scale businesses (part two)

Le blog de Valiantys - jeu, 07/21/2016 - 08:30

In part one of this blog, we discussed the unique IT challenges facing large, complex enterprises. Today, we explore how Atlassian’s enterprise solutions are perfectly placed to meet these demands, and give you the lowdown on Atlassian tools in enterprise-scale businesses. Tell me about Atlassian In 2001, Atlassian was another one of those “tech start-ups” you ...

The post Leveraging Atlassian tools in enterprise-scale businesses (part two) appeared first on Valiantys Blog - Atlassian Expert.

Catégories: Blog Société

En route vers RIO, interview Kilian Le Blouch

Blog d’Ippon Technologies - mar, 07/19/2016 - 15:51

Kilian Le Blouch
est un judoka français Ă©voluant dans la catĂ©gorie des – 66 kg. Kilian a terminĂ© 3Ăšme au tournoi de Paris 2016. EntraĂźneur des jeunes du FLAM91, il a notamment Ă©tĂ© le coach de Walide Khyar pendant 8 ans. Quelques annĂ©es plus tard, ils se retrouvent dans la sĂ©lection française pour les Jeux Olympiques de Rio de Janeiro ! 

En compagnie d’Alexandre Iddir et Walide Khyar, ces trois judokas vont reprĂ©senter Ippon aux Jeux Olympiques !

Bonjour Kilian, peux-tu te présenter ?

J’ai 26 ans, mariĂ© pas d’enfant, enfin pas Ă  moi mais Ă  FLAM91 j’en ai un paquet &#x1f609;

Sportif de haut niveau depuis 6 ans, je m’entraĂźne tous les jours ou presque depuis bientĂŽt 12 ans !

Actuellement je me consacre principalement Ă  ma vie d’athlĂšte et Ă  celle d’entraĂźneur chez les jeunes U15 U18 U21.

Je suis quelqu’un de pro qui ne laisse rien au hasard, je cherche la perfection et le progrĂšs constamment !

On me dit mĂȘme parfois que je suis un chouĂŻa fou &#x1f609;


Comment as-tu découvert le judo ?

J’ai dĂ©couvert le judo lors d’un dispositif mis en place par l’OMS(Office municipal des sports) de ma ville ChĂątenay-Malabry (92) oĂč je pratiquais le rugby et le judo.

J’ai vite accrochĂ© mais je n’Ă©tais pas non plus un fou furieux de la discipline, j’ai pratiquĂ© pas mal de sport au cours de ma jeunesse.


Quelle est ta recette pour devenir un champion ?

Ma recette pour devenir champion c’est d’ĂȘtre sĂ©rieux et constant. Je lĂąche rien !!!

Je suis trĂšs curieux, je cherche, je me cherche…

Et la notion de plaisir me semble ĂȘtre un Ă©lĂ©ment trĂšs important, j’adore m’entraĂźner, transpirer, me dĂ©passer… Et la confrontation Ă  l’entraĂźnement qui me permet de valider tout ce que j’ai fait pour progresser !!!


A quel moment as tu senti que tu pouvais intĂ©grer l’Ă©quipe de France ?

Je pense que c’est lors de mon premier stage lors de la prĂ©paration des championnat du monde Ă  Rotterdam (Pays-Bas) oĂč je posais de rĂ©els problĂšmes Ă  mes adversaires, je ne lĂąchais rien !  Les mec ne me connaissait pas et je leur ai montrĂ© que j’avais une grosse envie et que j’étais volontaire malgrĂ© le fait qu’il me restait des progrĂšs Ă  faire.


Comment gĂšres tu la pression ?

La pression est un Ă©lĂ©ment important dans la performance…

Je fais donc en sorte de visualiser la rĂ©ussite puis avant de monter sur le tapis je me dĂ©tends un peu via un travail sur la respiration, enfin lorsque je monte je mets en place ce que l’on appelle un ancrage qui me permet de dĂ©velopper tous les chevaux que j’ai sous le capot…


Un petit rituel avant de rentrer sur le tatami ?

Non, enfin le travail mental et la vérification de mon équipement font partis de mes habitudes.

Enfin, je fais une petite priĂšre car je suis quelqu’un de croyant…


Peux-tu nous donner trois musiques qui te motivent avant un combat ?
Je n’ai pas spĂ©cialement de musique mais j’aime le rap ,les tubes du moments, les sons latino et le rai !!


Faire les JO, tu en avais rĂȘvĂ© il y a 10 ans ?

Plus exactement il y a 8 ans, lorsque je suis allé à Pékin voir les jeux.

J’ai adorĂ© c’est un moment qui restera gravĂ© dans ma mĂ©moire !


Quel légende du sport souhaites tu rencontrer dans le village olympique ?

Aucune mais j’ai beaucoup de respect pour les athlĂštes de fond et les triathlĂ©tes.


Ton objectif Ă  Rio ?

Tout donner, rien regretter, montrer de quoi je suis capable et la plus belle des médailles sera au rendez vous &#x1f609;


Catégories: Blog Société

Onboarding @Ippon

Blog d’Ippon Technologies - mar, 07/19/2016 - 14:25

L’Onboarding constitue notre programme d’intĂ©gration. Il permet Ă  l’ensemble des nouveaux Ippon d’adopter notre culture d’entreprise afin d’ĂȘtre parfaitement intĂ©grĂ© dans la communautĂ© d’expert d’Ippon.

Au programme: 3 jours de confĂ©rences, serious game, cours d’improvisation thĂ©atrale, escape game…

Aujourd’hui c’est #Onboarding Ă  Ippon ! Notre mission : rassembler les meilleurs experts

— Ippon Technologies (@ippontech) 4 juillet 2016


Breaktime for the onBording session @ippontech — Faten Habachi (@fatenh) 5 juillet 2016

Quand les nouveaux Ippons s’Ă©clatent #intĂ©gration #onboarding Bienvenue Ă  eux ! — Jean-Marie Caillaud (@JMCaillaud) 5 juillet 2016

AprĂšs une journĂ©e JHipster et Spark, c’est une soirĂ©e escape game @ippontech. A vos enquĂȘtes ⌛ — Nathalie ROBIN (@nathalie_robin) 5 juillet 2016

3Ăšme jour de notre #Onboarding avec au programme : un cours d’improvisation #Integration

— Ippon Technologies (@ippontech) 6 juillet 2016

Cyril Gerla, Ippon depuis trois semaines revient avec nous sur ce moment fort !

Pourquoi as-tu choisi Ippon ?

Je souhaitais travailler sur des projets innovants en sortant de ma zone de confort.

Tu as participĂ© Ă  l’Onboarding (programme d’intĂ©gration Ippon), qu’en as tu pensĂ© ? 

Ce fĂ»t une superbe expĂ©rience, c’Ă©tait intĂ©ressant de dĂ©couvrir l’ensembles des acteurs d’Ippon. On a vraiment compris ce qu’attendait Ippon de notre rĂŽle de consultant. Le programme Ă©tait cohĂ©rent avec un fil conducteur entre toutes les activitĂ©s.

Peux-tu présenter les activités ?

Un jeu Ă  base de lego, un serious game, un escape game et un cours d’improvisation thĂ©Ăątrale. C’Ă©tait un mĂ©lange astucieux entre esprit d’Ă©quipe et dĂ©veloppement personnel.

Quelle activité as-tu préférée ?

Sans hĂ©siter, j’ai adorĂ© le cours d’improvisation et l’escape game !

En terme de technologie, quelles sont tes spĂ©cialitĂ©s ? Pour l’instant Java, Spring et Hibernate, je souhaite monter en compĂ©tences sur Javascript afin d’avoir un profil plus “Front”.  

Catégories: Blog Société

Protocol Buffers: Benchmark et utilisation sur mobile

Aller de plus en plus vite sur smartphone est devenu essentiel. Au delĂ  du moyen de communication, le format de donnĂ©es utilisĂ© joue un rĂŽle sur la vitesse. Le JSON est aujourd’hui standard pour les API. Mais ce format de donnĂ©e est-il adaptĂ© au mobile? La manipulation d’un JSON en Android, par exemple, n’est pas simple.

D’autres formats de donnĂ©es Ă©mergent depuis quelques annĂ©es comme Thrift, Avro, Message Pack ou encore Protocol Buffers.

Protocol Buffers, c’est la possibilitĂ© d’avoir un format binaire qui soit facilement adaptable et manipulable. C’est aussi une structure de base extrĂȘmement simple Ă  Ă©crire et comprendre, qui permet de gĂ©nĂ©rer du code source facilement pour plusieurs langages.

Protocol Buffers (protobuf) a dĂ©jĂ  fait parler de lui sur ce blog, en 2012. La version utilisĂ©e Ă©tait alors 2.4.1, et la norme d’écriture, proto2.


Le dĂ©veloppement de protobuf a dĂ©butĂ© en 2001, la derniĂšre version stable date d’octobre 2014. Mais c’est la version bĂȘta-3 3.0.0 qui sera utilisĂ©e tout le long de cet article. Avec cette version bĂȘta, la norme proto3 fait son apparition. Le but de cette nouvelle norme est de simplifier un peu plus les fichiers de dĂ©claration de structure protobuf.

message Hello {
  message Bye {
    required string name = 1;
    optional int32 count = 2 [default = 1];

  repeated Bye bye = 1;
  optional bool check = 2;
message Hello {                            
  repeated Bye bye = 1;
  bool check = 2;

message Bye {
  string name = 1;
  int32 count = 2;
Norme proto2
Norme proto3

Parmi les changements visibles entre proto2 et proto3, on note la disparition des attributs “optional” et “required”. L’attribut “required” Ă©tait dĂ©jĂ  dĂ©conseillĂ© par Google : il empĂȘche la suppression ultĂ©rieure du champ concernĂ© des futures versions de l’objet. En effet, supprimer, modifier ou ajouter un champ “required” cause des bugs de lecture d’une donnĂ©e protobuf.

Outre les attributs, les valeurs par dĂ©faut ne peuvent plus ĂȘtre modifiĂ©es. Le premier argument en faveur de ces Ă©volutions reste la simplification des objets. Le deuxiĂšme est l’extension de protobuf Ă  d’autres langages, qui eux, n’acceptent pas forcĂ©ment les valeurs par dĂ©faut. Ce choix permet donc d’uniformiser la gĂ©nĂ©ration dans les langages prĂ©sents et futurs.

Malgré tout, la norme proto2 est toujours acceptée par le générateur de Protocol Buffers.

Dans sa version 2.6.1, Protocol Buffers peut se dĂ©cliner sur quatre langages : C++, Java, Go et Python. Actuellement, la version 3.0.0-beta-3 propose neuf dĂ©clinaisons. C# et Objectif-C ont Ă©tĂ© ajoutĂ©s en bĂȘta. JavaScript, Ruby et Javanano sont actuellement en alpha.

Protocol Buffers est sous licence BSD. Tout le monde a alors la possibilité de participer à son évolution. Cela permet donc une expansion rapide. On peut désormais trouver une multitude de générateurs protobuf pour beaucoup de langages différents. Cette liste répertorie une partie des implémentations existantes.


Pour visualiser les performances de Protocol Buffers, un client (Nexus 5, Android 6.0.1) fait appel à un serveur (Go) pour lui transmettre du contenu texte. L’appel se fait en local, via HTTP/2.

Schema Benchmark Protobuf

Environnement de Tests

Afin de comparer les rĂ©sultats, d’autres formats de donnĂ©es sont introduits : XML, JSON et MessagePack. Pour le format JSON, trois librairies sont testĂ©es : Jackson, Jackson Jr et Moshi. Du cĂŽtĂ© de protobuf, il y a deux librairies utilisĂ©es : l’implĂ©mentation officielle de Google (bĂȘta-3.0.0) et Wire de Square (2.2.0).

Temps de Traitement

Ce temps de traitement correspond au temps entre la fin de rĂ©ception des paquets et l’envoi des objets finaux Ă  l’affichage.

Le client demande donc au serveur 10 fichiers d’un nombre variable de paragraphes (entre 50 et 500). Ces paragraphes sont choisis alĂ©atoirement afin que les donnĂ©es reçues soient diffĂ©rentes d’une demande Ă  une autre. Chaque demande est renouvelĂ©e 50 fois afin d’avoir une moyenne pour chaque nombre de paragraphes. Ainsi, le temps d’initialisation de l’objet “parser” (que ce soit pour le JSON, MessagePack ou Protobuf) qui intervient au premier tour, est diluĂ©. Ce choix est fait pour s’approcher de la rĂ©alitĂ©: l’objet “parser” est initialisĂ© au premier passage et est rĂ©utilisĂ© tout au long de l’usage de l’application.


RĂ©sultats Benchmark: temps en ms par le nombre de paragraphes par fichier

PremiÚre constatation déjà connue : XML est totalement hors course. Pour plus de lisibilité, on retire XML du second schéma.


RĂ©sulats Benchmark sans XML: temps en ms par le nombre de paragraphes par fichier

Pour les autres formats, on peut constater un temps de traitement plus faible pour Protocol Buffers. Pour le JSON Gzippé, le coût du traitement est multiplié par 1,2 par rapport au JSON. Le facteur entre JSON (avec Jackson, soit le plus bas) et Protocol Buffers est de presque 2.
La conclusion est donc qu’en temps de traitement sur des donnĂ©es textes, Protocol Buffers est nettement Ă  son avantage.


image (3)

MĂ©moire totale allouĂ©e pour l’appel et le traitement d’un fichier de 10 000 paragraphes

Concernant le coĂ»t mĂ©moire, on s’aperçoit assez facilement que Protocol Buffers consomme presque aussi peu que Jackson pour le JSON.


Au niveau de la compression de la donnée initiale, on peut constater que le binaire protobuf est plus léger que celui de MessagePack ou encore du JSON Gzippé.

image (1)

CÎté Android

MalgrĂ© ces rĂ©sultats encourageants, la mise en place d’une nouvelle solution peut paraĂźtre pĂ©rilleuse. Pour Protocol Buffers, l’utilisation reste relativement simple. Prenons Android comme exemple. On a le choix entre l’ImplĂ©mentation Officielle de Google (IOG) et la version de Square, Wire. Au-delĂ  de l’efficacitĂ©, la comparaison de plusieurs autres points est nĂ©cessaire.

Génération du code :

Deux façons de générer votre code : en ligne de commande ou en pré-build.

En ligne de commande :

Pour IOG, le paquet de la derniÚre version est disponible et contient un exécutable.

protoc --java_out=. *.proto

Pour Wire, un jar est aussi disponible.

java -jar wire-compiler-2.2.0-jar-with-dependencies.jar --java_out=. --path_proto=. *.proto

En pré-build :

Du cĂŽtĂ© d’IOG, ce n’est pas possible. Du moins pour la norme proto3. Un plugin Gradle existe mais nĂ©cessite gradle 2.12 mais ne comprend que proto2.

Wire est plus efficace sur ce point. Square dispose officiellement d’une version Gradle du plugin Wire, mais le dĂ©pĂŽt n’est plus Ă  jour depuis environ un an. De plus, il n’y a aucune information d’utilisation et impossible de le trouver sur les dĂ©pĂŽts officiels tel que jcenter ou mavenCentral. Un des forks rĂ©sout ces problĂšmes : le plugin Wire Gradle par Jiechic.

La mise en place est ensuite trĂšs simple :

Dans build.gradle du projet :

classpath ‘com.jiechic.librairy.wire:wire-gradle-plugin:1.0.0’

Dans build.gradle de l’app:

apply plugin: 'com.squareup.wire'
dependencies { compile 'com.squareup.wire:wire-runtime:2.2.0' }

Il suffit ensuite de placer les fichiers proto dans src/main/proto. A la compilation, les objets seront générés dans build/generated/source/proto.

Objets Générés :

Square gagne sans contestation. Les fichiers gĂ©nĂ©rĂ©s par IOG sont illisibles et rebutants. Ceux de Square sont bien plus simples Ă  comprendre. De plus, les objets gĂ©nĂ©rĂ©s sont aussi plus simples Ă  l’utilisation.

Encode/Decode :

Dans mon cas, seule la partie ‘decode’ de chaque version a Ă©tĂ© utilisĂ©e. Les syntaxes sont simples. Par exemple, la structure est la suivante :

syntax = “proto3”;
package hello;
option java_package = “com.sdu.testprotoreceive”;

message Hello {
   string name = 1;

IOG version:

HelloOuterClass.Hello hello = HelloOuterClass.Hello.parseFrom(byteArray);

Wire version:

Hello hello = hello.ADAPTER.decode(byteArray);

Les objets générés par Wire étant plus simples, ils sont aussi plus naturels à utiliser.

Autres langages

Le serveur utilisé pour les tests présentés plus haut est en Go. La génération des objets Go depuis les fichiers proto3 se fait ainsi :

protoc --go_out=. *.proto

La commande est gĂ©nĂ©rique d’un langage Ă  un autre, ce qui rend l’usage trĂšs simple. Pour interprĂ©ter le fichier gĂ©nĂ©rĂ©, la librairie n’est pas sur le mĂȘme dĂ©pĂŽt que celui des autres langages :

go get -u
go get -u

Example d’utilisation:

func sendProto(w http.ResponseWriter, r *http.Request) {
  hello := new(hello.Hello)
  hello.Name = “Marie”
  hello.Number = 32
  w.Header().Set("Content-Type", "application/x-protobuf")
  helloCompress, err := proto.Marshal(hello)
  if err != nil {
    log.Fatal("Compress Problem (Marshal error)")

Le dernier langage testĂ© est le C#. Encore une fois, c’est la simplicitĂ© qui prime.

public static void Main (string[] args)
  WebRequest wrGETURL = WebRequest.Create( "http://xx.xx.xx.xx:8000/");
  Stream streamHello = wrGETURL.GetResponse().GetResponseStream();
  Hello hello = Hello.Parser.ParseFrom(ReadFully(streamHello));
  Console.WriteLine (hello.Name+" "+hello.Number+" "+hello.Bool);

Ici, la fonction ReadFully permet seulement de transformer le Stream en tableau de bytes.

Mise en Oeuvre

Mise en oeuvre

Schéma de la mise en oeuvre disponible: le dépÎt, le client Go, le serveur Go, les clients Android

Un jeu de test fourni sur Github vous permet de voir une mise en oeuvre plus concrĂšte. Un dĂ©pĂŽt Go contient le fichier protobuf et possĂšde une application pour gĂ©nĂ©rer les objets dans les langages souhaitĂ©s. Un serveur Go va chercher dans ce dĂ©pĂŽt son objet, un client Go fait de mĂȘme. Le client Android sous Wire trouve le fichier protobuf et gĂ©nĂšre ses objets en prĂ©-build. Le client Android sous IOG rĂ©cupĂšre le fichier jar crĂ©Ă© par le dĂ©pĂŽt Go.


La gĂ©nĂ©ration des objets pour Java, Golang et C# s’est faite en trois lignes de code grĂące Ă  un fichier trĂšs simple Ă  Ă©crire.

L’utilisation de ces objets est trĂšs semblable d’un langage Ă  un autre et ressemble assez aux fonctions pour dĂ©coder du JSON.

Pour un contenu texte, sur un client Android, Protobuf possĂšde plusieurs avantages comme la simplicitĂ© (“build”) ou le gain en temps de traitement (“run”). Son utilisation Ă  la place du JSON peut mĂȘme ĂȘtre conseillĂ© dans le cas d’un nouveau projet.

Il faut néanmoins prendre en compte que certains outils sont peu ou pas mis à jour (comme le plugin gradle par Square).

La V3 tente de simplifier l’utilisation et d’agrandir le champs des utilisateurs, avec toujours plus de nouveaux langages. L’apprĂ©hension du binaire, l’utilisation de nouveaux formats et le JSON dĂ©jĂ  en place depuis longtemps freinent le changement. C’est, je pense, les raisons qui laisse Protocol Buffers peu utilisĂ©.

Catégories: Blog Société

Leveraging Atlassian tools in enterprise-scale businesses (part one)

Le blog de Valiantys - mar, 07/19/2016 - 08:30

Atlassian has been hard at work developing tailor-made enterprise offerings for companies with large, complex environments. Companies that have already adopted the offerings are raving about them, but what sold them on Atlassian solutions in the first place? In this two-part blog, we take a closer look at where the offerings originated from, and how to ...

The post Leveraging Atlassian tools in enterprise-scale businesses (part one) appeared first on Valiantys Blog - Atlassian Expert.

Catégories: Blog Société

LCC 151 - Tu mets quoi comme antivirus toi ?

Emmanuel, Guillaume et Antonio discutent avec StĂ©phanie des nouvelles du front(y compris -end). On y parle garbage collector, microprofile, javascript et mĂȘme d’antivirus Windows.

Enregistré le 13 juillet 2016

TĂ©lĂ©chargement de l’épisode LesCastCodeurs-Episode–151.mp3

Stéphanie Moallic

News Langages

Default method et performance du code compilé Scala
Go et l’amĂ©lioration de son garbage collector
JMM Et tu comprends
 Et tu comprends plus
NPM fail encore
Node.JS bridge for COBOL
Belles assertions Ă  la Spock pour Java
.Net Core 1.0 releasé pour Microsoft, OS X et Linux


Micro Profile
Oracle est comité sur Java EE
Websphere 9 compatible avec Java EE 7
Vulnérabilité Spring MVC/Security
Mettre Ă  jour Hibernate ORM dans Wildfly
Vert.x 3.3


JWT comme une session
JWT pas une session
Les fonctionnalités les plus excitantes de Angular 2
Tutoriel Glide et Gaelyk

JavaScript et CSS

Pas besoin de Lodash/Underscore
Pas besoin de JavaScript


Neo4J JDBC driver
Github archive dataset sur BigQuery
Ce qu’on peut apprendre de millions de lignes de code sur Github
On peut utiliser Groovy pour faire du Spark


Kubernetes 1.3
5 days of Kubernetes 1.3
Kubernetes et autoscaling
Minikube pour lancer un cluster en local
Docker 1.12 inclus l’orchestration de conteneurs
le résumé Docker 1.12 de Nicolas Deloof

Architecture Outils et DevOps

JUnit 5.0.0M1
AVG rachetĂ© et l’antivirus pour l’ordinateur de tante Christine
Android Studio 2.2 M5


Le pilote automatique Tesla dans un accident mortel

Organisation, communication et politique

Smart contracts et ses revers
Un contre point sur la force des smart contracts

Outils de l’épisode

Windows Defender

Rubrique du débutant

Le garbage collector


Jugsummercamp le 16 septembre
JavaOne du 18–22 septembre
ngEurope 25, 26 octobre 2016
Codeurs en Seine, le CfP le jeudi 24 novembre (avec des ateliers le 26 novembre)
DevFest Nantes, le CfP les 9 et 10 novembre Ă  Nantes. CfP jusqu’à fin aoĂ»t.
Devoxx Belgique du 7 au 11 novembre

Nous contacter

Contactez-nous via twitter
sur le groupe Google
ou sur le site web
Flattr-ez nous (dons) sur
En savoir plus sur le sponsoring?


Catégories: Blog Individuel

Why Scrum with JIRA Software?

Le blog de Valiantys - jeu, 07/14/2016 - 09:00

I recently attended a Scrum Master training session and one thing that the trainer said over and over again was: “Post-its over tools!”. I couldn’t ignore the pure hatred that the trainer had towards these tools (even though some of it was sarcastic – he really meant it!) The reasons for his dislike were: When you ...

The post Why Scrum with JIRA Software? appeared first on Valiantys Blog - Atlassian Expert.

Catégories: Blog Société

Les 7 clĂ©s d’une CommunautĂ© de ScrumMaster ou PO qui rĂ©ussit

Qualitystreet - Jean Claude GROSJEAN - mer, 07/13/2016 - 15:15

et oui, car bien que leur nĂ©cessitĂ© ne soit plus Ă  prouver dans le cadre d’une transformation agile organisationnelle,  il est vrai que les communautĂ©s de pratiques* peuvent vite s’essouffler… ScrumMaster et Product Owner, deux rĂŽles, nouveaux rĂŽles de surcroĂźt, pour lesquels les RH des entreprises ont encore un bon train de retard. Sans oublier…

The post Les 7 clĂ©s d’une CommunautĂ© de ScrumMaster ou PO qui rĂ©ussit appeared first on QualityStreet - Blog Pro de Jean Claude Grosjean.

Catégories: Blog Individuel

Uniformiser un Use Case Data comme un chef !

Il est difficile d’apporter une rĂ©ponse adaptĂ©e Ă  un problĂšme lorsque celui-ci n’est pas clairement dĂ©fini. La solution nĂ©cessitera un temps de dĂ©veloppement Ă©levĂ© Ă  cause d’un nombre incalculable d’aller-retours entre le Product Owner et le reste de l’Ă©quipe. Pour Ă©viter ce gĂąchis de temps et d’effort, il faut arriver Ă  faire Ă©merger une vision commune de la problĂ©matique.

Mais alors, comment peut-on exprimer prĂ©cisĂ©ment un besoin sans y passer des heures ? C’est sur cet exercice ardu que nous allons nous pencher aujourd’hui Ă  travers cet article.

Cerner le contexte

Pour avoir un cadre un peu plus concret, nous allons nous projeter dans l’univers du (Big) Data oĂč les attentes peuvent ĂȘtre un peu floues. Voici un exemple typique : « Je veux analyser toutes les donnĂ©es disponibles pour recommander les meilleurs produits aux consommateurs ».

Plusieurs questions sautent aux yeux : De quelles donnĂ©es est-il question ? Sous quelle forme doit se faire la recommandation ? Comment mesurer l’efficacitĂ© de la recommandation ? Etc.

En se basant sur un article de Gianmario Spacagna et sur ce blog, un ensemble de questions orientées Data est ressorti, voici ce que nous avons retenu :

  • Quel problĂšme cherchons-nous Ă  rĂ©soudre ?
  • Pour qui ?
  • Comment faites-vous actuellement ?
  • Quel impact bĂ©nĂ©fique cela peut avoir pour le mĂ©tier ?
  • Quelles sont les sources de donnĂ©es et d’oĂč viennent-elles ?
  • Quels sont les livrables attendus et comment sont-ils utilisĂ©s ? (algorithme, rapport, etc.)
  • Quand pouvons-nous considĂ©rer la phase d’exploration comme terminĂ©e ?
  • Comment mesurer objectivement la qualitĂ© de toute solution, qu’elle que soit son implĂ©mentation ?
  • Que cherchons-nous Ă  faire grĂące Ă  ce Use Case : faire des Ă©conomies ou amĂ©liorer les revenus ?

Cette liste n’est pas exhaustive mais elle permet dĂ©jĂ  d’avoir une vision plus globale du problĂšme, l’idĂ©e Ă©tant de simplifier au maximum la vie des data scientists lors de la phase d’exploration.

Une fois la liste de questions identifiées, il manque encore le principal : les réponses ! Pour ce faire, le chef vous propose une petite recette de cuisine agile.

Use Case Data façon Agile Ingrédients pour 12 personnes :

1 use case

1 liste de questions

10 feuilles A4

1 bloc de post-it

4 stylos

1 chronomĂštre

RĂ©alisation :

Difficulté : Facile

Préparation : 10 min

Cuisson : 40 min

Dressage : 10 min

Temps Total : 1 h


RĂ©aliser un canevas en disposant les questions sur 2 feuilles A4.


RĂ©pĂ©ter le processus 4 fois. RĂ©server un canevas au frais jusqu’au moment du dressage.


Réunir les personnes concernées par le Use Case : client, marketing, direction, data scientist, data engineer, etc.

Remercier les participants de s’ĂȘtre libĂ©rĂ©s puis Ă©noncer la liste des questions sur lesquelles ils vont travailler.


RĂ©partir les participants en 4 groupes, bien mixer les profils.

Astuce du chef : Mixer les profils techniques avec les profils fonctionnels permet d’avoir une vision plus complĂšte de la rĂ©ponse Ă  apporter.

Faire des petites Ă©quipes permet d’éviter l’effet « un qui travaille, les autres regardent », le chef recommande des groupes de 3 Ă  4 personnes maximum.


Fournir post-its, stylos et canevas aux 4 équipes pour collecter les réponses.

Astuce du chef : Demander aux Ă©quipes d’écrire sur des post-its plutĂŽt que directement sur le canevas, cela vous permettra de sauter l’Ă©tape 1 la prochaine fois.


Lancer un compte Ă  rebours de 40 min pour la cuisson et laisser cogiter.

Astuce du chef : Annoncer le temps restant Ă  la moitiĂ© du temps imparti et dans les derniĂšres minutes, cela met une pression saine aux participants qui se concentrent alors sur l’essentiel.

Veiller à ce que les réflexions restent à bonne température, la cocotte-minute ne doit pas exploser sous la pression.


Énoncer Ă  tour de rĂŽle les rĂ©ponses aux questions.


Sortir le dernier canevas du frigo et aller chercher un consensus sur le résultat final.


Lancer un compte Ă  rebours de 10 min pour le dressage et laisser le Use Case prendre forme.


lean canevas

Bonne dégustation ! Conclusion

J’espĂšre que la recette vous a plu. Comme en cuisine, il y a deux Ă©tapes primordiales : la prĂ©paration et la cuisson.

La prĂ©paration (la recherche des questions et la confection du canevas) peut s’adapter Ă  quasiment tous vos besoins. Cette Ă©tape est trĂšs flexible car elle ne s’applique pas uniquement Ă  des Use Cases Data. Il vous suffit d’avoir un problĂšme et les bonnes questions Ă  poser aux bonnes personnes pour ajuster la recette et avoir un Use Case Ă  votre sauce.

La cuisson (la rĂ©flexion) doit ĂȘtre bien surveillĂ©e : ni trop longue, ni trop courte et Ă  bonne tempĂ©rature. Cette Ă©tape de confrontation d’idĂ©es peut prĂ©senter Ă©galement des vertus de teambuilding.

PS : Toute ressemblance entre le canevas décrit dans la recette et le lean canvas ne serait pas si fortuite que ça.

Catégories: Blog Société

Connexion par accÚs pré-autorisé avec Doorkeeper

L'actualité de Synbioz - mar, 07/12/2016 - 23:00

Pour faire suite Ă  mon prĂ©cĂ©dent article sur l’administration des accĂšs Doorkeeper, dans lequel je vous avais proposĂ© une adaptation pour permettre leur gestion par un administrateur, je voudrais maintenant aborder la partie connexion avec ces accĂšs.

Il va falloir mettre en place un processus d’autorisation spĂ©cifique Ă  cette gestion d’accĂšs customisĂ©e, ainsi qu’une stratĂ©gie d’authentification en accord avec celui-ci dans les applications clientes.

Lire la suite...

Catégories: Blog Société

Retour sur le tout premier Paris Container Day

Blog d’Ippon Technologies - mar, 07/12/2016 - 13:22

Ce mercredi 28 juin, j’ai eu la chance de participer au tout premier Paris Container Day, organisĂ© par Xebia dans le magnifique restaurant Elyseum privatisĂ© pour l’occasion. Durant cette journĂ©e, nous avons pu assister Ă  diffĂ©rents talks ou hands-on autour des technologies de containerisation. Vous avez pensĂ© « Docker » ? Oui, mais pas que !

À travers la keynote, animĂ©e par Pablo Lopez, directeur technique de Xebia, nous avons bien intĂ©grĂ© que les containers Ă©taient devenus un standard de facto au cours des 3 derniĂšres annĂ©es. Bien Ă©videmment, le concept de « container » existe depuis longtemps, mais il a Ă©tĂ© largement dĂ©mocratisĂ© avec l’apparition de Docker. Au dĂ©but de son existence, Docker a tout d’abord suscitĂ© la curiositĂ©, entraĂźnant les dĂ©veloppeurs Ă  faire des essais en local, parfois trĂšs exotiques, pour connaĂźtre les possibilitĂ©s de ce nouvel outil. Il faudra compter une bonne annĂ©e, avant de vraiment voir des containers en production et encore une annĂ©e avant qu’il soit massivement adoptĂ©. Seulement, faire tourner une dizaine de containers sur 2 serveurs, ou plusieurs milliers de containers sur du cloud, ça ne demande pas les mĂȘmes efforts pour le dĂ©ploiement, la supervision ou encore le maintien en conditions opĂ©rationnelles.

La stratĂ©gie et les enjeux ne sont plus aujourd’hui de savoir quelle technologie de containers utiliser, mais plutĂŽt de la maniĂšre dont ils vont ĂȘtre dĂ©ployĂ©s, provisionnĂ©s, multipliĂ©s, mis Ă  jour ou encore surveillĂ©s.

C’est ainsi que sont apparus les « orchestrateurs », magnifiques outils nous permettant de nous abstraire complĂštement de l’infrastructure — « J’ai besoin de faire tourner en permanence 10 instances de mon container : dĂ©brouille toi, mets les oĂč tu veux, je ne veux pas le savoir ! » — ou de la perte de ressources — « Un serveur qui abritait des containers est mort ? Pas de problĂšme, ils ont Ă©tĂ© crĂ©Ă©s ailleurs ». — Aujourd’hui, les 3 orchestrateurs principaux sont : Docker Swarm (Docker), Kubernetes (initialement dĂ©veloppĂ© par Google), Mesos/Marathon (Apache/Mesosphere).

La journĂ©e s’annonce bien, remise dans le contexte efficace et de nombreuses confĂ©rences sur tous ces sujets en perspective. Ne pouvant pas ici dĂ©tailler l’intĂ©gralitĂ© des confĂ©rences auxquelles j’ai assistĂ©, je vous propose un petit feedback par « produit » et plus particuliĂšrement sur Kubernetes et Mesosphere.

Quoi de neuf chez Docker ?

La DockerCon 2016 Ă  Seattle vient de se terminer. Jean-Laurent de Morlhon Ă©tait donc lĂ  pour nous prĂ©senter les nouveautĂ©s de Docker et les faits marquants. En plus d’une remise dans le contexte de la stratĂ©gie de Docker, “qui n’est pas de changer le monde, mais de vous permettre de le faire”, puis de l’annonce d’un “Docker Store” permettant de rechercher des images officielles, voici les deux principaux sujets que j’ai retenu.

Docker Desktop


Travaillant sur Linux, j’avoue ne pas ĂȘtre directement impactĂ© par cette annonce, mais elle me parait ĂȘtre de taille. Les versions Windows et Mac de Docker sont officiellement disponibles en version Beta. L’idĂ©e est d’uniformiser l’expĂ©rience utilisateur, quelle que soit la plateforme utilisĂ©e. Il ne sera donc plus nĂ©cessaire d’utiliser vagrant ou docker-machine pour lancer des containers sur vos machines.

Docker 1.12


Autre annonce de taille : la sortie de Docker 1.12. Pour la gestion des clusters, Docker proposait un outil externe appelĂ© Swarm. DĂ©sormais, Swarm est directement intĂ©grĂ© dans le deamon Docker. Avec lui viennent Ă©galement les mĂ©canismes de gestion et de dĂ©couverte des services, ainsi que de la sĂ©curitĂ©. Il n’est plus nĂ©cessaire de tout mettre en place manuellement (cluster Consul pour le stockage des informations, ajout d’un agent Swarm sur les serveurs, etc.), Docker s’en charge pour vous, fini les dĂ©pendances externes.


Merci à Jean-Laurent de Morlhon pour sa conférence : Retour de la DockerCon 2016, les faits marquants.

Les slides disponibles ici :

De Borg Ă  Kubernetes Un peu d’histoire

Google utilise des containers depuis de nombreuses annĂ©es et aujourd’hui en dĂ©marre plusieurs milliers par semaine. Chez eux, tout est containerisĂ© (Search, Maps, Gmail, etc.).

Pour gĂ©rer leur parc de containers, ils utilisent un outil interne appelĂ© Borg. SchĂ©matiquement, un agent « borglet » est installĂ© sur chacun des nƓuds (physiques ou virtuels) et communique avec un « Borg master ». Ainsi, le master est informĂ© en permanence par les agents de l’Ă©tat des diffĂ©rents nƓuds (CPU, RAM, disques, containers dĂ©marrĂ©s, etc.). Et inversement, il est capable d’envoyer des instructions aux agents pour qu’ils dĂ©marrent ou arrĂȘtent des instances de container.


Leur outil Ă©tant trop liĂ© Ă  l’infrastructure et aux spĂ©cificitĂ©s de Google, ils ont dĂ©cidĂ© de rĂ©Ă©crire un nouvel orchestrateur open source conservant les concepts de base : Kubernetes. Afin d’Ă©viter de trop diverger ou de le rendre spĂ©cifique, Google a cĂ©dĂ© la propriĂ©tĂ© de Kubernetes Ă  la CNCF (Cloud Native Computing Foundation) qui est dĂ©sormais garante du respect des standards.

Merci à Alexis Moussine-Pouchkine pour sa conférence : Kubernetes, votre assurance-vie pour le Cloud.

Les concepts

Kubernetes utilise un ensemble de concepts et de mots clĂ©s, qu’il faut nĂ©cessairement comprendre avant de commencer.

  • Node : serveur physique ou logique sur lequel est installĂ© l’agent Kubelet,
  • Pod : plus petite unitĂ© logique dans Kubernetes. Il peut ĂȘtre composĂ© de 1 ou plusieurs containers,
  • Labels : il est possible de dĂ©finir un ensemble de clĂ©s/valeurs sur chacun des composants de Kubernetes (pod, service, 
). Il sera possible de regrouper les Ă©lĂ©ments en fonction de leurs labels (Selector). Par exemple, on pourra labelliser les nodes « role:front », « role:bdd » ou les pods « version:v2 »
  • Service : dĂ©fini un ensemble de pods et leur assigne un nom par lequel y accĂ©der (DNS)
  • Replication Controller : assure que le nombre d’instances spĂ©cifiĂ© d’un pod correspond bien au nombre d’instances dĂ©marrĂ©es sur le cluster. Sinon, il arrĂȘtera ou dĂ©marrera automatiquement des instances du pod concernĂ©.

Ainsi, en jouant avec ces concepts, il est trĂšs facile d’augmenter ou de diminuer le nombre d’instances de chaque container, d’interroger un container d’un certain type sans savoir oĂč il est ni mĂȘme lequel est appelĂ©, ou encore de mettre Ă  jour les applications sans interruption de service.

Kubernetes est Ă©galement capable de gĂ©rer l’auto-scalling ; c’est Ă  dire qu’en fonction de seuils dĂ©finis sur un pod (CPU > 90 %, RAM > 90 %, 
), Kubernetes pourra dĂ©marrer automatiquement de nouvelles instances de ce pod afin de lisser la charge.

Merci Ă  Cedric Hauber, Matthieu Parisot et Yann Lambret pour leur hands’on : Kubernetes par l’exemple avec une magnifique application sur l’euro 2016 (dois-je dire que l’Espagne a gagnĂ© pendant le hands-on ?).


Pour la plupart des applications distribuĂ©es, il est nĂ©cessaire de mettre en place un espace de stockage de type clĂ©/valeur afin de persister l’Ă©tat du cluster. Kubernetes se base sur etcd pour stocker l’intĂ©gralitĂ© des informations du cluster (nodes, pods, etc.).

Durant sa confĂ©rence, Jonathan Boulle de chez CoreOs, nous a parlĂ©, entre autres, des gros efforts de performance sur la v3 d’etcd par rapport Ă  la v2. Il a Ă©galement indiquĂ© que malgrĂ© les amĂ©liorations, ils ne sont pas encore au niveau de Zookeeper qui obtient les meilleurs scores en terme de vitesse de lecture et d’Ă©criture par rapport Ă  consul, etcd2 et etcd3, si on considĂšre que ces outils sont vraiment comparables.
Etcd_Zookeeper_Consul_1K Etcd3_Zookeeper

Merci à Jonathan Boulle pour sa conférence : How CoreOS sees the container industry.

Slides disponibles ici :

Mesosphere : gĂ©rons des ressources plutĂŽt que des nƓuds

Contrairement Ă  Kubernetes, la volontĂ© de Apache Mesos est de gĂ©rer un ensemble de machines comme si elles ne constituaient qu’une seule et mĂȘme machine. Cette application permet de crĂ©er une sur-couche aux diffĂ©rents OS installĂ©s sur les serveurs d’un cluster afin de s’abstraire de la notion de machine et de ne gĂ©rer qu’un ensemble de ressources comme s’il s’agissait d’un cloud privĂ©. Il est ainsi possible de dĂ©marrer un service, lancer une commande, ou exĂ©cuter un script sur le cluster, sans avoir Ă  connaĂźtre le serveur rĂ©ellement utilisĂ©.

Tout comme Kubernetes, Mesos fonctionne grĂące Ă  un agent dĂ©ployĂ© sur l’intĂ©gralitĂ© des nƓuds du cluster (appelĂ© Mesos-Slave) qui communique avec un agent (Mesos-Master) dĂ©ployĂ© sur des nƓuds « Master ». Il est trĂšs largement conseillĂ© de ne pas cumuler les fonctions “slave” et “master” sur le mĂȘme noeud. Les serveurs masters devraient ĂȘtre exclusivement dĂ©diĂ©s Ă  la gestion du cluster. En revanche, c’est Zookeeper qui est utilisĂ© pour le stockage des informations fournies par les agents Mesos, stockage distribuĂ© clĂ©/valeur qui a largement fait ses preuves. Afin de diminuer les risques d’erreur (arrĂȘt d’une machine par exemple), il est recommandĂ© de monter un cluster d’au moins 3 masters. Mesos recense donc au travers de ses agents l’intĂ©gralitĂ© des ressources disponibles. Si vous voulez commencer Ă  dĂ©ployer des containers Docker, Mesos n’est pas suffisant, vous aurez besoin de l’application Marathon.


Marathon est le vĂ©ritable « orchestrateur » de services tournant sur un cluster Mesos. Sur l’interface de Marathon, il est donc possible de crĂ©er des « applications » avec tout un tas de paramĂštres tels que les limites de CPU et de RAM, le container Docker Ă  utiliser ou le service Ă  dĂ©marrer, comment vĂ©rifier qu’il est en bonne santĂ©, ou encore le nombre d’instances que l’on souhaite faire tourner. Marathon va communiquer avec les masters du cluster Mesos, afin que ces derniers gĂšrent toutes les opĂ©rations. Mesos se chargera de rĂ©partir la charge sur les diffĂ©rents slaves, alors que Marathon surveillera l’Ă©tat du cluster au travers des APIs de Mesos et demandera l’arrĂȘt ou le dĂ©marrage d’applications en fonction des paramĂštres de scalabilitĂ© saisis.

À la diffĂ©rence de Mesos, sous licence Apache et entiĂšrement maintenu par la communautĂ©, Marathon est une application open source poussĂ©e par la sociĂ©tĂ© Mesosphere. Cette derniĂšre propose une solution open source complĂšte de gestion de plateforme Ă©volutive (cloud privĂ©) basĂ©e sur Mesos : baptisĂ©e DC/OS. Plus qu’un outil, DC/OS est un systĂšme d’exploitation distribuĂ© sur un cluster. En plus des fonctionnalitĂ©s des Mesos, DC/OS permet de faciliter les dĂ©ploiements et l’isolation de services stateless ou de containers, gĂ©rer la communication entre les services ou encore permettre du load balancing.


DĂ©velopper un systĂšme d’exploitation distribuĂ© c’est une chose, mais ça demande un peu plus de configuration que simplement l’ajout d’un agent sur une machine. Comment faire pour tester sur un environnement local les possibilitĂ©s de DC/OS. Pour ce faire, Mesosphere a mis Ă  disposition “Minimesos” qui permet d’installer et d’auto-configurer les diffĂ©rents outils de la stack en une fois, sur son poste de dĂ©veloppement.

Merci Ă  Alex Rukletsov pour sa confĂ©rence : How cluster managers affect the landscape of modern distributed computing—why we decided to open source DC/OS

Merci à Philip Norman et Franck Scholten pour leur conférence : Deep dive into one of the application of DCOS : Velocity

Continuous Delivery avec Jenkins 2

Je ne pouvais terminer cet article sans évoquer la brillante intervention de Nicolas De Loof qui est venu nous parler de déploiement continu avec Jenkins 2.

D’apparence, rien de rĂ©volutionnaire avec cette nouvelle version. Et pourtant
 Fini le clickodrome, place aux scripts Groovy et aux pipelines ! Vous pouvez dĂ©sormais dĂ©finir les diffĂ©rentes Ă©tapes de votre build dans un seul fichier de configuration, sans avoir besoin de crĂ©er plusieurs jobs s’enchaĂźnant les uns les autres. Pour ceux qui ne l’auraient pas dĂ©jĂ  fait, je vous invite Ă  regarder sa confĂ©rence au Devoxx France 2016 (disponible ici :

“Mais c’est le container day, quel est le rapport avec Jenkins ?” “Facile, il y a un plugin pour tout !”. Nous avons donc pu dĂ©couvrir que Jenkins possĂšde Ă©galement des plugins Docker, permettant de gĂ©nĂ©rer une image, ou bien de construire son projet directement dans un container (afin par exemple de s’assurer que les composants nĂ©cessaires au build soient dans des versions maĂźtrisĂ©es). Et grĂące Ă  Philip Norman, nous savons Ă©galement qu’il existe un plugin pour Marathon, qui permet de dĂ©ployer le container gĂ©nĂ©rĂ© directement sur le cluster Mesos.

Merci Ă  Nicolas De Loof pour sa confĂ©rence : Évolution du Continuous Integration/Continuous Delivery avec l’émergence des conteneurs et leurs Ă©volutions.

Pour finir, je souhaiterais remercier tous les speakers que je n’ai pas citĂ©, qui sont venus partager leurs connaissances, leurs compĂ©tences et leurs expĂ©riences sur les containers.

FĂ©licitations Ă  tout le monde !

Catégories: Blog Société

Appaloosa-Store, la filiale d’OCTO, s’exporte aux États-Unis !

Logo de la start-up AppaloosaCrĂ©Ă©e au sein d’OCTO en 2011, la filiale Appaloosa-Store n’a pas manquĂ© de faire parler d’elle ces derniers mois. Reconnu par Gartner pour la qualitĂ© de son produit et rĂ©compensĂ© par Le Grand Prix de l’Innovation Digitale (ID16), l’app store privĂ© prend dĂ©finitivement le large, jusqu’à dĂ©couvrir, en septembre, de nouveaux horizons

Un succÚs confirmé en parallÚle par les belles performances financiÚres de la start-up.

Retour, avec fierté, sur ces derniÚres actus.



C’est officiel : Appaloosa traversera l’Atlantique dùs septembre.

SĂ©lectionnĂ©e pour le programme d’accĂ©lĂ©ration de The Refiners, la start-up aura l’opportunitĂ© de s’immerger dans la culture et les pratiques de la Silicon Valley, par l’intermĂ©diaire de son CEO Julien Ott.

“Lors de notre dernier passage aux US fin 2015, nous avions remarquĂ© que notre produit y avait un fort potentiel, mais que notre message devait ĂȘtre adaptĂ© avant de dĂ©marcher des clients, explique Julien Ott. The Refiners va nous permettre de positionner notre produit sur le marchĂ© amĂ©ricain et de l’adresser rapidement grĂące Ă  leur rĂ©seau de contacts. Nous souhaitons valider avant fin 2016 l’opportunitĂ© d’y ouvrir une filiale.”

3 mois de formation intensive, de mentorship et de prospection. On attend avec impatience le retour d’expĂ©rience de Julien sur le sujet !


Appaloosa-Store en quelques mots / chiffres

Appaloosa rĂ©sout le problĂšme de la distribution privĂ©e, la mise Ă  jour et la gestion d’applications mobiles. La start-up aide les Ă©quipes mobiles et digitales Ă  construire, tester, dĂ©ployer et gĂ©rer leurs applications, qu’elles soient dĂ©ployĂ©es pour les testeurs ou les employĂ©s.

En quelques minutes, Appaloosa permet la crĂ©ation d’un app store privĂ© sur tout type d’appareil mobile.

Clients Appaloosa Store

Plus de 10,000,000 applications via 7 000 stores privés.

300 % de croissance entre 2014 et 2015.

600 K de chiffre d’affaires en 2015.


Grand Prix de l’Innovation Digitale : ID Bronze catĂ©gorie Data

OrganisĂ© par Petit Web, le Grand Prix de L’Innovation Digitale (ID16) rĂ©compense l’innovation des start-up et entreprises dans 7 catĂ©gories. Ses critĂšres : “le caractĂšre inĂ©dit du projet et son impact actuel ou potentiel sur son marchĂ©â€.

RĂ©compensĂ©e dans la catĂ©gorie Data, Appaloosa a remportĂ© la semaine derniĂšre l’ID Bronze.

Un prix qui confirme – si besoin en Ă©tait – l’intĂ©rĂȘt et la confiance du secteur pour Appaloosa.

Appaloosa Ă  l'ID16

Appaloosa parmi les laurĂ©ats de l’ID16

.@AppaloosaStore team won the ID Bronze award at the Grand Prix #ID16 yesterday! Oh yeaah! Thanks @petit_web jury!

— (@AppaloosaStore) 6 juillet 2016


Appaloosa Ă©tait Ă  VivaTech !
  • Talk et interview

Participation de Julien Ott au talk “Corunning innovation : Avec Appaloosa, SNCF accĂ©lĂšre la culture du test et du learn” sur le stand SNCF.

Appaloosa a aidé SNCF à construire un app store natif pour leur communauté de plus de 2000 testeurs. Vous pouvez les rejoindre sur


Interview de Julien Ott au stand Widobiz


  • Les “off”

Impossible d’avoir ratĂ© la team Appaloosa Ă  Viva Tech (ou alors, vous avez ratĂ© le clou de votre visite
) ! Avec ses coiffes d’indien et sa sharing box, le stand d’Appaloosa s’est rapidement imposĂ© comme un passage obligatoire.

Appaloosa - Salon Viva Tech Start up               Appaloosa - Salon Viva Tech Start up                Appaloosa - Salon Viva Tech Start up


MĂȘme Emmanuel Macron y a “rĂ©vĂ©lĂ© son cĂŽtĂ© Sioux”… ou presque.

emmanuel-macron-viva-tech-appaloosa                Emmanuel Macron à Viva Tech avec Appaloosa

Petite cerise sur le gĂąteau, @AppaloosaStore figurait parmi les comptes Twitter les plus influents des 3 jours (634 mentions #Vivatech @AppaloosaStore).

Gartner : Appaloosa reconnue 2 fois en 2016

VĂ©ritable rĂ©fĂ©rence pour les DSI et les acheteurs, Gartner identifie par deux fois Appaloosa comme un outil de qualitĂ©, et un acteur qui monte. Sa reconnaissance n’est pas seulement une fiertĂ© : elle tĂ©moigne du dynamisme de la start-up sur le marchĂ© et de l’intĂ©rĂȘt grandissant du secteur pour sa technologie.

  1. Leader in the Mobile Application Management market guide (March 2016)
  2. Cool Vendor in France for technologies and services (April 2016)

Vous en voulez plus ? Retrouvez toutes les actus et les articles d’Appaloosa sur leur blog !

Photo de la Team Appaloosa Store



Articles suggested :

  2. Livre Blanc : Banque Digitale, les FinTech cannibalisent la banque
  3. Inside USI 2015 – compte-rendu des sessions

Catégories: Blog Société

[Agile Tour 2016] C’est parti !

Agile Nantes - mar, 07/12/2016 - 12:26
SAVE THE DATE C’est le jeudi 13 octobre 2016 que se dĂ©roulera la 8Ăšme Ă©dition à l’École des Mines de Nantes (4 Rue Alfred Kastler, 44300 Nantes). Le thĂšme de cette annĂ©e : l’ExpĂ©rience ! Cet Ă©vĂ©nement ne pourrait pas exister sans son public, ses orateurs et ses sponsors, alors on compte sur votre prĂ©sence ! APPEL À ORATEURS Envie de [...]
Catégories: Association

CQRS, petites recettes pour vos architectures web

Le blog Webnet - lun, 07/11/2016 - 18:01
Architecture, CQRS, de quoi parle-t-on ? CQRS, définition

CQRS est un acronyme pour Command Query Responsability Segregation. Il s’agit d’un pattern d’architecture qui vise Ă  sĂ©parer les couches de lecture et d’écriture.

Le besoin est nĂ© du constat que la plupart des architectures proposent une unique couche d’accĂšs aux donnĂ©es permettant de faire la lecture et l’écriture. Or, dans la plupart des applications, les besoins en Ă©criture ne coĂŻncident pas avec ceux en lecture.

Prenons l’exemple d’un quelconque site de e-commerce, lĂ  oĂč les infos de la fiche produit seront lues des milliers de fois chaque jour (parfois chaque seconde), la mise au panier n’interviendra qu’à un rythme beaucoup moins soutenu.

D’une maniĂšre gĂ©nĂ©rale, on va sĂ©parer (Segregation) la responsabilitĂ© (Responsability) des lectures (Query) et Ă©criture (Command).

NĂ©anmoins, la mise en place de CQRS n’est pas chose aisĂ©e et peut poser quelques problĂšmes.

CQRS, problématique

Quand on essaie pour la premiÚre fois de comprendre CQRS, on se retrouve devant quelque chose de passablement abstrait et plutÎt difficile à intégrer avec de réels problÚmes :

  • Comment je vais pouvoir implĂ©menter ça ?
  • Comment adapter ces concepts Ă  mon contexte actuel ?
  • Est-ce pertinent pour mon besoin ?
  • Est-ce que ça ne va pas coĂ»ter trop de temps par rapport au gain final ?

Toutes ces questions sont centrales et pertinentes. On ne doit pas se lancer dans un modĂšle d’architecture sans en maĂźtriser les tenants et aboutissants, sans ĂȘtre capable d’en tirer ce qui est pertinent pour notre besoin du moment et sans s’assurer que notre projet aura Ă  y gagner dĂšs le dĂ©part.


Architecture, niveau 1, le monolithe

On avait une petite application à coder, on est pros, on est propres, on a fait du n-tiers qui marche bien :
C’est beau, ça marche, tout le monde est content

Et puis il faut ajouter de nouvelles fonctionnalités, modifier et enrichir les existantes

On se rend alors compte qu’on a codĂ© un vĂ©ritable monolithe avec un couplage fort entre les couches et que chaque Ă©volution impacte toutes les couches. Et comme disait nos ancĂȘtres les gaulois, « bouger un monolithe, c’est dur », avant l’arrivĂ©e de la potion magique

Pour pallier à tout ça, en tant que bons concepteurs orientés objet que nous sommes, on va découpler un peu tout ça pour rendre ce monolithe un peu plus souple.


Architecture, niveau 2, le découplage

On ne va plus appeler directement chacune des couches, mais on va passer par des interfaces, ça nous permettra de mettre un peu de gĂ©nĂ©ricitĂ© et de mutualiser du code. Ça nous permettra de mettre en place des tests unitaires pour se protĂ©ger lors des prochaines Ă©volutions !

On va également isoler chaque élément de domaine afin de cloisonner les fonctionnalités pour prévenir les régressions intempestives !
Petit exemple avec le domaine « Command » qui va permettre de gérer toutes les commandes de notre superbe application de e-commerce !


Ah, là, on est bien
 Si on met ça en place pour chaque classe de domaine qu’on possùde


On n’aurait pas cassĂ© le RAP (Reused Abstraction Principle) ? On a mis en place un niveau d’abstraction (notre interface) qui n’est utilisĂ© qu’une seule fois ! Le principe de l’abstraction est de pouvoir ĂȘtre rĂ©utilisé ! Sans ça, on ne profite pas de ce que l’abstraction aurait Ă  offrir et on ajoute de la lourdeur aux instanciations et aux tests unitaires !

Et quand viennent les nouvelles demandes d’évolution, on se retrouve face Ă  un nouveau monolithe
 DĂ©couplĂ©, mais monolithe quand mĂȘme ! Et on nous demande de nouvelles vues, de nouvelles donnĂ©es, sauf qu’à chaque modification de table, on casse toutes nos implĂ©mentations, modĂšles et vues actuels
 Accessoirement, l’application commence Ă  poser des problĂšmes de performances

Il va peut-ĂȘtre falloir commencer Ă  sĂ©parer les modules de lecture et d’écriture


Architecture, niveau 3, CQRS (un peu)

Quels sont les Ă©lĂ©ments les plus affichĂ©s dans mon application ? La fiche article ? Le panier ? Les promos ? TrĂšs bien, on va crĂ©er une autoroute pour ces Ă©lĂ©ments-lĂ . Pour le reste, on va s’assurer que nos donnĂ©es restent fiables.4

On possĂšde une base en lecture dĂ©normalisĂ©e, nos performances sont maintenant bien meilleures ! On a mis en place un module qui rĂ©percute les Ă©critures sur la base de lecture et tout va bien non ? Pas tout Ă  fait

La mise en place de ce mode de codage reste coĂ»teuse et le faire pour chaque domaine fonctionnel de l’application s’annonce beaucoup trop long. Les demandes d’évolutions vont s’empiler et le client va s’impatienter
 Il faut donc prioriser les domaines Ă  basculer, mais comment choisir ?

Pour rĂ©pondre Ă  cette interrogation, il convient de rĂ©pondre Ă  une question fondamentale : quel est l’avantage stratĂ©gique du mĂ©tier ? Sur quoi veut-il faire la diffĂ©rence ? Quel est son plan de dĂ©veloppement business Ă  moyen terme ?

On va ainsi devoir dialoguer avec le mĂ©tier, et pour le faire efficacement, il conviendra de modĂ©liser ses concepts en termes de domaines, d’Ă©vĂ©nements faits
 Tous les acteurs du projet, fonctionnels ET techniques y trouveront du sens !


Architecture, niveau 4, CQRS (un peu plus avec du DDD)

Maintenant que « tout le monde » fait du scrum, on va s’appuyer sur notre pratique des user stories pour orienter tout ça vers les notions de faits et d’Ă©vĂ©nements. Mon client peut ajouter un produit Ă  son panier ? Il en dĂ©coule un fait, une intention, ‘AjoutProduitAuPanier’ et un Ă©vĂ©nement (immuable puisque dĂ©jĂ  passĂ©) ‘ProduitAjoutĂ©AuPanier’. Au niveau code, on va transformer ces intentions en Command et ces Ă©vĂ©nements en Events. Regrouper ces faits et Ă©vĂ©nements par Ă©lĂ©ments de domaine (panier, commande, navigation
) est hĂ©ritĂ© du DDD (Domain Driven Design ou Conception DirigĂ©e par le Domaine). On dispose ici d’un langage commun avec le mĂ©tier et d’un parallĂšle fort entre l’organisation mĂ©tier et technique ce qui va faciliter la lecture du code pour les futurs entrant.

CĂŽtĂ© technique, les actions utilisateurs vont dĂ©clencher des commandes (rĂ©versibles) suivies par des Ă©vĂ©nements (immuables). Il s’agit ensuite de bien organiser tout ça afin d’assurer la pertinence du tout.


Tout ce petit monde fonctionne Ă  merveille, mais maintenant que le business tourne bien, le marketing, la direction et d’autres entitĂ©s du mĂ©tier se sont greffĂ©s au projet et aimeraient obtenir des informations sur les comportements utilisateurs (ajout/suppression du panier, articles explorĂ©s avant ajout au panier
). Comment faire ça sans rĂ©-impacter tous les scĂ©nario de l’application ? Il nous faudrait un genre de machine Ă  voyager dans le temps !!!


Architecture, niveau 5, CQRS (encore plus, avec DDD et ES)

On a une machine Ă  voyager dans le temps ! Ce sont nos Ă©vĂ©nements ! Pour permettre le voyage dans le temps, il convient de stocker tous ces Ă©vĂ©nements. On pourra ainsi reconstruire tout un cheminement Ă  travers l’application en temps rĂ©el. On pourra Ă©galement restaurer avec finesse Ă  un Ă©tat antĂ©rieur : la sauvegarde du panier a planté ? Peu importe, on sait quels articles ont Ă©tĂ© ajoutĂ©s puis enlevĂ©s du panier ! On appelle ce concept l’Event Sourcing (ES).


C’est ce genre de fonctionnement qui est utilisĂ© par les banques pour calculer avec certitude un solde sur un compte bancaire. Le solde n’est pas enregistrĂ© tel quel, il est recalculĂ© Ă  partir des mouvements successifs et peut donc ĂȘtre retrouvĂ© Ă  n’importe quel jour du mois avec beaucoup de facilitĂ©.


Architecture, CQRS, pourquoi, oĂč, comment, combien ?

CQRS peut nous aider Ă  rĂ©soudre des problĂ©matiques particuliĂšrement complexes. NĂ©anmoins, sa difficultĂ© de mise en Ɠuvre doit inciter Ă  la prudence. Il faut se poser les bonnes questions :

  • Ai-je rĂ©ellement besoin d’un modĂšle aussi complexe ?
  • Ai-je besoin de tous les niveaux d’implĂ©mentation ?
  • Ai-je l’équipe me permettant de mettre en place ces concepts ?
  • Est-ce que je suis bien outillĂ© pour le faire ?

Face Ă  une problĂ©matique mĂ©tier forte, ce qui importe plus, c’est la capacitĂ© de l’architecte Ă  faire preuve de pragmatisme et Ă  prĂ©fĂ©rer une solution adaptĂ©e Ă  une solution Ă©lĂ©gante.  Il faut Ă©galement se souvenir que c’est le besoin mĂ©tier qui doit diriger nos choix en architecture et non l’application qui doit piloter les besoins mĂ©tiers.


CQRS, quelques ressources

Cet article a Ă©tĂ© trĂšs largement inspirĂ© (jusqu’au titre) de la prĂ©sentation faites par Thomas Jaskula ( au MUG Lyon le 24/06/2016 :

J’ai Ă©galement utilisĂ© quelques sites en amont pour dĂ©grossir le sujet : ,

Quelques notions sur le DDD peuvent s’avĂ©rer fort utiles : ,

Enfin des bouquins de référence proposé par Thomas Jaskula lors de la présentation : et


Catégories: Blog Société

Functional Programming in Javascript, Dan Mantyla

Taverne d'Arma - Programmation - dim, 07/10/2016 - 22:20


Cela fait quelques annĂ©es que j'entends parler de programmation fonctionnelle et que je tourne autour du sujet, lisant quelques articles, regardant quelques tutoriel, sans jamais y plonger rĂ©ellement. Il faut dire que mĂȘme si je me suis intĂ©ressĂ© Ă  quelques technologies comme Scala ou mĂȘme Clojure, je suis aujourd'hui principalement un dĂ©veloppeur front-end qui reste dans l'Ă©cosystĂšme javascript. Ma curiositĂ© a Ă©tĂ© encore plus attisĂ©e quand j'ai eu Ă  travailler avec un ingĂ©nieur fĂ©ru de fonctionnel (Karol, si tu me lis ! ;) ), et de nombreuses discussions que j'ai eu avec lui ont continuĂ© Ă  faire Ă©voluer mon "coding style" vers ce type de programmation.

Puis récemment, je suis tombé (pas totalement par hasard) sur ce livre de Dan Mantyla : "Functional Programming in Javascript". Curieux de voir ce que je pouvais en tirer pour m'améliorer encore, je l'ai rapidement téléchargé sur ma liseuse et je l'ai lu (dévoré ?) en moins d'une semaine. Donc concrÚtement, bon ou mauvais ouvrage ?

Commençons par ces points forts :

  • L'ouvrage est plutĂŽt pragmatique : il explique ce qui est faisable en javascript et quels sont les limites du systĂšme
  • Il fournit quelques liens vers des librairies importants les concepts fonctionnels (Lazy.js et Bacon.Js, par exemple)
  • Puis il dĂ©taille point par point les grands principes (functors, nomades) en les transcrivant en JS
  • Il m'a mis le nez devant un petit dĂ©tail : les promesses (dont je suis trĂšs fan) ne sont rien de plus que des monades... Moi qui avait du mal avec ce concept, je me rend compte qu'en fait je l'utilise naturellement depuis bien longtemps ^^

Pour moi, cet ouvrage ne manque que d'une chose : un réel exemple concret, sur une application classique, des apports du fonctionnels. Aujourd'hui, l'ouvrage donne les informations pour faire du fonctionnels en javascript et essaye d'en donner les raisons, mais les quelques exemples présent dans le livre sont trop réduit pour vraiment convaincre. Dommage !

Il ne me reste plus qu'Ă  expĂ©rimentĂ© de façon plus concrĂšte ! Et Ă©tant donnĂ© que j'ai un nouveau projet oĂč j'ai complĂštement les mains libres, plus d'excuse ;)

Catégories: Blog Individuel

Partagez la connaissance

Partagez sur les réseaux sociaux