Note de lecture : Testing Microservices with Mountebank, par Brandon Byars

Note : 4 ; Une guide d’utilisation de Mountebank par son créateur. Bien écrit, mais assez basique

Mountebank est un framework de test (encore un) bien adapté au test des microservices, utilisant comme l’auteur nous le développera, le principe de l’imposture ! Malheureusement pour moi, la bête s’utilise avec du code JavaScript (avec du Node.js pour être précis), un obstacle que je n’avais pas anticipé. Cela a certainement impacté la note, dommage car le principe de ce moteur de test qui permet de simuler les services environnant au runtime ouvre nombre de perspectives.

Reprenons au départ : le volume se présente sous forme d’un texte de près de 220 pages découpé en 3 parties totalisant 10 chapitres. La première partie « premières étapes » ne compte que 2 chapitres sur 40 pages. Le premier chapitre « testing microservices » campe le décor. Il positionne clairement cet outil sur le volet « end to end » et introduit les notions de prédicats et d’imposteurs qui seront clé par la suite. Le second chapitre est le « hello world » … mais il s’avère rapidement être plus que cela. Il commence doucement en requêtes curl et en json, mais bascule rapidement sur le JavaScript ! L’auteur brûle un peu les étapes.

La seconde partie compte 6 chapitres et s’étend sur 130 pages. C’est le gros de la troupe et il est d’ailleurs sobrement intitulé « using Mountebank ». Il s’ouvre au chapitre 3 par le concept de réponses préfabriquées (canned responses), ce qui nous amène aussi à évoquer les prédicats. C’est plutôt clair et bien illustré. Les prédicats sont justement le sujet du chapitre 4. On les aborde en commençant par les expressions régulières pour terminer avec le JSonpath en passant par les champs multivalués. Le chapitre est riche et clair la plupart du temps.

Lire la suite

Note de lecture : Microservices Patterns, par Chris Richardson

Note : 8 ; La bible du Microservice !

A beaucoup de points de vue, c’est un livre imposant ! D’abord par sa taille : 470 pages, découpées en seulement 13 chapitres, mais aussi par son contenu qui va assez loin dans les aspects techniques abordés. Le propos n’en reste pas moins clair, je regrette juste que les fameux patterns soient juste évoqués mais pas vraiment documentés en tant que tel.

Le premier chapitre couvre une trentaine de pages et aborde deux sujets : le monolithe et les patterns. Le monolithe est traité avec intelligence, loin du bashing habituel. Ici on part du postulat d’une architecture hexagonale pour explorer les conséquences en maintenance et en organisation d’équipe ! La big picture des patterns vaut aussi le détour, pas seulement pour la classification de ces derniers, mais aussi par la qualité de l’explication sur l’approche patterns.

Ce sont aussi une trentaine de pages consacrées au chapitre 2 sur les stratégies de décomposition. On y parle, et c’est un peu inattendu, UML, Use Cases et DDD. C’est aussi le moment pour l’auteur d’exposer sa vision du découpage en « capabilities » et « services ». C’est intéressant, de bon niveau même, mais pas flamboyant.

Les choses sérieuses commencent au chapitre 3 et ses 45 pages sur l’IPC qui en est le sujet ! Il couvre les aspects conceptuels tels que la définition des interfaces, le versionning et les transactions. Puis on rentre dans le dur avec la communication synchrone (ReST, gRPC), puis asynchrone (JMS, Kafka), en publication ou en requête / réponse. Le chapitre s’étend jusqu’aux patterns essentiels que sont le circuit breaker et le gateway. C’est du solide.

Lire la suite

Note de lecture : Microservices in Action, par Morgan Bruce & Paulo A. Pereira

Note : 4 ; Plus sur l’infrastructure microservices que sur le microservice lui-même… avec beaucoup d’inaction dans ce « in action » !

Petite déception pour ce nouvel opus de la série « in action » de chez Manning. Celui-ci manque un peu de concret et de profondeur, malgré ses 350 pages. J’étais prévenu, le code serait en Python, mais au final il y en a assez peu, ce qui est à la fois un bien et un mal pour moi. La plus grande surprise est sans doute que l’on ne rentre pas dans la conception des microservices, mais plutôt dans l’architecture de systèmes à base de microservices qui est, il est vrai, une partie importante du concept. Ces architectures sont illustrées à base de diagrammes où chaque microservice est représenté sous forme d’hexagone : est-ce une évocation de l’architecture hexagonale d’Alistair Cockburn ? Nous n’aurons pas la réponse dans ces pages.

L’ouvrage lui-même est structuré en 4 parties pour un total de 13 chapitres. La première, “the lay of the land” couvre moins de 50 pages sur 2 chapitres. On débute par une introduction générale, ou plutôt un teasing des thèmes qui seront développés au fil des pages sur les principes et les challenges que représentent la conception de microservices. Le second chapitre rentre dans l’étude de cas qui servira de fil rouge : SimpleBank. Personnellement, je trouve celle-ci un peu complexe. L’illustration du découpage de feature en service s’en ressent.

La seconde partie s’intitule « design » et compte 5 chapitres sur 135 pages. C’est donc la partie la plus conséquente du livre. Elle débute par un chapitre 3 dédié à l’architecture des applications. Hélas elle reste très haut niveau, brossant à peine les styles d’architectures et les patterns de communication. Petite mention toutefois pour le « micro front-end » que je croise ici pour la première fois. Le chapitre 4 aborde sur 30 pages la question de la conception de nouvelles fonctionnalités. Les auteurs s’appuient sur les notions de « business capabilities » et de « technical capabilities » et sur un découpage en cas d’utilisation ! C’est finalement dans ce chapitre que je trouve trace de la Clean Architecture de Robert Martin, alors que je pensais la croiser au chapitre précédant.

Lire la suite

Note de lecture : Enterprise Java Microservices, par Ken Finnigan

Note : 3 ; Un « placement de produit » JBoss peu attractif.

Il commence à y avoir pas mal d’ouvrages sur les Microservices et tous ne se valent pas. Hélas, comme nous allons le voir, celui-ci ne rentre pas dans la bonne catégorie. Au départ il se voulait plus ou moins l’équivalent du « Spring Microservices in Action » pour JEE.

Avec 227 pages, l’ouvrage n’est guère volumineux. Le tout est structuré en 11 chapitres regroupés en deux parties. La première partie « microservices basics » compte les 5 premiers d’entre-eux et totalise une centaine de pages. Le premier chapitre est sobrement intitulé « Enterprise Java Microservices » ! Il s’agit surtout d’un survol pour nous rappeler ce qu’est une architecture JEE, puis sa conséquence le monolithe. C’est de manière simplifiée que l’auteur nous présente l’architecture microservices dans ses grandes lignes pour terminer sur les patterns permettant de transiter de l’un à l’autre. Un chapitre simple mais hélas simpliste.

On rentre dans le dur avec le chapitre 2 qui nous propose le cas d’utilisation du livre, le site Cayambe, et le développement d’une application minimaliste en REST. C’est l’occasion de faire notre « hello world » en architecture JEE new style. Pas transcendant, mais correct. La chapitre 3 prends un peu de hauteur pour nous présenter les différentes options pour développer des microservices dans le monde Java. J’ai beaucoup aimé l’approche « cartographique » et la largeur de l’écosystème abordé. Bien sûr (hélas) ceci est là pour nous montrer que Thorntail (aujourd’hui déjà à l’abandon) est le meilleur ! Un biais qui nuit à la qualité du chapitre.

Lire la suite

Note de lecture : Testing Java Microservices, par Alex Soto Bueno, Andy Gumbrecht & Jason Porter

Note : 6 ; Très pertinent sur la stratégie et la mise en œuvre des tests, souvent moins sur la clarté des explications.

Voici un livre qui s’est fait attendre plusieurs années. Au début, il s’agissait de produire un texte consacré à Arquilian. Finalement, le contexte s’est élargi aux tests de microservices de manière plus générale, Arquilian continuant à se tailler la part du lion, mais d’autres outils de test complétant le paysage, comme nous le verrons.

L’ouvrage totalise 260 pages réparties en 10 chapitres. Cela donne une moyenne de taille par chapitre relativement raisonnable mais quand même un peu plus élevée que ce que j’apprécie généralement. On démarre fort logiquement par un premier chapitre très court pour introduire les microservices. Il s’agit de présenter l’architecture microservices au niveau conceptuel. Une présentation pas vraiment fameuse, avec une représentation qui ne me parle guère et une architecture s’éloignant un peu de celle de Newman et où j’aurais aimé une pincée d’architecture hexagonale.

Le second chapitre présente l’application de test, ou plutôt l’architecture de test, sur une petite trentaine de pages. En fait, les auteurs ont fait le choix de rassembler des architectures techniques différentes : Spring Boot, TomEE et WildFly Swarm. A l’exception du vidéo service sur Spring Boot, le reste s’adosse à Java EE 7 ! Un choix dépassé depuis longtemps, peut-être justifié par le fait que les auteurs sont employés de JBoss ou parce qu’initialement Arquilian était dédié à JEE ? Quoi qu’il en soit, ce choix aurait dû être abandonné, il y avait déjà fort à faire en se contentant de Spring Boot et cette multiplicité introduit une regrettable complexité et de la confusion.

Lire la suite

Note de lecture : The Tao of Microservices, par Richard Rodger

Note : 2 ; Une vision “nano composants” bien éloignée de celle de Sam Newman et Martin Fowler…

Certains livres doivent se lire vite, pour que la douleur ne dure pas trop longtemps. Comme pour l’arrachage d’une dent ! Pour commencer, le livre est une tromperie sur la marchandise : point de microservices selon Fowler ou Newman, ici il s’agit d’une architecture crée par l’auteur. Comme elle est différente des autres, il l’appelle « 2.0 », les autres c’est 1.0 ! En fait ce n’est d’ailleurs pas simplement une architecture, mais selon l’auteur la solution ultime et définitive au développement logiciel, sur les plans techniques et organisationnels.

Car sur le plan technique, l’auteur fait la peau à tout ce qui est différent de sa solution au chapitre 1. Selon lui, la conception objet produit de grosses hiérarchies de classes trop couplées et incompréhensibles… libérons-nous de cette escroquerie. L’approche guidée par les tests est un écran de fumée tandis que les approches agiles obligent les équipiers à ce parler pour compenser le couplage de leur conception. Enfin le « don’t repeat yourself » est contre-productif, pour ne pas le qualifier de sabotage. J’en passe encore quelques-uns mais on aura compris l’idée : tout ce que l’auteur n’a pas su faire marcher ne marche pas pour la totalité des mortels. Bien sûr son architecture, à l’image des potions-miracle du far-west, adresse la totalité de ces problèmes sans aucuns inconvénients.

Tout ce bashing couvre une bonne partie du chapitre 1 de ce livre de près de 300 pages qui en compte 9. Mais pas seulement, on en trouve aussi dans les autres chapitres. En fait les différents chapitres tendent à se ressembler pas mal (à l’exception de l’étude de cas du chapitre 9), il n’est donc pas très utile de les passer tous en revue.

Lire la suite

Note de lecture : Spring Microservices in Action, par John Carnell

Note : 7 ; Il reprend là où « Spring Boot in Action » s’arrête…

Effectivement, « Spring Boot in Action » m’avait laissé sur ma faim. C’est essentiellement parce qu’il se focalisait sur la construction d’une application MVC, nous laissant un peu démuni sur la construction d’un serveur Rest, qui constitue pourtant l’un des cas d’usage nominaux. C’est bien sur ce cas d’usage et pas un autre que se focalise ce volume. Mais il va plus loin en couvrant l’intégralité de l’architecture microservices grâce à la stack Neflix et à son intégration dans Spring.

Je commence à froncer les sourcils à partir de 300 pages, mais les 350 de celui-ci se digèrent assez bien, malgré des chapitres aussi en moyenne plus volumineux que ce que j’apprécie généralement : ce volume en compte 10. Les 35 pages de l’introduction s’avalent très bien, on y a droit à une vue générale de l’architecture des applications microservices avec Spring Boot. C’est à la fois plus concret que ce que l’on croise généralement et aussi fort bien illustré, une constante du livre. Certes on n’a pas produit de code (mais l’auteur nous en dispense des fragments) mais on a un plan précis de ce qui nous attends.

La trentaine de pages du chapitre 2 nous amène vers le « hello world » du microservice et même un peu plus loin avec un certain nombre de considérations liées au déploiement. Tout cela s’avale très bien et on peut déjà se salir les mains avec succès. Cela dit, moi j’aurais fait deux chapitres… C’est également une trentaine de pages qui nous attends avec le chapitre 3, où l’on prend de plein fouet la stack Netflix, plus exactement, Eureka, à partir duquel l’auteur nous amène à construire un serveur de configuration. L’architecture de déploiement prends soudain beaucoup plus de complexité, mais c’est somme toute le destin des architectures microservices.

Lire la suite

Note de lecture : Building Microservices, par Sam Newman

Note : 7 ; La promesse tenue d’un tour d’horizon ni trop technique, ni stratosphérique.

Cet ouvrage est déjà la référence sur l’architecture Microservices, donc de fait un préalable à mes autres lectures sur le sujet ! Le texte en lui-même est de taille moyenne, avec 250 pages structurées en 12 chapitres. Le propos n’est pas de rentrer ici dans des arcanes techniques, mais de rester à un niveau architectural concret, mettant en œuvre des patterns spécifiques à ce type d’architecture. C’est donc un bon deal.

Le premier chapitre est assez succinct et reste à très haut niveau : pourquoi fait-on des microservices ? Quelles en sont les propriétés principales ? Quels sont les bénéfices attendus ? Si l’on ne retrouve pas le thème de l’hétérogénéité technologique ailleurs (une propriété pourtant importante), les autres se retrouvent égrenés au long des autres chapitres : résilience, scalabilité, alignement sur l’organisation, facilité de déploiement ou de remplacement et composabilité. Le chapitre 2 est plus inattendus, car il s’intéresse au rôle de l’architecte. Un rôle bien mal défini et qui n’a rien à voir avec le rôle des architectes certifiés du génie civile, comme le fait remarquer l’auteur ! C’est en tant que « architecte évolutionnaire » que Sam Newman conçoit ce rôle, à cheval entre la vision et la gouvernance (zoning du domaine, alignement stratégique), mais aussi humain à travers la capitalisation de pratique et la collaboration avec l’équipe. Au final un chapitre qui est une heureuse surprise.

Le chapitre 3 est court d’une dizaine de pages : comment modéliser un service. Ici, l’auteur fait un lien naturel avec les « bounded contexts » du Domain-Driven Design. Mais il évoque aussi un sujet que l’on retrouvera plus loin : le découpage en microservices se fait par split de services ou applications de plus forte granularité. Le chapitre 4 est lui le plat de résistance de l’ouvrage : l’intégration ! J’en retiens plusieurs éléments : tout d’abord la mise en œuvre de chorégraphie distribuée via des évènements plutôt qu’une orchestration centralisée. Des appels synchrones qu’il faut rendre simples et agnostiques. Si je ne suis pas d’accord avec l’avis de l’auteur pour qui SOAP est protocole dépendant et REST protocole indépendant (désolé, mais c’est l’inverse), je trouve intéressant son appréciation de XML par rapport à Json, qui n’est pas dans l’air du temps. Bien sûr qui dit asynchronisme des évènements dit transaction distribuées ou mécanisme de compensation, des sujets ici tout juste évoqués, tout comme le versionning sémantique.

Lire la suite

Note de lecture : Spring Boot in Action, par Craig Walls

Note : 6 ; Craig Walls (heureusement) toujours égal à lui-même !

J’avais hâte d’aborder ce volume, car on m’avai dit grand bien de Spring Boot. Craig Walls balaye consciencieusement tous les aspects de cette famille de frameworks depuis plusieurs années, avec une plume qui rend tout cela agréable : bon point. Atre bon point, le volume réduit du livre qui est de seulement 180 pages. Hélas cela a conduit à certains choix de contenus que je trouve malheureux ou qui au moins m’ont frustré. Mais j’y reviendrais.

Pour l’instant, voyons le contenu, qui compte 8 chapitres. Le premier « bootstrapping Spring Boot » ne compte que 22 pages, juste de quoi faire le tour du propriétaire et voir les différentes manières d’installer Spring Boot et d’initialiser un projet. C’est aussi l’occasion de voir que le reste du livre va faire l’impasse sur pas moins de 4 sur 5 types de projets que permet Spring Boot (page 13). C’est fâcheux et c’est le principal reproche que j’ai à faire au texte. Cela lui coute 2 points sur ma note de lecture !

Le second chapitre est consacré au « hello world » (d’est du MVC, bien sûr…). Autant dire que ses 25 pages sont précieuses. C’est un plaisir à lire et l’auteur couvre bien les aspects lié au build, à la structure du « starter » et à la gestion commune des dépendances. L’auteur montre une préférence marquée pour Gradle pour le build, mais Maven n’est pas mis à l’écart.

Lire la suite