Ce support présente les notions de Flink dont le TD a besoin, dans l'ordre où le TD les rencontre. Il ne couvre pas l'état durable, les checkpoints, les garanties de livraison ni les watermarks en détail : ce sont les sujets des séances suivantes.
Une application qui consomme un topic Kafka avec la bibliothèque cliente (comme le ConsoleConsumer de la mission 3 ou le CounterWorker du TP Kafka) suit toujours le même schéma :
consumer.subscribe(List.of("Counters"));
while (true) {
for (ConsumerRecord<String, String> r : consumer.poll(Duration.ofMillis(500))) {
traiter(r); // le métier : quelques lignes
}
}
Le métier tient en quelques lignes. Tout le reste est à la charge du développeur :
| Préoccupation | Ce qu'il faut écrire soi-même |
|---|---|
| Répartir le travail | Lancer plusieurs exemplaires de l'application ; le groupe de consommateurs se partage les partitions |
| Regrouper par clé | S'appuyer sur le partitionnement Kafka… qui ne correspond pas toujours à la clé du calcul |
| Garder un état | Une Map en mémoire, perdue à l'arrêt |
| Reprendre après une panne | Commiter les offsets, sauvegarder et restaurer l'état (topic compacté), le tout de façon cohérente |
| Calculer par tranche de temps | Découper les fenêtres, décider quand une fenêtre est terminée, gérer les retards |
| Écrire le résultat | Un producer, et sa cohérence avec les offsets lus (transactions) |
Dès que le traitement dépasse « lire, transformer, écrire un message à la fois », ce code d'infrastructure devient majoritaire et difficile à rendre juste.
Apache Flink est un moteur de traitement de flux distribué. Le développeur décrit quoi calculer (lire, transformer, regrouper, agréger, écrire) ; Flink décide comment l'exécuter sur un cluster :
producteurs ──► Kafka (topic d'entrée) ──► job Flink ──► Kafka (topic de sortie), base, fichiers…
stockage durable du flux calcul résultats
Kafka et Flink sont complémentaires : Kafka stocke et transporte le flux (durable, rejouable, partitionné), Flink le calcule. Flink n'a pas de stockage de messages propre : il lit et écrit dans des systèmes externes.
Flink traite les deux avec la même API : pour lui, un lot n'est qu'un flux qui se termine. Dans ce TD, tous les flux sont non bornés.
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.
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
}
}
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é :
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
Quand main arrive à env.execute(…), aucun message n'a encore été lu. Flink a seulement enregistré ce plan :
A : String B : CounterEvent C : PointTotal D : PointTotal
① lire ────────────► ② parser ────────────► ③ convertir ────────────► ④ cumuler ──┬──► ⑤ afficher
« Counters » (keyBy + reduce) │
└──► ⑥ écrire dans
« point-totals »
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.
À 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.
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(…).
public static void main(String[] args) throws Exception {
// 1. L'environnement d'exécution : le point d'entrée de tout job
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 2. La source
DataStream<String> lignes = env.fromSource(source, WatermarkStrategy.noWatermarks(), "ma source");
// 3. Les transformations
DataStream<Integer> longueurs = lignes.map(String::length);
// 4. Le sink
longueurs.print();
// 5. Le lancement
env.execute("mon job");
}
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).
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.
C'est l'appel à env.execute() qui :
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.
Une transformation reçoit une fonction, écrite au choix :
// 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; }
}
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 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 :
events.map(e -> Tuple2.of(e.counterId(), 1L))
.returns(Types.TUPLE(Types.STRING, Types.LONG));
Sans .returns(…), le job échoue dès sa construction avec un message explicite (« could not be determined automatically… »).
KafkaSource<String> source = KafkaSource.<String>builder()
.setBootstrapServers("kafka-1:19092") // comme bootstrap.servers
.setTopics("Counters")
.setGroupId("td1-job01") // comme group.id
.setStartingOffsets(OffsetsInitializer.latest()) // où commencer à lire
.setValueOnlyDeserializer(new SimpleStringSchema()) // octets de la valeur → String
.build();
DataStream<String> messages = env.fromSource(source, WatermarkStrategy.noWatermarks(), "Kafka : Counters");
| Réglage | Équivalent côté consumer Kafka |
|---|---|
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 ».
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.
print() est le sink le plus simple : il écrit chaque élément (son toString()) sur la sortie standard de la machine qui l'exécute, précédé d'un préfixe optionnel et du numéro de sous-tâche quand le parallélisme dépasse 1 :
TOTAL:2> PointTotal[pointCode=P003, events=42, …]
Attention : print numérote les sous-tâches à partir de 1, alors que l'interface web les numérote à partir de 0. Sur le cluster, cette sortie se trouve donc dans les journaux des TaskManagers, pas dans le terminal qui a soumis le job.
Le sink Kafka écrit dans un topic. Il faut lui indiquer comment transformer chaque élément en clé et en valeur :
KafkaSink<PointTotal> sink = KafkaSink.<PointTotal>builder()
.setBootstrapServers("kafka-1:19092")
.setRecordSerializer(KafkaRecordSerializationSchema.<PointTotal>builder()
.setTopic("point-totals")
.setKeySerializationSchema(t -> t.pointCode().getBytes(StandardCharsets.UTF_8))
.setValueSerializationSchema(t -> t.toJson().getBytes(StandardCharsets.UTF_8))
.build())
.setDeliveryGuarantee(DeliveryGuarantee.AT_LEAST_ONCE)
.build();
totals.sinkTo(sink);
Comme pour un producer Kafka, la clé détermine la partition de destination : tous les messages de même clé arrivent dans la même partition, dans l'ordre. Les garanties de livraison (AT_LEAST_ONCE, EXACTLY_ONCE) reposent sur les checkpoints et seront vues plus tard.
| Opération | Pour chaque élément reçu | Type de sortie | Exemple |
|---|---|---|---|
map | exactement 1 élément émis | peut changer | String → CounterEvent |
filter | 0 ou 1 élément émis : l'élément lui-même, s'il passe le test | identique | garder les mesures dont entries >= 15 |
flatMap | 0, 1 ou n éléments émis | peut changer | découper une phrase en mots ; ignorer une ligne illisible |
map et filter sont des cas particuliers de flatMap. Celui-ci reçoit un collecteur et décide combien de fois l'appeler :
public static class ParseOrSkip implements FlatMapFunction<String, CounterEvent> {
@Override
public void flatMap(String json, Collector<CounterEvent> out) {
try {
out.collect(CounterEvent.parse(json)); // 1 sortie
} catch (IllegalArgumentException e) {
System.err.println("Message ignoré : " + e.getMessage()); // 0 sortie
}
}
}
Une exception levée dans une fonction utilisateur fait échouer le job : Flink l'arrête puis le redémarre selon sa stratégie de redémarrage. Si l'erreur vient d'un message invalide, le redémarrage relit le même message et échoue à nouveau. Un flatMap qui écarte les éléments invalides évite cette boucle ; en production, on les envoie plutôt vers une sortie dédiée (l'équivalent d'une DLQ).
Ces trois opérateurs calculent leur sortie à partir du seul élément courant : ils n'ont rien à mémoriser entre deux éléments. On dit qu'ils sont sans état (stateless).
Conséquence pour l'exécution : n'importe quelle instance de l'opérateur peut traiter n'importe quel élément. On peut donc les dupliquer librement et leur envoyer les éléments sans se soucier de leur clé.
Deux enchaînements peuvent donner le même résultat avec un coût différent. Filtrer tôt réduit le nombre d'éléments que les opérateurs suivants doivent traiter, sérialiser et transmettre. C'est la même règle qu'en SQL, où l'on restreint les lignes avant de joindre ou d'agréger.
Pour calculer un cumul par point de comptage, il faut que tous les éléments d'un même point soient traités au même endroit. C'est le rôle de keyBy :
KeyedStream<CounterEvent, String> parPoint = events.keyBy(CounterEvent::pointCode);
keyBy prend une fonction qui extrait la clé de chaque élément. Flink calcule un hachage de cette clé et envoie l'élément à l'instance de l'opérateur suivant chargée de ce hachage. Garanties :
keyBy ne transforme pas les éléments : il produit un KeyedStream, sur lequel deviennent disponibles les opérations par clé (agrégations, fenêtres, état).
Comparaison avec Kafka. Le partitionnement Kafka et keyBy reposent sur la même idée (même clé → même destination), mais à deux niveaux différents :
keyBy est choisie par chaque traitement, selon ce qu'il calcule, et peut être différente de la clé Kafka.
Dans le flux des compteurs, la clé Kafka est le capteur (COUNTER-00001-1) : les deux portes d'un même point peuvent être dans deux partitions différentes. Un consumer Kafka ne voit donc pas forcément tout un point ; un keyBy(pointCode) rétablit ce regroupement, sans toucher au topic.
Sur un KeyedStream, une agrégation combine chaque nouvel élément avec le résultat courant de sa clé :
// reduce : (cumul courant, nouvel élément) → nouveau cumul, du même type
DataStream<PointTotal> totals = events
.map(PointTotal::of) // chaque mesure → un total « unitaire »
.keyBy(PointTotal::pointCode)
.reduce(PointTotal::plus); // a.plus(b) : additionne les deux totaux
| Agrégation | Rôle |
|---|---|
reduce(f) | combine deux éléments du même type en un seul, avec une fonction fournie |
sum(champ) | somme d'un champ (position dans un Tuple, ou nom d'attribut d'un POJO) |
min(champ), max(champ) | minimum, maximum d'un champ |
minBy(champ), maxBy(champ) | l'élément entier qui porte le minimum, le maximum |
Sur un flux non borné, il n'y a pas de « dernier élément », donc pas de résultat final : ces agrégations émettent le nouveau résultat à chaque élément reçu. La sortie est une suite de cumuls de plus en plus grands :
P001 : 9 → P001 : 17 → P001 : 30 → …
Pour obtenir un résultat par tranche de temps plutôt qu'un cumul sans fin, on utilise une fenêtre (§ 7).
Entre deux éléments, l'opérateur reduce doit se souvenir du cumul de chaque clé. Ce cumul est un état par clé (keyed state), conservé par Flink dans l'instance qui gère la clé :
instance #0 de « reduce » instance #1 de « reduce »
┌──────────────────────────┐ ┌──────────────────────────┐
│ P002 → {entries: 812…} │ │ P001 → {entries: 790…} │
│ P003 → {entries: 655…} │ │ P004 → {entries: 701…} │
└──────────────────────────┘ │ P005 → {entries: 688…} │
└──────────────────────────┘
C'est l'équivalent de la Map<String, …> qu'un consumer Kafka tiendrait à la main, avec deux différences : Flink la répartit automatiquement entre les instances selon la clé, et il sait la sauvegarder (checkpoint) pour la restaurer après une panne ou un redémarrage.
Dans le TD, les checkpoints ne sont pas activés. L'état n'existe donc qu'en mémoire : arrêter le job, c'est perdre les cumuls ; le resoumettre, c'est repartir de zéro. Les checkpoints et la reprise sur panne sont l'objet de la séance « état et tolérance aux pannes ».
client (flink run, IDE) ──── jar + graphe du job ───► ┌────────────┐
│ JobManager │ coordonne, interface web :8081
└─────┬──────┘
déploie les tâches │
┌──────────────────────────────────────┴──────┐
┌──────▼─────────┐ ┌───────▼────────┐
│ TaskManager 1 │ ◄═══ données échangées ══► │ TaskManager 2 │
│ [slot] [slot] │ entre les tâches │ [slot] [slot] │
└────────────────┘ └────────────────┘
| Composant | Rôle |
|---|---|
| Client | Construit le graphe (exécute main jusqu'à execute()) et le soumet avec le jar |
| JobManager | Reçoit les jobs, transforme le graphe en tâches, les place dans des slots, surveille l'exécution, redémarre en cas d'échec ; sert l'interface web |
| TaskManager | Processus Java (JVM) qui exécute les tâches et échange les données avec les autres TaskManagers |
| Slot | Une « place » d'exécution dans un TaskManager. Le nombre de slots se règle par TaskManager (taskmanager.numberOfTaskSlots) |
Un job Flink n'est pas un programme qu'on lance en plusieurs exemplaires : c'est un programme confié au cluster, qui décide où et combien de fois exécuter chaque opérateur.
Chaque opérateur s'exécute en un ou plusieurs exemplaires en parallèle. Le parallélisme est leur nombre ; chaque exemplaire est une sous-tâche (subtask), numérotée à partir de 0.
source (p = 3) map (p = 3) reduce (p = 2)
[ source #0 ] ──────► [ map #0 ] ──┐ ┌──► [ reduce #0 ]
[ source #1 ] ──────► [ map #1 ] ──┼═════┤
[ source #2 ] ──────► [ map #2 ] ──┘ └──► [ reduce #1 ]
FORWARD HASH (keyBy)
Le parallélisme se règle à plusieurs niveaux ; le plus précis l'emporte :
| Niveau | Comment |
|---|---|
| Opérateur | .setParallelism(n) sur l'opérateur, dans le code |
| Job | env.setParallelism(n) dans le code, ou flink run -p n à la soumission |
| Cluster | parallelism.default dans la configuration (1 dans le TD) |
Par défaut, Flink place dans un même slot une sous-tâche de chaque opérateur du job (slot sharing) : un slot peut accueillir toute une « tranche » du traitement. Un job a donc besoin d'autant de slots que le plus grand parallélisme de ses opérateurs.
S'il n'y a pas assez de slots libres, le job ne peut pas démarrer : il reste en attente de ressources, puis échoue. Les slots occupés par un job ne sont pas disponibles pour les autres : sur un petit cluster, il faut arrêter les jobs dont on n'a plus besoin.
Flink attribue les partitions du topic aux sous-tâches de la source. Une partition est lue par une seule sous-tâche ; une sous-tâche peut lire plusieurs partitions.
| Partitions | Sous-tâches source | Répartition |
|---|---|---|
| 3 | 1 | la sous-tâche lit les 3 partitions |
| 3 | 3 | une partition chacune |
| 3 | 4 | une sous-tâche ne reçoit rien |
C'est la même règle que pour un groupe de consommateurs Kafka : le nombre de partitions borne le parallélisme utile de la lecture. Pour lire plus vite, il faut à la fois plus de sous-tâches et plus de partitions.
La manière dont les éléments passent d'un opérateur au suivant dépend de l'opération :
| Liaison | Quand | Effet |
|---|---|---|
FORWARD | même parallélisme, aucune redistribution demandée | la sous-tâche i envoie à la sous-tâche i, localement |
HASH | après un keyBy | chaque élément va à la sous-tâche chargée du hachage de sa clé ; les données traversent le réseau |
REBALANCE | parallélismes différents sans keyBy | distribution à tour de rôle, pour équilibrer la charge |
Une liaison HASH ou REBALANCE est une redistribution (shuffle) : les éléments sont sérialisés et peuvent changer de machine. C'est l'étape la plus coûteuse d'un job.
Quand deux opérateurs consécutifs sont reliés par une liaison FORWARD (même parallélisme, pas de redistribution), Flink les chaîne : il les exécute dans la même tâche, dans le même thread, en se passant les éléments par simple appel de méthode, sans sérialisation ni file d'attente.
code : source ──► map ──► filter ──► keyBy ──► reduce ──► print
exécution : [ source → map → filter ] ══ HASH ══► [ reduce → print ]
tâche 1 tâche 2
L'interface web affiche une boîte par tâche, avec le nom des opérateurs chaînés à l'intérieur. Le chaînage améliore nettement les performances ; on peut le désactiver (env.disableOperatorChaining()) pour observer chaque opérateur séparément, au prix d'échanges supplémentaires entre tâches.
| Élément | Ce qu'il montre |
|---|---|
| Overview | TaskManagers, slots totaux et disponibles, jobs en cours |
| Graphe du job | Une boîte par tâche, la liaison entre les boîtes, le parallélisme |
| Records Received / Sent | Éléments échangés entre tâches ; ce qui entre ou sort vers un système externe (Kafka, affichage) n'y figure pas forcément |
| SubTasks | Le détail par sous-tâche : où elle s'exécute, combien d'éléments elle a traités |
| Exceptions | Les erreurs qui ont fait échouer le job ou l'ont fait redémarrer |
Une agrégation continue (§ 5.2) produit un cumul qui grossit indéfiniment. Pour des indicateurs utiles, on veut des résultats par tranche de temps : « entrées du point P001 entre 08:00 et 08:15 ».
Une fenêtre regroupe les éléments d'une même clé sur un intervalle de temps et produit un résultat quand l'intervalle se termine.
events.keyBy(CounterEvent::pointCode) // 1. par clé
.window(TumblingProcessingTimeWindows.of(Duration.ofSeconds(10))) // 2. découpage du temps
.process(new Summarize(...)); // 3. calcul sur chaque fenêtre
fixes (tumbling) |----A----|----B----|----C----| chaque élément dans une seule fenêtre
glissantes (sliding) |----A----|
|----B----| taille et pas différents : chevauchement
|----C----|
de session |-A-| |---B---| |-C-| fermées après une période d'inactivité
Le TD n'utilise que des fenêtres fixes (tumbling) : de taille constante, sans chevauchement, alignées sur l'horloge (une fenêtre de 15 minutes commence à 00, 15, 30 ou 45). Les deux autres formes seront vues plus tard.
Après window(…), on indique le calcul à faire sur chaque fenêtre :
process(ProcessWindowFunction) : reçoit tous les éléments de la fenêtre à sa fermeture, ainsi que ses bornes ; la plus souple, mais Flink doit garder tous les éléments en mémoire ;reduce / aggregate : combinent les éléments au fil de l'eau, Flink ne garde qu'un résultat partiel par fenêtre ; plus économes.
public static class Summarize extends ProcessWindowFunction<CounterEvent, WindowSummary, String, TimeWindow> {
@Override
public void process(String pointCode, Context ctx, Iterable<CounterEvent> elements,
Collector<WindowSummary> out) {
// appelée une fois par clé et par fenêtre ; ctx.window() donne le début et la fin
}
}
Toute la question est de savoir de quelle horloge on parle :
| Horloge | Définition | Dans le flux des compteurs |
|---|---|---|
| Temps de traitement (processing time) | L'heure de la machine qui exécute l'opérateur, au moment où l'élément passe | l'heure réelle |
| Temps de l'événement (event time) | L'heure à laquelle l'événement s'est produit, inscrite dans le message | le champ timestamp (horloge simulée) |
En temps de traitement, une fenêtre contient « ce qui est arrivé pendant ces 10 secondes ». C'est simple et immédiat, mais le résultat dépend de la vitesse du flux, des ralentissements et des redémarrages : relire l'historique ne redonne pas les mêmes fenêtres.
En temps de l'événement, une fenêtre contient « ce qui s'est produit entre 08:00 et 08:15 », quel que soit le moment où les messages sont lus. Le résultat est reproductible : relire le topic redonne les mêmes fenêtres. C'est l'horloge qui a un sens métier, au prix d'une difficulté : savoir quand une fenêtre est terminée.
En temps de traitement, la fenêtre [10:00:00, 10:00:10[ se ferme quand l'horloge de la machine atteint 10:00:10.
En temps de l'événement, il n'y a pas d'horloge à consulter : le temps avance avec les messages. Et ceux-ci peuvent arriver dans le désordre (plusieurs partitions, plusieurs producteurs, retards réseau). Flink a besoin de deux informations, fournies par une WatermarkStrategy :
WatermarkStrategy<CounterEvent> strategie = WatermarkStrategy
.<CounterEvent>forBoundedOutOfOrderness(Duration.ofMinutes(1)) // retard toléré
.withTimestampAssigner((e, tsKafka) -> e.eventTimeMillis()); // où lire l'heure de l'événement
events.assignTimestampsAndWatermarks(strategie)
.keyBy(CounterEvent::pointCode)
.window(TumblingEventTimeWindows.of(Duration.ofMinutes(15)))
.process(new Summarize(...));
timestamp du message.forBoundedOutOfOrderness(1 min), le watermark suit l'heure d'événement la plus élevée vue jusqu'ici, moins une minute.
Une fenêtre en temps de l'événement se ferme quand le watermark dépasse sa fin : la fenêtre [08:00, 08:15[ produit son résultat lorsqu'un message daté d'au moins 08:16 environ est passé (08:15 + 1 minute de tolérance).
Une sous-tâche qui ne reçoit aucun message (par exemple une source sans partition) ne fait jamais avancer son watermark, et bloque alors les fenêtres en aval. withIdleness(…) indique à Flink de l'ignorer après un certain temps d'inactivité.
Le fonctionnement détaillé des watermarks, le traitement des messages arrivés après la fermeture de leur fenêtre et les fenêtres glissantes et de session sont l'objet de la séance « traitements, fenêtres et agrégations ».
| Mode | Comment | Usage |
|---|---|---|
| Local (mini-cluster) | Exécuter main depuis l'IDE ou avec Maven : JobManager et TaskManager démarrent dans la même JVM | Mise au point rapide : points d'arrêt, affichage dans la console de l'IDE |
| Cluster | Construire le jar, puis le soumettre (flink run, ou ./scripts/flink.sh run dans le TD) | Exécution distribuée, comme en production |
Sur le cluster, un job soumis s'exécute avec le jar tel qu'il était à la soumission. Pour prendre en compte une modification : recompiler, arrêter l'ancien job, soumettre le nouveau.
Le cluster fournit déjà les bibliothèques de Flink. Le jar d'un job ne contient donc que son propre code et les bibliothèques que le cluster n'a pas (ici, le connecteur Kafka). Dans le pom.xml, les dépendances de Flink sont déclarées avec le scope provided : utilisées à la compilation, mais pas embarquées dans le jar.
Pour exécuter le job hors du cluster (depuis l'IDE), il faut les remettre dans le classpath : c'est le réglage Add dependencies with “provided” scope to classpath d'IntelliJ.
Un job reçoit ses arguments comme tout programme Java (String[] args). Passer les valeurs qui varient (seuil, topic, point de départ dans Kafka, parallélisme…) en paramètres plutôt qu'en constantes permet de soumettre le même jar avec des réglages différents, sans recompiler. Dans le TD, la classe Params lit les arguments de la forme –nom valeur.
| Préoccupation | Consumer Kafka écrit à la main | Job Flink |
|---|---|---|
| Lire le topic | subscribe + boucle de poll | KafkaSource + fromSource |
| Répartir les partitions | Le groupe de consommateurs, avec ses rebalances | Flink attribue les partitions aux sous-tâches de la source |
| Exécuter en parallèle | Lancer N exemplaires de l'application | Régler le parallélisme ; le cluster place les sous-tâches |
| Regrouper par clé | Dépend de la clé Kafka choisie par le producteur | keyBy sur n'importe quel champ |
| Garder un état | Map en mémoire | État par clé géré par Flink |
| Sauvegarder l'état et la position de lecture | Commit des offsets + topic compacté, à synchroniser soi-même | Checkpoints (séance suivante) |
| Fenêtres de temps | Calcul des bornes, détection de la fin, à la main | window(…) + watermarks |
| Message invalide | try/catch, DLQ à la main | flatMap qui écarte, sortie dédiée |
| Écrire le résultat | Producer, transactions | KafkaSink, garanties de livraison |
Le développeur garde la responsabilité du métier : quelles données lire, quelle clé choisir, quels calculs faire, quelle horloge utiliser. Flink prend en charge la mécanique de l'exécution distribuée.
// Environnement et lancement
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(2); // parallélisme par défaut du job
env.disableOperatorChaining(); // désactiver le chaînage (pour observer)
env.execute("nom du job"); // construit le graphe et le lance
// Source
DataStream<String> s = env.fromSource(kafkaSource, WatermarkStrategy.noWatermarks(), "nom");
// Transformations sans état
s.map(x -> ...) // 1 → 1
.filter(x -> ...) // 1 → 0 ou 1
.flatMap((x, out) -> ...) // 1 → 0..n (avec une classe si le type est générique)
.returns(Types....) // préciser le type produit par une lambda
.name("nom affiché") // nom de l'opérateur dans l'interface web
.setParallelism(3); // parallélisme de cet opérateur
// Par clé
s.keyBy(x -> cle) // redistribution par hachage de la clé
.reduce((a, b) -> ...) // ou .sum(champ), .min(champ), .max(champ)…
// Fenêtres
s.keyBy(x -> cle)
.window(TumblingProcessingTimeWindows.of(Duration.ofSeconds(10))) // temps de traitement
.process(new MaProcessWindowFunction());
s.assignTimestampsAndWatermarks(strategie)
.keyBy(x -> cle)
.window(TumblingEventTimeWindows.of(Duration.ofMinutes(15))) // temps de l'événement
.process(new MaProcessWindowFunction());
// Sinks
s.print("PREFIXE");
s.sinkTo(kafkaSink);
Les notions laissées de côté dans ce TD, traitées dans les séances suivantes :
aggregate, ProcessFunction et minuteries (timers), sorties annexes (side outputs).Documentation officielle : Apache Flink 2.2 (rubriques Concepts et Application Development → DataStream API).