Apache Kafka - Apache Kafka
 | |
| Autor (es) original (is) | |
|---|---|
| Desenvolvedor (s) | Apache Software Foundation |
| lançamento inicial | Janeiro de 2011 |
| Versão estável | 3.0.0 / 21 de setembro de 2021
|
| Repositório | |
| Escrito em | Scala , Java |
| Sistema operacional | Plataforma cruzada |
| Modelo | Processamento de fluxo , corretor de mensagens |
| Licença | Licença Apache 2.0 |
| Local na rede Internet |
kafka 
|
Apache Kafka é uma implementação de estrutura de um barramento de software usando processamento de fluxo . É uma plataforma de software de código aberto desenvolvida pela Apache Software Foundation escrita em Scala e Java . O projeto visa fornecer uma plataforma unificada, de alto rendimento e baixa latência para lidar com feeds de dados em tempo real. O Kafka pode se conectar a sistemas externos (para importação / exportação de dados) via Kafka Connect e fornece Kafka Streams, uma biblioteca de processamento de fluxo Java . O Kafka usa um protocolo binário baseado em TCP que é otimizado para eficiência e depende de uma abstração de "conjunto de mensagens" que agrupa naturalmente as mensagens para reduzir a sobrecarga da viagem de ida e volta da rede. Isso "leva a pacotes de rede maiores, operações de disco sequenciais maiores, blocos de memória contíguos [...] que permitem ao Kafka transformar um fluxo intermitente de gravações de mensagens aleatórias em gravações lineares."
História
O Kafka foi originalmente desenvolvido no LinkedIn e posteriormente abriu o código no início de 2011. Jay Kreps, Neha Narkhede e Jun Rao ajudaram a criar Kafka, que então deixou o LinkedIn para construir o Confluent. A graduação na Incubadora Apache ocorreu em 23 de outubro de 2012. Jay Kreps escolheu o nome do autor Franz Kafka para o software porque é "um sistema otimizado para escrita", e ele gostou do trabalho de Kafka.
Formulários
O Apache Kafka é baseado no log de confirmação e permite que os usuários se inscrevam nele e publiquem dados em qualquer número de sistemas ou aplicativos em tempo real. Os aplicativos de exemplo incluem o gerenciamento de correspondência de passageiros e motoristas no Uber , fornecendo análises em tempo real e manutenção preditiva para a casa inteligente British Gas e executando vários serviços em tempo real em todo o LinkedIn.
Arquitetura
O Kafka armazena mensagens de valor-chave que vêm de muitos processos arbitrários chamados produtores . Os dados podem ser particionados em diferentes "partições" dentro de diferentes "tópicos". Em uma partição, as mensagens são ordenadas estritamente por seus deslocamentos (a posição de uma mensagem em uma partição) e indexadas e armazenadas junto com um carimbo de data / hora. Outros processos chamados "consumidores" podem ler mensagens de partições. Para processamento de fluxo, o Kafka oferece a API Streams que permite gravar aplicativos Java que consomem dados do Kafka e gravar os resultados de volta no Kafka. O Apache Kafka também funciona com sistemas de processamento de fluxo externo, como Apache Apex , Apache Flink , Apache Spark , Apache Storm e Apache NiFi .
O Kafka é executado em um cluster de um ou mais servidores (chamados de brokers) e as partições de todos os tópicos são distribuídas entre os nós do cluster. Além disso, as partições são replicadas para vários brokers. Esta arquitetura permite que o Kafka entregue fluxos massivos de mensagens de uma forma tolerante a falhas e tem permitido substituir alguns dos sistemas de mensagens convencionais como Java Message Service (JMS), Advanced Message Queuing Protocol (AMQP), etc. Desde o 0.11. Versão 0.0, o Kafka oferece gravações transacionais , que fornecem processamento de fluxo exatamente uma vez usando a API Streams.
O Kafka oferece suporte a dois tipos de tópicos: regulares e compactados. Os tópicos regulares podem ser configurados com um tempo de retenção ou um limite de espaço. Se houver registros mais antigos que o tempo de retenção especificado ou se o limite de espaço for excedido para uma partição, Kafka terá permissão para excluir dados antigos para liberar espaço de armazenamento. Por padrão, os tópicos são configurados com um tempo de retenção de 7 dias, mas também é possível armazenar dados indefinidamente. Para tópicos compactados, os registros não expiram com base em limites de tempo ou espaço. Em vez disso, o Kafka trata as mensagens posteriores como atualizações de mensagens mais antigas com a mesma chave e garante nunca excluir a mensagem mais recente por chave. Os usuários podem excluir mensagens inteiramente escrevendo uma mensagem chamada de marca para exclusão com valor nulo para uma chave específica.
Existem cinco APIs principais no Kafka:
- API do produtor - permite que um aplicativo publique fluxos de registros.
- API do consumidor - permite que um aplicativo se inscreva em tópicos e fluxos de registros de processos.
- API do conector - executa as APIs de produtor e consumidor reutilizáveis que podem vincular os tópicos aos aplicativos existentes.
- API Streams - Esta API converte os streams de entrada em saída e produz o resultado.
- API Admin - usada para gerenciar tópicos Kafka, corretores e outros objetos Kafka.
As APIs de consumidor e produtor são baseadas no protocolo de mensagens Kafka e oferecem uma implementação de referência para clientes consumidores e produtores Kafka em Java. O protocolo de mensagens subjacente é um protocolo binário que os desenvolvedores podem usar para escrever seus próprios clientes consumidores ou produtores em qualquer linguagem de programação. Isso desbloqueia o Kafka do ecossistema Java Virtual Machine (JVM). Uma lista de clientes não Java disponíveis é mantida no wiki do Apache Kafka.
APIs Kafka
API Connect
Kafka Connect (ou Connect API) é uma estrutura para importar / exportar dados de / para outros sistemas. Ele foi adicionado na versão Kafka 0.9.0.0 e usa a API do Produtor e do Consumidor internamente. A própria estrutura do Connect executa os chamados "conectores" que implementam a lógica real para ler / gravar dados de outros sistemas. A API Connect define a interface de programação que deve ser implementada para construir um conector customizado. Muitos conectores de código aberto e comerciais para sistemas de dados populares já estão disponíveis. No entanto, o próprio Apache Kafka não inclui conectores prontos para produção.
API Streams
Kafka Streams (ou Streams API) é uma biblioteca de processamento de fluxo escrita em Java. Ele foi adicionado na versão Kafka 0.10.0.0. A biblioteca permite o desenvolvimento de aplicativos de processamento de fluxo com estado que são escalonáveis, elásticos e totalmente tolerantes a falhas. A API principal é uma linguagem específica de domínio de processamento de fluxo (DSL) que oferece operadores de alto nível como filtro, mapa , agrupamento, janelamento, agregação, junções e a noção de tabelas. Além disso, a API do processador pode ser usada para implementar operadores personalizados para uma abordagem de desenvolvimento de nível mais baixo. A DSL e a API do processador também podem ser combinadas. Para processamento de fluxo com estado, o Kafka Streams usa RocksDB para manter o estado do operador local. Como o RocksDB pode gravar no disco, o estado mantido pode ser maior do que a memória principal disponível. Para tolerância a falhas, todas as atualizações para os armazenamentos estaduais locais também são gravadas em um tópico no cluster Kafka. Isso permite recriar o estado lendo esses tópicos e alimentar todos os dados no RocksDB. A versão mais recente do Streams API é 2.8.0. O link também contém informações sobre como atualizar para a versão mais recente.
Compatibilidade de versão
Até a versão 0.9.x, os brokers Kafka são compatíveis com versões anteriores apenas com clientes mais antigos. Desde o Kafka 0.10.0.0, os corretores também são compatíveis com os clientes mais novos. Se um cliente mais novo se conectar a um corretor mais antigo, ele só poderá usar os recursos suportados pelo corretor. Para a API Streams, a compatibilidade total começa com a versão 0.10.1.0: um aplicativo 0.10.1.0 Kafka Streams não é compatível com 0.10.0 ou brokers mais antigos.
atuação
Monitorar o desempenho de ponta a ponta requer o rastreamento de métricas de corretores, consumidores e produtores, além de monitorar o ZooKeeper , que Kafka usa para coordenação entre os consumidores. Atualmente, existem várias plataformas de monitoramento para rastrear o desempenho do Kafka. Além dessas plataformas, a coleta de dados Kafka também pode ser realizada usando ferramentas comumente agrupadas com Java, incluindo JConsole .