Ingesta de datos con Spark Structured Streaming
Tip
Consulte la pestaña Texto e imágenes para obtener más detalles.
La ingesta de datos en tiempo real le permite procesar eventos a medida que ocurren en lugar de esperar intervalos de lotes. Cuando su organización necesita capturar lecturas de sensores de IoT, datos de flujo de clics o transacciones financieras a medida que ocurren, Spark Structured Streaming proporciona la base para la ingesta continua de datos en su lakehouse.
En esta unidad, aprenderá a configurar trabajos de transmisión estructurada que leen desde fuentes de transmisión y escriben en tablas del catálogo de Unity.
Descripción del modelo de Structured Streaming
Structured Streaming trata los datos entrantes como una tabla sin enlazar que crece continuamente a medida que llegan nuevos datos. Usa la misma API de DataFrame que ya conoce, pero en lugar de spark.read, usa spark.readStream para crear un DataFrame de transmisión que procese los datos de forma incremental.
Considere un escenario en el que los datos del sensor llegan continuamente desde el equipo de fabricación. En lugar de programar trabajos por lotes por hora para ingerir estos datos, puede configurar una tarea de transmisión en tiempo real que procese cada lectura en cuestión de segundos a partir de su llegada. El motor de streaming realiza un seguimiento de los registros que se han procesado mediante puntos de control, por lo que si el trabajo se reinicia, se reanuda desde donde se dejó sin reprocesar ni perder datos.
El patrón fundamental para la ingesta de streaming implica tres pasos:
-
Configuración del origen mediante
spark.readStreamcon detalles de conexión - Aplicar transformaciones para dar forma a los datos según sea necesario
-
Escribir en un receptor usando
writeStreamcon una ubicación de punto de control
Conexión a Kafka y Event Hubs
Azure Event Hubs proporciona un punto de conexión compatible con Apache Kafka, lo que significa que puede usar el mismo conector de Kafka para ambos servicios. Este enfoque unificado simplifica el código al trabajar con diferentes buses de mensajes.
En el ejemplo siguiente se leen mensajes de un tema de Kafka:
df_stream = (spark.readStream
.format("kafka")
.option("kafka.bootstrap.servers", "broker-server:9092")
.option("subscribe", "sensor-readings")
.option("startingOffsets", "latest")
.load())
Para Azure Event Hubs, se conecta a través de su interfaz compatible con Kafka. La diferencia clave es la configuración de autenticación, que usa SASL con la cadena de conexión de Event Hubs:
eh_namespace = "your-namespace"
eh_name = "your-eventhub"
connection_string = dbutils.secrets.get(scope="eventhubs", key="connection-string")
kafka_options = {
"kafka.bootstrap.servers": f"{eh_namespace}.servicebus.windows.net:9093",
"subscribe": eh_name,
"kafka.sasl.mechanism": "PLAIN",
"kafka.security.protocol": "SASL_SSL",
"kafka.sasl.jaas.config": f'kafkashaded.org.apache.kafka.common.security.plain.PlainLoginModule required username="$ConnectionString" password="{connection_string}";'
}
df_stream = (spark.readStream
.format("kafka")
.options(**kafka_options)
.load())
Al leer desde Kafka o Event Hubs a través de la interfaz compatible con Kafka, recibirá un esquema estándar con las columnas key, value, topic, partition, offset y timestamp. Las key columnas y value contienen datos binarios, por lo que normalmente se convierten en cadenas y se analiza el contenido:
from pyspark.sql.functions import col, from_json
from pyspark.sql.types import StructType, StringType, DoubleType
schema = StructType() \
.add("device_id", StringType()) \
.add("temperature", DoubleType()) \
.add("timestamp", StringType())
parsed_df = (df_stream
.select(col("value").cast("string").alias("json_value"))
.select(from_json(col("json_value"), schema).alias("data"))
.select("data.*"))
Uso del conector nativo de Event Hubs
Azure Databricks también proporciona un conector nativo de Event Hubs que simplifica la autenticación y proporciona acceso directo a características específicas de Event Hubs. Este conector usa el eventhubs formato :
connection_string = dbutils.secrets.get(scope="eventhubs", key="connection-string")
events = (spark.readStream
.format("eventhubs")
.option("eventhubs.connectionString", connection_string)
.load())
El conector nativo de Event Hubs devuelve un esquema diferente a la interfaz compatible con Kafka. La carga del evento se almacena en la body columna (en lugar de value), junto con columnas de metadatos específicas de Event Hubs adicionales:
# Extract and parse the event payload
payload = events.selectExpr("CAST(body AS STRING) AS payload")
Puede configurar opciones adicionales de Event Hubs, como el grupo de consumidores y la posición inicial:
events = (spark.readStream
.format("eventhubs")
.option("eventhubs.connectionString", connection_string)
.option("eventhubs.consumerGroup", "$Default")
.option("eventhubs.startingPosition", '{"offset": "-1", "seqNo": -1, "enqueuedTime": null, "isInclusive": true}')
.load())
La startingPosition opción controla dónde empezar a leer eventos. Use -1 para los eventos más recientes o configure un desfase específico, un número de secuencia o un tiempo en cola para sus necesidades de ingesta.
Configuración de ubicaciones de punto de control
Los puntos de control son el mecanismo que hace que structured Streaming sea tolerante a errores. El directorio de puntos de control almacena la información de desplazamiento que rastrea exactamente qué registros se han procesado. Si el trabajo de transmisión se detiene inesperadamente, puede reiniciarse y continuar desde el último punto de control confirmado.
Importante
Cada consulta de streaming debe tener su propia ubicación de punto de control única. El uso compartido de puntos de control entre diferentes consultas provoca errores de procesamiento de datos.
Al iniciar una escritura de streaming, especifique la ubicación del punto de comprobación:
checkpoint_path = "/checkpoints/sensor-ingestion"
query = (parsed_df.writeStream
.format("delta")
.option("checkpointLocation", checkpoint_path)
.toTable("catalog.schema.sensor_readings"))
Almacene los puntos de control en una ubicación confiable y duradera, como Azure Data Lake Storage. Los archivos de punto de comprobación son pequeños pero críticos para la recuperación, por lo que configura la ubicación de almacenamiento con las directivas de retención y copia de seguridad adecuadas.
Escritura de datos en streaming en tablas de Unity Catalog
Al escribir en las tablas del catálogo de Unity se utiliza el formato Delta Lake, que admite tanto escrituras de transmisión como transacciones ACID. La writeStream API refleja la API por lotes write , pero incluye opciones para el procesamiento continuo:
(parsed_df.writeStream
.format("delta")
.outputMode("append")
.option("checkpointLocation", "/checkpoints/my-stream")
.toTable("bronze.iot.sensor_readings"))
El modo de salida determina cómo se escriben los resultados:
- append: se agregan nuevas filas a la tabla. Utilice este modo para la mayoría de las cargas de trabajo de ingestión.
- update: se actualizan las filas modificadas. Use con agregaciones que generan actualizaciones.
- complete: todas las filas se reescribirán. Use con agregaciones que requieren un recalculo completo.
En escenarios de ingesta en los que se anexan datos sin procesar, el modo predeterminado append es adecuado.
Control del procesamiento con desencadenadores
Los desencadenadores determinan cuándo y con qué frecuencia procesa el motor de streaming los datos. Azure Databricks admite varias opciones de desencadenador:
| Trigger | Comportamiento |
|---|---|
| Valor predeterminado (sin desencadenador) | Procesa el siguiente lote tan pronto como se complete el lote anterior |
processingTime="10 seconds" |
Procesos en intervalos fijos |
availableNow=True |
Procesa todos los datos disponibles y, a continuación, se detiene |
once=True |
Procesa un microproceso y, a continuación, se detiene (en desuso) |
Para la ingesta continua que se ejecuta indefinidamente, omita la opción de desencadenador o use un intervalo de tiempo de procesamiento. Para los patrones de lotes incrementales en los que desea procesar todos los datos disponibles según una programación, use availableNow:
(parsed_df.writeStream
.format("delta")
.option("checkpointLocation", checkpoint_path)
.trigger(availableNow=True)
.toTable("catalog.schema.table_name"))
El availableNow desencadenador procesa todos los datos sin procesar desde el último punto de control y, a continuación, finaliza. Puede programar este patrón mediante trabajos de Databricks para que se ejecuten a intervalos regulares, combinando la eficacia del streaming (solo procesando nuevos datos) con la previsibilidad de los trabajos por lotes programados.
Supervisión de consultas de streaming
Las consultas de streaming activas aparecen en la interfaz de usuario de Spark en la pestaña Structured Streaming (Streaming estructurado ). También puede acceder al estado de la consulta mediante programación:
query = parsed_df.writeStream.format("delta").option("checkpointLocation", checkpoint_path).toTable("my_table")
# Check if the query is still running
print(query.isActive)
# Get the current status
print(query.status)
# View recent progress
print(query.recentProgress)
Use el método para bloquear la awaitTermination() ejecución hasta que la secuencia se complete o produzca un error. En caso de trabajos de producción, implemente el control de errores para capturar y responder a fallos de streaming.
try:
query.awaitTermination()
except Exception as e:
print(f"Stream failed: {e}")
En entornos de producción, configure la supervisión y las alertas para detectar cuándo los trabajos de streaming se atrasan o encuentran errores. Las métricas de streaming incluyen información de retraso que le ayuda a comprender si el procesamiento sigue el ritmo de los datos entrantes.