Como instalar o Apache Kafka no Debian 10

O Apache Kafka é um agente de mensagens distribuídas popular, desenvolvido para lidar com grandes volumes de dados em tempo real. Um cluster de Kafka é altamente escalonável e tolerante a falhas; além disso, ele tem uma taxa de transferência muito maior, comparada à de outros agentes de mensagens como o ActiveMQ ou o RabbitMQ. Embora ele seja geralmente usado como um sistema de mensagens publicar/assinar, muitas organizações também o usam para a agregação de registros porque ele oferece armazenamento persistente para mensagens publicadas.

Um sistema de mensagens publicar/assinar permite que um ou mais produtores publiquem mensagens sem considerar o número de consumidores ou como irão processar as mensagens. Clientes assinantes são notificados automaticamente sobre atualizações e a criação de novas mensagens. Este sistema é mais eficiente e escalável do que sistemas onde clientes questionam periodicamente para determinar se novas mensagens estão disponíveis.

Neste tutorial, você irá instalar e configurar o Apache Kafka 2.1.1 de maneira segura em um servidor Debian 10 e, em seguida, irá testar sua configuração produzindo e processando uma mensagem Hello World. Opcionalmente, na sequência você instalará o KafkaT para monitorar o Kafka e configurar um cluster do Kafka com vários nós.

Para acompanhar, você precisará de:

• Um servidor Debian 10 com pelo menos 4 GB de memória RAM e um usuário não raiz com privilégios sudo. Siga os passos especificados no nosso Guia inicial de configuração de servidor para o Debian 10 caso não tenha um usuário não raiz configurado.
• OpenJDK 11 instalado no seu servidor. Para instalar essa versão, siga as instruções no artigo Como instalar o Java com a Apt no Debian 10, que trata da instalação de versões específicas do OpenJDK. O Kafka é escrito em Java, de modo que ele exige um JVM.

Como o Kafka consegue lidar com os pedidos em uma rede, a prática recomendada é criar um usuário dedicado para ele. Isso minimiza os danos no seu computador com o Debian se o servidor Kafka for comprometido. Neste passo, você criará o usuário dedicado kafka.

Conectado como seu usuário não raiz - com privilégios de sudo, crie um usuário chamado kafka com o comando useradd:

sudo useradd kafka -m

O sinalizador -m garante que um diretório home será criado para o usuário. Esse diretório home, /home/kafka, funcionará como o diretório do seu espaço de trabalho para executar comandos mais tarde.

Defina a senha usando passwd:

sudo passwd kafka

Digite a senha que deseja usar para este usuário.

Em seguida, adicione o usuário kafka ao grupo sudo com o comando adduser, de modo que ele tenha os privilégios necessários para instalar as dependências do Kafka:

sudo adduser kafka sudo

Seu usuário kafka agora está pronto. Faça login nesta conta usando su:

su -l kafka

Agora que criou o usuário específico do Kafka, siga para o download e extração dos binários do Kafka.

Neste passo, você irá baixar e extrair os binários do Kafka para pastas dedicadas no diretório base do seu usuário kafka.

Para começar, crie um diretório em /home/kafka chamado Downloads para armazenar os seus downloads:

mkdir ~/Downloads

Em seguida, instale o curl usando a ferramenta apt-get para que você possa baixar arquivos remotos:

sudo apt-get update && sudo apt-get install curl

Quando solicitado, digite Y para confirmar o download do curl.

Assim que o curl estiver instalado, use-o para baixar os binários do Kafka:

curl "https://archive.apache.org/dist/kafka/2.1.1/kafka_2.11-2.1.1.tgz" -o ~/Downloads/kafka.tgz

Crie um diretório chamado kafka e mude para este diretório. Este é o diretório base da instalação do Kafka:

mkdir ~/kafka && cd ~/kafka

Extraia o arquivo que você baixou usando o comando tar:

tar -xvzf ~/Downloads/kafka.tgz --strip 1

Você especificou um sinalizador --strip 1 para garantir que o conteúdo do arquivo fosse extraído em ~/kafka/ - propriamente dito - e não em outro diretório dentro dele, como ~/kafka/kafka_2.12-2.1.1/.

Agora que baixou e extraiu os binários com sucesso, você pode passar a configurar o Kafka para permitir a exclusão de tópicos.

O comportamento padrão do Kafka não nos permitirá excluir um um tópico, a categoria, grupo ou nome do feed para os quais mensagens podem ser publicadas. Para modificar isso, você editará o arquivo de configuração.

As opções de configuração do Kafka estão especificadas em server.properties. Abra este arquivo com o nano ou seu editor favorito:

nano ~/kafka/config/server.properties

Vamos adicionar uma configuração que nos permitirá excluir tópicos do Kafka. Adicione a seguinte linha em destaque ao final do arquivo:

...
group.initial.rebalance.delay.ms

delete.topic.enable = true

Salve o arquivo e saia do nano. Agora que você configurou o Kafka, pode criar arquivos da unidade do systemd para executar e habilitar o Kafka na inicialização.

Nesta seção, você criará arquivos de unidade systemd para o serviço do Kafka. Isso irá ajudá-lo na realização de ações de serviço comuns como iniciar, parar e reiniciar o Kafka de uma maneira consistente com outros serviços do Linux.

O ZooKeeper é um serviço que o Kafka usa para gerenciar seu estado de cluster e suas configurações. Ele é normalmente usado em sistemas distribuídos como um componente integral. Neste tutorial, você usará o Zookeeper para gerenciar esses aspectos do Kafka. Caso queira saber mais sobre ele, acesse os documentos oficiais do ZooKeeper.

Primeiro, crie o arquivo de unidade para o zookeeper:

sudo nano /etc/systemd/system/zookeeper.service

Digite a seguinte definição de unidade no arquivo:

[Unit]
Requires=network.target remote-fs.target
After=network.target remote-fs.target

[Service]
Type=simple
User=kafka
ExecStart=/home/kafka/kafka/bin/zookeeper-server-start.sh /home/kafka/kafka/config/zookeeper.properties
ExecStop=/home/kafka/kafka/bin/zookeeper-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

A seção [Unit] especifica que o ZooKeeper exige conexão em rede e que o sistema de arquivos esteja pronto antes de começar.

A seção [Service] especifica que o systemd deve usar os arquivos de shell zookeeper-server-start.sh e zookeeper-server-stop.sh para iniciar e parar o serviço. Ela também especifica que o ZooKeeper deverá ser reinicializado automaticamente caso feche inexplicavelmente.

A seguir, crie o arquivo de serviço systemd para o kafka:

sudo nano /etc/systemd/system/kafka.service

Digite a seguinte definição de unidade no arquivo:

[Unit]
Requires=zookeeper.service
After=zookeeper.service

[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/server.properties > /home/kafka/kafka/kafka.log 2>&1'
ExecStop=/home/kafka/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

A seção [Unit] especifica que este arquivo de unidade depende do zookeeper.service. Isso irá garantir que o zookeeper seja iniciado automaticamente quando o serviço kafka começar.

A seção [Service] especifica que o systemd deve usar os arquivos de shell kafka-server-start.sh`` e kafka-server-stop.sh para começar e parar o serviço. Ele também especifica que o Zookeeper deve ser reiniciado automaticamente se ele fechar inexplicavelmente.

Agora que as unidades foram definidas, inicie o Kafka com o comando a seguir:

sudo systemctl start kafka

Para garantir que o servidor inicializou com sucesso, verifique os registros de diário para a unidade kafka:

sudo journalctl -u kafka

Você verá um resultado similar ao seguinte:

Output
Mar 23 13:31:48 kafka systemd[1]: Started kafka.service.

Agora, você possui um servidor Kafka que escuta na porta 9092, que é a porta padrão para o Kafka.

Você iniciou o serviço kafka, mas se tivesse que reinicializar seu servidor, ele ainda não seria inicializado automaticamente. Para ativar o kafka na inicialização do servidor, execute:

sudo systemctl enable kafka

Agora que iniciou e habilitou os serviços, é hora de verificar a instalação.

Vamos publicar e processar uma mensagem Hello World para garantir que o servidor do Kafka está se comportando corretamente. A publicação de mensagens no Kafka exige:

• Um produtor que permita a publicação de registros e dados em tópicos.
• Um consumidor que leia as mensagens e dados dos tópicos.

Primeiro, crie um tópico chamado TutorialTopic digitando:

~/kafka/bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic TutorialTopic

Você pode criar um produtor a partir da linha de comando usando o script kafka-console-producer.sh. O produtor espera receber o nome do host do servidor do Kafka, a porta e um nome de tópico como argumentos.

Publique a string Hello, World no tópico TutorialTopic, digitando:

echo "Hello, World" | ~/kafka/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic TutorialTopic > /dev/null

O sinalizador --broker-list determina a lista de agentes de mensagens para os quais serão enviadas mensagens que, neste caso, é o localhost:9092. O sinalizador --topic designa o tópico como TutorialTopic.

A seguir, você pode criar um consumidor no Kafka usando o script kafka-console-consumer.sh. Ele espera receber o nome do host e porta do servidor do ZooKeeper, além de um nome de tópico como argumentos.

O comando a seguir consome mensagens do TutorialTopic. Observe o uso do sinalizador --from-beginning, o qual permite o consumo de mensagens que foram publicadas antes da inicialização do consumidor:

~/kafka/bin/kafka-console-consumer.sh --bootstrap-server `localhost:9092` --topic TutorialTopic --from-beginning

O sinalizador --bootstrap-server fornece uma lista de entradas no cluster do Kafka. Neste caso, você está usando o localhost:9092.

Você verá Hello, World no seu terminal:

Output
Hello, World

O script continuará a executar, esperando que mais mensagens sejam publicadas no tópico. Sinta-se à vontade para abrir um novo terminal e iniciar um produtor para publicar mais algumas mensagens. Você deverá ser capaz de ver todas elas na saída do consumidor. Caso queira aprender mais sobre como usar o Kafka, consulte a documentação oficial do Kafka.

Quando você acabar os testes, pressione CTRL+C para parar o script do consumidor. Agora que testou a instalação, pode prosseguir com a instalação do KafkaT para administrar melhor seu cluster do Kafka.

O KafkaT é uma ferramenta do Airbnb que torna mais fácil para você ver detalhes sobre seu cluster do Kafka e executar certas tarefas administrativas da linha de comando. Uma vez que é uma gem do Ruby, você precisará do Ruby para usá-la. Você também precisará do pacote build-essential para poder compilar outras gems das quais ele depende. Instale-os usando a ferramenta apt:

sudo apt install ruby ruby-dev build-essential

Agora, você pode instalar o KafkaT usando o comando gem:

sudo CFLAGS=-Wno-error=format-overflow gem install kafkat

A opção CFLAGS=-Wno-error=format-overflow desabilita os avisos de excesso de formato; ela é necessária para a gem do ZooKeeper, que é uma dependência do KafkaT.

O KafkaT usa o .kafkatcfg como o arquivo de configuração para determinar a instalação e os diretórios de registros do seu servidor do Kafka. Ele também deve ter uma entrada que aponte o KafkaT para a sua instância do ZooKeeper.

Crie um arquivo novo chamado .kafkatcfg:

nano ~/.kafkatcfg

Adicione as linhas a seguir para especificar as informações necessárias sobre o seu servidor do Kafka e a instância do Zookeeper:

{
  "kafka_path": "~/kafka",
  "log_path": "/tmp/kafka-logs",
  "zk_path": "localhost:2181"
}

Agora, você está pronto para usar o KafkaT. Para começar, veja a seguir como você o utilizaria para visualizar detalhes de todas as partições do Kafka:

kafkat partitions

Você verá o seguinte resultado:

Output
Topic                 Partition   Leader      Replicas        ISRs    
TutorialTopic         0             0         [0]             [0]
__consumer_offsets	  0		        0		  [0]			  [0]
...

Esse resultado mostra o TutorialTopic, além de __consumer_offsets, um tópico interno usado pelo Kafka para armazenar informações relacionadas ao cliente. Você pode ignorar com segurança linhas começando com __consumer_offsets.

Para aprender mais sobre o KafkaT, consulte o seu repositório do GitHub.

Agora que instalou o KafkaT, opcionalmente poderá configurar o Kafka em um cluster dos servidores Debian 10 para criar um cluster com vários nós.

Caso queira criar um cluster com vários agentes, usando mais servidores Debian 10, repita o Passo 1, Passo 4 e Passo 5 em cada um dos seus novos computadores. Além disso, faça as seguintes alterações no arquivo ~/kafka/config/server.properties em relação a cada um deles:

• Altere o valor da propriedade broker.id, de modo que ela seja única ao longo do cluster. Essa propriedade identifica exclusivamente cada servidor no cluster e pode ter qualquer string como seu valor. Por exemplo, "server1", "server2" etc. seriam úteis como identificadores.

• Altere o valor da propriedade zookeeper.connect, de modo que todos os nós apontem para a mesma instância do ZooKeeper. Essa propriedade especifica o endereço da instância do ZooKeeper e segue o formato <HOSTNAME/IP_ADDRESS>:<PORT>. Para este tutorial, você usaria your_first_server_IP:2181, substituindo your_first_server_IP pelo endereço IP do servidor Debian 10 que você já configurou.

Caso queira ter várias instâncias do ZooKeeper em seu cluster, o valor da propriedade zookeeper.connect em cada nó deve ser uma string idêntica, separada por vírgulas que liste os endereços de IP e os números de porta de todas as instâncias do ZooKeeper.

Agora que todas as instalações estão prontas, você pode remover os privilégios de admin do usuário kafka. Antes de fazer isso, faça log-off e torne a fazer login como se fosse qualquer outro usuário não raiz com privilégios sudo. Se você ainda estiver executando a mesma sessão de shell com a qual você iniciou este tutorial, simplesmente digite exit.

Remova o usuário kafka do grupo sudo:

sudo deluser kafka sudo

Para melhorar ainda mais a segurança do seu servidor Kafka, bloqueie a senha do usuário kafka, usando o comando passwd. Isso assegura que ninguém poderá se conectar diretamente ao servidor usanto essa conta:

sudo passwd kafka -l

Neste ponto, somente um usuário raiz ou um usuário com privilégios sudo poderão fazer login como kafka, digitando o comando a seguir:

sudo su - kafka

No futuro, se você quer desbloqueá-lo, use o comando passwd com a opção -u:

sudo passwd kafka -u

Agora, você restringiu com sucesso os privilégios de admin do usuário kafka.

Agora, você tem o Apache Kafka executando em segurança no seu servidor Debian. Você pode usar isso nos seus projetos, criando produtores e consumidores do Kafka usando clientes do Kafka, os quais estão disponíveis para a maioria das linguagens de programação. Para saber mais sobre o Kafka, consulte também a documentação do Apache Kafka.