Como segurar e monitorizar 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 há verificações de segurança habilitadas. Embora isso seja útil para exploração e desenvolvimento, as implantações de produção devem seradevidamente protegidas 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 a criptografia de tráfego TLS e autenticação SASL para fornecer um fluxo de login padrão de 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 por meio de uma interface baseada na web, fácil de usar, fornecida pelo AKHQ.

Pré-requisitos

Para completar este tutorial, você precisará de:

• Uma Droplet com pelo menos 4GB de RAM e 2 CPUs. No caso de um servidor Ubuntu, siga a Configuração Inicial do Servidor para obter instruções de configuração.
• O Apache Kafka está instalado e configurado em sua droplet. Para obter instruções de configuração, siga o tutorial Introdução ao Kafka. Você deve completar apenas o Passo 1 e o Passo 2.
• Uma compreensão de como o Java lida com chaves e certificados. Para mais informações, visite o tutorial Java Keytool Essentials: Trabalhando com Java Keystores.
• O Grafana instalado no seu servidor ou máquina local. Por favor, visite o tutorial Como Instalar e Proteger o Grafana no Ubuntu para obter instruções. Você precisa completar apenas os primeiros quatro passos.
• Um nome de domínio registrado em pleno está apontado para sua droplet. Este tutorial usará seu_dominio ao longo e se referirá ao mesmo nome de domínio como pré-requisito do Grafana. Você pode comprar um nome de domínio no Namecheap, obter um de graça no Freenom ou usar o registrador de domínio de sua escolha.

Passo 1 – Configurando os Protocolos de Segurança do Kafka

Na sua configuração padrão, Kafka permite que qualquer pessoa se conecte a ele sem verificar a origem da solicitação. Isso significa que seu cluster é acessível a todos por padrão. Embora isso seja adequado para testes, pois reduz a carga de manutenção em máquinas locais e instalações privadas, instalações de Kafka em produção e voltadas para o público devem ter recursos de segurança habilitados para prevenir acessos não autorizados.

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

Gerando Certificados TLS e Stores

Para gerar os certificados e chaves necessários para configurar TLS, você usará o script do repositório Confluent Platform Security Tools. Primeiro, clone-o para o seu diretório home executando o seguinte comando:

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

Navegue até ele:

cd ~/kafka-ssl

Você vai usar o script chamado kafka-generate-ssl-automatic.sh, e ele exige que você forneça seus país, estado, organização e cidade como variáveis de ambiente. esses parâmetros são usados para criar os certificados, mas seu conteúdo é não importante. Você também precisará fornecer uma senha, que é usada para segurar o Java trust e key store que serão gerados.

Execute os seguintes comandos para configurar as variáveis de ambiente necessárias, substituindo your_tls_password com seu valor de preferência:

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

Note que a PASSWORD deve ter pelo menos seis caracteres de comprimento.

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

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

Em seguida, execute-o para gerar os arquivos necessários:

./kafka-generate-ssl-automatic.sh

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

ls -l

A saída deve se parecer com isto:

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, de confiança e key store 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á Kafka para usá-los e autenticar usuários usando SASL.

Você modificará o arquivo server.properties localizado na pasta config/kraft no diretório de instalação. Você instalou ele na pasta kafka do diretório pessoal como parte dos pré-requisitos. Navigue até ele executando:

cd ~/kafka

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

nano config/kraft/server.properties

Localize as seguintes linhas:

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

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

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

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

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

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

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

Então, localize a linha listener.security.protocol.map:

# Mapeia nomes de ouvidores para protocolos de segurança, o padrão é que eles 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 ouvidores para protocolos de segurança, o padrão é que eles 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ê definiu o alias BROKER que usou nos ouvintes e o mapeou para SASL_SSL, o que significa que tanto SSL (um nome antigo para TLS) quanto SASL devem ser 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

Primeiro, você define os locais e senhas para os armazéns de chaves e confiança gerados. Você define o parâmetro ssl.client.auth como required, instruindo o Kafka a não permitir conexões que não apresentem um certificado TLS válido. Em seguida, você define o mecanismo SASL como PLAIN, habilitando-o. PLAIN é diferente de PLAINTEXT pois requer o uso de uma conexão criptografada, e ambos dependem de uma combinação de credenciais de nome de usuário e senha.

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

Lembre-se de substituir your_tls_password pela senha que você passou para o script na seção anterior,然后 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 framework para implementar fluxos de autenticação, e aceita definições de credenciais no formato JAAS.

Você as armazenará 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 credenciais principais 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 a 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 ela 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 isso, 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. Quando terminar, salve e feche o arquivo. Recarregue a definição do serviço executando:

sudo systemctl daemon-reload

Em seguida, reinicie o Kafka:

sudo systemctl restart kafka

Agora, você configurou tanto a criptografia TLS quanto a autenticação SASL para sua instalação do Kafka, e agora aprenderá como se conectar a ele com os scripts de console fornecidos.

Passo 2 – Conectando a um Cluster Seguro

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

Os scripts fornecidos para manipulação de tópicos, produção e consumo de mensagens também usam Java internamente, e portanto aceitam uma configuração JAAS detalhando as localizações da loja de chaves e de confiança, bem como as credenciais SASL.

Você armazenará essa configuração em um arquivo chamado client-jaas.conf no seu diretório home. 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=

Assim como antes, você define o protocolo como SASL_SSL e fornece os caminhos e senhas para as lojas de chaves e de confiança que você criou. Em seguida, você define o mecanismo SASL como PLAIN e fornece as credenciais do usuário admin. Você explicitamente limpa o parâmetro ssl.endpoint.identification.algorithm para evitar problemas de conexão, já que os scripts iniciais definem o nome de host da máquina em que eles são executados como o ponto final do certificado, o que pode não ser correto.

Substitua your_tls_password pelo valor correto, depois salve e feche o arquivo.

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

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

O comando deve executar 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 new_topic está presente:

Output
__consumer_offsets
new_topic
...

Nesta seção, você configurou sua instalação do Kafka para usar criptografia TLS para 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 do Kafka através do JMX usando o Prometheus.

Passo 3 – Monitoramento de Métricas JMX do Kafka Usando o 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 de 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 é 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 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.

Após a instalação, você precisará adicionar a biblioteca do exportador JMX para o Prometheus à sua instalação do Kafka. Navegue até a página de releases e selecione o último lançamento 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á detectada pelo Kafka.

Antes de ativar o exportador, você precisa definir quais métricas ele relatará ao Prometheus, e você armazenará essa configuração em um arquivo chamado jmx-exporter.yml sob config/ da instalação do Kafka. O projeto do exportador JMX fornece uma configuração padrão adequada, então execute o seguinte comando para armazená-lo como jmx-exporter.yml sob 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

Em seguida, para ativar o exportador, você precisará modificar o serviço systemd do Kafka. Você precisará modificar a variável de ambiente KAFKA_OPTS para incluir o exportador, além de sua configuração. Execute o seguinte comando para editar o serviço:

sudo systemctl edit --full kafka

Modifique a linha Environment para que ela fique 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,然后 reinicie o Kafka executando:

sudo systemctl restart kafka

Após um minuto, verifique se o exportador JMX está em execução consultando se a porta 7075 está sendo usada:

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, o que se refere ao exportador JMX.

Agora você configurará o Prometheus para supervisionar 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 etiqueta `job=` a qualquer série de tempo coletada a partir desta configuração.
  - job_name: 'prometheus'

    # Substitua a configuração global padrão 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 raspagem que contém exatamente um ponto final para raspagem:
# Aqui é o próprio Prometheus.
scrape_configs:
  # O nome do trabalho é adicionado como uma etiqueta `job=` a qualquer série de tempo raspada a partir desta configuração.
  - job_name: 'prometheus'

    # Substitua a configuração global padrão e raspue os alvos deste trabalho a cada 5 segundos.
    scrape_interval: 5s
    scrape_timeout: 5s

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

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

  - job_name: node
    # Se o prometheus-node-exporter estiver instalado, pegue as estatísticas sobre o computador local por padrão.
    # Seu computador local.
    static_configs:
      - targets: ['localhost:9100']

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

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

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

sudo systemctl restart prometheus

No seu navegador, navegue até a porta 9090 em seu domínio. Você terá acesso à interface do usuário do Prometheus. Na Status, clique em Alvos para listar os trabalhos:

Note que o Prometheus aceitou o trabalho kafka e começou a raspagem de suas métricas. Agora você vai aprender a 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, na área de Conexões da 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 Novo provedor de Dados no canto superior direito. Você será solicitado a preencher o endereço de uma instância do Prometheus:

Insira http://your_domain_name:9090, substituindo por seu domínio real, depois role para baixo e clique em Salvar & testar. Você deveria 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, como mostrado:

Por exemplo, selecione a métrica kafka_log_log_size, que mostra a quantidade de espaço ocupado pelo 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 tópico disponível:

Neste passo, você configurou a exportação de métricas JMX fornecidas pelo 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ê aprenderá a gerenciar um cluster Kafka usando uma interface web.

Passo 4 – Gerenciando Clusters Kafka Com AKHQ

Neste passo, você aprenderá como configurar e usar o AKHQ, uma aplicação web para gerenciar clusters Kafka. Ele permite listar e manipular tópicos, partições, grupos de consumidores e parâmetros de configuração, além de produzir e consumir mensagens de tópicos de um único local.

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

mkdir ~/akhq

Navegue até ele:

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 home:

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 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: ""

should be translated to:

Esta é uma configuração básica do AKHQ, especificando um cluster em localhost:9092 com os parâmetros de SASL e TLS correspondentes especificados. Multiplos 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 maneira 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 automaticamente reiniciado se sair.

A seção [Install] ordena ao systemd para iniciar este serviço quando você se conecta 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 sendo executado 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:

O 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:

O AKHQ preencherá automaticamente o nome do tópico para você. No campo Valor, digite Hello World!,然后 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, o 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. No momento, o cluster consiste em apenas um nó:

Clicar 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 alterações, você pode aplicá-las pressionando o botão Atualizar configurações no canto inferior direito. Similarmente, você pode visualizar e modificar as configurações de qualquer tópico acessando-o e mudando para a aba Configurações.

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 nós e tópicos de Kafka remotamente. Ele permite que você produza e consome mensagens em tópicos e atualize os parâmetros de configuração de tópicos e nós em tempo real.

Conclusão

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

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