Configurar modo em tempo real
Esta página descreve como executar query no modo em tempo real diretamente com as APIs de Structured Streaming no compute. Para obter um tutorial passo a passo, consulte Tutorial: execução uma carga de trabalho de transmissão em tempo real. Para obter informações conceituais sobre o modo em tempo real, consulte Conceitos do modo em tempo real.
O modo em tempo real nos LakeFlow Pipelines é compatível com pipelines gerenciados em compute clássico e Serverless, com requisitos separados de runtime, fonte, destino e operador.
Pré-requisitos
Para usar o modo tempo real, você deve configurar seu compute para atender aos seguintes requisitos:
- Use o compute clássico. Os modos de acesso dedicado e padrão são compatíveis. O modo de acesso padrão é compatível apenas com Python. A configuração direta da query nesta página não é compatível em notebooks ou jobs serverless. Para processamento em tempo real serverless, use o modo em tempo real em Lakeflow pipelines.
- Utilize Databricks Runtime 16.4 LTS ou superior.
- Desative a escala automática.
- Desligue o Photon.
- Defina
spark.databricks.streaming.realTimeMode.enabledcomotrue. - Desative as instâncias spot para evitar interrupções.
Para cargas de trabalho sensíveis à latência com UDFs (Funções Definidas pelo Usuário), a Databricks recomenda o uso do modo de acesso dedicado. Consulte as funções da tabela.
Para obter instruções sobre como criar e configurar compute clássica, consulte a referência de configuração de computação.
joins de transmissão para transmissão
Joins internos de transmissão para transmissão requerem configuração adicional para o modo em tempo real. Joins externos de transmissão para transmissão não são aceitos. Consulte join de transmissão para transmissão.
Para executar um join Stream a Stream em modo de tempo real com vários outros Stream no mesmo cluster, é necessário usar o Databricks Runtime 18 LTS e acima.
Para habilitar joins de transmissão para transmissão para o modo de tempo real, defina as seguintes configurações do Spark:
- 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;
Configuração da consulta
Para executar uma consulta no modo tempo real, é necessário habilitar o trigger tempo real. Os gatilhos em tempo real são suportados apenas no modo de atualização.
- 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()
Propagação de marca d’água em tempo real
No Databricks Runtime 19 e acima, o modo de tempo real oferece suporte à propagação de marca d’água em tempo real. Cada operador com estado avança a sua marca d’água, limpa o estado, dispara timers de tempo de evento e passa a marca d’água a jusante em tempo real, em vez de apenas nos limites de lote.
A propagação de marca d’água em tempo real está ativa por default para novas queries no modo em tempo real nas versões recentes do Databricks Runtime 19. Para voltar ao comportamento anterior, no qual a marca d’água avança apenas nos limites dos lotes, defina esta configuração do Spark como false antes de começar a query. Você pode defini-la na sessão, conforme mostra o seguinte exemplo, ou na configuração do Spark do 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;
Ativar a propagação de marca d’água em tempo real por default não afeta as queries existentes. Uma query mantém a configuração com a qual começou, inclusive após uma reinicialização a partir do mesmo checkpoint. Para alterar a configuração de uma query existente, reinicie a query a partir de um novo checkpoint.
Para novas queries stateful, você pode ver uma filtragem de eventos tardios mais agressiva e uma retenção de estado mais curta do que com a semântica anterior. Valide em um ambiente de pré-produção antes de execução novas queries em produção.
Para saber como a propagação de marca d’água em tempo real afeta os operadores com estado, consulte transformWithState no modo em tempo real e Consultas com estado de várias etapas.
Marca-d’água min-of-max
Quando a propagação de marca d’água em tempo real está ativada, o modo em tempo real computa a marca d’água com semântica de mínimo dos máximos para todas as fontes compatíveis com o modo em tempo real. Para cada withWatermark, o Databricks rastreia o tempo máximo de evento visto em cada partição de fonte. A marca d’água é o mínimo desses máximos por partição, menos o atraso da marca d’água. A marca d’água avança apenas na velocidade da partição de fonte mais lenta, portanto, eventos de uma partição mais lenta não são descartados como tardios porque uma partição mais rápida moveu a marca d’água para frente.
Para a maioria das fontes, cada partição de entrada Spark é uma partição de origem. As fontes do Apache Kafka são uma exceção: o Databricks rastreia cada partição de tópico do Kafka como uma partição de origem, mesmo quando uma partição de entrada Spark lê várias delas. Por exemplo, se você definir maxPartitions como um valor inferior ao número de partições de tópico do Kafka, uma partição de tópico lenta ainda reterá a marca-d’água quando ela compartilhar uma partição de entrada Spark com outras mais rápidas.
O Databricks persiste apenas um valor de marca d’água entre lotes, não um valor para cada partição de origem. Se uma partição de origem não receber dados durante um lote, a marca d’água não avançará nesse lote.
Quando a propagação de marca-d’água em tempo real está desativada, o modo em tempo real usa a semântica max-of-max, como faz o modo micro-lotes. A marca-d’água é o horário máximo do evento em todas as partições de origem, menos o atraso da marca-d’água.
Se um operador com estado tiver mais de uma entrada withWatermark, como um join de transmissão para transmissão, o Databricks combinará suas marcas-d’água com a política de múltiplas marcas-d’água.
Formas de query que não são suportadas
Quando a propagação de marca d’água em tempo real está ativada, o Databricks rejeita os seguintes formatos de query ao planejar um lote, antes que qualquer tarefa seja executada:
- Um shuffle antes de
withWatermark, comorepartition(n).withWatermark(...). A query falha com o erro SHUFFLE_NOT_SUPPORTED_BEFORE_WATERMARK. - Mais de um shuffle entre um operador stateful e o
withWatermarkmais próximo ou operador stateful antes dele na query. O Databricks verifica cada entrada de um operador stateful separadamente, então cada entrada de um join pode ter um shuffle. Por exemplo,withWatermark(...), depoisrepartition(2), depoisgroupByKey(...).transformWithState(...)tem dois shuffles: aquele querepartitionadiciona e aquele quegroupByKeyadiciona. A query falha com o erro MULTIPLE_SHUFFLES_NOT_SUPPORTED.
Se sua carga de trabalho precisar de um desses formatos de query, entre em contato com o suporte do Databricks.
dimensionamento de cálculo
Você pode executar um Job de tempo real por recurso compute se a compute tiver slots de tarefa suficientes.
Para execução em modo de baixa latência, o número total de slots de tarefas disponíveis deve ser maior ou igual ao número de tarefas em todos os estágios da consulta.
Exemplos de cálculo de slots
tipo de tubulação | Configuração | Vagas necessárias |
|---|---|---|
Sem estado em estágio único (fonte + destino Kafka) |
| 8 vagas |
Com estado em dois estágios (fonte Kafka + embaralhamento) |
| 28 vagas (8 + 20) |
Três estágios (fonte Kafka + shuffle + repartição) |
| 48 vagas (8 + 20 + 20) |
Se você não definir maxPartitions, use o número de partições no tópico do Kafka.