Tags

, , , ,

A ideia deste Post é explicar um pouco do que é o Apache Kafka e alguns conceitos sobre ele, depois em detalhes vou mostrar como subir um Container no Docker utilizando o arquivo docker-compose.yml com todas as imagens necessárias para iniciarmos nossos estudos com o Apache Kafka.

Dividiremos em em partes essa série de posts utilizando o framework Spring Boot com Kafka. Em breve estarei disponibilizando as demais partes.

Mas o que é o Apache Kafka?

O Apache Kafka é uma plataforma de software de código fonte aberto para processamento de fluxo de mensagens escrita em Scala com Java. Entre as vantagens da plataforma podemos enfatizar sua forma de unificar os seus componentes e Plugins externos, baixa latência e alto rendimento se aproximando e muito do Feed de dados em tempo real.

Abaixo alguns conceitos que envolvem o Apache Kafka

  • Mensagens – Entenda por mensagens toda a informação que trafega sobre o Apache Kafka, seja uma frase, uma palavra, um array de bytes etc..
  • Streaming – O Streaming aplicado nesta plataforma se trata de todo fluxo de uma mensagem até a captura pelo Apache Kafka e o consumo desta mensagem.
  • Tópico – Um tópico é uma forma de rotular ou categorizar uma mensagem, imagine um armário com 10 gavetas, cada gaveta pode ser um tópico e o armário é a plataforma Apache Kafka, portanto alem de categorizar ele agrupa as mensagens, uma outra analogia melhor sobre o tópico seria tabelas em banco de dados relacionais
  • Producer – O producer ou produtor é quem se conecta a uma plataforma de mensagens e envia uma ou mais mensagens para um tópico especifico.
  • Consumer – O consumer ou consumidor é quem se conecta a uma plataforma de mensagens e consome uma ou mais mensagens de um tópico especifico.
  • Broker – O conceito de broker na plataforma do Kafka é nada mais do que praticamente o proprio Kafka, ele é quem gerencia os tópicos, define a forma de armazenamento das mensagens, logs etc.
  • Cluster – O conceito de cluster é nada mais do que um conjunto de Brokers que se comunicam entre si ou não para uma melhor escalabilidade e tolerância a falhas.
  • Log file – Cada tópico armazena seus registros em um formato de log, ou seja, de forma estrutura e sequencial, o log file portanto são os arquivos que contem a informação de um tópico.
  • Partitions – As partitions ou partições como o próprio nome disse é a camada de partição das mensagens dentro de um tópico, este particionamento garante a elasticidade, tolerância a falha e escalabilidade do Apache Kafka, portanto cada tópico pode ter varias partições em diferentes localidades
  • Replicas – As replicas são como partições das partições, elas tem o mesmo papel da partição mas como uma forma de redundância de determinada partição, portanto as partições Kafka são altamente disponíveis e replicadas, quando os dados do fluxo são persistentes no Kafka, eles ficam disponíveis mesmo que o aplicativo falhe.
  • Segmentos – Os segmentos ficam dentro das partições e segmentam as informações contidas nos logs files daquela partição, todo tópico possui sua partição e sua segmentação, a segmentação serve para gerenciar a ordenação da informação do log file bem como o tempo que ela ira ficar persistida.

Agora Abaixo vou fazer uma breve explicação o que se referem as imagens que vamos adicionar ao arquivo docker-compose.yml que serão todas as imagens necessárias para completar essa nossa serie de posts.

Zookeeper – Apache Zookeeper é um serviço centralizado para manter informações de configurações e nomenclaturas entre serviços distribuídos. O Kafka utiliza o Zookeeper para sincronizar as configurações entre diferentes clusters, ele consegue monitorar quais brokers fazem parte do cluster Kafka, ele também é usado pelos brokers Kafka para determinar qual brokers é o líder de uma determinada partição e tópico e realizar eleições de líder. O Zookeeper também armazena configurações para tópicos e permissões entre outras coisas…

Broker – É um servidor na camada Kafka, que armazena fluxos de eventos de uma ou mais fontes. O Broker é o núcleo do Kafka e são responsáveis pelo armazenamento, recebimento e replicação das mensagens

Poderíamos subir o Apache Kafka apenas com essas duas imagens, Zookeeper e Broker, porem estarei iniciando mais imagens para nosso estudo poder ser ainda mais completo.

Rest-Proxy – O Proxy REST do Kafka permite interagir com o cluster Kafka por meio de uma API REST via HTTPS. Dessa maneira, os clientes do Kafka podem ficar fora da rede virtual. Os clientes podem fazer chamadas HTTPS simples e seguras para o cluster Kafka, em vez de usar as bibliotecas Kafka.

Schema-Registry – Basicamente, tanto para produtores quanto para consumidores do Kafka , o Registro de Schemas no Kafka armazena os Schemas Avro.

  • Ele oferece uma interface RESTful para gerenciar esquemas Avro.
  • Ele permite o armazenamento de um histórico de esquemas versionados.
  • Além disso, ele suporta a verificação de compatibilidade de esquema para Kafka.
  • Usando o Avro Schema, podemos configurar as configurações de compatibilidade para dar suporte à evolução dos esquemas do Kafka.

Basicamente, o projeto de serialização Kafka Avro oferece serializadores. Com a ajuda do Avro e do Kafka Schema Registry, tanto os Kafka Producers quanto os Kafka Consumers que usam a serialização Kafka Avro lidam com o gerenciamento de esquemas, bem como com a serialização de registros.

Control-Center – Control Center é uma ferramenta baseada na web para gerenciar e monitorar Apache Kafka® na plataforma Confluent. O Control Center fornece uma interface com o usuário que permite obter uma visão geral rápida do funcionamento do cluster, observar e controlar mensagens, tópicos e registro de esquema e desenvolver e executar consultas ksqlDB.

Subindo nosso Container Docker !!!

Caso ainda não tenha instalado o Docker, clique no link e faça sua instalação.

Agora de uma maneira muito simples vamos subir nosso container colocando o conteúdo do arquivo abaixo em um arquivo chamado docker-compose.yml (Fique atento a extensão YML) e salve o arquivo em um local de sua preferencia. 

services:

  zookeeper:
    image: confluentinc/cp-zookeeper:5.5.1
    hostname: zookeeper
    container_name: zookeeper
    ports:
      - "2181:2181"
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000

  broker:
    image: confluentinc/cp-kafka:5.5.1
    hostname: broker
    container_name: broker
    depends_on:
      - zookeeper
    ports:
      - "29092:29092"
      - "9092:9092"
      - "9101:9101"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://broker:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_JMX_PORT: 9101

  schema-registry:
    image: confluentinc/cp-schema-registry:5.5.1
    hostname: schema-registry
    container_name: schema-registry
    depends_on:
      - zookeeper
      - broker
    ports:
      - "8081:8081"
    environment:
      SCHEMA_REGISTRY_HOST_NAME: schema-registry
      SCHEMA_REGISTRY_KAFKASTORE_CONNECTION_URL: 'zookeeper:2181'

  rest-proxy:
    image: confluentinc/cp-kafka-rest:5.5.1
    depends_on:
      - zookeeper
      - broker
      - schema-registry
    ports:
      - 8082:8082
    hostname: rest-proxy
    container_name: rest-proxy
    environment:
      KAFKA_REST_HOST_NAME: rest-proxy
      KAFKA_REST_BOOTSTRAP_SERVERS: 'broker:29092'
      KAFKA_REST_LISTENERS: "http://0.0.0.0:8082"
      KAFKA_REST_SCHEMA_REGISTRY_URL: 'http://schema-registry:8081'

  control-center:
    image: confluentinc/cp-enterprise-control-center:5.4.0
    hostname: control-center
    container_name: control-center
    depends_on:
      - zookeeper
      - broker
      - schema-registry
    ports:
      - "9021:9021"
    environment:
      CONTROL_CENTER_BOOTSTRAP_SERVERS: 'broker:29092'
      CONTROL_CENTER_ZOOKEEPER_CONNECT: 'zookeeper:2181'
      CONTROL_CENTER_SCHEMA_REGISTRY_URL: http://schema-registry:8081
      CONTROL_CENTER_REPLICATION_FACTOR: 1
      CONTROL_CENTER_INTERNAL_TOPICS_PARTITIONS: 1
      CONTROL_CENTER_MONITORING_INTERCEPTOR_TOPIC_PARTITIONS: 1
      CONFLUENT_METRICS_TOPIC_REPLICATION: 1
      PORT: 9021

No meu caso salvei em C:\Docker\kafka e no CMD execute o comando abaixo para subir o container:

docker compose up

Pode ser que apareça algumas mensagens de Warning mas pode ignorar.

O Docker irá realizar o download das imagens na primeira vez que você executar e logo após irá inicia-las. Sugiro ficar atento a tela e se ver ela parando (que infelizmente pode acontecer) aperte a tecla ENTER para continuar

Após alguns minutos, talvez 5 ou mais dependendo da configuração da sua maquina abra do Docker desktop e veja por exemplo a tela abaixo, onde uma das imagens possa ser que não tenha subido.

Fique tranquilo, basta selecionar a imagem em questão e ao lado direito no canto superior clique em play(Botão azul) conforme abaixo e aguarde ficar em Running.

Após alguns minutos veja se esta tudo com status Running e pronto, subimos todas as imagens necessárias para iniciarmos nossos estudos do Spring Boot + Kafka.

”Por enquanto é isso pessoal e até a próxima! 

/:-D