Configurer le mode temps réel
Cette page décrit comment exécuter des query en mode temps réel directement avec les APIs Structured Streaming sur un compute classique. Pour un tutoriel étape par étape, consultez Tutoriel : Exécuter une charge de travail de streaming en temps réel. Pour obtenir des informations conceptuelles sur le mode temps réel, consultez Concepts du mode temps réel.
Le mode temps réel dans les LakeFlow Pipelines prend en charge les pipelines gérés sur les computes classiques et Serverless, avec des exigences distinctes en termes de runtime, de sources, de puits et d’opérateurs.
Prérequis
Pour utiliser le mode temps réel, vous devez configurer votre compute afin de satisfaire aux exigences suivantes :
- Utilisez le compute classique. Les modes d’accès dédié et standard sont pris en charge. Le mode d’accès standard est pris en charge uniquement pour Python. La configuration de la query directe sur cette page n’est pas prise en charge dans les Notebooks ou les Job Serverless. Pour le traitement en temps réel Serverless, utilisez le mode temps réel dans les LakeFlow Pipelines.
- Utiliser Databricks Runtime 16.4 LTS et versions supérieures.
- Désactiver la mise à l'échelle automatique.
- Désactiver Photon.
- Définir
spark.databricks.streaming.realTimeMode.enabledsurtrue. - Désactivez les instances ponctuelles pour éviter les interruptions.
Pour les charges de travail sensibles à la latence avec des UDF, Databricks vous recommande d'utiliser le mode d'accès dédié. Voir Fonctions de table.
Pour obtenir des instructions sur la création et la configuration du compute classique, consultez Référence de configuration du compute.
Jointures Stream à Stream
Les jointures internes stream-to-stream nécessitent une configuration supplémentaire pour le mode temps réel. Les jointures externes stream-to-stream ne sont pas prises en charge. Consultez l’article dédié à la jointure stream-to-stream.
Pour exécuter une jointure Stream to Stream en mode temps réel avec plusieurs autres Stream sur le même cluster, vous devez utiliser Databricks Runtime 18 LTS ou une version ultérieure.
Pour activer les jointures Stream vers Stream en mode temps réel, définissez les configurations Spark suivantes :
- Python
- Scala
- SQL
spark.conf.set("spark.databricks.streaming.realTimeMode.streamStreamJoin.enabled", "true")
spark.conf.set("spark.sql.streaming.join.stateFormatVersion", "4")
spark.conf.set("spark.sql.streaming.join.stateFormatV4.enabled", "true")
spark.conf.set("spark.sql.streaming.stateStore.rocksdb.mergeOperatorVersion", "2")
spark.conf.set("spark.sql.streaming.realTimeMode.controlMessage.enabled", "true")
spark.conf.set("spark.databricks.streaming.realTimeMode.streamStreamJoin.enabled", "true")
spark.conf.set("spark.sql.streaming.join.stateFormatVersion", "4")
spark.conf.set("spark.sql.streaming.join.stateFormatV4.enabled", "true")
spark.conf.set("spark.sql.streaming.stateStore.rocksdb.mergeOperatorVersion", "2")
spark.conf.set("spark.sql.streaming.realTimeMode.controlMessage.enabled", "true")
SET spark.databricks.streaming.realTimeMode.streamStreamJoin.enabled = true;
SET spark.sql.streaming.join.stateFormatVersion = 4;
SET spark.sql.streaming.join.stateFormatV4.enabled = true;
SET spark.sql.streaming.stateStore.rocksdb.mergeOperatorVersion = 2;
SET spark.sql.streaming.realTimeMode.controlMessage.enabled = true;
Configuration de la query
Pour exécuter une query en mode temps réel, vous devez activer le Trigger temps réel. Les Trigger temps réel ne sont pris en charge qu’en mode mise à jour.
- Python
- Scala
query = (
spark.readStream
.format("kafka")
.option("kafka.bootstrap.servers", broker_address)
.option("subscribe", input_topic)
.load()
.writeStream
.format("kafka")
.option("kafka.bootstrap.servers", broker_address)
.option("topic", output_topic)
.option("checkpointLocation", checkpoint_location)
.outputMode("update")
# In PySpark, the realTime trigger requires specifying the interval.
.trigger(realTime="5 minutes")
.start()
)
import org.apache.spark.sql.streaming.Trigger
val readStream = spark.readStream
.format("kafka")
.option("kafka.bootstrap.servers", brokerAddress)
.option("subscribe", inputTopic).load()
.writeStream
.format("kafka")
.option("kafka.bootstrap.servers", brokerAddress)
.option("topic", outputTopic)
.option("checkpointLocation", checkpointLocation)
.outputMode("update")
.trigger(Trigger.RealTime())
// Trigger.RealTime can also accept an argument specifying the batch duration.
// For example, this code sets a batch duration of 5 minutes:
// .trigger(Trigger.RealTime("5 minutes"))
.start()
Propagation de watermark en temps réel
Dans Databricks Runtime 19 et versions supérieures, le mode temps réel prend en charge la propagation de watermark en temps réel. Chaque opérateur avec état avance son watermark, nettoie l’état, déclenche des minuteurs d’heure d’événement et transmet le watermark en aval en temps réel, plutôt qu’uniquement aux limites de batch.
La propagation du watermark en temps réel est activée par default pour les nouvelles query en mode temps réel dans les récentes versions de Databricks Runtime 19. Pour revenir au comportement précédent, dans lequel le watermark n’avance qu’aux limites des batch, définissez cette configuration Spark sur false avant de start la query. Vous pouvez le définir dans la session, comme le montre l’exemple suivant, ou dans la configuration Spark du compute :
- Python
- Scala
- SQL
spark.conf.set("spark.databricks.streaming.realTimeMode.realTimeWatermark.enabled", "false")
spark.conf.set("spark.databricks.streaming.realTimeMode.realTimeWatermark.enabled", "false")
SET spark.databricks.streaming.realTimeMode.realTimeWatermark.enabled = false;
L'activation de la propagation du watermark en temps réel default n'affecte pas les query existantes. Une query conserve le paramètre avec lequel elle a start, y compris après un redémarrage à partir du même point de contrôle. Pour modifier le paramètre d'une query existante, redémarrez la query à partir d'un nouveau point de contrôle.
Pour les nouvelles queries avec état, vous pourrez observer un filtrage des événements tardifs plus agressif et une conservation de l’état plus courte qu’avec les sémantiques précédentes. Validez dans un environnement de pré-production avant d'exécuter de nouvelles queries en production.
Pour savoir comment la propagation de watermark en temps réel affecte les opérateurs avec état, consultez transformWithState en mode temps réel et Queries avec état en plusieurs étapes.
Filigrane min-of-max
Lorsque la propagation de watermark en temps réel est activée, le mode temps réel compute le watermark avec une sémantique « min-of-max » pour toutes les sources prises en charge par le mode temps réel. Pour chaque withWatermark, Databricks suit le temps d'événement maximal observé dans chaque partition source. Le watermark est le minimum de ces maximums par partition, moins le délai de watermark. Le watermark n'avance qu'à la vitesse de la partition source la plus lente. Les événements d'une partition plus lente ne sont donc pas abandonnés car une partition plus rapide a avancé le watermark.
Pour la plupart des sources, chaque partition d’entrée Spark est une partition source. Les sources Apache Kafka constituent une exception : Databricks suit chaque partition de sujet Kafka en tant que partition source, même lorsqu’une partition d’entrée Spark en lit plusieurs. Par exemple, si vous définissez maxPartitions sur une valeur inférieure au nombre de partitions de sujet Kafka, une partition de sujet lente retient toujours le filigrane lorsqu’elle partage une partition d’entrée Spark avec des partitions plus rapides.
Databricks ne conserve qu’une seule valeur de watermark entre les batchs, et non une valeur pour chaque partition source. Si une partition source ne reçoit aucune donnée pendant un batch, le watermark n’avance pas dans ce batch.
Lorsque la propagation de filigrane en temps réel est désactivée, le mode temps réel utilise la sémantique max-of-max, tout comme le mode micro-batch. Le watermark est l'heure maximale des événements sur toutes les partitions sources, moins le délai de watermark.
Si un opérateur avec état a plus d’une entrée withWatermark, telle qu’une jointure entre Stream et Stream, Databricks combine leurs watermarks avec la politique de plusieurs watermarks.
Formes de query qui ne sont pas prises en charge
Lorsque la propagation de watermark en temps réel est activée, Databricks rejette les formes de query suivantes lorsqu'il planifie un batch, avant l'exécution de toute tâche :
- Un shuffle avant
withWatermark, tel querepartition(n).withWatermark(...). La query échoue avec l’erreur SHUFFLE_NOT_SUPPORTED_BEFORE_WATERMARK. - Plus d’un shuffle entre un opérateur Stateful et le
withWatermarkou opérateur Stateful le plus proche avant lui dans la query. Databricks vérifie séparément chaque entrée d’un opérateur Stateful, de sorte que chaque entrée d’une jointure peut avoir un shuffle. Par exemple,withWatermark(...), puisrepartition(2), puisgroupByKey(...).transformWithState(...)comporte deux shuffles : celui querepartitionajoute et celui quegroupByKeyajoute. La query échoue avec l’erreur MULTIPLE_SHUFFLES_NOT_SUPPORTED.
Si votre charge de travail nécessite l’une de ces formes de query, contactez le support Databricks.
Dimensionnement du compute
Vous pouvez exécuter un Job en temps réel par ressource de compute si le compute dispose de suffisamment d'emplacements de tâches.
Pour fonctionner en mode faible latence, le nombre total d'emplacements de tâche disponibles doit être supérieur ou égal au nombre de tâches à travers toutes les étapes de query.
Exemples de calcul d'emplacement
Type de pipeline | Configuration | Emplacements requis |
|---|---|---|
Sans état à un seul étage (source Kafka + sink) |
| 8 emplacements |
À deux étapes et avec état (source Kafka + brassage) |
| 28 slots (8 + 20) |
À trois étapes (source Kafka + shuffle + repartition) |
| 48 emplacements (8 + 20 + 20) |
Si vous ne définissez pas maxPartitions, utilisez le nombre de partitions dans le sujet Kafka.