| Les deux révisions précédentes Révision précédente | |
| eadl:bloc5:fm4:chap1 [2026/11/16 18:54] – jcheron | eadl:bloc5:fm4:chap1 [2026/11/16 19:22] (Version actuelle) – jcheron |
|---|
| ==== 2.1 Un job est un graphe de flux ==== | ==== 2.1 Un job est un graphe de flux ==== |
| |
| Un programme Flink ne traite pas les messages lui-même : il **décrit un circuit** que les messages vont parcourir. Ce circuit est fait d'**étapes** (les boîtes ci-dessous) reliées par des **flèches** : chaque flèche indique que les éléments produits par une étape sont envoyés à l'étape suivante, toujours dans le même sens. | === Ce que fait le code d'un consumer Kafka === |
| |
| <html><div class='imageB'></html> | Dans le ''ConsoleConsumer'' de la mission 3, le code **traite les messages** : la boucle s'exécute pour chaque lot de messages, et chaque ligne agit sur un message réel. |
| <code> | |
| [ source ] ──► [ transformation ] ──► [ transformation ] ──► [ sink ] | |
| Kafka map, filter… keyBy + reduce… print, Kafka… | |
| </code> | |
| <html></div></html> | |
| |
| Le circuit n'est pas forcément une simple ligne : une étape peut alimenter plusieurs étapes. Dans le ''Job03Agregation'', les cumuls partent à la fois vers un affichage et vers un topic Kafka : | <sxh java> |
| | while (true) { |
| | for (ConsumerRecord<String, String> r : consumer.poll(Duration.ofMillis(500))) { |
| | CounterEvent e = CounterEvent.parse(r.value()); // ce message-ci est parsé, maintenant |
| | System.out.println(e); // ce message-ci est affiché, maintenant |
| | } |
| | } |
| | </sxh> |
| | |
| | === Ce que fait le code d'un job Flink === |
| | |
| | Dans un job Flink, le code **ne touche aucun message**. Chaque appel de méthode ajoute une **étape** à un plan de traitement, et chaque variable ''DataStream'' représente le **lien** entre deux étapes. Voici le cœur du ''Job03Agregation'', annoté : |
| | |
| | <sxh java> |
| | DataStream<String> messages = // lien A : des String (le JSON brut) |
| | env.fromSource(source, ..., "Kafka : Counters"); // étape ① : lire le topic |
| | |
| | DataStream<CounterEvent> events = // lien B : des CounterEvent |
| | messages.flatMap(new ParseOrSkip()); // étape ② : parser, à partir de A |
| | |
| | DataStream<PointTotal> unitaires = // lien C : des PointTotal |
| | events.map(PointTotal::of); // étape ③ : convertir, à partir de B |
| | |
| | DataStream<PointTotal> totals = // lien D : des PointTotal (cumuls) |
| | unitaires.keyBy(PointTotal::pointCode) |
| | .reduce(PointTotal::plus); // étape ④ : cumuler par point, à partir de C |
| | |
| | totals.print("TOTAL"); // étape ⑤ : afficher, à partir de D |
| | totals.sinkTo(sink); // étape ⑥ : écrire dans Kafka, à partir de D |
| | |
| | env.execute("Job03 - cumul par point"); // seulement maintenant : envoyer le plan au cluster et le démarrer |
| | </sxh> |
| | |
| | Quand ''main'' arrive à ''env.execute(...)'', aucun message n'a encore été lu. Flink a seulement enregistré ce plan : |
| |
| <html><div class='imageB'></html> | <html><div class='imageB'></html> |
| <code> | <code> |
| [ source ] ──► [ parsing ] ──► [ map ] ──► [ reduce ] ──┬──► [ print ] | A : String B : CounterEvent C : PointTotal D : PointTotal |
| └──► [ Kafka « point-totals » ] | ① lire ────────────► ② parser ────────────► ③ convertir ────────────► ④ cumuler ──┬──► ⑤ afficher |
| | « Counters » (keyBy + reduce) │ |
| | └──► ⑥ écrire dans |
| | « point-totals » |
| </code> | </code> |
| <html></div></html> | <html></div></html> |
| |
| C'est pourquoi on parle de **graphe** (des boîtes reliées par des flèches) plutôt que de chaîne. Le vocabulaire courant : un **graphe orienté** (les flèches ont un sens), ou //dataflow// (les données « coulent » le long des flèches). Dans ce graphe : | On lit le code et le schéma de la même façon : |
| | |
| | ^ Dans le code ^ Dans le schéma ^ Vocabulaire ^ |
| | | un appel ''fromSource'' | l'étape ①, sans flèche entrante | **source** | |
| | | un appel ''flatMap'', ''map'', ''reduce''… | une étape ② à ④ | **opérateur** (transformation) | |
| | | un appel ''print'', ''sinkTo'' | les étapes ⑤ et ⑥, sans flèche sortante | **sink** | |
| | | une variable ''DataStream<T>'' | une flèche, qui transporte des éléments de type ''T'' | **flux** | |
| | | ''x.map(...)'' : la méthode appelée **sur** la variable ''x'' | la flèche part de l'étape qui a produit ''x'' | **lien** entre deux étapes | |
| | |
| | Le dernier point est la clé de lecture : écrire ''events.map(...)'', c'est dire « l'étape ''map'' reçoit ce que produit l'étape qui a donné ''events'' ». En suivant les variables, on retrouve les flèches. |
| | |
| | Le plan a deux sorties (⑤ et ⑥) parce que le code appelle deux méthodes sur la même variable ''totals'' : la flèche D se divise en deux. C'est pour cela qu'on parle de **graphe** (des étapes reliées par des flèches, avec des embranchements possibles) plutôt que de simple chaîne, et de graphe **orienté** parce que les données ne circulent que dans le sens des flèches. On rencontre aussi le terme anglais //dataflow//. |
| | |
| | === Une fois le job lancé === |
| |
| * une **source** produit les éléments (lecture d'un topic Kafka) ; | À l'appel de ''execute()'', le plan est envoyé au cluster, qui le met en marche : **chaque étape fonctionne en permanence**, reçoit les éléments de sa flèche d'entrée, applique sa fonction, et envoie le résultat sur sa flèche de sortie. Les lambdas écrites dans le code (''PointTotal::of'', ''PointTotal::plus''…) sont alors appelées pour chaque élément, sur les TaskManagers. |
| * des **transformations** (ou opérateurs) les modifient, les filtrent, les regroupent ; | |
| * un **sink** les envoie à l'extérieur (affichage, topic Kafka, base de données). | |
| |
| Les arêtes du graphe sont des **DataStream** : un ''DataStream<T>'' est un flux, potentiellement infini, d'éléments de type ''T''. Chaque transformation prend un ou plusieurs ''DataStream'' et en produit un nouveau. | Ce graphe est celui que l'interface web de Flink affiche pour un job en cours (//Running Jobs//, puis le job). On peut aussi l'afficher depuis le code, sous forme de texte JSON, en ajoutant ''System.out.println(env.getExecutionPlan());'' juste avant ''env.execute(...)''. |
| |
| ==== 2.2 Le squelette d'un job ==== | ==== 2.2 Le squelette d'un job ==== |