Test technique Apache Flink : stream processing avancé

Flink est la référence pour le stream processing à faible latence. En entretien Senior, on évalue la compréhension de l event time, du stateful processing et des garanties de livraison.

Data Builder·Juin 2025·6 min de lecture·Data Engineer

Sommaire

Flink vs Spark Streaming
Event time vs processing time
Stateful processing
Checkpointing et fault tolerance
Flink SQL
Cas d usage
Grille

1Flink vs Spark Structured Streaming

Question discriminante

Dans quel cas choisissez-vous Flink plutôt que Spark Streaming ?

	Spark Streaming	Apache Flink
Modèle	Micro-batch (100ms minimum)	True streaming (event by event)
Latence	100ms - 1s	1-10ms
State management	Limité	Très riche (RocksDB)
Exactement-une-fois	Possible mais complexe	Natif
Idéal pour	Équipes Spark, batch + streaming unified	Latence sub-seconde, état complexe, fraude temps réel

2Event time vs processing time

Question discriminante

Quelle est la différence entre event time et processing time dans Flink ?

from pyflink.datastream import StreamExecutionEnvironment
from pyflink.common.time import Time
from pyflink.datastream.window import TumblingEventTimeWindows

env = StreamExecutionEnvironment.get_execution_environment()

# Processing time : l heure système quand l event est traité
# Simple mais incohérent si les events arrivent en retard
stream.window(TumblingProcessingTimeWindows.of(Time.minutes(5)))

# Event time : l heure DANS l event (quand il s est passé)
# Cohérent, mais nécessite des watermarks pour les retardataires
stream \
    .assign_timestamps_and_watermarks(
        WatermarkStrategy
            .for_bounded_out_of_orderness(Duration.of_seconds(10))
            .with_timestamp_assigner(MyTimestampAssigner())
    ) \
    .window(TumblingEventTimeWindows.of(Time.minutes(5)))

Event time recommandé — pour les analytics. Les résultats sont déterministes même si les events arrivent en retard
Processing time — pour les cas où la latence est critique et la cohérence moins importante

3Stateful processing : l avantage de Flink

Question discriminante

Qu est-ce que le stateful processing dans Flink ? Donnez un exemple concret.

from pyflink.datastream import KeyedProcessFunction
from pyflink.datastream.state import ValueStateDescriptor

# Détecter les sessions utilisateur avec état
class SessionDetector(KeyedProcessFunction):
    def open(self, runtime_context):
        # État persistant par clé (user_id)
        self.last_event_time = runtime_context.get_state(
            ValueStateDescriptor('last_event', Types.LONG())
        )
        self.session_start = runtime_context.get_state(
            ValueStateDescriptor('session_start', Types.LONG())
        )

    def process_element(self, event, ctx):
        current_time = event.timestamp
        last_time = self.last_event_time.value()
        
        if last_time is None or (current_time - last_time) > 30 * 60 * 1000:
            # Nouvelle session (> 30 minutes d inactivité)
            self.session_start.update(current_time)
        
        self.last_event_time.update(current_time)
        yield event

4Checkpointing et fault tolerance

Question discriminante

Comment Flink garantit-il exactly-once en cas de panne ?

Checkpointing — Flink sauvegarde périodiquement l état de tous les opérateurs. En cas de panne, reprend depuis le dernier checkpoint
Distributed snapshots — algorithme de Chandy-Lamport : snapshot cohérent sans arrêter le traitement
Exactly-once — combinaison du checkpointing Flink + transactions sur les sinks (Kafka transactions, JDBC transactions)
Configuration — env.enable_checkpointing(60000) : checkpoint toutes les 60 secondes
Backend — RocksDB pour les gros états (spillover sur disque), HashMapStateBackend pour les petits états (tout en RAM)

5Flink SQL : streaming avec SQL

Question discriminante

Comment écrivez-vous un job Flink avec SQL plutôt que l API Java/Python ?

from pyflink.table import EnvironmentSettings, TableEnvironment

env_settings = EnvironmentSettings.in_streaming_mode()
tbl_env = TableEnvironment.create(env_settings)

# Définir la source Kafka
tbl_env.execute_sql("""
    CREATE TABLE orders (
        order_id STRING,
        user_id STRING,
        amount DOUBLE,
        event_time TIMESTAMP(3),
        WATERMARK FOR event_time AS event_time - INTERVAL '5' SECOND
    ) WITH (
        'connector' = 'kafka',
        'topic' = 'orders',
        'properties.bootstrap.servers' = 'kafka:9092',
        'format' = 'json'
    )
""")

# Agrégation sur une fenêtre temporelle
tbl_env.execute_sql("""
    SELECT
        TUMBLE_START(event_time, INTERVAL '5' MINUTE) AS window_start,
        user_id,
        SUM(amount) AS total_amount
    FROM orders
    GROUP BY TUMBLE(event_time, INTERVAL '5' MINUTE), user_id
""")

6Cas d usage Flink en production

Question discriminante

Dans quels contextes d entreprise voit-on Flink déployé ?

Détection de fraude temps réel — analyser chaque transaction en quelques millisecondes, croiser avec l historique du compte
Alertes métier immédiates — alerter quand le stock d un produit tombe sous un seuil, en temps réel
ETL streaming — transformer les events Kafka et charger dans BigQuery/Snowflake en quasi-temps-réel
Feature engineering temps réel — calculer des features (moyenne mobile, count récent) pour le serving ML

7Grille par niveau

Niveau	Maitrise	Signal GO	NO-GO
Confirmé	Event time vs processing time, watermarks, Flink SQL	Explique la différence event/processing time, a écrit du Flink SQL	Ne sait pas la différence entre Flink et Spark Streaming
Senior	Stateful processing, checkpointing, exactly-once	A implémenté du stateful processing, comprend le checkpointing	Ne sait pas ce qu est le stateful processing

Vous recrutez un Data Engineer streaming avancé ?

Premier entretien gratuit. Rapport GO/NO-GO sous 48h.

Tester gratuitement Reserver un appel