Como Segurar e Monitorar o Kafka

Introdução

Apache Kafka suporta vários protocolos de segurança e fluxos de autenticação para garantir que apenas pessoal e aplicações autorizados possam se conectar ao cluster. Na sua configuração padrão, Kafka permite o acesso de todos, mas não tem verificações de segurança habilitadas. Embora isso seja útil para exploração e desenvolvimento, as implantações de produção devem ser adequadamente seguras antes de serem expostas ao mundo exterior. Além disso, esses ambientes devem ser monitorados para garantir a operação suave e prevenir possíveis falhas.

Neste tutorial, você fortalecerá sua instalação do Kafka, configurando criptografia de tráfego TLS e autenticação SASL para fornecer um fluxo de login padrão com nome de usuário e senha. Você verá como configurar os scripts de produtor e consumidor fornecidos para se conectar a um cluster seguro. Em seguida, você aprenderá como exportar métricas do Kafka e visualizá-las no Grafana. Você também aprenderá como acessar os nós e tópicos do seu cluster através de uma interface web fácil de usar, fornecida pelo AKHQ.

Pré-requisitos

Para completar este tutorial, você precisará:

• Uma Droplet com pelo menos 4GB de RAM e 2 CPUs. No caso de um servidor Ubuntu, siga as instruções de Configuração Inicial do Servidor.
• O Apache Kafka está instalado e configurado na sua droplet. Para instruções de configuração, siga o tutorial Introdução ao Kafka. Você deve concluir apenas Passo 1 e Passo 2.
• Um entendimento de como o Java gerencia chaves e certificados. Para obter informações adicionais, acesse o tutorial Java Keytool Essentials: Working with Java Keystores.
• O Grafana instalado no seu servidor ou computador local. Por favor, visite o tutorial Como Instalar e Segurar o Grafana no Ubuntu para as instruções. Você precisa concluir apenas os primeiros quatro passos.
• Um nome de domínio totalmente registrado que está apontado para sua droplet. Este tutorial usará your_domain ao longo e referir-se-á ao mesmo nome de domínio que o pré-requisito do Grafana. Você pode comprar um nome de domínio em Namecheap, obter um grátis em Freenom ou usar o registrador de domínios de sua escolha.

Passo 1 – Configurando Protocolos de Segurança do Kafka

Na configuração padrão do Kafka, é permitido que qualquer pessoa se conecte a ele sem verificar a origem da solicitação. Isso significa que seu cluster está acessível a todos por padrão. Apesar de bom para testes, pois reduz a sobrecarga de manutenção em máquinas locais e instalações privadas, instalações de produção e de acesso público do Kafka devem ter funcionalidades de segurança habilitadas para evitar acesso não autorizado.

Neste passo, você configurará o broker do Kafka para usar criptografia TLS para o tráfego entre o broker e os consumidores. Você também configurará o SASL como o framework de autenticação para verificar as credenciais quando se conecta ao cluster.

Gerando Certificado TLS e Armazenamentos

Para gerar os certificados e chaves necessários para configurar o TLS, você usará o script do repositório Ferramentas de Segurança do Confluent Platform. Primeiro, clonar para o diretório pessoal executando o seguinte comando:

git clone https://github.com/confluentinc/confluent-platform-security-tools.git ~/kafka-ssl

Navegue até ele:

cd ~/kafka-ssl

O script que você usará é chamado kafka-generate-ssl-automatic.sh, e ele requer que você forneça seu país, estado, organização e cidade como variáveis de ambiente. Esses parâmetros são usados para criar os certificados, mas o conteúdo deles não é importante. Você também precisará fornecer uma senha, que será usada para proteger a loja de chaves e confiança Java que será gerada.

Execute os seguintes comandos para configurar as variáveis de ambiente necessárias, substituindo your_tls_password pelo valor desejado:

export COUNTRY=US
export STATE=NY
export ORGANIZATION_UNIT=SE
export CITY=New York
export PASSWORD=your_tls_password

Observe que a PASSWORD deve ter pelo menos seis caracteres.

Dê permissões executáveis ao script executando:

chmod +x kafka-generate-ssl-automatic.sh

Então, execute-o para gerar os arquivos necessários:

./kafka-generate-ssl-automatic.sh

Haverá muita saída. Quando estiver completo, liste os arquivos no diretório:

ls -l

A saída deve ser semelhante a esta:

Output
rw-rw-r-- 1 kafka kafka    964 May 13 09:33 README.md
-rw-rw-r-- 1 kafka kafka   1063 May 13 09:34 cert-file
-rw-rw-r-- 1 kafka kafka   1159 May 13 09:34 cert-signed
-rwxrw-r-- 1 kafka kafka   6016 May 13 09:33 kafka-generate-ssl-automatic.sh
-rwxrwxr-x 1 kafka kafka   7382 May 13 09:33 kafka-generate-ssl.sh
drwxrwxr-x 2 kafka kafka   4096 May 13 09:34 keystore
-rw-rw-r-- 1 kafka kafka 184929 May 13 09:33 single-trust-store-diagram.pages
-rw-rw-r-- 1 kafka kafka  36980 May 13 09:33 single-trust-store-diagram.pdf
drwxrwxr-x 2 kafka kafka   4096 May 13 09:34 truststore

Você verá que o certificado, confiança e loja de chaves foram criados com sucesso.

Configurando Kafka para TLS e SASL

Agora que você tem os arquivos necessários para habilitar a criptografia TLS, você configurará o Kafka para usá-los e autenticará os usuários usando SASL.

Você modificará o arquivo server.properties localizado na pasta config/kraft no diretório de instalação. Você instalou isso na pasta kafka no diretório de usuário principal como parte dos pré-requisitos. Use o comando abaixo para navegar até ele:

cd ~/kafka

Abra o arquivo de configuração principal para edição:

nano config/kraft/server.properties

Procure as seguintes linhas:

...
listeners=PLAINTEXT://:9092,CONTROLLER://:9093

# Nome do ouvinte usado para comunicação entre os brokers.
inter.broker.listener.name=PLAINTEXT

# Nome do ouvinte, nome do host e porta que o broker anunciará aos clientes.
# Se não definido, usa o valor para "ouvinte".
advertised.listeners=PLAINTEXT://localhost:9092

Altere-os para parecerem com este exemplo, substituindo PLAINTEXT por BROKER:

...
listeners=BROKER://:9092,CONTROLLER://:9093

# Nome do ouvinte usado para comunicação entre os brokers.
inter.broker.listener.name=BROKER

# Nome do ouvinte, nome do host e porta que o broker anunciará aos clientes.
# Se não definido, usa o valor para "ouvinte".
advertised.listeners=BROKER://localhost:9092

Em seguida, procure a linha listener.security.protocol.map:

# Mapeia nomes de ouvinte para protocolos de segurança, o padrão é que sejam os mesmos. Veja a documentação de configuração para mais detalhes
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Mapeie BROKER para SASL_SSL adicionando a definição no início do valor:

# Mapeia nomes de ouvinte para protocolos de segurança, o padrão é que sejam os mesmos. Veja a documentação de configuração para mais detalhes
listener.security.protocol.map=BROKER:SASL_SSL,CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Aqui, você adicionou a definição do alias BROKER que você usou nos listeners e mapeado para SASL_SSL, o que significa que tanto o SSL (um nome anterior para TLS) quanto o SASL serão usados.

A seguir, navegue até o final do arquivo e adicione as seguintes linhas:

ssl.truststore.location=/home/kafka/kafka-ssl/truststore/kafka.truststore.jks
ssl.truststore.password=your_tls_password
ssl.keystore.location=/home/kafka/kafka-ssl/keystore/kafka.keystore.jks
ssl.keystore.password=your_tls_password
ssl.key.password=your_tls_password
ssl.client.auth=required

sasl.enabled.mechanisms=PLAIN
sasl.mechanism.controller.protocol=PLAIN
sasl.mechanism.inter.broker.protocol=PLAIN

authorizer.class.name=org.apache.kafka.metadata.authorizer.StandardAuthorizer
allow.everyone.if.no.acl.found=false
super.users=User:admin

Você define primeiro as localizações e as senhas para os trust e key stores gerados. Você define o parâmetro ssl.client.auth para required, instruindo o Kafka a negar quaisquer conexões que não apresentem um certificado TLS válido. Em seguida, você define o mecanismo SASL para PLAIN, o que o habilita. PLAIN é diferente de PLAINTEXT em que exige o uso de uma conexão encriptada, e ambos dependem de uma combinação de credenciais de nome de usuário e senha.

Finalmente, você define a classe StandardAuthorizer como a classe autorizadora, que verifica as credenciais contra um arquivo de configuração que você criará em breve. Em seguida, você define o parâmetro allow.everyone.if.no.acl.found para false, restringindo o acesso para conexões com credenciais inadequadas. Você também marca o usuário admin como superusuário, pois deve haver pelo menos um para executar tarefas administrativas no cluster.

Lembre-se de substituir your_tls_password pela senha passada no script da seção anterior, então salve e feche o arquivo.

Depois de configurar o Kafka, você precisará criar um arquivo que define as credenciais permitidas para a conexão. O Kafka suporta o Java Authentication and Authorization Service (JAAS), uma estrutura para implementar fluxos de autenticação, e aceita definições de credenciais no formato JAAS.

Você irá armazená-los em um arquivo chamado kafka-server-jaas.conf sob config/kraft. Crie e abra-o para edição executando:

nano config/kraft/kafka-server-jaas.conf

Adicione as seguintes linhas:

KafkaServer {
 org.apache.kafka.common.security.plain.PlainLoginModule required
 username="admin"
 password="admin"
 user_admin="admin";
};

A username e password definem as principais credenciais que são usadas para comunicação entre brokers no cluster, quando múltiplos nós estão presentes. A linha user_admin define um usuário cujo nome de usuário é admin com senha admin, que pode se conectar ao broker de fora. Salve e feche o arquivo quando terminar.

O Kafka precisa estar ciente do arquivo kafka-server-jaas.conf pois ele complementa a configuração principal. Você precisará modificar a configuração do serviço systemd kafka e passar uma referência para ele. Execute o seguinte comando para abrir o serviço para edição:

sudo systemctl edit --full kafka

Passando --full, você obtém acesso aos conteúdos completos do serviço. Encontre a linha ExecStart:

...
User=kafka
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/kraft/server.properties > /home/kafka/kafka/kafka.log 2>&1'
...

Adicione a seguinte linha acima dela, para que fique assim:

...
User=kafka
Environment="KAFKA_OPTS=-Djava.security.auth.login.config=/home/kafka/kafka/config/kraft/kafka-server-jaas.conf"
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/kraft/server.properties > /home/kafka/kafka/kafka.log 2>&1'
...

Com isto, você define o parâmetro java.security.auth.login.config na configuração para o caminho do arquivo de configuração JAAS, desacoplando-o da configuração principal do Kafka. Depois disso, salve e feche o arquivo. Recarregue a definição do serviço executando:

sudo systemctl daemon-reload

Então, reinicie o Kafka:

sudo systemctl restart kafka

Você agora configurou tanto o criptografia TLS quanto a autenticação SASL para sua instalação do Kafka, e vai aprender a conectar-se a ela usando os scripts de console fornecidos.

Passo 2 – Conectando the um Cluster Seguro

Neste passo, você aprenderá a conectar-se the the um cluster do Kafka seguro usando arquivos de configuração JAAS com os scripts de console fornecidos.

Os scripts fornecidos para manipular os tópicos, produzindo e consumindo mensagens, também usam Java internamente, e portanto, aceitam uma configuração JAAS que detalha as localizações dos depósitos de confiança e chaves, bem como as credenciais SASL.

Você armazenará essa configuração em um arquivo chamado client-jaas.conf no diretório de usuário. Crie e abra-o para edição:

nano ~/client-jaas.conf

Adicione as seguintes linhas:

security.protocol=SASL_SSL
ssl.truststore.location=/home/kafka/kafka-ssl/truststore/kafka.truststore.jks
ssl.truststore.password=your_tls_password
ssl.keystore.location=/home/kafka/kafka-ssl/keystore/kafka.keystore.jks
ssl.keystore.password=your_tls_password

sasl.mechanism=PLAIN
sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="admin" password="admin";
ssl.endpoint.identification.algorithm=

Configura o protocolo como SASL_SSL e fornece os caminhos e a senha para os armazéns de chaves e confiança que você criou. Em seguida, define o mecanismo SASL como PLAIN e fornece as credenciais para o usuário admin. Especificamente, limpa o parâmetro ssl.endpoint.identification.algorithm para evitar problemas de conexão, pois os scripts iniciais definem o nome do host da máquina em que está sendo executado como o ponto final do certificado, o que pode não ser correto.

Substitua sua_senha_tls pelo valor apropriado,然后 salve e feche o arquivo.

Para passar esse arquivo para os scripts, você pode usar o parâmetro --command-config. Tente criar um novo tópico no cluster com o seguinte comando:

bin/kafka-topics.sh --bootstrap-server localhost:9092 --create --topic new_topic --command-config ~/client-jaas.conf

O comando deve ser executado com sucesso:

Output
...
Created topic new_topic.

Para verificar se foi criado, liste todos os tópicos no cluster executando:

bin/kafka-topics.sh --bootstrap-server localhost:9092 --list --command-config ~/client-jaas.conf

A saída mostrará que o new_topic está presente:

Output
__consumer_offsets
new_topic
...

Nesta seção, você configurou sua instalação Kafka para usar criptografia TLS para o tráfego e SASL para autenticação com combinações de nome de usuário e senha. Agora, você aprenderá como exportar várias métricas Kafka através de JMX usando Prometheus.

Passo 3 – Monitorando Métricas JMX do Kafka Usando Prometheus

Nesta seção, você vai usar o Prometheus para coletar métricas de Kafka e torná-las consultáveis no Grafana. Isso envolve configurar o exportador JMX para Kafka e conectá-lo ao Prometheus.

[Extensões de Gerenciamento Java (JMX) é um framework para aplicações Java que permite que desenvolvedores coletem métricas gerais e personalizadas sobre a operação da aplicação em tempo de execução em um formato padrão. Como o Kafka está escrito em Java, ele suporta o protocolo JMX e expõe suas métricas personalizadas através dele, como o status de tópicos e broker.

Configurando Kafka e o Prometheus

Antes de prosseguir, você precisará instalar o Prometheus. Em máquinas Ubuntu, você pode usar o apt. Atualize seus repositórios executando:

sudo apt update

Então, instale o Prometheus:

sudo apt install prometheus -y

Para outros plataformas, siga as instruções de instalação no site oficial.

Uma vez instalado, você precisará adicionar a biblioteca do exportador JMX para Prometheus à sua instalação do Kafka. Navegue até a página de lançamentos e selecione a versão mais recente com javaagent no nome. No momento da escrita, a versão mais recente disponível era 0.20.0. Use o seguinte comando para baixá-lo para o diretório libs/ onde o Kafka está instalado:

curl https://repo.maven.apache.org/maven2/io/prometheus/jmx/jmx_prometheus_javaagent/0.20.0/jmx_prometheus_javaagent-0.20.0.jar -o ~/kafka/libs/jmx_prometheus_javaagent.jar

A biblioteca do exportador JMX agora será carregada pelo Kafka.

Antes de ativar o exportador, você precisa definir quais métricas ele vai relatar para o Prometheus, e você armazenará essa configuração em um arquivo chamado jmx-exporter.yml na config/ da instalação do Kafka. O projeto do exportador JMX fornece uma configuração padrão apropriada, portanto, execute o seguinte comando para armazená-lo como jmx-exporter.yml na config/ da sua instalação do Kafka:

curl https://raw.githubusercontent.com/prometheus/jmx_exporter/main/example_configs/kafka-2_0_0.yml -o ~/kafka/config/jmx-exporter.yml

A seguir, para ativar o exportador, você precisará modificar o serviço de sistema do Kafka. você precisará modificar a variável de ambiente KAFKA_OPTS para incluir o exportador, bem como sua configuração. Execute o seguinte comando para editar o serviço:

sudo systemctl edit --full kafka

Modifique a linha Environment para parecer assim:

Environment="KAFKA_OPTS=-Djava.security.auth.login.config=/home/kafka/kafka/config/kraft/kafka-server-jaas.conf -javaagent:/home/kafka/kafka/libs/jmx_prometheus_javaagent.jar=7075:/home/kafka/kafka/config/jmx-exporter.yml"

Aqui, você utiliza o argumento -javaagent para inicializar o exportador JMX com sua configuração.

Salve e feche o arquivo quando terminar, então reinicie o Kafka executando:

sudo systemctl restart kafka

Após um minuto, verifique se o exportador JMX está sendo executado consultando se a porta 7075 está em uso:

sudo ss -tunelp | grep 7075

Output
tcp   LISTEN 0      3                  *:7075             *:*    users:(("java",pid=6311,fd=137)) uid:1000 ino:48151 sk:8 cgroup:/system.slice/kafka.service v6only:0 <->

Esta linha mostra que o porto 7075 está em uso por um processo Java iniciado pelo serviço Kafka, que se reflete no exportador JMX.

Agora você vai configurar o Prometheus para monitorar as métricas JMX exportadas. O arquivo de configuração principal está localizado em /etc/prometheus/prometheus.yml, portanto, abra-o para edição:

sudo nano /etc/prometheus/prometheus.yml

Localize as seguintes linhas:

...
# Uma configuração de coleta contendo exatamente um endpoint para coletar:
# Aqui é o próprio Prometheus.
scrape_configs:
  # O nome do trabalho é adicionado como uma tag `job=` a qualquer série de tempo coletada a partir desta configuração.
  - job_name: 'prometheus'

    # Substitua a predefinição global e colete alvos deste trabalho a cada 5 segundos.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.

    static_configs:
      - targets: ['localhost:9090']

  - job_name: node
    # If prometheus-node-exporter is installed, grab stats about the local
    # machine by default.
    static_configs:
      - targets: ['localhost:9100']

Abaixo das scrape_configs, que especifica quais endpoints o Prometheus deve monitorar, adicione uma nova seção para a coleta de métricas do Kafka:

# Uma configuração de scrape contendo exatamente um endpoint para scrape:
# Aqui, é o próprio Prometheus.
scrape_configs:
  # O nome do trabalho é adicionado como uma etiqueta `job=<nome_do_trabalho>` a qualquer série temporal raspada desta configuração.
  - job_name: 'prometheus'

    # Substitui o padrão global e raspada de targets deste trabalho a cada 5 segundos.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path padrão é '/metrics'
    # esquema padrão é 'http'.

    static_configs:
      - targets: ['localhost:9090']

  - job_name: node
    # Se o prometheus-node-exporter estiver instalado, obtenha estatísticas sobre a máquina local
    # por padrão.
    static_configs:
      - targets: ['localhost:9100']

  - job_name: 'kafka'
    static_configs:
    - targets: ['your_domain:7075']

O trabalho kafka tem um alvo, que aponta para o endpoint do exporter JMX.

Lembre-se de substituir seu_dominio pelo seu nome de domínio,然后 salve e feche o arquivo. Em seguida, reinicie o Prometheus executando:

sudo systemctl restart prometheus

No seu navegador, navegue até a porta 9090 no seu domínio. Você acessará a UI do Prometheus. Sob Status, clique em Targets para listar os trabalhos:

Observe que o Prometheus aceitou o trabalho kafka e começou a raspar suas métricas. Agora, você aprenderá como acessá-las no Grafana.

Consultar Métricas no Grafana

Como parte dos pré-requisitos, você instalou o Grafana em sua Droplet e o expôs em your_domain. Navegue até ele no seu navegador, e em Conexões na barra lateral, clique em Adicionar Nova Conexão, depois digite Prometheus no campo de busca.

Clique em Prometheus, em seguida, clique no botão Adicionar Nova Fonte de Dados no canto superior direito. Você será solicitado a preencher o endereço de uma instância do Prometheus:

Digite http://your_domain_name:9090, substituindo pelo seu domínio real, em seguida, scroll para baixo e clique em Salvar & testar. Você deve receber uma mensagem de sucesso:

A conexão do Prometheus foi adicionada ao Grafana. Clique em Explorar na barra lateral, e você será solicitado a selecionar um métrica. Você pode digitar kafka_ para listar todas as métricas relacionadas ao cluster, conforme mostrado:

Por exemplo, selecione a métrica kafka_log_log_size, que mostra quão grande o log interno no disco é por partição, em seguida, clique em Executar consulta no canto superior direito. Você verá os tamanhos resultantes ao longo do tempo para cada um dos tópicos disponíveis:

Neste passo, você configurou a exportação de métricas JMX fornecidas por Kafka e configurou o Prometheus para coletá-las. Em seguida, você se conectou a ele a partir do Grafana e executou uma consulta nas métricas do Kafka. Agora, você vai aprender a gerenciar um cluster Kafka usando uma interface web.

Passo 4 – Gerenciando clusters Kafka com AKHQ

Neste passo, você vai aprender a configurar e usar AKHQ, uma aplicação web para gerenciar clusters Kafka. Ela permite que você liste e manipule tópicos, partições, grupos de consumidores e parâmetros de configuração, bem como produzir e consumir mensagens de tópicos em um único local.

Você armazenará o executável e sua configuração em um diretório chamado akhq. Crie-o em seu diretório pessoal executando:

mkdir ~/akhq

Abra-o:

cd ~/akhq

No seu navegador, visite a página de lançamentos oficiais e copie o link para o arquivo JAR da versão mais recente. No momento da escrita, a versão mais recente era 0.24.0. Execute o seguinte comando para baixá-lo para o seu diretório pessoal:

curl -L https://github.com/tchiotludo/akhq/releases/download/0.24.0/akhq-0.24.0-all.jar -o ~/akhq/akhq.jar

Agora você baixou o AKHQ e está pronto para definir sua configuração para se conectar ao seu cluster. Você armazenará isso em um arquivo chamado akhq-config.yml. Crie e abra-o para edição executando:

nano ~/akhq/akhq-config.yml

Adicione as seguintes linhas:

akhq:
  connections:
    localhost-sasl:
      properties:
        bootstrap.servers: "localhost:9092"
        security.protocol: SASL_SSL
        sasl.mechanism: PLAIN
        sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username="admin" password="admin";
        ssl.truststore.location: /home/kafka/kafka-ssl/truststore/kafka.truststore.jks
        ssl.truststore.password: secret
        ssl.keystore.location: /home/kafka/kafka-ssl/keystore/kafka.keystore.jks
        ssl.keystore.password: secret
        ssl.key.password: secret
        ssl.endpoint.identification.algorithm: ""

Esta é uma configuração básica do AKHQ, especificando um cluster em localhost:9092 com os parâmetros SASL e TLS correspondentes especificados. Múltiplos clusters simultâneos também são suportados, pois você pode definir quantas conexões quiser. Isso torna o AKHQ versátil para gerenciar o Kafka. Quando terminar, salve e feche o arquivo.

Em seguida, você precisará definir um serviço systemd para executar o AKHQ em segundo plano. Serviços systemd podem ser iniciados, parados e reiniciados de forma consistente.

Você armazenará a configuração do serviço em um arquivo chamado code-server.service, no diretório /lib/systemd/system, onde o systemd armazena seus serviços. Crie usando seu editor de texto:

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

Adicione as seguintes linhas:

[Unit]
Description=akhq

[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c 'java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar'
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

Primeiro, especifique a descrição do serviço. Em seguida, na seção [Service], defina o tipo do serviço (simple significa que o comando deve simplesmente ser executado) e forneça o comando que será executado. Você também especifica que o usuário sob o qual ele é executado é kafka e que o serviço deve ser reiniciado automaticamente se ele for encerrado.

A seção [Install] ordena ao systemd para iniciar este serviço quando você se conectar ao seu servidor. Salve e feche o arquivo quando terminar.

Carregue a configuração do serviço executando:

sudo systemctl daemon-reload

Inicie o serviço AKHQ executando o seguinte comando:

sudo systemctl start akhq

Em seguida, verifique se foi iniciado corretamente observando seu status:

sudo systemctl status akhq

A saída deve ser assim:

Output
● akhq.service - akhq
     Loaded: loaded (/etc/systemd/system/akhq.service; disabled; vendor preset: enabled)
     Active: active (running) since Wed 2024-05-15 07:37:10 UTC; 3s ago
   Main PID: 3241 (sh)
      Tasks: 21 (limit: 4647)
     Memory: 123.3M
        CPU: 4.474s
     CGroup: /system.slice/akhq.service
             ├─3241 /bin/sh -c "java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar"
             └─3242 java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar

AKHQ está agora em execução em segundo plano. Por padrão, ele está exposto na porta 8080. No seu navegador, navegue até o seu domínio com essa porta para acessá-lo. Você verá a visualização padrão, mostrando a lista de tópicos:

Você pode clicar duas vezes na linha correspondente do tópico na tabela para acessá-lo e obter uma visualização detalhada:

AKHQ permite que você veja as mensagens no tópico, bem como partições, grupos de consumidores e suas configurações. Você também pode esvaziar ou copiar o tópico usando os botões no canto inferior direito.

Como o tópico new_topic está vazio, pressione o botão Produzir para o tópico, que abrirá a interface para selecionar os parâmetros da nova mensagem:

AKHQ preencherá automaticamente o nome do tópico para você. No campo Valor, digite Olá Mundo!,然后 pressione Produzir. A mensagem será enviada para Kafka, e você a verá na aba Dados:

Como o conteúdo de uma mensagem pode ser muito grande, AKHQ mostra apenas a primeira linha. Para ver a mensagem completa, pressione na área escura após a linha para revelá-la.

Na barra lateral esquerda, você também pode listar os brokers no cluster pressionando em Nós. Atualmente, o cluster consiste em apenas um nó:

Clicando duas vezes em um nó abrirá sua configuração, permitindo que você altere qualquer uma das configurações de forma remota:

Após fazer as mudanças, você pode aplicá-las clicando no botão Atualizar configs no canto inferior direito. Similarmente, você pode visualizar e modificar a configuração de qualquer dos tópicos acessando-os e mudando para a aba Configs.

Nesta seção, você configurou o AKHQ, uma aplicação web que fornece uma interface de usuário fácil de usar para gerenciar e observar remotamente os nós e tópicos do Kafka. Ele permite que você produza e consome mensagens em tópicos e atualize os parâmetros de configuração dos tópicos e nós em tempo real.

Conclusão

Neste tutorial, você garantiu sua instalação do Kafka configurando o TLS para criptografia e o SASL para autenticação de usuário. Você também configurou o exporte de métricas usando o Prometheus e visualizou-as no Grafana. Em seguida, você aprendeu a usar o AKHQ, uma aplicação web para gerenciar clusters do Kafka.

O autor selecionou Apache Software Foundation para receber uma doação como parte do programa Write for DOnations..