Apache Kafka Tutorial
Apache Kafka
Para uma definição de alto nível, vamos apresentar uma breve definição para o Apache Kafka:
Apache Kafka é um log distribuído, tolerante a falhas e com scalable horizontalmente,.
Essas eram algumas palavras de alto nível sobre Apache Kafka. Vamos entender os conceitos em detalhes aqui.
- Distribuído: Kafka divide os dados que ele contém em vários servidores e cada um desses servidores é capaz de lidar com solicitações de clientes para a parcela de dados que ele contém
- Tolerante a falhas: Kafka não tem um único ponto de falha. Em um sistema SPOF, como um banco de dados MySQL, se o servidor que hospeda o banco de dados diminuir, o aplicativo será parafusado. Em um sistema que não possui um SPOF e consiste em nós múltiplos, mesmo que a maior parte do sistema diminua, ainda é o mesmo para um usuário final.
- Scalável horizontalmente: Esse tipo de conflito refere -se a adicionar mais máquinas ao cluster existente. Isso significa que o Apache Kafka é capaz de aceitar mais nós em seu cluster e não fornecer tempo de inatividade para as atualizações necessárias para o sistema. Veja a imagem abaixo para entender o tipo de conceitos de partida:
- Cometer log: Um log de commit é uma estrutura de dados como uma lista vinculada. Ele anexa qualquer mensagem que chegue a ele e sempre mantém seu pedido. Os dados não podem ser excluídos deste log até que um tempo especificado seja alcançado para esses dados.
Esparaduras verticais e horizontais
Um tópico em Apache Kafka é como uma fila onde as mensagens são armazenadas. Essas mensagens são armazenadas por uma quantidade configurável de tempo e a mensagem não é excluída até que esse tempo seja alcançado, mesmo que tenha sido consumido por todos os consumidores conhecidos.
Kafka é escalável, pois são os consumidores que realmente armazenam que a mensagem foi buscada por eles durarem como um valor de 'deslocamento'. Vejamos uma figura para entender melhor isso:
Partion e compensação de tópicos em Apache Kafka
Introdução com Apache Kafka
Para começar a usar o Apache Kafka, ele deve ser instalado na máquina. Para fazer isso, leia Instale o Apache Kafka no Ubuntu.
Certifique -se de ter uma instalação de Kafka ativa se quiser experimentar exemplos que apresentamos mais adiante na lição.
Como funciona?
Com Kafka, o Produtor APLICAÇÕES PUBLICA mensagens que chega a um kafka Nó e não diretamente para um consumidor. A partir deste nó kafka, as mensagens são consumidas pelo Consumidor formulários.
Produtor e consumidor Kafka
Como um único tópico pode obter muitos dados de uma só vez, para manter a Kafka Horizontalmente escalável, cada tópico é dividido em partições e cada partição pode viver em qualquer máquina de nós de um cluster. Vamos tentar apresentá -lo:
Partições de tópicos
Novamente, o Kafka Broker não mantém registro de qual consumidor consumiu quantos pacotes de dados. É o responsabilidade dos consumidores para acompanhar os dados que consumiu.
Persistência em disco
Kafka persiste os registros da mensagem que recebe dos produtores no disco e não os mantém na memória. Uma pergunta que pode surgir é como isso torna as coisas viáveis e rápidas? Havia várias razões por trás disso, o que a torna uma maneira ideal de gerenciar os registros da mensagem:
- Kafka segue um protocolo de agrupamento dos registros da mensagem. Os produtores produzem mensagens que persistem para disco em grandes pedaços e os consumidores consomem esses registros de mensagens em grandes pedaços lineares também.
- A razão pela qual o disco grava é linear é que isso torna as leituras rapidamente devido à diminuição do tempo de leitura do disco linear.
- As operações de disco linear são otimizadas por Sistemas operacionais também usando técnicas de Escreva-se e Leia adiante.
- OS moderno também usa o conceito de Pagecaching O que significa que eles armazenam alguns dados de disco na RAM gratuita disponível.
- Como Kafka persiste dados em dados padrão uniformes em todo o fluxo do produtor até o consumidor, eles usam o uso do Otimização com cópia zero processo.
Distribuição e replicação de dados
Como estudamos acima de que um tópico é dividido em partições, cada registro de mensagem é replicado em vários nós do cluster para manter a ordem e os dados de cada registro, caso um dos nó morra.
Embora uma partição seja replicada em vários nós, ainda há um líder de partição nó através do qual os aplicativos leem e escrevem dados sobre o tópico e o líder replica dados sobre outros nós, que são denominados seguidores daquela partição.
Se os dados do registro da mensagem forem altamente importantes para um aplicativo, a garantia do registro da mensagem é segura em um dos nós poderá ser aumentado aumentando o aumento do fator de replicação do cluster.
O que é Zookeeper?
Zookeeper é uma loja de valor-chave distribuída e tolerante a falhas. Apache Kafka depende muito do Zookeeper para armazenar mecânicos de cluster, como os batimentos cardíacos, distribuindo atualizações/configurações, etc.
Ele permite que os corretores Kafka se inscrevam e saibam sempre que qualquer alteração em relação a um líder de partição e distribuição de nós acontece.
Aplicativos de produtores e consumidores se comunicam diretamente com o Zookeeper Aplicação para saber qual nó é o líder da partição para um tópico para que eles possam realizar leituras e gravações do líder da partição.
Transmissão
Um processador de fluxo é um componente principal em um cluster Kafka que leva um fluxo contínuo de dados de registro de mensagens dos tópicos de entrada, processa esses dados e cria um fluxo de dados para produzir tópicos que podem ser qualquer coisa, de lixo a um banco de dados.
É completamente possível realizar processamento simples diretamente usando as APIs do produtor/consumidor, embora, para processamento complexo, como combinar fluxos, a Kafka fornece uma biblioteca de API de fluxos integrados, mas observe que esta API deve ser usada em nossa própria base de código e não T execute em um corretor. Funciona semelhante à API do consumidor e nos ajuda.
Quando usar o apache kafka?
Enquanto estudamos nas seções acima, o Apache Kafka pode ser usado para lidar com um grande número de registros de mensagens que podem pertencer a um número praticamente infinito de tópicos em nossos sistemas.
Apache Kafka é um candidato ideal quando se trata de usar um serviço que pode nos permitir seguir a arquitetura orientada por eventos em nossos aplicativos. Isso se deve às suas capacidades de persistência de dados, arquitetura tolerante a falhas e altamente distribuída, onde aplicativos críticos podem contar com seu desempenho.
A arquitetura escalável e distribuída de Kafka facilita muito a integração com os microsserviços e permite que um aplicativo se dissocie com muita lógica de negócios.
Criando um novo tópico
Podemos criar um tópico de teste teste No servidor Apache Kafka com o seguinte comando:
Creatinig um tópico
sudo kafka-topics.Sh-Create-Zoookeeper localhost: 2181-Replicação-fator 1
--Partições 1 -Teste -tópico
Aqui está o que recebemos com este comando:
Crie novo tópico Kafka
Um tópico de teste será criado que podemos confirmar com o comando mencionado:
Confirmação de criação de tópicos Kafka
Escrevendo mensagens em um tópico
Como estudamos anteriormente, uma das APIs presentes em Apache Kafka é o API do produtor. Usaremos esta API para criar uma nova mensagem e publicar no tópico que acabamos de criar:
Escrevendo mensagem para o tópico
Sudo kafka-console-produtor.SH-Localhost de Lista de Boscadores: 9092-Testes Tópicos
Vamos ver a saída para este comando:
Publique mensagem para o tópico Kafka
Depois de pressionarmos a tecla, veremos um novo sinal de seta (>), o que significa que podemos inserir dados agora:
Digitando uma mensagem
Basta digitar algo e pressionar para iniciar uma nova linha. Eu digitei em 3 linhas de textos:
Lendo mensagens do tópico
Agora que publicamos uma mensagem sobre o tópico Kafka que criamos, esta mensagem estará lá para algum momento configurável. Podemos lê -lo agora usando o API do consumidor:
Lendo mensagens do tópico
SUDO KAFKA-CONSOLE-SUMER.sh -zookeeper localhost: 2181 --
Teste de tópicos-de adiamento
Aqui está o que recebemos com este comando:
Comando para ler mensagem do tópico Kafka
Poderemos ver as mensagens ou linhas que escrevemos usando a API do produtor, como mostrado abaixo:
Se escrevermos outra nova mensagem usando a API do produtor, ela também será exibida instantaneamente no lado do consumidor:
Publicar e consumo ao mesmo tempo
Conclusão
Nesta lição, analisamos como começamos a usar o Apache Kafka, que é um excelente corretor de mensagens e pode atuar como uma unidade especial de persistência de dados também.