One place for hosting & domains

      So installieren Sie Apache Kafka unter Debian 10


      Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Apache Kafka ist ein beliebter Distributed Message Broker, der für die Verarbeitung großer Mengen von Echtzeitdaten ausgelegt ist. Ein Kafka-Cluster ist hochgradig skalierbar und fehlertolerant und bietet einen wesentlich höheren Durchsatz im Vergleich zu anderen Message Brokern wie ActiveMQ und RabbitMQ. Obwohl er im Allgemeinen als Publish/Subscribe-Messaging-System verwendet wird, verwenden ihn viele Organisationen auch für die Protokollaggregation, da er einen persistenten Speicher für veröffentlichte Nachrichten bietet.

      Ein Publish/Subscribe-Messaging-System ermöglicht einem oder mehreren Producern die Veröffentlichung von Nachrichten, ohne die Anzahl der Consumer oder die Art und Weise der Nachrichtenverarbeitung zu berücksichtigen. Abonnierte Clients werden automatisch über Aktualisierungen und die Erstellung neuer Nachrichten informiert. Dieses System ist effizienter und skalierbar als Systeme, bei denen Clients in regelmäßigen Abständen abfragen, ob neue Nachrichten verfügbar sind.

      In diesem Tutorial werden Sie Apache Kafka 2.1.1 sicher auf einem Debian 10-Server installieren und konfigurieren und anschließend Ihre Einrichtung testen, indem Sie eine Nachricht Hello World erzeugen und konsumieren. Sie installieren dann wahlweise KafkaT, um Kafka zu überwachen und einen Kafka-Mehrknoten-Cluster einzurichten.

      Voraussetzungen

      Um dem Tutorial zu folgen, benötigen Sie Folgendes:

      • Einen Debian-10-Server mit mindestens 4 GB RAM und einem Benutzer ohne Root-Berechtigung und mit sudo-Privilegien. Wenn Sie keinen Benutzer ohne Root-Berechtigung eingerichtet haben, folgen Sie den Schritten in unserem Leitfaden zur Ersteinrichtung von Debian 10.
      • Auf Ihrem Server installiertes OpenJDK 11. Um diese Version zu installieren, folgen Sie den Anweisungen in So installieren Sie Java mit Apt unter Debian 10 zur Installation bestimmter Versionen von OpenJDK. Kafka ist in Java geschrieben und benötigt daher eine JVM.

      Hinweis: Installationen ohne 4GB RAM können zum Ausfall des Kafka-Dienstes führen, wobei die Java Virtual Machine (JVM) während des Starts eine Out Of Memory-Ausnahme auslöst.

      Schritt 1 – Erstellen eines Benutzers für Kafka

      Da Kafka Anfragen über ein Netzwerk verarbeiten kann, ist die Einrichtung eines dedizierten Benutzers eine bewährte Methode. Dies minimiert den Schaden an Ihrem Debian-Rechner, sollte der Kafka-Server kompromittiert werden. In diesem Schritt erstellen Sie den dedizierten Benutzer kafka.

      Melden Sie sich als Benutzer ohne Root- und mit sudo-Berechtigung an und erstellen Sie mit dem Befehl useradd einen Benutzer namens kafka:

      Das Flag -m stellt sicher, dass ein Home-Verzeichnis für den Benutzer erstellt wird. Dieses Home-Verzeichnis, /home/kafka, dient als Ihr neues Arbeitsbereichsverzeichnis für die spätere Ausführung von Befehlen.

      Legen Sie das Passwort mit passwd fest:

      Geben Sie das für diesen Benutzer gewünschte Passwort ein.

      Fügen Sie als Nächstes den Benutzer kafka mit dem Befehl adduser zur Gruppe sudo hinzu, damit er über die erforderlichen Berechtigungen zur Installation der Abhängigkeiten von Kafka verfügt:

      Ihr Benutzer kafka ist nun bereit. Melden Sie sich mit su bei diesem Konto an:

      Nachdem Sie nun den Kafka-spezifischen Benutzer erstellt haben, können Sie mit dem Herunterladen und Extrahieren der Kafka-Binärdateien fortfahren.

      In diesem Schritt laden Sie die Kafka-Binärdateien herunter und extrahieren sie in spezielle Ordner im Home-Verzeichnis ihres Benutzers kafka.

      Erstellen Sie zu Beginn ein Verzeichnis in /home/kafka namens Downloads, um Ihre Downloads zu speichern:

      Installieren Sie als Nächstes curl unter Verwendung von apt-get, damit Sie Remote-Dateien herunterladen können:

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

      Wenn Sie dazu aufgefordert werden, geben Sie Y ein, um den Download von curl zu bestätigen.

      Sobald curl installiert ist, verwenden Sie es zum Herunterladen der Kafka-Binärdateien:

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

      Erstellen Sie ein Verzeichnis namens kafka und wechseln Sie in dieses Verzeichnis. Dies ist das Basisverzeichnis der Kafka-Installation:

      • mkdir ~/kafka && cd ~/kafka

      Extrahieren Sie das von Ihnen heruntergeladene Archiv mit dem Befehl tar:

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

      Sie haben das Flag --strip 1 angegeben, um sicherzustellen, dass der Inhalt des Archivs in ~/kafka/ selbst und nicht in ein anderes Verzeichnis innerhalb des Archivs extrahiert wird, wie z. B. ~/kafka/kafka_2.12-2.1.1/.

      Nachdem Sie die Binärdateien erfolgreich heruntergeladen und extrahiert haben, können Sie mit der Konfiguration von Kafka fortfahren, um das Löschen von Themen zu erlauben.

      Schritt 3 – Konfigurieren des Kafka-Servers

      Das Standardverhalten von Kafka erlaubt es uns nicht, ein Thema, eine Kategorie, eine Gruppe oder den Feed-Namen zu löschen, an die Nachrichten veröffentlicht werden können. Um dies zu ändern, bearbeiten Sie die Konfigurationsdatei.

      Die Konfigurationsoptionen von Kafka werden in server.properties angegeben. Öffnen Sie diese Datei mit nano oder Ihrem bevorzugten Editor:

      • nano ~/kafka/config/server.properties

      Fügen wir eine Einstellung hinzu, die es uns erlaubt, Kafka-Themen zu löschen. Fügen Sie die folgende hervorgehobene Zeile am Ende der Datei hinzu:

      ~/kafka/config/server.properties

      ...
      group.initial.rebalance.delay.ms
      
      delete.topic.enable = true
      

      Speichern Sie die Datei und beenden Sie nano. Nachdem Sie Kafka konfiguriert haben, können Sie systemd Unit-Dateien erstellen, um Kafka beim Start auszuführen und zu aktivieren.

      Schritt 4 – Erstellen von Systemd Unit-Dateien und Starten des Kafka-Servers

      In diesem Abschnitt erstellen Sie systemd Unit-Dateien für den Kafka-Dienst. Dies wird Ihnen bei der Durchführung allgemeiner Dienstaktionen wie dem Starten, Stoppen und Neustarten von Kafka in einer Weise helfen, die mit anderen Linux-Diensten konsistent ist.

      ZooKeeper ist ein Dienst, den Kafka zur Verwaltung seines Clusterstatus und seiner Konfigurationen verwendet. Er wird häufig in verteilten Systemen als integraler Bestandteil verwendet. In diesem Tutorial verwenden Sie Zookeeper, um diese Aspekte von Kafka zu verwalten. Wenn Sie mehr darüber erfahren möchten, besuchen Sie die offiziellen ZooKeeper-Dokumentationen.

      Erstellen Sie zuerst die Unit-Datei für zookeeper:

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

      Geben Sie die folgende Unit-Definition in die Datei ein:

      /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
      

      Der Abschnitt [Unit] legt fest, dass ZooKeeper eine Vernetzung erfordert und das Dateisystem bereit sein muss, bevor es gestartet werden kann.

      Der Abschnitt [Service] legt fest, dass systemd die Shell-Dateien zookeeper-server-start.sh und zookeeper-server-stop.sh zum Starten und Stoppen des Dienstes verwenden soll. Er legt auch fest, dass ZooKeeper automatisch neu gestartet werden soll, wenn er abnormal endet.

      Erstellen Sie als Nächstes die Dienstdatei systemd für kafka:

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

      Geben Sie die folgende Unit-Definition in die Datei ein:

      /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
      

      Der Abschnitt [Unit] legt fest, dass diese Unit-Datei von zookeeper.service abhängt. Dadurch wird sichergestellt, dass zookeeper automatisch gestartet wird, wenn der Dienst kafka startet.

      Der Abschnitt [Service] legt fest, dass systemd die Shell-Dateien kafka-server-start.sh und kafka-server-stop.sh zum Starten und Stoppen des Dienstes verwenden soll. Er legt auch fest, dass ZooKeeper automatisch neu gestartet werden soll, wenn er abnormal endet.

      Nachdem die Units definiert wurden, starten Sie Kafka mit dem folgenden Befehl:

      • sudo systemctl start kafka

      Um sicherzustellen, dass der Server erfolgreich gestartet wurde, überprüfen Sie die Journalprotokolle für die Unit kafka.

      Sie sehen eine Ausgabe, die der folgenden ähnelt:

      Output

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

      Sie haben nun einen Kafka-Server, der auf Port 9092, den Standardport für Kafka, lauscht.

      Sie haben den Dienst kafka gestartet, aber wenn Sie Ihren Server neu starten würden, würde der Dienst noch nicht automatisch gestartet. Um kafka beim Serverstart zu aktivieren, führen Sie Folgendes aus:

      • sudo systemctl enable kafka

      Nachdem Sie die Dienste nun gestartet und aktiviert haben, ist es an der Zeit, die Installation zu überprüfen.

      Schritt 5 – Testen der Installation

      Veröffentlichen und konsumieren wir eine Nachricht Hello World, um sicherzustellen, dass sich der Kafka-Server korrekt verhält. Die Veröffentlichung von Nachrichten in Kafka erfordert:

      • Einen producer, der die Veröffentlichung von Datensätzen und Daten zu Themen ermöglicht.
      • Einen consumer, der Nachrichten und Daten zu Themen liest.

      Erstellen Sie zuerst ein Thema namens TutorialTopic, indem Sie Folgendes eingeben:

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

      Sie können einen Producer von der Befehlszeile aus mit dem Skript kafka-console-producer.sh erstellen. Es erwartet den Hostnamen des Kafka-Servers, den Port und einen Themennamen als Argumente.

      Veröffentlichen Sie die Zeichenfolge Hello, World zum Thema TutorialTopic, indem Sie Folgendes eingeben:

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

      Das Flag --broker-list bestimmt die Liste der Nachrichten-Broker, an die die Nachricht gesendet werden soll, in diesem Fall localhost:9092. --topic bezeichnet das Thema als TutorialTopic.

      Als Nächstes können Sie mit dem Skript kafka-console-consumer.sh einen Kafka-Consumer erstellen. Es erwartet den Hostnamen des ZooKeeper-Servers, den Port und einen Themennamen als Argumente.

      Der folgende Befehl konsumiert Nachrichten von TutorialTopic. Beachten Sie die Verwendung des Flags --from-beginning, das den Verbrauch von Nachrichten erlaubt, die vor dem Start des Consumers veröffentlicht wurden:

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

      --bootstrap-server bietet eine Liste von Eingängen in den Kafka-Cluster. In diesem Fall verwenden Sie localhost:9092.

      Sie sehen Hello, World auf Ihrem Terminal:

      Output

      Hello, World

      Das Skript wird kontinuierlich weiter ausgeführt und wartet darauf, dass weitere Nachrichten zu dem Thema veröffentlicht werden. Zögern Sie nicht, ein neues Terminal zu öffnen und einen Producer zu starten, um weitere Nachrichten zu veröffentlichen. Sie sollten sie alle in der Ausgabe des Consumers sehen können. Wenn Sie mehr über die Verwendung von Kafka erfahren möchten, lesen Sie die offizielle Kafka-Dokumentation.

      Wenn Sie dem Testen fertig sind, drücken Sie STRG+C, um das Consumer-Skript zu stoppen. Nachdem Sie die Installation getestet haben, können Sie mit der Installation von KafkaT fortfahren, um Ihren Kafka-Cluster besser zu verwalten.

      Schritt 6 – Installieren von KafkaT (optional)

      KafkaT ist ein Tool von Airbnb, das die Anzeige von Details über Ihren Kafka-Cluster und die Durchführung bestimmter administrativer Aufgaben von der Befehlszeile aus erleichtert. Da es sich um ein Ruby Gem handelt, benötigen Sie Ruby, um es zu benutzen. Sie benötigen weiterhin das Paket build-essential um die anderen Gems zu erstellen, von denen es abhängt. Installieren Sie es mit apt:

      • sudo apt install ruby ruby-dev build-essential

      Sie können KafkaT nun mit dem Befehl gem installieren:

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

      Die Option CFLAGS=-Wno-error=format-overflow deaktiviert die Formatüberlauf-Warnungen und ist für das ZooKeeper Gem erforderlich, das eine Abhängigkeit von KafkaT ist.

      KafkaT verwendet .kafkatcfg als Konfigurationsdatei, um die Installations- und Protokollverzeichnisse Ihres Kafka-Servers zu bestimmen. Es sollte auch einen Eintrag zum Verweis von KafkaT auf Ihre ZooKeeper-Instanz haben.

      Erstellen Sie eine neue Datei namens .kafkatcfg:

      Fügen Sie die folgenden Zeilen hinzu, um die erforderlichen Informationen über Ihren Kafka-Server und die Zookeeper-Instanz zu spezifizieren:

      ~/.kafkatcfg

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

      Sie können KafkaT nun verwenden. Als Erstes wird hier beschrieben, wie Sie es verwenden würden, um Details über alle Kafka-Partitionen anzuzeigen:

      Sie sehen den folgenden Output:

      Output

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

      Diese Ausgabe zeigt TutorialTopic sowie __consumer_offsets, ein internes Thema, das von Kafka zur Speicherung von clientbezogenen Informationen verwendet wird. Sie können die mit __consumer_offsets beginnenden Zeilen sicher ignorieren.

      Weitere Informationen über KafkaT finden Sie in seinem GitHub Repository.

      Nachdem Sie KafkaT installiert haben, können Sie Kafka optional auf einem Cluster von Debian 10-Servern einrichten, um einen Mehrfachkonten-Cluster zu erstellen.

      Schritt 7 – Einrichten eines Mehrfachknoten-Clusters (optional)

      Wenn Sie einen Multi-Broker-Cluster unter Verwendung von weiteren Debian 10-Servern erstellen möchten, wiederholen Sie Schritt 1, Schritt 4 und Schritt 5 auf jedem der neuen Rechner. Nehmen Sie zusätzlich die folgenden Änderungen in der Datei ~/kafka/config/server.properties für jeden Rechner vor:

      • Ändern Sie den Wert der Eigenschaft broker.id so, dass er im gesamten Cluster eindeutig ist. Diese Eigenschaft identifiziert jeden Server im Cluster eindeutig und kann eine beliebige Zeichenfolge als Wert haben. Beispielsweise wären „server1“, „server2“ etc. als Identifikatoren nützlich.

      • Ändern Sie den Wert der Eigenschaft zookeeper.connect so, dass alle Knoten auf die gleiche ZooKeeper-Instanz verweisen. Diese Eigenschaft gibt die Adresse der zookeeper-Instanz an und folgt dem Format <HOSTNAME/IP_ADDRESS>:<PORT>. Für dieses Tutorial würden Sie your_first_server_IP:2181 verwenden, wobei Sie your_first_server_IP durch die IP-Adresse des von Ihnen bereits eingerichteten Debian 10-Servers ersetzen.

      Wenn Sie mehrere ZooKeeper-Instanzen für Ihren Cluster haben möchten, sollte der Wert der Eigenschaft zookeeper.connect auf jedem Knoten eine identische, durch Komma getrennten Zeichenfolge sein, die die IP-Adressen und die Portnummern aller ZooKeeper-Instanzen auflistet.

      Hinweis: Wenn Sie eine Firewall auf dem Debian 10-Server mit installiertem Zookeeper aktiviert haben, stellen Sie sicher, dass Port 2181 geöffnet ist, um eingehende Anfragen der anderen Knoten im Cluster zu ermöglichen.

      Schritt 8 – Einschränkung des Kafka-Benutzers

      Nachdem jetzt alle Installationen abgeschlossen sind, können Sie die Admin-Berechtigungen des Benutzers kafka entfernen. Bevor Sie dies tun, melden Sie sich wieder als beliebiger Benutzer ohne Root- und mit sudo-Berechtigung an. Wenn Sie noch die gleiche Shell-Sitzung ausführen, mit der Sie das Tutorial gestartet haben, geben Sie einfach exit ein.

      Entfernen Sie den Benutzer kafka aus der Gruppe sudo:

      Um die Sicherheit Ihres Kafka-Servers weiter zu verbessern, sperren Sie das Passwort des Benutzer kafka mit dem Befehl passwd. Dadurch wird sichergestellt, dass sich niemand mit diesem Konto direkt am Server anmelden kann:

      Zu diesem Zeitpunkt kann sich nur der Benutzer root oder sudo als kafka anmelden, indem folgender Befehl eingegeben wird:

      Wenn Sie es in Zukunft entsperren möchten, verwenden Sie passwd mit der Option -u:

      Sie haben nun erfolgreich die Admin-Berechtigungen des Benutzers kafka eingeschränkt.

      Zusammenfassung

      Apache Kafka wird nun sicher auf Ihrem Debian-Server ausgeführt. Sie können es in Ihren Projekten verwenden, indem Sie Kafka-Producer und -Consumer mit Kafka-Clients erstellen, die für die meisten Programmiersprachen verfügbar sind. Weitere Informationen über Kafka können Sie auch der Apache Kafka-Dokumentation entnehmen.



      Source link

      Como instalar o Apache Kafka no Debian 10


      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:

      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:

      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:

      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:

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

      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:

      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:

      ~/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:

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

      /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.she 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:

      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.

      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:

      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:

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

      ~/.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:

      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.

      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:

      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:

      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:

      No futuro, se você quer desbloqueá-lo, use o comando passwd com a opção -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.



      Source link

      Cómo instalar Apache Kafka en Debian 10


      El autor seleccionó la Free and Open Source Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Apache Kafka es un popular intermediario de mensajes distribuidos diseñado para gestionar grandes volúmenes de datos en tiempo real. Un clúster de Kafka es muy escalable y tolerante a fallos, y también tiene una capacidad mucho mayor en comparación con otros intermediarios de mensajes, como ActiveMQ y RabbitMQ. Aunque se utiliza generalmente como un sistema de mensajería de publicación y subscripción, muchas organizaciones también lo utilizan para la agregación de registros debido a que ofrece almacenamiento persistente para mensajes publicados.

      Un sistema de mensajería de publicación y subscripción permite a uno o más productores publicar mensajes sin tener en cuenta el número de consumidores ni la forma en que procesarán los mensajes. Los clientes suscritos reciben una notificación automática sobre las actualizaciones y la creación de nuevos mensajes. Este sistema es más eficaz y escalable que sistemas en los cuales los clientes de tanto en tanto averiguan si hay nuevos mensajes disponibles.

      A través de este tutorial, instalará y configurará Apache Kafka 2.1.1 de forma segura en un servidor de Debian 10 y luego probará su configuración produciendo y consumiendo un mensaje Hello World. Luego instalará de forma opcional KafkaT para controlar Kafka y configurar un clúster con varios nodos de Kafka.

      Requisitos previos

      Para continuar, necesitará lo siguiente:

      Nota: En instalaciones que no cuenten con 4 GB de RAM, el servicio de Kafka puede fallar; la máquina virtual Java (JVM) puede mostrar una excepción de Out Of Memory durante el inicio.

      Paso 1: Creación de un usuario para Kafka

      Debido a que Kafka puede manejar solicitudes a través de una red, una práctica recomendada es crear un usuario específico para ello. Esto minimiza los daños a su máquina de Debian en caso de que el servidor de Kafka se vea comprometido. Debe crear el usuario específico kafka en este paso.

      Tras iniciar sesión como usuario sudo no root, cree un usuario llamado kafka con el comando de useradd:

      El indicador -m garantiza que se cree un directorio de inicio para el usuario. Este directorio de inicio, /home/kafka, actuará como su directorio de espacio de trabajo para ejecutar comandos más adelante.

      Establezca la contraseña usando passwd:

      Introduzca la contraseña que desea usar para este usuario.

      A continuación, añada el usuario kafka al grupo sudo con el comando adduser, de modo que tenga los privilegios necesarios para instalar las dependencias de Kafka.

      Con esto, su usuario kafka estará listo. Inicie sesión en esta cuenta usando su:

      Ahora que ha creado el usuario específico de Kafka, puede descargar y extraer los binarios de Kafka.

      En este paso, descargará los archivos binarios de Kafka y extráigalos en carpetas específicas del directorio de inicio de su usuario kafka.

      Para comenzar, cree un directorio en /home/kafka llamado Downloads para almacenar sus descargas:

      A continuación, instale curl usando apt-get para poder descargar archivos remotos:

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

      Cuando se le solicite, escriba Y para confirmar la descarga de curl.

      Una vez que curl esté instalado, úselo para descargar los binarios de Kafka:

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

      Cree un directorio llamado kafka y ábralo. Este será el directorio de base de la instalación de Kafka:

      • mkdir ~/kafka && cd ~/kafka

      Extraiga el archivo que descargó usando el comando tar:

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

      Especificó el indicador --strip 1 para garantizar que el contenido del archivo se extraiga en ~/kafka/ en sí y no en otro directorio dentro de este, como ~/kafka/kafka_2.12-2.1.1/​​​.

      Ahora que descargó y extrajo los binarios con éxito, podrá configurar Kafka para permitir la eliminación de temas.

      Paso 3: Configuración del servidor de Kafka

      El comportamiento predeterminado de Kafka no nos permitirá eliminar un tema, la categoría, el grupo ni el nombre del feed en el cual pueden publicarse los mensajes. Para modificar esto, debe editar el archivo de configuración.

      Las opciones de configuración de Kafka se especifican en server.properties. Abra este archivo con nano o su editor favorito:

      • nano ~/kafka/config/server.properties

      Agreguemos una configuración que nos permita eliminar temas de Kafka. Añada la siguiente línea destacada a la parte inferior del archivo:

      ~/kafka/config/server.properties

      ...
      group.initial.rebalance.delay.ms
      
      delete.topic.enable = true
      

      Guarde el archivo y cierre nano. Ahora que configuró Kafka, puede crear archivos de unidad systemd para ejecutar y habilitar Kafka al inicio.

      Paso 4: Creación de archivos de unidad systemd e inicio del servidor de Kafka

      En esta sección, creará archivos de unidad systemd para el servicio de Kafka. Esto le permitirá realizar acciones de servicio comunes, como iniciar, detener y reiniciar Kafka con un método compatible con otros servicios de Linux.

      ZooKeeper es un servicio que Kafka usa para administrar su estado de clúster y sus configuraciones. Se utiliza comúnmente en sistemas distribuidos como componente integral. En este tutorial, usará Zookeeper para administrar estos aspectos de Kafka. Si desea obtener más información sobre él, consulte los documentos oficiales de Zookeeper.

      Primero, cree el archivo de unidad para zookeeper:

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

      Introduzca la siguiente definición de unidad en el archivo:

      /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
      

      En la sección [Unit], se especifica que para el inicio de Zookeeper la interconexión y el sistema de archivos deben estar listos.

      En la sección [Service] se especifica que systemd debe usar los archivos de shell zookeeper-server-start.sh y zookeeper-server-stop.sh“ para iniciar y detener el servicio. También se especifica que Zookeeper debe reiniciarse automáticamente si no se cierra de forma normal.

      A continuación, cree el archivo de servicio de systemd para kafka:

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

      Introduzca la siguiente definición de unidad en el archivo:

      /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
      

      En la sección [Unit] se especifica que este archivo de unidad depende de zookeeper.service. Esto garantizará que zookeeper se inicie de forma automática al iniciarse el servicio Kafka.

      En la sección [Service] se especifica que systemd debe usar los archivos de shell kafka-server-start.sh y kafka-server-stop.sh” para iniciar y detener el servicio. También se especifica que Kafka debe reiniciarse de automáticamente si se cierra de forma anormal.

      Ahora que se definieron las unidades, inicie Kafka con el siguiente comando:

      • sudo systemctl start kafka

      Para asegurarse de que el servidor se haya iniciado de forma correcta, consulte los registros de diario para la unidad kafka:

      Verá resultados similares al siguiente:

      Output

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

      Ahora tiene un servidor de Kafka que escucha en el puerto 9092, que es el predeterminado para Kafka.

      Inició el servicio kafka. Sin embargo, si reinicia su servidor no se iniciará automáticamente. Para habilitar kafka en el arranque del servidor, ejecute lo siguiente:

      • sudo systemctl enable kafka

      Ahora que inició y habilitó los servicios, es hora de verificar la instalación.

      Paso 5: Pruebas de instalación

      Publicaremos y consumiremos un mensaje Hello World para asegurarnos de que el comportamiento del servidor de Kafka sea correcto. Para publicar mensajes en Kafka es necesario lo siguiente:

      • Un productor que permita la publicación de registros y datos en temas.
      • Un consumidor que lea mensajes y datos de temas.

      Primero, cree un tema llamado TutorialTopic escribiendo:

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

      Puede crear un productor desde la línea de comando usando la secuencia de comandos kafka-console-producer.sh. Se necesitan el nombre de host y el puerto del servidor de Kafka, y un nombre de tema como argumentos.

      Publique la cadena Hello, World en el tema TutorialTopic escribiendo lo siguiente:

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

      El indicador --broker-list determina la lista de intermediarios de mensajes a los que se enviará el mensaje (en este caso, localhost:9092). --topic designa el tema como TutorialTopic.

      A continuación, puede crear un consumidor de Kafka usando la secuencia de comandos kafka-console-consumer.sh. Como argumentos, se necesitan el nombre de host y puerto del servidor de ZooKeeper, y un nombre de tema.

      El siguiente comando consume mensajes de TutorialTopic. Tenga en cuenta el uso del indicador de --from-beginning, que permite el consumo de mensajes publicados antes de iniciar el consumidor:

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

      --bootstrap-server ofrece una lista de las entradas en el clúster Kafka. En este caso, utiliza localhost:9092.

      Verá Hello, World en su terminal:

      Output

      Hello, World

      La secuencia de comandos continuará ejecutándose y esperando que se publiquen más mensajes en el tema. Siéntase libre de abrir un terminal nuevo e iniciar un productor para publicar algunos mensajes más. Debería poder verlos a todos en el resultado del consumidor. Si desea obtener más información sobre cómo usar Kafka, consulte la documentación oficial de Kafka.

      Cuando termine de realizar pruebas, presione CTRL+C para detener la secuencia de comandos de consumidor. Ahora que probó la instalación, puede instalar KafkaT para administrar mejor su clúster de Kafka.

      Paso 6: Instalar KafkaT (opcional)

      KafkaT es una herramienta de Airbnb que le permite ver fácilmente detalles sobre su clúster Kafka y realizar algunas tareas administrativas desde la línea de comandos. Debido a que es un gem joya de Ruby, necesitará Ruby para usarlo. También necesitará el paquete build-essential para poder compilar otros gem de los que depende. Realice la instalación usando apt:

      • sudo apt install ruby ruby-dev build-essential

      Ahora podrá instalar KafkaT usando el comando gem:

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

      La opción CFLAGS=-Wno-error=format-overflow deshabilita las advertencias de sobreflujo de formato y es necesaria para la gema de ZooKeeper, que es una dependencia de KafkaT.

      KafkaT utiliza .kafkatcfg como archivo de configuración para determinar los directorios de instalación y registro de su servidor de Kafka. También debe tener una entrada que apunte a KafkaT en su instancia de ZooKeeper.

      Cree un nuevo archivo llamado .kafkatcfg:

      Agregue las siguientes líneas para especificar la información requerida sobre su servidor de Kafka y su instancia de Zookeeper:

      ~/.kafkatcfg

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

      Con esto, estará listo para usar KafkaT. Para comenzar, esta es la forma en que lo utilizaría para ver información sobre todas las particiones de Kafka:

      Verá lo siguiente:

      Output

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

      En este resultado se muestran TutorialTopic y __consumer_offsets, un tema interno que Kafka usa para almacenar información relacionada con el cliente. Puede ignorar líneas de forma segura comenzando con __consumer_offsets.

      Para obtener más información sobre KafkaT, consulte su repositorio de GitHub.

      Ahora que instaló KafkaT, puede configurar de forma opcional Kafka en un clúster de servidores de Debian 10 para crear un clúster de varios nodos.

      Paso 7: Configuración de un clúster multinodo (opcional)

      Si desea crear un clúster de varios gestores usando más servidores de Debian 10, repita los pasos 1, 4 y 5 en cada una de las máquinas nuevas. Además, realice los siguientes cambios en el archivo ~/kafka/config/server.properties para cada uno:

      • Cambie el valor de la propiedad broker.id para que sea único en todo el clúster. Esta propiedad identifica de forma única cada servidor en el clúster y puede tener cualquier cadena como valor. Por ejemplo, "server1" y "server2", entre otros, serían identificadores útiles.

      • Cambie el valor de la propiedad de zookeeper.connect para que todos los nodos apunten a la misma instancia de ZooKeeper. Esta propiedad especifica la dirección de la instancia de ZooKeeper y sigue el formato <HOSTNAME/IP_ADDRESS>:<PORT>. Para este tutorial, utilizaría your_first_server_IP:2181, sustituyendo your_first_server_IP con la dirección IP del servidor de Debian 10 que ya configuró.

      Si desea tener varias instancias de ZooKeeper para su clúster, el valor de la propiedad zookeeper.connect de cada nodo debe ser una cadena idéntica y separada por comas que enumere las direcciones IP y los números de puerto de todas las instancias de ZooKeeper.

      Nota: Si hay un firewall activo en el servidor de Debian 10 con Zookeeper instalado, asegúrese de abrir el puerto 2181 para permitir solicitudes entrantes de los otros nodos del clúster.

      Paso 8: Restricción del usuario de Kafka

      Ahora que todas las instalaciones están listas, puede eliminar los privilegios de administración del usuario kafka. Antes de hacerlo, cierre sesión y vuelva a iniciarla como cualquier otro usuario sudo no root. Si aún ejecuta la misma sesión de shell con la que inició este tutorial , simplemente escriba exit.

      Elimine el usuario kafka del grupo sudo:

      Para mejorar aún más la seguridad de su servidor, bloquee la contraseña del usuario kafka usando el comando passwd. Esto garantiza que nadie pueda iniciar sesión directamente en el servidor usando esta cuenta:

      En este momento, solo un usuario root o sudo puede iniciar sesión como kafka escribiendo el siguiente comando:

      Si desea desbloquearlo posteriormente, utilice passwd con la opción -u:

      De esta manera, ha restringido con éxito los privilegios de administrador del usuario kafka.

      Conclusión

      Ahora, tendrá Apache Kafka activo de forma segura en su servidor de Debian. Puede usarlo en sus proyectos creando productores y consumidores de Kafka usando clientes de Kafka, que están disponibles para la mayoría de los lenguajes de programación. Para obtener más información sobre Kafka, también puede consultar la documentación sobre Apache Kafka.



      Source link