Introdução ao Apache Kafka

Prévia do material em texto

O que é o Apache Kafka ? 
 
Apache kafka é uma plataforma de streaming distribuída. 
 
Apache Kafka, como funciona ? 
 
Descrevendo de forma bem sucinta, você produz uma mensagem, essa mensagem 
é anexada a um tópico e você então consome essa mensagem. 
 
Em quais situações utilizar o Apache Kafka ? 
 
Construindo pipelines de fluxo de dados em tempo real que confiantemente obtêm 
dados entre sistemas ou aplicativos. 
Construindo aplicativos de streaming em tempo real que transformam ou reagem 
aos fluxos de dados. 
 
Mensagens 
 
Mensagem é dita com principal recurso do Kafka, podendo ser um simples “hello 
world” até mesmo um json do domínio do seu negócio. 
 
O que são tópicos ? 
 
Nada mais é do que um agrupamento de mensagens, onde no momento da criação, 
devemos decidir seu nome, número de partições e fator de replicação. Quando produzimos 
uma mensagem, ela deve ser publicada em um tópico é repartição. Tópicos são 
responsáveis por realizar a interação entre produtores e consumidores. 
 
 
 
 
 Partições 
 
Não existe limite de partições a serem criadas em um tópico isso facilita a 
disponibilidade. As partições são distribuídas ao broker do cluster. 
 
OBSERVAÇÕES IMPORTANTES 
1. Mensagens nas partições são imutáveis. 
2. Mensagens nas partições são ordenadas. 
3. Mensagens nas partições recebem um identificador metadado conhecido como 
offset. 
 
Fator de replicação 
 
Configurado também no momento da criação do tópico, deve ficar ali entre 1 é o 
número de brokers do cluster, é utilizado para caso algum broker fique indisponível, então 
não venha atrapalhar a disponibilidade para consumo das mensagens. Gera cópias das 
partições em outros brokers. 
 
 
 
 
Produtores 
 
O conceito de produtor no Kafka é bastante simples, Suponhamos que temos dados 
que gostaríamos de persistir no cluster kafka, então o que o produtor faz é simplesmente 
pegar esses dados é publicar em qualquer partição dentro de um tópico Kafka. No momento 
da produção uma mensagem deve conter uma chave e um payload, a partir da chave ele 
decide em qual partição vai cair a mensagem, caso a chave seja sempre a mesma, sempre 
cairá na mesma partição. 
 
Consumidores 
 
Descrevendo de forma sucinta, são responsáveis por consumir mensagens de um 
determinado tópico. Quando criar um consumidor, existe a necessidade de definir um grupo 
para esse consumidor “utilizado para que não aconteça processamento duplicado para um 
mesmo grupo”, o Kafka utiliza isto para equilibrar a entrega de mensagens. Sendo assim ele 
somente irá enviar a mensagem para um assinante de cada grupo. Cada consumidor se 
assina em um partição para consumir, quando existe mais de uma partição eles fazem uma 
divisão das partições. Caso contenha mais de um consumidor para um tópico com a 
quantidade de partição superior a quantidade de consumidor, um consumidor ficará sem 
partição para consumir. 
 
 
Zookeeper 
 
Necessário para o Kafka rodar, é utilizado para sistemas distribuídos. é o Kafka é um 
sistema distribuído, sendo assim delegando bastante tarefas ao zookeeper. 
 
Pontos positivos: 
 
Escalabilidade, resiliência, tolerante a falhas. Ou seja, caso algum nó ali do cluster 
venha demonstrar alguma anormalidade, você ainda terá nós disponíveis para servir o 
consumidor. 
 
 
 
 
Apache Avro 
 
Bastante conhecido na comida big data, rapido para serialização e deserialização. 
Avro possui tipos primitivos, schemas definidos usando json, contém um esquema, 
pode fazer o schema evoluir. 
 
{"namespace": "io.confluent.examples.clients.basicavro", 
 "type": "record", 
 "name": "Payment", 
 "fields": [ 
 {"name": "id", "type": "string"}, 
 {"name": "amount", "type": "double"} 
 ] 
} 
 
 
 
 
Confluent Schema registry 
 
 
Evitar a dados no tópico sem nenhum sentido. Garantir que não quebre a aplicação. 
 
Como o kafka trabalha, ele recebe bytes e envia bytes. 
 
 
 
 
 
Porém nossos dados tem um significado além do bytes, para isso devemos utilizar 
do ​AVRO JUNTAMENTE COM SCHEMA REGISTRY. ​Então quais seriam os benefícios? 
conseguir verificar a compatibilidade na medida que os esquemas evoluem. A ideia é impor 
um contrato que o produtor vai escrever dados com um schema, sendo assim deverá 
manter este contrato verificando a compatibilidade do schema entre o produtor é o 
consumidor. 
Ao publicar um mensagem no tópico elas são serializados como avro, um esquema 
define a estrutura dos dados. 
 
Schema registry vive fora do kafka 
 
 
Produtor​: Verifica se o esquema está disponível , se não ele registrado. 
O registro de schema:​ Verificar se é o mesmo de antes, ou uma evolução válida, 
se não ele retorna uma exceção, caso válido, incluirá apenas uma referência ID DO 
SCHEMA na mensagem enviada ao kafka. 
Consumidor​: Recuperam os esquemas. 
 
Configuração​: 
 
Deve informar o serializador ou deserealizador. 
Url do Schema registry. 
Plugin do avro no build.gradle ou pom.xml; 
 
O schema registry possui endpoints REST, você pode usá-los para para visualizar assuntos 
e os esquemas associados. 
 
 
$ curl --silent -X GET http://localhost:8081/subjects/ | jq . 
[ 
 ​"transactions-value" 
] 
 
Evolução do schema e compatibilidade 
 
Os schemas evoluem e precisam ser compatíveis. 
 
 
 
Endpoints REST também para a configuração de compatibilidade do schema. 
 
$ curl -X PUT -H ​"Content-Type: application/vnd.schemaregistry.v1+json"​ ​\ 
 --data ​'{"compatibility": "BACKWARD_TRANSITIVE"}'​ ​\ 
 http://localhost:8081/config/transactions-value