Note : 6 ; Clair sur la mise en jambe, mais insuffisant sur la gestion en production

J’ai une affection particulière pour Storm, car j’ai activement participé à l’amener dans un projet à une époque où les frameworks Big Data temps réel et plus particulièrement Storm n’étaient pas pris pour acquis. Il aura fallu attendre près de 2 ans de plus pour voir apparaître un ouvrage dédié de bonne facture. Comme nous le verrons, ce dernier ne se limite pas à Storm sensu-stricto.

Le présent ouvrage accuse ses 250 pages totalisant 9 chapitres. Des chapitre relativement longs en moyenne selon mon standard, donc. Le premier d’entre eux ne l’est pas, car il ne pèse que 10 pages. C’est une introduction de haut niveau dont le but est de camper la place de Storm dans le mode du Big Data, et plus précisément dans celui du Big Data temps réel que les auteurs re-segmentent en « stream » et « micro-batching ». En passant, les auteurs positionnent Storm par rapport non seulement à Hadoop, mais à Spark, Samza et Kafka Stream.

Le chapitre 2 est d’avantage dédié architecture et présente les concepts centraux de Storm : Typologie, Tuples, Bolts et Spout. Le tout est abondamment illustré, y compris par des extraits de codes qui ont le bon goût de ne pas être trop longs. L’homme pressé qui n’a pas trop de temps à consacrer pour comprendre Storm y trouvera à se nourrir ! J’avoue que je trouve ce chapitre particulièrement réussi.

Ce sont plus de 40 pages qui sont accordées au chapitre 3 « topology design ». On y retrouve la qualité des représentations du chapitre 2. Il aborde la complexité des topologies de manière progressive, ce qui est un autre bon point. Cela dit, le chapitre aurait pu avantageusement être subdivisé en deux. Ainsi les aspects avancés comme le threading, le parallélisme et la persistance auraient pu être mis dans un chapitre « avancé ». Cela dit, la progressivité du propos nous permet d’arriver au bout de cette presque demi-centaine de pages sans peine.

Le chapitre 4 aborde un aspect important de Storm : la robustesse. Plusieurs fonctionnalités sont au rendez-vous : la garantie de déliverie, le retry ou l’anchoring, entre autres. Un chapitre qui devient un peu plus difficile d’abord que les précédents.

Avec le chapitre 5 et ses 25 pages, on aborde un aspect délicat de Storm, un point réellement compliqué je dois dire : son déploiement. Là encore les auteurs font du bon boulot, tout d’abord en définissant les différents concepts runtime (worker process, worker node, executor, task, etc.) et en présentant comment tout cela s’articule dans une configuration master / slave. Peut-être la surcouche avec Zookeeper aurait-elle mérité un chapitre à part, car cela passe un peu trop rapidement pour que l’on puisse bien comprendre. On a aussi droit à une séance « copies d’écrans ». Ce n’est jamais génial, mais c’est quand même un tout petit peu mieux que d’habitude.

C’est au tunning que sont consacrées les 30 pages du chapitre 6. L’introduction est un peu longue, mais à partir de là les auteurs font l’effort de décomposer la démarche permettant de localiser le goulot d’étranglement, en montrant comment les indices se montrent au travers de l’IHM. Le chapitre se clôt sur la « metrics collecting API », mais ce dernier sujet est traité réellement rapidement. Dommage !

Toujours sous le thème du tunning, le chapitre 7 est dévolu aux contentions de ressources. 25 pages semblent nécessaires pour couvrir ce sujet. Les auteurs explorent les différentes dimensions de la contention de ressources : workers, CPU, configuration JVM, etc. Chacun de de ses dimensions est abordée avec un angle « pattern » structuré en : problème, solution, discussion. Cela donne un abord un peu abstrait à ce chapitre et un peu plus aride que les précédents. Mais il fait le boulot.

J’aime bien le chapitre 8, « Storm internals », je regrette même qu’il ne couvre qu’une vingtaine de pages. Il détaille bien, entre autre chose, le fonctionnement des threads de l’Executor , avec ses queues d’entrée et de sortie, le tout brillamment illustré ! Le routage des tâches et le fonctionnement des buffers referment cette partie. Une bonne surprise.

Le livre se referme sur un chapitre consacré à Trident. De mon point de vue c’est autre chose que Storm, bien qu’il soit construit sur ce dernier, le paradigme étant sensiblement différent. De fait, on est plutôt ici dans le monde du « micro batching ». Je ne lui donne pas beaucoup de chances face à Spark. Dans le cas présent, on voit d’ailleurs Trident couplé avec Kafka. J’avoue n’avoir regardé le sujet que de loin car il m’intéressait assez peu.

On est rarement déçu par la série « in action » de Manning. Ici encore, ça fait le boulot, même un peu mieux qu’attendu par les qualités pédagogiques du texte. Je regrette seulement que l’on ait pas eu une partie consacré aux patterns d’usage opérationnels de Storm, comme le sujet des « fenêtres glissantes », d’ailleurs apparu ultérieurement dans la version 1.0 du framework !

Référence complète : Storm Applied – Sean T. Allen, Matthew Jankowski & Peter Pathirana – Manning 2015 – ISBN : 978 1 617291 89 0