Table of Contents
*O autor selecionou o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.*
Introdução
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.
Pré-requisitos
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.
Nota: as instalações sem 4 GB de memória RAM podem provocar a falha do serviço Kafka, levando a Máquina Virtual Java (JVM) a gerar uma exceção de Out of Memory [Exceção de Memória] durante a inicialização.
Passo 1 — Criando um Usuário para o Kafka
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.
Passo 2 — Fazendo download e Extraindo os 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.
Passo 3 — Configurando o Servidor do Kafka
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:
[label ~/kafka/config/server.properties]
...
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.
Passo 4 — Criando Arquivos de Unidade Systemd e Iniciando o Servidor do Kafka
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:
[label /etc/systemd/system/zookeeper.service]
[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:
[label /etc/systemd/system/kafka.service]
[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:
[secondary_label 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.
Passo 5 — Testando 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:
[secondary_label 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.
Passo 6 — Instalando o KafkaT (Opcional)
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:
[label ~/.kafkatcfg]
{
"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:
[secondary_label 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.
Passo 7 — Configurando um cluster com vários nós (Opcional)
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.
Nota: caso tenha um firewall ativado no servidor Debian 10 com o Zookeeper instalado, certifique-se de abrir a porta 2181 para permitir a entrada de pedidos dos demais nós do cluster.
Passo 8 — Restringindo o usuário do Kafka
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.
Conclusão
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.
