Compartilhar via

Fluxos do Kafka para Hubs de Eventos do Azure

  • Artigo

Este artigo fornece detalhes sobre como usar a biblioteca de clientes dos Fluxos do Kafka com os Hubs de Eventos do Azure.

Observação

A funcionalidade dos Fluxos de Kafka está disponível apenas em Versão preliminar pública para Hubs de Eventos Premium e Camadas Dedicadas.

Visão geral

Os Fluxos do Apache Kafka é uma biblioteca de clientes somente Java que fornece uma estrutura para o processamento de dados de streaming e a criação de aplicativos em tempo real em relação aos dados armazenados nos tópicos do Kafka. Todo o processamento tem como escopo o cliente, enquanto os tópicos do Kafka atuam como o armazenamento de dados para dados intermediários, antes que a saída seja gravada no tópico de destino.

Os Hubs de Eventos fornecem um ponto de extremidade Kafka para ser usado com seus aplicativos cliente Kafka existentes como uma alternativa para executar seu próprio cluster Kafka. Os Hubs de Eventos funcionam com vários aplicativos Kafka existentes. Para saber mais, consulte Hubs de Eventos para o Apache Kafka.

Usando Fluxos do Kafka com Hubs de Eventos do Azure

Os Hubs de Eventos do Azure dão suporte nativo ao protocolo AMQP e ao Kafka. No entanto, para garantir o comportamento compatível dos Fluxos de Kafka, alguns dos parâmetros de configuração padrão precisam ser atualizados para clientes Kafka.

Propriedade Comportamento padrão para Hubs de Eventos Comportamento modificado para Fluxos de Kafka Explicação
messageTimestampType definido como AppendTime deve ser definido como CreateTime Os Fluxos de Kafka dependem do carimbo de data/hora de criação em vez de acrescentarem carimbo de data/hora
message.timestamp.difference.max.ms o valor máximo permitido é de 90 dias A propriedade é usada apenas para controlar carimbos de data/hora anteriores. A hora futura é definida como 1 hora e não pode ser alterada. Isso está alinhado com a especificação do protocolo Kafka
min.compaction.lag.ms o valor máximo permitido é de dois dias
Tópicos de retenção infinitos truncamento baseado em tamanho de 250 GB para cada tópico-partição
Excluir a API de registro para tópicos de retenção infinita Não implementado. Como solução alternativa, o tópico pode ser atualizado e um tempo de retenção finito pode ser definido. Isso será feito em GA

Outras considerações

Aqui estão algumas outras considerações para ter em mente.

  • Os aplicativos cliente de Fluxos de Kafka devem receber permissões de gerenciamento, leitura e gravação para que todos os namespaces possam criar tópicos temporários para processamento de fluxo.
  • Tópicos temporários e partições contam para a cota para o namespace fornecido. Elas devem ser mantidas em consideração ao provisionar o namespace ou cluster.
  • O tempo de retenção infinito para o Repositório de “Deslocamento” é limitado pelo tempo máximo de retenção de mensagens do SKU. Verifique as Cotas de Hubs de Eventos para obter esses valores específicos da camada.

Isso inclui atualizar a configuração do tópico em messageTimestampType para usar CreateTime (ou seja, hora de criação do evento) em vez de AppendTime (ou seja, a hora do acréscimo do log).

Para substituir o comportamento padrão (necessário), a configuração abaixo deve ser definida no ARM (Azure Resource Manager).

Observação

Somente as partes específicas do modelo do ARM são mostradas para realçar a configuração que precisa ser atualizada.

{
  "parameters": {
    "namespaceName": "contoso-test-namespace",
    "resourceGroupName": "contoso-resource-group",
    "eventHubName": "contoso-event-hub-kafka-streams-test",
    ...
    "parameters": {
      "properties": {
        ...
        "messageTimestampType": "CreateTime",
        "retentionDescription": {
          "cleanupPolicy": "Delete",
          "retentionTimeInHours": -1,
          "tombstoneRetentionTimeInHours": 1
        }
      }
    }
  }
}

Conceitos dos Fluxos de Kafka

Os Fluxos de Kafka fornecem uma camada de abstração simples sobre as APIs de produtor e consumidor do Kafka para ajudar os desenvolvedores a começar a usar cenários de streaming em tempo real mais rapidamente. A biblioteca leve depende de um agente compatível com Apache Kafka (como os Hubs de Eventos do Azure) para a camada de mensagens interna e gerencia um repositório de estado local tolerante a falhas. Com a API transacional, a biblioteca de fluxos do Kafka dá suporte a recursos avançados de processamento, como exatamente uma vez processando e um registro por vez processando.

Os registros que chegam fora de ordem se beneficiam de operações de janela baseadas em tempo de evento.

Observação

Recomendamos familiarizar-se com documentação de Fluxos de Kafka e conceitos principais de Fluxos de Kafka.

Fluxos

Um fluxo é a representação abstrata de um tópico Kafka. Ele consiste em um conjunto de dados não associado, atualizando continuamente os registros de dados imutáveis, em que cada registro de dados é um par chave-valor.

Topologia de processamento de fluxo

Um aplicativo de fluxos do Kafka define a lógica computacional por meio de um DAG (grafo acíclico direcionado) representado por uma topologia do processador. A topologia do processador é composta por processadores de fluxo (nós na topologia) que representam uma etapa de processamento, conectada por fluxos (bordas na topologia).

Os processadores de fluxo podem ser encadeados a processadores upstream ou processadores downstream, exceto para determinados casos especiais:

  • Processadores de origem – esses processadores não têm processadores upstream e são lidos diretamente de um ou mais fluxos. Em seguida, eles podem ser encadeados a processadores downstream.
  • Processadores de coletor – esses processadores não têm processadores downstream e devem gravar diretamente em um fluxo.

A topologia de processamento de fluxo pode ser definida com o DSL dos Fluxos de Kafka ou com a API do Processador de nível inferior.

Dualidade de fluxo e tabela

Fluxos e tabelas são duas abstrações diferentes, mas úteis, fornecidas pelo DSL dos Fluxos de Kafka, modelando séries temporais e formatos de dados relacionais que devem coexistir para casos de uso de processamento de fluxo.

O Kafka estende ainda mais isso e introduz uma dualidade entre fluxos e tabelas, em que

  • Um fluxo pode ser considerado como um changelog de uma tabela e
  • Uma tabela pode ser considerada como um instantâneo do valor mais recente de cada chave em um fluxo.

Essa dualidade permite que tabelas e fluxos sejam usados de forma intercambiável conforme exigido pelo caso de uso.

Por exemplo

  • Unir dados estáticos do cliente (modelados como uma tabela) com transações dinâmicas (modeladas como um fluxo) e
  • Unir as posições de portfólio em mudanças em um portfólio de day traders (modelado como um fluxo) com o feed de dados de mercado mais recente (modelado como um fluxo).

Hora

Os Fluxos de Kafka permitem que as funções de janela e de cortesia com registros de dados fora de ordem sejam ingeridos e ainda sejam incluídos no processamento. Para garantir que esse comportamento seja determinístico, há noções adicionais de tempo em fluxos Kafka. Estão incluídos:

  • Hora de criação (também conhecida como “Hora do evento”) – Esse é o momento em que o evento ocorreu e o registro de dados foi criado.
  • Tempo de processamento – Esse é o momento em que o registro de dados é processado pelo aplicativo de processamento de fluxo (ou quando é consumido).
  • Tempo de acréscimo (também conhecido como “Tempo de criação”) – Esse é o momento em que os dados são armazenados e confirmados no armazenamento do agente Kafka. Isso difere do tempo de criação devido à diferença de tempo entre a criação do evento e a ingestão real pelo agente.

Operações com estado

O gerenciamento de estado permite aplicativos de processamento de fluxo sofisticados, como unir e agregar dados de fluxos diferentes. Isso é feito com repositórios de estado fornecidos pelo Kafka Streams e acessados usando operadores com estado no DSL dos Fluxos de Kafka.

As transformações com estado na DSL incluem:

Janela e carência

As operações de janela no DSL dos Fluxos de Kafka permitem que os desenvolvedores controlem como os registros são agrupados para uma determinada chave para operações com estado, como agregações e uniões.

As operações de janela também permitem a especificação de um período de carência para fornecer alguma flexibilidade para registros fora de ordem para uma determinada janela. Um registro destinado a uma determinada janela e que chega após a janela determinada, mas dentro do período de carência é aceito. Os registros que chegam após o término do período de carência são descartados.

Os aplicativos devem utilizar os controles de período de janela e carência para melhorar a tolerância a falhas para registros fora de ordem. Os valores apropriados variam de acordo com a carga de trabalho e devem ser identificados empiricamente.

Garantias de processamento

Os usuários corporativos e técnicos buscam extrair os principais insights de negócios da saída de cargas de trabalho de processamento de fluxo, que se traduzem em altos requisitos de garantia transacional. Os fluxos de Kafka funcionam com transações Kafka para garantir garantias de processamento transacional integrando-se com o sistema de armazenamento subjacente dos agentes compatíveis com Kafka (como os Hubs de Eventos do Azure) para garantir que as confirmações de deslocamento e as atualizações do repositório de estado sejam gravadas atomicamente.

Para garantir garantias de processamento transacional, a configuração processing.guarantee nas configurações dos Fluxos de Kafka deve ser atualizada do valor padrão de at_least_once para exactly_once_v2 (para versões do cliente no Apache Kafka 2.5 ou posteriores) ou exactly_once (para versões do cliente antes do Apache Kafka 2.5.x).

Próximas etapas

Este artigo forneceu uma introdução aos Hubs de Eventos para Kafka. Para saber mais, confira Guia do desenvolvedor do Apache Kafka para Hubs de Eventos do Azure.

Para obter um tutorial com as instruções detalhadas para criar um hub de eventos e acessá-lo usando SAS ou OAuth, confira Início Rápido: streaming de dados com Hubs de Eventos usando o protocolo Kafka.

Além disso, confira os exemplos de OAuth no GitHub.