Ingerir dados com Spark Structured Streaming
Tip
Consulte a guia Texto e imagens para obter mais detalhes!
A ingestão de dados em tempo real permite-lhe processar eventos à medida que ocorrem, em vez de esperar por intervalos de lote. Quando a sua organização precisa de capturar leituras de sensores IoT, dados de clickstream ou transações financeiras à medida que ocorrem, o Spark Structured Streaming fornece a base para a ingestão contínua de dados no seu lakehouse.
Nesta unidade, aprendes a configurar trabalhos de Structured Streaming que leem de fontes de streaming e escrevem em tabelas do Unity Catalog.
Compreenda o modelo de Streaming Estruturado
O Structured Streaming trata os dados recebidos como uma tabela ilimitada que cresce continuamente à medida que novos dados chegam. Usas a mesma API DataFrame que já conheces, mas em vez de spark.read, usas spark.readStream para criar um DataFrame em streaming que processa dados de forma incremental.
Considere um cenário em que os dados dos sensores chegam continuamente de equipamentos de fabrico. Em vez de agendar trabalhos em lote a cada hora para ingerir esses dados, pode configurar um trabalho de streaming que processa cada leitura em segundos após a sua chegada. O motor de streaming regista quais registos foram processados usando checkpoints, por isso, se o trabalho reiniciar, retoma do ponto em que parou sem reprocessamento de dados ou perda de dados.
O padrão fundamental para a ingestão de streaming envolve três passos:
-
Configure a fonte usando
spark.readStreamcom detalhes de ligação - Aplicar transformações para moldar os dados conforme necessário
-
Escreve para um sumidouro usando
writeStreamcom uma localização de checkpoint
Liga-te à Kafka e aos Centros de Eventos
O Hubs de Eventos do Azure fornece um endpoint compatível com Apache Kafka, o que significa que pode usar o mesmo conector Kafka para ambos os serviços. Esta abordagem unificada simplifica o seu código ao trabalhar com diferentes barramentos de mensagens.
O exemplo seguinte lê mensagens de um tópico de Kafka:
df_stream = (spark.readStream
.format("kafka")
.option("kafka.bootstrap.servers", "broker-server:9092")
.option("subscribe", "sensor-readings")
.option("startingOffsets", "latest")
.load())
Para os Hubs de Eventos do Azure, liga-se através da sua interface compatível com Kafka. A diferença chave é a configuração de autenticação, que usa SASL com a sua cadeia de conexão do 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())
Ao ler a partir do Kafka ou Event Hubs através da interface compatível com Kafka, recebe-se um esquema padrão com as colunas key, value, topic, partition, offset e timestamp. As colunas key e value contêm dados binários, por isso, normalmente, converte-se para string e analisa-se o conteúdo.
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.*"))
Use o conector nativo Event Hubs
O Azure Databricks também fornece um conector nativo de Event Hubs que simplifica a autenticação e proporciona acesso direto a funcionalidades específicas dos Event Hubs. Este conector utiliza o eventhubs formato:
connection_string = dbutils.secrets.get(scope="eventhubs", key="connection-string")
events = (spark.readStream
.format("eventhubs")
.option("eventhubs.connectionString", connection_string)
.load())
O conector nativo dos Event Hubs devolve um esquema diferente da interface compatível com Kafka. A carga útil do evento é armazenada na body coluna (em vez de value), juntamente com colunas adicionais de metadados específicas dos Centros de Eventos:
# Extract and parse the event payload
payload = events.selectExpr("CAST(body AS STRING) AS payload")
Pode configurar opções adicionais nos Centros de Eventos, como grupo de consumidores e posição 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())
A startingPosition opção controla onde começar a ler eventos. Use -1 para os eventos mais recentes ou configure um offset específico, número de sequência ou tempo de enfileiramento para as suas necessidades de ingestão.
Configurar localizações de pontos de controlo
Os checkpoints são o mecanismo que torna o Streaming Estruturado tolerante a falhas. O diretório de pontos de controlo armazena a informação de offset que acompanha exatamente quais os registos que foram processados. Se o seu trabalho de streaming parar inesperadamente, pode reiniciar, e continuar a partir do último ponto de verificação comprometido.
Importante
Cada consulta de streaming deve ter o seu próprio ponto de controlo único. Partilhar pontos de verificação entre diferentes consultas causa erros no processamento de dados.
Ao iniciar uma gravação em fluxo contínuo, especifique a localização do checkpoint:
checkpoint_path = "/checkpoints/sensor-ingestion"
query = (parsed_df.writeStream
.format("delta")
.option("checkpointLocation", checkpoint_path)
.toTable("catalog.schema.sensor_readings"))
Guarde os seus pontos de controlo num local fiável e durado, como o Azure Data Lake Storage. Os ficheiros de checkpoint são pequenos mas críticos para a recuperação, por isso configure a sua localização de armazenamento com políticas adequadas de backup e retenção.
Escrever dados de streaming em tabelas do Catálogo Unity
A escrita em tabelas do Catálogo Unity utiliza o formato Delta Lake, que suporta tanto gravações em fluxo contínuo como transações ACID. A writeStream API espelha a API por lote write , mas inclui opções para processamento contínuo:
(parsed_df.writeStream
.format("delta")
.outputMode("append")
.option("checkpointLocation", "/checkpoints/my-stream")
.toTable("bronze.iot.sensor_readings"))
O modo de saída determina como os resultados são escritos:
- anexar: Novas linhas são adicionadas à tabela. Use este modo para a maioria das cargas de trabalho de ingestão.
- atualização: As linhas alteradas foram atualizadas. Use com agregações que produzam atualizações.
- complete: Todas as linhas são reescritas. Use com agregações que exigem recálculo completo.
Para cenários de ingestão em que adicionas dados brutos, o modo padrão append é apropriado.
Processamento de controlo com gatilhos
Os gatilhos determinam quando e com que frequência o motor de streaming processa dados. O Azure Databricks suporta várias opções de trigger:
| Acionador | Comportamento |
|---|---|
| Padrão (sem gatilho) | Processa o lote seguinte assim que o lote anterior termina |
processingTime="10 seconds" |
Processos em intervalos fixos |
availableNow=True |
Processa todos os dados disponíveis e depois pára |
once=True |
Processa um micro-lote e depois pára (obsoleto) |
Para ingestão contínua que dura indefinidamente, omita a opção de disparo ou utilize um intervalo de tempo de processamento. Para padrões em lote incremental onde pretende processar todos os dados disponíveis num calendário, utilize availableNow:
(parsed_df.writeStream
.format("delta")
.option("checkpointLocation", checkpoint_path)
.trigger(availableNow=True)
.toTable("catalog.schema.table_name"))
O availableNow disparador processa todos os dados não processados desde o último ponto de verificação e depois termina. Pode agendar este padrão usando Databricks Jobs para correr a intervalos regulares, combinando a eficiência do streaming (apenas processando dados novos) com a previsibilidade dos trabalhos em lote agendados.
Monitorizar consultas de streaming
As consultas de streaming ativo aparecem na interface do Spark, no separador Structured Streaming . Também pode aceder ao estado da consulta de forma programática:
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 o awaitTermination() método para bloquear a execução até que o fluxo termine ou falhe. Para cargas de trabalho de produção, implemente tratamento de erros para capturar e responder a falhas em streaming.
try:
query.awaitTermination()
except Exception as e:
print(f"Stream failed: {e}")
Em ambientes de produção, configure monitorização e alertas para detetar quando os trabalhos de streaming ficam atrasados ou encontram erros. As métricas de streaming incluem informação de lag que o ajuda a perceber se o seu processamento acompanha os dados recebidos.