Os padrões de design orientados para microsserviços tornaram nossos aplicativos mais escaláveis ​​do que nunca. Servidores de API RESTful, front-end e até os bancos de dados agora são horizontalmente escaláveis. A escala horizontal é o ato de adicionar novos nós ao seu cluster de aplicativos para oferecer suporte à carga de trabalho adicional. Por outro lado, também permite reduzir o consumo de recursos, quando a carga de trabalho diminui, a fim de economizar custos. Sistemas horizontalmente escaláveis ​​precisam ser distribuídos do sistema. Esses sistemas que podem sobreviver à falha de várias VMs, contêineres ou links de rede e ainda permanecem online e saudáveis ​​para o usuário final.

Ao falar sobre sistemas distribuídos como acima, encontramos o problema da análise e monitoramento. Cada nó está gerando muitas informações sobre sua própria saúde (uso da CPU, memória etc.) e sobre o status do aplicativo, juntamente com o que os usuários estão tentando fazer. Esses detalhes devem ser registrados em:

1. A mesma ordem em que eles são criados,
2. Separado em termos de urgência (análise em tempo real ou lotes de dados) e o mais importante,
3. O mecanismo com o qual eles são coletados deve ser um distribuído e escalável; caso contrário, ficamos com um único ponto de falha. Algo que o design do sistema distribuído deveria evitar.

Por que usar Kafka?

Apache Kafka é lançado como uma plataforma de streaming distribuída. Em Kafka Lingo, Produtores gerar continuamente dados (fluxos) e Consumidores são responsáveis ​​pelo processamento, armazenamento e análise. Kafka Corretores são responsáveis ​​por garantir que, em um cenário distribuído, os dados possam alcançar de produtores a consumidores sem nenhuma inconsistência. Um conjunto de corretores Kafka e outro software chamado funcionário do zoológico constituem uma implantação típica de Kafka.

O fluxo de dados de muitos produtores precisa ser agregado, particionado e enviado a vários consumidores, há muitos embaralhados envolvidos. Evitar a inconsistência não é uma tarefa fácil. É por isso que precisamos de kafka.

Os cenários em que Kafka pode ser usado é bastante diverso. Qualquer coisa, desde dispositivos IoT até cluster de VMs e seus próprios servidores básicos. Em qualquer lugar onde muitas 'coisas' querem simultaneamente sua atenção .. .Isso não é muito científico é? Bem, a arquitetura Kafka é um buraco de coelho próprio e merece um tratamento independente. Vamos primeiro ver uma implantação muito superficial do software.

Usando o Docker compor

De qualquer maneira imaginativa que você decida usar Kafka, uma coisa é certa - você não o usará como uma única instância. Não deve ser usado dessa maneira, e mesmo que o seu aplicativo distribuído precise de apenas uma instância (corretor) por enquanto, ele acabará crescendo e você precisa ter certeza de que Kafka pode acompanhar.

Docker-Compose é o parceiro perfeito para esse tipo de escalabilidade. Em vez disso, para executar os corretores Kafka em diferentes VMs, contêntamos e alavancamos o Docker compor para automatizar a implantação e a escala. Os contêineres do Docker são altamente escaláveis ​​nos hosts de Docker, bem como em um cluster, se usarmos Docker Swarm ou Kubernetes. Por isso, faz sentido alavancá -lo para tornar Kafka escalável.

Vamos começar com uma única instância de corretor. Crie um diretório chamado Apache-Kafka e dentro dele crie seu Docker-Compose.yml.

$ mkdir apache-kafka
$ CD Apache-kafka
$ vim Docker-Compose.yml

O conteúdo seguinte será colocado em seu docker-composição.Arquivo YML:

Versão: '3'
Serviços:
funcionário do zoológico:
Imagem: Wurstmeister/Zookeper
Kafka:
Imagem: Wurstmeister/Kafka
Portas:
- "9092: 9092"
ambiente:
Kafka_adverted_host_name: localhost
Kafka_zookeeper_connect: Zookeeper: 2181

Depois de salvar o conteúdo acima no seu arquivo de composição, na mesma execução do diretório:

$ Docker -Compõe Up -d

Ok, então o que fizemos aqui?

Compreendendo o Docker-Compose.yml

A Compose iniciará dois serviços, conforme listado no arquivo YML. Vejamos o arquivo um pouco de perto. A primeira imagem é o Zookeeper, que Kafka exige para acompanhar vários corretores, a topologia da rede e sincronizar outras informações. Como os serviços Zookeeper e Kafka farão parte da mesma rede de pontes (isso é criado quando executamos o Docker-Compose Up), não precisamos expor nenhuma porta. O corretor Kafka pode conversar com o Zookeeper e isso é tudo o que o Zookeeper de Comunicação precisa.

O segundo serviço é o próprio Kafka e estamos apenas executando uma única instância, ou seja, um corretor. Idealmente, você gostaria de usar vários corretores para alavancar a arquitetura distribuída de Kafka. O serviço ouve na porta 9092 que é mapeado para o mesmo número da porta no host do Docker e é assim que o serviço se comunica com o mundo exterior.

O segundo serviço também possui algumas variáveis ​​de ambiente. Primeiro, é kafka_adverted_host_name definido como localhost. Este é o endereço no qual Kafka está em execução e onde produtores e consumidores podem encontrá -lo. Mais uma vez, esse deve ser o conjunto para localhost, mas sim para o endereço IP ou o nome do host com isso, os servidores podem ser alcançados em sua rede. O segundo é o nome do host e o número da porta do seu serviço Zookeeper. Desde que nomeamos o serviço Zookeeper ... bem, Zookeeper é isso que o nome do host será, dentro da Docker Bridge Network que mencionamos.

Executando um fluxo de mensagem simples

Para que Kafka comece a trabalhar, precisamos criar um tópico dentro dele. Os clientes do produtor podem então publicar fluxos de dados (mensagens) para o tópico referido e os consumidores podem ler o referido Datastream, se forem inscritos nesse tópico em particular.

Para fazer isso, precisamos iniciar um terminal interativo com o contêiner kafka. Liste os contêineres para recuperar o nome do contêiner Kafka. Por exemplo, neste caso, nosso contêiner é chamado Apache-kafka_kafka_1

$ docker ps

Com o nome do contêiner Kafka, agora podemos cair dentro deste contêiner.

$ Docker Exec -it Apache -kafka_kafka_1
Bash-4.4#

Abra dois terminais tão diferentes para usar um como consumidor e outro produtor.

Lado do produtor

Em um dos prompts (aquele que você escolhe ser produtor), insira os seguintes comandos:

## para criar um novo tópico chamado teste
Bash-4.4# kafka-topics.Sh-Create-Zookeeper Zookeeper: 2181-Replicação-fator 1
--Partições 1 -teste tópico
## para iniciar um produtor que publica o datastream da entrada padrão para Kafka
Bash-4.4# kafka-console-produtor.SH-Localhost de Lista de Boscadores: 9092-Teste-tópico
>

O produtor está agora pronto para obter informações do teclado e publicá -lo.

Lado do consumidor

Mova -se para o segundo terminal conectado ao seu contêiner Kafka. O comando a seguir inicia um consumidor que se alimenta do tópico de teste:

$ kafka-consumidor-consumidor.sh-bootstrap-server localhost: 9092-teste tópico

De volta ao produtor

Agora você pode digitar mensagens no novo prompt e toda vez que você acertar, retorna, a nova linha é impressa no prompt do consumidor. Por exemplo:

> Esta é uma mensagem.

Esta mensagem é transmitida ao consumidor, através de Kafka, e você pode vê -la impressa no prompt do consumidor.

Configurações do mundo real

Agora você tem uma imagem difícil de como funciona a configuração de Kafka. Para o seu próprio caso de uso, você precisa definir um nome de host que não é localhost, você precisa de vários corretores para fazer parte do seu cluster Kafka e, finalmente, precisa configurar clientes de consumidores e produtores.

Aqui estão alguns links úteis:

1. Cliente Python do confluente
2. Documentação oficial
3. Uma lista útil de demos

Espero que você se divirta explorando Apache Kafka.