| Prochaine révision | Révision précédente |
| eadl:bloc5:fm4:chap1 [2026/11/16 18:16] – créée jcheron | eadl:bloc5:fm4:chap1 [2026/11/17 00:23] (Version actuelle) – [3.1 La source Kafka] jcheron |
|---|
| ===== 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 décrit un **graphe orienté** (//dataflow//) : | Pour comprendre Flink, il faut oublier la façon dont fonctionne un consumer classique : |
| | |
| | * **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. |
| | * **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. |
| | |
| | <sxh java> |
| | // 1. Consumer Kafka classique : chaque message est traité MAINTENANT, par ce code |
| | 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> |
| | |
| | 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 ] ──► [ transformation ] ──► [ transformation ] ──► [ sink ] | A : String B : CounterEvent C : PointTotal D : PointTotal |
| Kafka map, filter… keyBy + reduce… print, Kafka… | ① lire ────────────► ② parser ────────────► ③ convertir ────────────► ④ cumuler ──┬──► ⑤ afficher |
| | « Counters » (keyBy + reduce) │ |
| | └──► ⑥ écrire dans |
| | « point-totals » |
| </code> | </code> |
| <html></div></html> | <html></div></html> |
| |
| * une **source** produit les éléments (lecture d'un topic Kafka) ; | 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. |
| * 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. | 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. |
| |
| ==== 2.2 Le squelette d'un job ==== | 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.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 | |
| events.filter(new FiltreAffluence(15)); | |
| | |
| public static class FiltreAffluence implements FilterFunction<CounterEvent> { | |
| 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''). | 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… »//). |
| |
| ==== 2.5 Les types des éléments ==== | Il suffit alors de préciser le type produit avec ''.returns(...)'' : |
| | |
| 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> |
| .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 ==== |
| |