Phenquestions
Apache Kafka
Para uma definição de alto nível, vamos apresentar uma breve definição para Apache Kafka:
Apache Kafka é um log de commit distribuído, tolerante a falhas e escalonável horizontalmente.
Essas foram algumas palavras de alto nível sobre o Apache Kafka. Vamos entender os conceitos em detalhes aqui.
- Distribuído: Kafka divide os dados que contém em vários servidores e cada um desses servidores é capaz de lidar com solicitações de clientes para o compartilhamento de dados que 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 cair, o aplicativo é danificado. Em um sistema que não possui um SPoF e consiste em vários nós, mesmo que a maior parte do sistema caia, ainda é o mesmo para um usuário final.
- Escalonável horizontalmente: Este tipo de ataque refere-se à adição de 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 atualizações necessárias para o sistema. Olhe para a imagem abaixo para entender o tipo de conceito de scailing:
- Commit Log: Um log de confirmação é uma estrutura de dados como uma lista vinculada. Ele anexa todas as mensagens que chegam e sempre mantém sua ordem. Os dados não podem ser excluídos deste registro até que uma hora especificada seja atingida para esses dados.
Raspagem vertical e horizontal
Um tópico no Apache Kafka é como uma fila onde as mensagens são armazenadas. Essas mensagens são armazenadas por um período de tempo configurável e a mensagem não é excluída até que esse tempo seja atingido, mesmo que tenha sido consumida por todos os consumidores conhecidos.
O Kafka é escalonável, pois são os consumidores que realmente armazenam a mensagem que foi buscada por eles por último como um valor de 'deslocamento'. Vejamos uma figura para entender isso melhor:
Divisão de tópico e compensação do consumidor no Apache Kafka
Introdução ao Apache Kafka
Para começar a usar o Apache Kafka, ele deve estar instalado na máquina. Para fazer isso, leia Instalar Apache Kafka no Ubuntu.
Certifique-se de ter uma instalação Kafka ativa se quiser tentar os exemplos que apresentamos mais tarde na lição.
Como funciona?
Com Kafka, o Produtor aplicativos publicam 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 o Kafka horizontalmente escalonável, cada tópico é dividido em partições e cada partição pode residir em qualquer máquina de nó de um cluster. Vamos tentar apresentá-lo:
Partições de tópico
Novamente, o Kafka Broker não mantém registro de qual consumidor consumiu quantos pacotes de dados. É o responsabilidade dos consumidores de manter o controle dos dados consumidos.
Persistência para o disco
Kafka mantém os registros de mensagens que obtém dos produtores no disco e não os mantém na memória. Uma questão que pode surgir é como isso torna as coisas viáveis e rápidas? Existem vários motivos por trás disso, o que o torna uma maneira ideal de gerenciar os registros de mensagens:
- Kafka segue um protocolo de agrupamento dos registros de mensagens. Os produtores produzem mensagens que são persistidas no disco em grandes blocos e os consumidores também consomem esses registros de mensagens em grandes blocos lineares.
- A razão pela qual as gravações do disco são lineares é que isso torna as leituras mais rápidas devido ao tempo de leitura linear do disco altamente reduzido.
- As operações de disco linear são otimizadas por Sistemas operacionais bem como usando técnicas de escrever para trás e Leia adiante.
- OS modernos também usam o conceito de Pagecaching o que significa que eles armazenam em cache alguns dados do disco na RAM disponível gratuitamente.
- Como o Kafka persiste os dados em um padrão uniforme de dados em todo o fluxo do produtor ao consumidor, ele faz uso do otimização de cópia zero processar.
Distribuição e replicação de dados
Como estudamos acima, 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 no caso de um dos nós morrer.
Mesmo que 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 gravam dados no tópico e o líder replica os dados em outros nós, que são denominados como seguidores daquela partição.
Se os dados do registro da mensagem são altamente importantes para um aplicativo, a garantia do registro da mensagem para ser seguro em um dos nós pode ser aumentada aumentando o fator de replicação do Cluster.
O que é Zookeeper?
Zookeeper é um armazenamento de chave-valor distribuído altamente tolerante a falhas. O Apache Kafka depende fortemente do Zookeeper para armazenar a mecânica do cluster como a pulsação, distribuindo atualizações / configurações, etc).
Ele permite que os corretores Kafka se inscrevam e saibam sempre que ocorrer qualquer alteração em relação a um líder de partição e distribuição de nó.
Os aplicativos de produtor e consumidor se comunicam diretamente com o Zookeeper aplicativo para saber qual nó é o líder da partição para um tópico para que 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 pega um fluxo contínuo de dados de registro de mensagem de tópicos de entrada, processa esses dados e cria um fluxo de dados para tópicos de saída que podem ser qualquer coisa, de lixo a um Banco de Dados.
É completamente possível realizar um processamento simples diretamente usando as APIs produtor / consumidor, embora para processamento complexo, como combinação de streams, o Kafka forneça uma biblioteca de APIs Streams integrada, mas observe que essa API deve ser usada dentro de nossa própria base de código e não para correr em um corretor. Funciona de forma semelhante à API do consumidor e nos ajuda a dimensionar o trabalho de processamento de fluxo em vários aplicativos.
Quando usar o Apache Kafka?
Conforme 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 virtualmente 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 a 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 confiar em seu desempenho.
A arquitetura escalável e distribuída do Kafka torna a integração com microsserviços muito fácil e permite que um aplicativo se desvincule de muitas lógicas de negócios.
Criando um novo tópico
Podemos criar um tópico de teste testando no servidor Apache Kafka com o seguinte comando:
Criação de um tópico
tópicos de sudo kafka.sh --create --zookeeper localhost: 2181 --fator de replicação 1--partições 1 - teste de tópico
Aqui está o que recebemos de volta com este comando:
Criar Novo Tópico Kafka
Será criado um tópico de teste que podemos confirmar com o comando mencionado:
Confirmação da criação do tópico Kafka
Escrever mensagens sobre um tópico
Como estudamos anteriormente, uma das APIs presentes no Apache Kafka é a API do produtor. Usaremos essa 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 --broker-list localhost: 9092 --topic testingVamos ver a saída deste comando:
Publicar mensagem no tópico Kafka
Assim que pressionarmos a tecla, veremos um novo sinal de seta (>) que significa que podemos inserir dados agora:
Digitando uma mensagem
Basta digitar algo e pressionar para iniciar uma nova linha. Digitei 3 linhas de texto:
Lendo mensagens do tópico
Agora que publicamos uma mensagem no Tópico Kafka que criamos, essa mensagem estará lá por algum tempo configurável. Podemos ler agora usando o API do consumidor:
Lendo mensagens do tópico
sudo kafka-console-consumidor.sh --zookeeper localhost: 2181 --teste de tópico - desde o início
Aqui está o que recebemos de volta com este comando:
Comando para ler a mensagem do tópico Kafka
Poderemos ver as mensagens ou linhas que escrevemos usando a API do Produtor, conforme mostrado abaixo:
Se escrevermos outra nova mensagem usando a API do Produtor, ela também será exibida instantaneamente no lado do Consumidor:
Publicar e consumir ao mesmo tempo
Conclusão
Nesta lição, vimos como começamos a usar o Apache Kafka, que é um excelente Message Broker e também pode atuar como uma unidade especial de persistência de dados.
