eadl:bloc5:fm4:chap1

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
eadl:bloc5:fm4:chap1 [2026/11/16 18:54] – jcheroneadl:bloc5:fm4:chap1 [2026/11/16 19:22] (Version actuelle) – jcheron
Ligne 63: Ligne 63:
 ==== 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 ====
  • eadl/bloc5/fm4/chap1.txt
  • Dernière modification : il y a 34 minutes
  • de jcheron
  • Actuellement bloqué par : jcheron