Ingerir dados com o Streaming Estruturado do Spark

Concluído(a)

Dica

Consulte a guia Texto e imagens para obter mais detalhes!

A ingestão de dados em tempo real permite processar eventos à medida que ocorrem em vez de esperar por intervalos em lotes. Quando sua organização precisa capturar leituras de sensor de IoT, dados de sequência de cliques ou transações financeiras quando ocorrem, o Streaming Estruturado do Spark fornece a base para a ingestão contínua de dados em seu lakehouse.

Nesta unidade, você aprenderá a configurar trabalhos de Streaming Estruturado que leem de fontes de streaming e gravam em tabelas do Catálogo do Unity.

Entender o modelo de Streaming Estruturado

O Structured Streaming trata os dados recebidos como uma tabela ilimitada que cresce continuamente à medida que novos dados chegam. Você usa a mesma API DataFrame que já conhece, mas em vez de spark.read, usa spark.readStream para criar um DataFrame de streaming que processa dados incrementalmente.

Considere um cenário em que os dados do sensor chegam continuamente do equipamento de fabricação. Em vez de agendar trabalhos em lotes por hora para ingerir esses dados, você pode configurar um trabalho de streaming que processe cada leitura em segundos após a chegada. O mecanismo de streaming rastreia quais registros foram processados usando pontos de verificação, portanto, se o trabalho for reiniciado, ele será retomado de onde parou sem reprocessar ou perder dados.

O padrão fundamental para a ingestão de streaming envolve três etapas:

  1. Configurar a origem usando spark.readStream com detalhes da conexão
  2. Aplicar transformações para moldar os dados conforme necessário
  3. Gravar em um coletor usando writeStream um local de ponto de verificação

Conectar-se ao Kafka e aos Hubs de Eventos

Os Hubs de Eventos do Azure fornecem um ponto de extremidade compatível com Apache Kafka, o que significa que você pode usar o mesmo conector Kafka para ambos os serviços. Essa abordagem unificada simplifica seu código ao trabalhar com diferentes barramentos de mensagens.

O seguinte exemplo lê mensagens de um tópico 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, você se conecta por meio de sua interface compatível com Kafka. A principal diferença é a configuração de autenticação, que usa SASL com a 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 do Kafka ou Event Hubs por meio da interface compatível com Kafka, você recebe um esquema padrão com key, value, topic, partition, offset e timestamp colunas. As colunas key e value contêm dados binários, portanto, normalmente, você as converte em string e analisa 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.*"))

Usar o conector nativo do Event Hubs

O Azure Databricks também fornece um conector nativo dos Hubs de Eventos que simplifica a autenticação e fornece acesso direto aos recursos específicos dos Hubs de Eventos. Esse conector usa 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 Hubs de Eventos retorna um esquema diferente da interface compatível com Kafka. O conteúdo do evento é armazenado na coluna body (em vez de value), juntamente com colunas de metadados específicas dos Hubs de Eventos adicionais:

# Extract and parse the event payload
payload = events.selectExpr("CAST(body AS STRING) AS payload")

Você pode configurar opções adicionais de Hubs 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 deslocamento específico, número de sequência ou tempo de enfileiramento para suas necessidades de ingestão.

Configurar locais de ponto de verificação

Pontos de verificação são o mecanismo que torna o Streaming Estruturado tolerante a falhas. O diretório de ponto de verificação armazena as informações de deslocamento que rastreiam exatamente os registros que foram processados. Se o trabalho de streaming for interrompido inesperadamente, ele poderá reiniciar e continuar do último ponto de verificação confirmado.

Importante

Cada consulta de streaming deve ter seu próprio local de ponto de verificação exclusivo. O compartilhamento de pontos de verificação entre consultas diferentes causa erros de processamento de dados.

Ao iniciar uma gravação de streaming, especifique o local do ponto de verificação:

checkpoint_path = "/checkpoints/sensor-ingestion"

query = (parsed_df.writeStream
    .format("delta")
    .option("checkpointLocation", checkpoint_path)
    .toTable("catalog.schema.sensor_readings"))

Armazene seus pontos de verificação em um local confiável e durável, como o Azure Data Lake Storage. Os arquivos de ponto de verificação são pequenos, mas críticos para recuperação, portanto, configure seu local de armazenamento com políticas de backup e retenção apropriadas.

Gravar dados de streaming em tabelas do Catálogo do Unity

A gravação em tabelas do Catálogo do Unity usa o formato Delta Lake, que dá suporte a gravações de streaming e transações ACID. A writeStream API espelha a API do 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 gravados:

  • append: novas linhas são adicionadas à tabela. Utilize esse modo para a maioria dos trabalhos de ingestão.
  • atualização: as linhas alteradas são atualizadas. Use com agregações que produzem atualizações.
  • completo: todas as linhas são reescritas. Use com agregações que exigem recálculo completo.

Para cenários de ingestão em que se acrescenta dados brutos, o modo padrão append é apropriado.

Controlar o processamento com gatilhos

Os gatilhos determinam quando e com que frequência o mecanismo de streaming processa dados. O Azure Databricks dá suporte a várias opções de gatilho:

Trigger Comportamento
Padrão (sem gatilho) Processa o próximo lote assim que o lote anterior for concluído
processingTime="10 seconds" Processos em intervalos fixos
availableNow=True Processa todos os dados disponíveis e, em seguida, para
once=True Processa um microlote e, em seguida, para (obsoleto)

Para ingestão contínua que é executada indefinidamente, omita a opção de gatilho ou use um intervalo de tempo de processamento. Para padrões de lote incrementais em que você deseja processar todos os dados disponíveis em um agendamento, use availableNow:

(parsed_df.writeStream
    .format("delta")
    .option("checkpointLocation", checkpoint_path)
    .trigger(availableNow=True)
    .toTable("catalog.schema.table_name"))

O availableNow gatilho processa todos os dados não processados desde o último ponto de verificação e termina. Você pode agendar esse padrão usando trabalhos do Databricks para serem executados em intervalos regulares, combinando a eficiência do streaming (apenas processando novos dados) com a previsibilidade de trabalhos em lotes agendados.

Monitorar consultas de streaming

As consultas de streaming ativas aparecem na interface do usuário do Spark na guia Streaming Estruturado . Você também pode acessar o status da consulta programaticamente:

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 seja concluído ou falhe. Para cargas de produção, implemente o tratamento de erros para capturar e responder a falhas durante a transmissão de dados:

try:
    query.awaitTermination()
except Exception as e:
    print(f"Stream failed: {e}")

Em ambientes de produção, configure monitoramento e alertas para detectar quando trabalhos de streaming ficam para trás ou encontram erros. As métricas de streaming incluem informações de retardo que ajudam você a entender se o processamento acompanha os dados de entrada.