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
Prochaine révision
Révision précédente
eadl:bloc5:fm4:chap1 [2026/11/16 18:54] – jcheroneadl:bloc5:fm4:chap1 [2026/11/17 00:23] (Version actuelle) – [3.1 La source Kafka] jcheron
Ligne 61: Ligne 61:
 ===== 2. Le modèle de programmation ===== ===== 2. Le modèle de programmation =====
  
-==== 2.1 Un job est un graphe de flux ====+==== 2.1 L'analogie de la plomberie : consumer Kafka vs job Flink ====
  
-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.+Pour comprendre Flink, il faut oublier la façon dont fonctionne un consumer classique :
  
-<html><div class='imageB'></html> +  * **Un consumer Kafka, c'est porter des seaux d'eau :** votre code prend les messages à la main dans une boucle ''while (true)'', traite chacun immédiatement, puis passe au suivant. 
-<code> +  * **Un job Flink, c'est installer de la tuyauterie :** votre code ne touche à **aucun message**. Il sert uniquement à assembler un réseau de tuyaux (un robinet d'arrivée, un filtre, une évacuation). Tant que la vanne générale n'est pas ouverte, pas une goutte ne circule. 
-  [ source ] ──► [ transformation ] ──► [ transformation ] ──► [ sink ] + 
-     Kafka          map, filter…          keyBy + reduce…       print, Kafka… +<sxh java> 
-</code> +// 1. Consumer Kafka classique : chaque message est traité MAINTENANT, par ce code 
-<html></div></html>+while (true) { 
 +    for (ConsumerRecord<String, String> r : consumer.poll(Duration.ofMillis(500))) { 
 +        traiter(r.value()); 
 +    } 
 +} 
 + 
 +// 2. Flink : on assemble des tuyaux, AUCUN message n'est lu par ces lignes 
 +DataStream<String> entrees  = env.fromSource(...);              // robinet d'arrivée 
 +DataStream<String> retenues = entrees.filter(s -> !s.isBlank()); // filtre posé sur le tuyau 
 +retenues.sinkTo(...);                                           // évacuation 
 + 
 +env.execute("Mon job");   // ON OUVRE LA VANNE : les données commencent à couler 
 +</sxh> 
 + 
 +Kafka n'est pas remplacé pour autant : il reste le réservoir d'où vient l'eau et où elle repart. Ce qui change, c'est la façon d'écrire le traitement entre les deux. 
 + 
 +==== 2.2 Un job est un graphe : source, opérateurs, sink ==== 
 + 
 +Dans Flink, une variable ''DataStream'' ne contient pas de données en mémoire : elle représente un **tuyau**, qui transportera des éléments d'un certain type d'une étape à la suivante. Le réseau complet est un **graphe de flux** (//dataflow//), construit avec trois sortes de briques : 
 + 
 +^ Brique Flink ^ Rôle ^ Dans le code ^ 
 +| **Source** (entrée) | D'où viennent les données | ''env.fromSource(...)'' | 
 +| **Opérateur** (transformation) | Ce qu'on fait subir aux données | ''map()'', ''filter()'', ''reduce()''… | 
 +| **Sink** (sortie) | Où partent les résultats | ''sinkTo()'', ''print()'' | 
 + 
 +=== Exemple : le Job03Agregation, tuyau par tuyau === 
 + 
 +Voici le cœur du ''Job03Agregation'' (mission 7). Chaque appel de méthode pose une **étape** (①, ②…), chaque variable ''DataStream'' est un **tuyau** (A, B…) : 
 + 
 +<sxh java> 
 +DataStream<String> messages =                        // tuyau A : des String (le JSON brut) 
 +        env.fromSource(source, ..., "Kafka : Counters");   // étape ① : lire le topic 
 + 
 +DataStream<CounterEvent> events =                    // tuyau B : des CounterEvent 
 +        messages.flatMap(new ParseOrSkip());              // étape ② : parser, alimentée par A 
 + 
 +DataStream<PointTotal> unitaires =                   // tuyau C : des PointTotal 
 +        events.map(PointTotal::of);                       // étape ③ : convertir, alimentée par B 
 + 
 +DataStream<PointTotal> totals =                      // tuyau D : des PointTotal (les cumuls) 
 +        unitaires.keyBy(PointTotal::pointCode) 
 +                 .reduce(PointTotal::plus);               // étape ④ : cumuler par point, alimentée par C 
 + 
 +totals.print("TOTAL");                               // étape ⑤ : afficher, alimentée par D 
 +totals.sinkTo(sink);                                 // étape ⑥ : écrire dans Kafka, alimentée par D 
 + 
 +env.execute("Job03 - cumul par point");              // la vanne : le réseau est envoyé au cluster et démarre 
 +</sxh>
  
-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 :+Quand ''main'' arrive à ''env.execute(...)'', aucun message n'a encore été lu. Flink a seulement enregistré ce réseau :
  
 <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 :+Règle de lecture : écrire ''x.map(...)'', c'est brancher l'étape ''map'' **sur le tuyau** ''x'', donc à la sortie de l'étape qui a produit ''x''. En suivant les variables, on retrouve les tuyaux.
  
-  * une **source** produit les éléments (lecture d'un topic Kafka) ; +Le réseau a deux sorties (⑤ et ⑥) parce que le code branche deux étapes sur le même tuyau ''totals'' : D se divise en deux. C'est pourquoi on parle de **graphe** (des étapes reliées par des tuyaux, avec des embranchements possibles) plutôt que de simple chaîne, et de graphe **orienté** parce que les données ne circulent que dans un sens.
-  * 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. On peut aussi l'obtenir depuis le code, en texte JSON, avec ''System.out.println(env.getExecutionPlan());'' placé juste avant ''env.execute(...)''.
  
-==== 2.2 Le squelette d'un job ====+==== 2.3 La structure de base d'un job ==== 
 + 
 +Un job Flink suit presque toujours cette structure en 5 étapes (avec, si besoin, plusieurs sources ou plusieurs sinks, comme ci-dessus) :
  
 <sxh java> <sxh java>
 public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
-    // 1. L'environnement d'exécution : le point d'entrée de tout job+    // 1. Obtenir l'environnement d'exécution
     StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();     StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  
-    // 2. La source +    // 2. Poser la SOURCE (entrée) 
-    DataStream<String> lignes = env.fromSource(source, WatermarkStrategy.noWatermarks(), "ma source");+    DataStream<String> lignes = env.fromSource(source, WatermarkStrategy.noWatermarks(), "Kafka");
  
-    // 3. Les transformations+    // 3. Poser les OPÉRATEURS (transformations)
     DataStream<Integer> longueurs = lignes.map(String::length);     DataStream<Integer> longueurs = lignes.map(String::length);
  
-    // 4. Le sink+    // 4. Poser le SINK (sortie)
     longueurs.print();     longueurs.print();
  
-    // 5. Le lancement+    // 5. OUVRIR LA VANNE (lancer l'exécution)
     env.execute("mon job");     env.execute("mon job");
 } }
 </sxh> </sxh>
  
-''getExecutionEnvironment()'' s'adapte au contexte : lancé depuis l'IDE, le programme démarre un **mini-cluster** dans sa propre JVM ; soumis à un cluster (''flink run''), il utilise ce cluster. Le même code sert dans les deux cas. Dans le TD, ''Jobs.environment()'' ajoute seulement quelques réglages au mini-cluster local (port de l'interface web, nombre de slots).+''getExecutionEnvironment()'' s'adapte au contexte, sans changer une ligne de code : lancé depuis l'IDE, le job s'exécutera dans un **mini-cluster local** démarré dans la JVM de l'IDE (au moment de ''execute()'') ; soumis à un cluster avec ''flink run'', il s'exécutera sur ce cluster.
  
-==== 2.3 Une construction paresseuse ====+Dans les jobs du TD, cette ligne est remplacée par ''Jobs.environment()'', qui appelle ''getExecutionEnvironment()'' et ajoute seulement quelques réglages au mini-cluster local (port de l'interface web, nombre de slots).
  
-Les étapes 2 à 4 **n'exécutent rien** : elles ajoutent des nœuds au graphe. Aucun message n'est lu lorsque la ligne ''map(...)'' s'exécute.+==== 2.4 La construction paresseuse (lazy evaluation) ==== 
 + 
 +Tant que le programme n'arrive pas à la ligne ''env.execute()'', **aucun message n'est lu**. Le code de ''main'' s'exécute bien, mais les lignes ''fromSource'', ''map'' ou ''sinkTo'' se contentent de dessiner le plan, dans la mémoire du programme client.
  
 C'est l'appel à ''env.execute()'' qui : C'est l'appel à ''env.execute()'' qui :
  
-  - fige le graphe décrit jusque-là ; +  - fige le plan de traitement (le graphe) ; 
-  - l'envoie au cluster (ou au mini-cluster) ; +  - l'envoie au **JobManager**, qui le découpe en tâches et les répartit sur les **TaskManagers** ; 
-  - démarre l'exécution, qui se poursuit jusqu'à l'arrêt du job.+  - lance l'écoulement continu des données, jusqu'à l'arrêt du job.
  
-Conséquence : le code de ''main'' est exécuté **une seule fois**, à la soumission, sur la machine qui soumet le job. Seules les **fonctions** passées aux opérateurs (les lambdas de ''map'', ''filter''…) sont exécutées sur les TaskManagers, pour chaque élément. Un ''System.out.println'' placé dans ''main'' s'affiche donc une fois, chez le client ; placé dans une lambda de ''map'', il s'affiche dans les journaux des TaskManagers, une fois par élément.+**Conséquence directe :** le code de ''main'' s'exécute **une seule fois**, sur la machine qui soumet le job. En revanche, le code passé **aux opérateurs** (les lambdas comme ''String::length'' ou ''PointTotal::plus'') s'exécute **une fois par message** qui traverse le tuyau, sur les TaskManagers.
  
-==== 2.4 Les fonctions utilisateur ====+Un ''System.out.println'' placé dans ''main'' s'affiche donc une fois, chez le client ; placé dans une lambda de ''map'', il s'affiche dans les journaux des TaskManagers, pour chaque élément.
  
-Une transformation reçoit une fonction, écrite au choix :+==== 2.5 Préciser le type produit par une lambda ====
  
-<sxh java> +Cette situation se présente à la mission 7 (expérience d).
-// sous forme de lambda ou de référence de méthode +
-events.filter(e -> e.entries() >= 15);+
  
-// sous forme de classe, quand la logique est plus longue ou réutilisée +Flink doit connaître le type exact des éléments pour les transférer d'une machine à l'autre. Il le déduit en général tout seul, y compris pour les ''record'' Java. Mais Java efface les paramètres des types génériques à la compilation : avec une **lambda** qui produit un ''Tuple2<String, Long>'', Flink ne sait plus ce que contient le tuple, et le job échoue dès sa construction (//« could not be determined automatically… »//).
-events.filter(new FiltreAffluence(15));+
  
-public static class FiltreAffluence implements FilterFunction<CounterEvent> { +Il suffit alors de préciser le type produit avec ''.returns(...)'' :
-    private final int seuil; +
-    public FiltreAffluence(int seuil) { this.seuil = seuil; } +
-    @Override +
-    public boolean filter(CounterEvent e) { return e.entries() >= seuil; } +
-} +
-</sxh> +
- +
-Ces fonctions sont **sérialisées** puis envoyées aux TaskManagers : elles ne doivent référencer que des objets sérialisables (pas de connexion ouverte, pas de client Kafka créé dans ''main''). +
- +
-==== 2.5 Les types des éléments ==== +
- +
-Flink doit connaître le type des éléments de chaque flux pour les sérialiser quand ils passent d'une machine à l'autre. Il le déduit en général tout seul, y compris pour les ''record'' Java et les classes simples (POJO). +
- +
-Il n'y parvient pas toujours avec une **lambda qui produit un type générique**, comme ''Tuple2<String, Long>'' : à l'exécution, Java a effacé les paramètres de type (//type erasure//). Il faut alors les préciser :+
  
 <sxh java> <sxh java>
Ligne 155: Ligne 190:
       .returns(Types.TUPLE(Types.STRING, Types.LONG));       .returns(Types.TUPLE(Types.STRING, Types.LONG));
 </sxh> </sxh>
- 
-Sans ''.returns(...)'', le job échoue dès sa construction avec un message explicite (//« could not be determined automatically… »//). 
  
 ===== 3. Lire et écrire dans Kafka ===== ===== 3. Lire et écrire dans Kafka =====
  
-==== 3.1 La source Kafka ====+==== 3.1 Lire depuis Kafka avec KafkaSource ==== 
 + 
 +Pour brancher Flink sur Kafka, on configure un objet ''KafkaSource'' à l'aide d'un //builder//, puis on l'injecte dans l'environnement Flink.
  
 <sxh java> <sxh java>
 +// 1. Configurer la connexion à Kafka
 KafkaSource<String> source = KafkaSource.<String>builder() KafkaSource<String> source = KafkaSource.<String>builder()
-        .setBootstrapServers("kafka-1:19092")                  // comme bootstrap.servers +        .setBootstrapServers("kafka-1:19092")                  // Adresse du cluster Kafka 
-        .setTopics("Counters") +        .setTopics("Counters")                                 // Topic à écouter 
-        .setGroupId("td1-job01")                               // comme group.id +        .setGroupId("td1-job01")                               // Identifiant du groupe 
-        .setStartingOffsets(OffsetsInitializer.latest())       // où commencer à lire +        .setStartingOffsets(OffsetsInitializer.latest())       // Où commencer la lecture ? 
-        .setValueOnlyDeserializer(new SimpleStringSchema())    // octets de la valeur → String+        .setValueOnlyDeserializer(new SimpleStringSchema())    // Convertir les octets reçus en String
         .build();         .build();
  
-DataStream<String> messages = env.fromSource(source, WatermarkStrategy.noWatermarks(), "Kafka : Counters");+// 2. Créer le flux de données (le premier tuyau) 
 +DataStream<String> messages = env.fromSource( 
 +        source,  
 +        WatermarkStrategy.noWatermarks(), // Gestion du temps (désactivée pour l'instant) 
 +        "Kafka : Counters"                // Nom de l'étape affiché dans l'interface web 
 +);
 </sxh> </sxh>
  
-^ Réglage ^ Équivalent côté consumer Kafka ^ +=== Les réglages essentiels ===
-| ''setBootstrapServers'' | ''bootstrap.servers'' | +
-| ''setGroupId'' | ''group.id'' | +
-| ''setStartingOffsets(OffsetsInitializer.earliest())'' | lire depuis le début des partitions | +
-| ''setStartingOffsets(OffsetsInitializer.latest())'' | lire seulement les nouveaux messages | +
-| ''setStartingOffsets(OffsetsInitializer.committedOffsets(...))'' | reprendre aux offsets commités du groupe | +
-| ''setValueOnlyDeserializer'' | ''value.deserializer'' (la clé est ignorée) |+
  
-Le second argument de ''fromSource'' (la stratégie de watermarks) ne sert que pour le temps de l'événement (§ 7) ; ''noWatermarks()'' signifie « pas de temps de l'événement ».+Si vous avez déjà manipulé un Consumer Kafka classique, les paramètres sont quasiment identiques :
  
-<WRAP important round> +^ Paramètre Flink ^ Ce que ça fait ^ Équivalent Consumer classique ^ 
-**La source Kafka de Flink n'est pas un membre de groupe de consommateurs.** Elle n'utilise ni ''subscribe'' ni les rebalances : c'est Flink qui **attribue lui-même les partitions** à ses sous-tâches (§ 6.4). Le ''group.id'' sert à nommer le client et à commiter les offsets dans Kafka, mais Flink ne les commite qu'au moment de ses //checkpoints// : sans checkpoint, le groupe n'apparaît pas, ou sans offsets, dans ''kafka-consumer-groups''. Les positions de lecture qui comptent sont celles que Flink sauvegarde dans ses propres checkpoints.+| ''setBootstrapServers(...)'' | Adresse des brokers Kafka | ''bootstrap.servers'' | 
 +| ''setTopics(...)'' | Topic(s) à consommer | ''consumer.subscribe(...)'' | 
 +| ''setGroupId(...)'' | Nom du groupe de lecture | ''group.id'' | 
 +| ''setValueOnlyDeserializer(...)'' | Décode le contenu du message en texte (ignore la clé) | ''value.deserializer = StringDeserializer'' | 
 +| ''setStartingOffsets(...)'' | Définit le point de départ lors du premier lancement | ''auto.offset.reset'' | 
 + 
 +Pour le point de départ (''StartingOffsets''), trois choix sont possibles : 
 +  * ''OffsetsInitializer.earliest()'' : lit **tout l'historique** depuis le tout début du topic. 
 +  * ''OffsetsInitializer.latest()'' : ignore l'historique et n'attend que les **prochains messages**. 
 +  * ''OffsetsInitializer.committedOffsets()'' : reprend là où le groupe s'était arrêté la dernière fois. 
 + 
 +<WRAP tip round> 
 +**Le 2e paramètre de ''env.fromSource'' :** ''WatermarkStrategy.noWatermarks()'' sert à indiquer à Flink comment gérer le temps lié aux événements. Pour l'instant, on n'en a pas besoin, donc on le désactive.
 </WRAP> </WRAP>
  
 +<WRAP important round>
 +**Attention au piège : Flink n'utilise pas le protocole standard de Kafka !**
 +
 +Contrairement à un Consumer Kafka classique :
 +  * **Pas de rebalance Kafka :** Flink ne laisse pas Kafka répartir les partitions. C'est Flink qui prend le contrôle et décide lui-même quelle tâche lit quelle partition.
 +  * **La vraie position de lecture est dans Flink, pas dans Kafka :** Flink mémorise ses offsets dans ses propres sauvegardes internes (les //checkpoints//).
 +  * **Le ''group.id'' sert surtout d'étiquette :** Flink ne commite les offsets dans Kafka qu'au moment de ses checkpoints (pour que vous puissiez voir l'avancement via les outils de monitoring Kafka). Si les checkpoints ne sont pas activés, votre ''group.id'' n'affichera aucun offset dans Kafka, mais Flink continuera quand même à lire correctement !
 +</WRAP>
 ==== 3.2 Les sinks ==== ==== 3.2 Les sinks ====
  
  • eadl/bloc5/fm4/chap1.1794851666.txt.gz
  • Dernière modification : il y a 8 heures
  • de jcheron