Par écosystème réactif, on entend un ensemble de composants dont Vert.x assure et facilite l’intégration à son modèle de programmation asynchrone. Cette intégration est évidemment plus naturelle lorsque le composant en question expose une interface avec des appels non bloquants (MongoDB, Redis, Postgres, etc). Sinon pour les composants dont les API sont bloquants (JDBC par exemple), Vert.x encapsule ces API pour rendre leur accès asynchrone.

L’écosystème réactif

Voici une liste non exhaustive de composants dont l’intégration est facilitée dans l’écosystème réactif Vert.x :

Bases de données

  • MySQL, PostgreSQL
  • JDBC
  • MongoDB
  • Redis

Authentification/Sécurité

  • Apache Shiro : authentification/habilitation à partir de LDAP, fichier de propriétés
  • JDBC : client et schéma de base de données pour gérer l’authentification dans une base de données relationnelle
  • MongoDB : client pour gérer l’authentification dans MongoDB
  • OAuth
  • JWT (JSON Web Token)

Métriques

  • DropWizard
  • Hawkular
  • Health Checks

Messaging/Intégration

  • AMQP 1.0
  • STOMP
  • SMTP
  • Kafka
  • RabbitMQ
  • Camel
  • JCA

Microservices

  • Discovery
  • Circuit breaker
  • Config
  • Consul
  • Kubernetes
  • GRPC

Clustering

  • Hazelcast
  • Apache Ignite
  • Infinispan
  • Apache Zookeeper

Test unitaire

Le test d’un code asynchrone n’est pas quelque chose d’évident, raison pour laquelle Vert.x fournit l’outil Vertx Unit. En Java Vertx Unit s’intègre avec JUnit.

Vert.x 3.5.0

Parmi les évolutions qui me parlent (mais il y en a d’autres toutes aussi importantes) :

  • Compatibilité Java 9 : Vert.x 3.5.0 peut être utilisé avec Java 9, mais pas comme module JPMS explicite, juste comme faisant parti module anonyme.
  • RxJava 2 : Je viens d’en parler, cette nouvelle version supporte RxJava 2.
  • Client MQTT : Nous avions vu l’utilisation de MQTT dans la partie Démo, où Vert.x était utilisé comme broker MQTT et Eclipse Paho et MQTT.js comme clients. Avec cette dernière version, Vert.x dispose désormais aussi d’un client MQTT.

Conclusion et ressources utiles sur Vert.x et la programmation réactive

Je suis bien content de finir ce article sur l’écosystème réactif de vert.x que j’ai pourtant commencé à préparer dès le premier week-end qui a suivi la conférence Devoxx (tenue du 04 au 07 avril 2017 pour rappel). Si j’ai pour habitude de prendre mon temps pour en apprendre le plus possible afin de faire le moins de fausses interprétations possibles, je pensais pourtant faire rapidement le tour de Vert.x et finir aussi vite ce rapport.

Tim Fox

Pour commencer, comme d’habitude je me remets à visionner la vidéo de l’université et m’arrête à la mention de Tim Fox qui a créé le projet Vert.x. Je n’avais jamais entendu parler de lui, enfin… en dehors du projet Vert.x que je ne suivais pas particulièrement. Je retrouve très vite ses premières présentations sur Vert.x. Je voulais surtout comprendre les motivations derrière la création de Vert.x. Mais j’avoue que ce n’était pas gagné au départ, lorsque Tim Fox présentait Vert.x comme « general purpose application platform ». Ensuite, au fil des vidéos et du temps, il introduisait Vert.x comme « Lightweight, reactive, application platform ». Et en se reportant au Manifeste Réactif plutôt bien expliqué, cette description est beaucoup plus claire, c’est d’ailleurs celle qui est sur la page d’accueil du site du projet.

Le choix d’implémentation technique

Ensuite je me suis intéressé aux choix d’implémentions techniques. Le projet étant inspiré de Node.js, cela explique facilement l’implémentation du pattern reactor et de l’approche événementielle. Quant aux verticles, ils sont inspirés du modèle acteur, mais ce modèle en lui-même n’est pas expliqué dans la documentation Vert.x pour faire comprendre l’intérêt de son adoption dans Vert.x, c’est un peu dommage. Akka par exemple fait un effort intéressant dans ce sens. Du ce fait, on va se limiter à l’hypothèse que l’idée des verticles découle de l’expérience de Tim Fox qui a travaillé sur RabbitMQ, un middleware oriented message implémenté dans le langage Erlang, reconnu entre autres pour son implémentation du modèle acteur.

Une autre idée originale dans Vert.x est son event bus, le fort background de Tim Fox dans le domaine du messaging (HornetQ/ActiveMQ Artemis, RabbitMQ) ayant certainement grandement influencé l’introduction de ce composant. L’event bus représente un énorme atout de Vert.x, il facilite énormément la mise en œuvre du modèle réactif dont se revendique Vert.x.

Netty

Un autre atout important est de reposer sur l’excellent projet Netty, un framework hautement performant pour la programmation réseau basé sur des entrées/sorties non bloquantes et l’approche événementielle. Les API de Netty pouvant être relativement de bas niveau pour une application classique, on pourra les exploiter à travers les API Vert.x qui les expose.
Nous ne nous sommes pas arrêtés là-dessus, mais il est important de mentionner que Vert.x fournit avec son écosystème un bon support pour la construction de systèmes à base de Microservices, en adressant explicitement par exemple les problématiques de déploiement et d’orchestration.

Enfin dans la découverte de Vert.x j’ai rencontré plein de références assez intéressantes pour mériter le détour. Le projet présente de nombreux cas d’usage et continue d’évoluer avec le support de nouveaux concepts et standards de l’industrie. Il se distingue par sa simplicité, la recherche de la haute performance et répond aux exigences pour la construction de systèmes réactifs. Une riche et très bonne documentation encourage et facilite l’apprentissage de l’outil. Et une fois les concepts maîtrisés, ils deviennent des acquis qui peuvent être facilement réutilisés dans tous les langages d’implémentation de Vert.x (Java, JavaScript, Groovy, Ruby, Ceylon, Kotlin et Scala).

Merci à Julien Ponge et Julien Viet pour nous avoir présenté cette université.

Ressources utiles

Vert.x
https://fr.wikipedia.org/wiki/Vert.x
Applications réactives avec Eclipse Vert x (vidéo)
Applications Réactives avec Eclipse Vert.x (slides)
A gentle guide to asynchronous programming with Eclipse Vert.x for Java developers
Building Reactive Microservices in Java
http://vertx.io/docs/
http://vertx.io/materials/

écosystème réactif – programmation réactive
https://www.reactivemanifesto.org
https://www.oreilly.com/ideas/reactive-programming-vs-reactive-systems
https://github.com/ReactiveX/RxJava

Modèle acteur
https://en.wikipedia.org/wiki/Actor_model
Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know…) (vidéo)

Netty
https://netty.io/index.html
https://www.manning.com/books/netty-in-action