Accueil›Blog›Test technique Spark Structured Streaming : watermarks, triggers, sinks

Guide recrutement data

Test technique Spark Structured Streaming : watermarks, triggers, sinks

Spark Structured Streaming est la solution de streaming de référence dans l écosystème Spark. En entretien, on évalue la maîtrise des watermarks pour gérer les retards et le choix des output modes.

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

Sommaire

Concepts streaming
Watermarks
Triggers
Output modes
Sinks et destinations
Kafka + Spark Streaming
Grille

1Différence entre batch et streaming

Question discriminante

Quelle est la différence fondamentale entre le traitement batch et streaming ?

Batch — traiter des données à intervalle fixe (chaque nuit, chaque heure). Latence : minutes à heures
Streaming — traiter chaque événement au fur et à mesure de son arrivée. Latence : millisecondes à secondes
Micro-batch — Spark Structured Streaming fonctionne en micro-batches par défaut. Traite les événements par petits lots toutes les N secondes
Quand streaming — détection de fraude temps réel, alertes métier immédiates, dashboards temps réel, CDC en quasi-temps-réel

2Watermarks : gérer les événements en retard

Question discriminante

Qu est-ce qu un watermark dans Spark Streaming ? Pourquoi est-il indispensable pour les agrégations temporelles ?

from pyspark.sql.functions import window, col

# Sans watermark : Spark garde l état de toutes les fenêtres
# en mémoire indéfiniment -> OOM

# Avec watermark : Spark oublie les fenêtres anciennes
result = (
    df_stream
    .withWatermark('event_timestamp', '10 minutes')  # tolérance retard
    .groupBy(
        window(col('event_timestamp'), '5 minutes'),  # fenêtre d agrégation
        col('user_id')
    )
    .agg({'amount': 'sum'})
)

# Le watermark dit : tout événement arrivant avec plus
# de 10 minutes de retard sera ignoré
# Libère l état des fenêtres fermées de la mémoire

Watermark — seuil de tolérance pour les événements en retard. Au-delà, Spark ignore l événement
Sans watermark — agrégations temporelles impossibles (état infini en mémoire)
Trade-off — watermark large = plus de retardataires capturés mais plus de mémoire

3Triggers : contrôler la fréquence de traitement

Question discriminante

Quels triggers Spark Streaming proposent-ils ? Quand utilisez-vous chacun ?

from pyspark.sql.streaming import StreamingQuery

# Micro-batch toutes les 30 secondes
query = df.writeStream\
    .trigger(processingTime='30 seconds')\
    .format('delta')\
    .start()

# Once : traiter une seule fois puis arrêter (batch streaming)
query = df.writeStream\
    .trigger(once=True)\
    .format('delta')\
    .start()

# AvailableNow : traiter tout ce qui est disponible (Spark 3.3+)
query = df.writeStream\
    .trigger(availableNow=True)\
    .format('delta')\
    .start()

# Continuous : latence sub-milliseconde (expérimental)
query = df.writeStream\
    .trigger(continuous='1 second')\
    .start()

4Output modes : append, update, complete

Question discriminante

Quelle est la différence entre les output modes append, update et complete ?

Mode	Comportement	Quand
append	N écrit que les nouvelles lignes	Pas d agrégation, ou avec watermark
update	Écrit les lignes modifiées depuis le dernier trigger	Agrégations incrementales, upsert
complete	Réécrit toute la table à chaque trigger	Petits agrégats qui tiennent en mémoire

5Sinks et destinations

Question discriminante

Quels sinks Spark Streaming supporte-t-il pour écrire les résultats ?

Delta Lake — sink recommandé. ACID, time travel, schema evolution
Kafka — produire des événements traités vers un nouveau topic
BigQuery — via BigQuery Connector pour Spark ou Spark-BigQuery
Console — afficher dans le terminal. Uniquement pour le debug
Memory — stocker dans une table temporaire Spark SQL. Uniquement pour le debug
ForeachBatch — écrire dans n importe quelle destination via une fonction Python custom

6Intégration Kafka + Spark Streaming

Question discriminante

Comment lisez-vous depuis Kafka et écrivez-vous dans Delta Lake ?

from pyspark.sql.functions import from_json, col
from pyspark.sql.types import StructType, StructField, StringType, FloatType

order_schema = StructType([
    StructField('order_id', StringType()),
    StructField('amount', FloatType()),
    StructField('status', StringType())
])

# Lire depuis Kafka
df_raw = spark.readStream\
    .format('kafka')\
    .option('kafka.bootstrap.servers', 'kafka:9092')\
    .option('subscribe', 'orders-events')\
    .option('startingOffsets', 'latest')\
    .load()

# Parser le JSON du message Kafka
df_parsed = df_raw.select(
    from_json(col('value').cast('string'), order_schema).alias('data'),
    col('timestamp').alias('kafka_timestamp')
).select('data.*', 'kafka_timestamp')

# Écrire dans Delta Lake
df_parsed.writeStream\
    .format('delta')\
    .outputMode('append')\
    .option('checkpointLocation', '/checkpoints/orders')\
    .start('/data/delta/orders')

7Grille par niveau

Niveau	Maitrise	Signal GO	NO-GO
Confirmé	readStream/writeStream, triggers, output modes	A écrit un job Spark Streaming basique, comprend les 3 output modes	Ne sait pas la différence entre batch et streaming Spark
Senior	Watermarks, Kafka intégration, checkpointing, optimisation	A configuré des watermarks, a fait tourner Kafka → Spark → Delta en production	Ne sait pas ce qu est un watermark

Vous recrutez un Data Engineer Spark Streaming ?

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

Tester gratuitement Reserver un appel