One place for hosting & domains

      Kafka

      How To Install Apache Kafka on Debian 10


      The author selected the Free and Open Source Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Apache Kafka is a popular distributed message broker designed to handle large volumes of real-time data. A Kafka cluster is highly scalable and fault-tolerant, and also has a much higher throughput compared to other message brokers such as ActiveMQ and RabbitMQ. Though it is generally used as a publish/subscribe messaging system, a lot of organizations also use it for log aggregation because it offers persistent storage for published messages.

      A publish/subscribe messaging system allows one or more producers to publish messages without considering the number of consumers or how they will process the messages. Subscribed clients are notified automatically about updates and the creation of new messages. This system is more efficient and scalable than systems where clients poll periodically to determine if new messages are available.

      In this tutorial, you will install and configure Apache Kafka 2.1.1 securely on a Debian 10 server, then test your setup by producing and consuming a Hello World message. You will then optionally install KafkaT to monitor Kafka and set up a Kafka multi-node cluster.

      Prerequisites

      To follow along, you will need:

      Note: Installations without 4GB of RAM may cause the Kafka service to fail, with the Java virtual machine (JVM) throwing an Out Of Memory exception during startup.

      Step 1 — Creating a User for Kafka

      Since Kafka can handle requests over a network, it is a best practice to create a dedicated user for it. This minimizes damage to your Debian machine should the Kafka server be compromised. You will create the dedicated user kafka in this step.

      Logged in as your non-root sudo user, create a user called kafka with the useradd command:

      The -m flag ensures that a home directory will be created for the user. This home directory, /home/kafka, will act as your workspace directory for executing commands later on.

      Set the password using passwd:

      Enter the password you wish to use for this user.

      Next, add the kafka user to the sudo group with the adduser command, so that it has the privileges required to install Kafka’s dependencies:

      Your kafka user is now ready. Log into this account using su:

      Now that you’ve created the Kafka-specific user, you can move on to downloading and extracting the Kafka binaries.

      Step 2 — Downloading and Extracting the Kafka Binaries

      In this step, you will download and extract the Kafka binaries into dedicated folders in your kafka user’s home directory.

      To start, create a directory in /home/kafka called Downloads to store your downloads:

      Next, install curl using apt-get so that you’ll be able to download remote files:

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

      When prompted, type Y to confirm the curl download.

      Once curl is installed, use it to download the Kafka binaries:

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

      Create a directory called kafka and change to this directory. This will be the base directory of the Kafka installation:

      • mkdir ~/kafka && cd ~/kafka

      Extract the archive you downloaded using the tar command:

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

      You specified the --strip 1 flag to ensure that the archive’s contents are extracted in ~/kafka/ itself and not in another directory inside of it, such as ~/kafka/kafka_2.12-2.1.1/.

      Now that you’ve downloaded and extracted the binaries successfully, you can move on to configuring Kafka to allow for topic deletion.

      Step 3 — Configuring the Kafka Server

      Kafka’s default behavior will not allow us to delete a topic, the category, group, or feed name to which messages can be published. To modify this, you will edit the configuration file.

      Kafka’s configuration options are specified in server.properties. Open this file with nano or your favorite editor:

      • nano ~/kafka/config/server.properties

      Let’s add a setting that will allow us to delete Kafka topics. Add the following highlighted line to the bottom of the file:

      ~/kafka/config/server.properties

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

      Save the file, and exit nano. Now that you’ve configured Kafka, you can create systemd unit files for running and enabling Kafka on startup.

      Step 4 — Creating Systemd Unit Files and Starting the Kafka Server

      In this section, you will create systemd unit files for the Kafka service. This will help you perform common service actions such as starting, stopping, and restarting Kafka in a manner consistent with other Linux services.

      ZooKeeper is a service that Kafka uses to manage its cluster state and configurations. It is commonly used in distributed systems as an integral component. In this tutorial, you will use Zookeeper to manage these aspects of Kafka. If you would like to know more about it, visit the official ZooKeeper docs.

      First, create the unit file for zookeeper:

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

      Enter the following unit definition into the file:

      /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
      

      The [Unit] section specifies that ZooKeeper requires networking and for the filesystem to be ready before it can start.

      The [Service] section specifies that systemd should use the zookeeper-server-start.sh and zookeeper-server-stop.sh shell files for starting and stopping the service. It also specifies that ZooKeeper should be restarted automatically if it exits abnormally.

      Next, create the systemd service file for kafka:

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

      Enter the following unit definition into the file:

      /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
      

      The [Unit] section specifies that this unit file depends on zookeeper.service. This will ensure that zookeeper gets started automatically when the kafka service starts.

      The [Service] section specifies that systemd should use the kafka-server-start.sh and kafka-server-stop.sh shell files for starting and stopping the service. It also specifies that Kafka should be restarted automatically if it exits abnormally.

      Now that the units have been defined, start Kafka with the following command:

      • sudo systemctl start kafka

      To ensure that the server has started successfully, check the journal logs for the kafka unit:

      You will see output similar to the following:

      Output

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

      You now have a Kafka server listening on port 9092, which is the default port for Kafka.

      You have started the kafka service, but if you were to reboot your server, it would not yet be started automatically. To enable kafka on server boot, run:

      • sudo systemctl enable kafka

      Now that you’ve started and enabled the services, it’s time to check the installation.

      Step 5 — Testing the Installation

      Let’s publish and consume a Hello World message to make sure the Kafka server is behaving correctly. Publishing messages in Kafka requires:

      • A producer, which enables the publication of records and data to topics.
      • A consumer, which reads messages and data from topics.

      First, create a topic named TutorialTopic by typing:

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

      You can create a producer from the command line using the kafka-console-producer.sh script. It expects the Kafka server’s hostname, port, and a topic name as arguments.

      Publish the string Hello, World to the TutorialTopic topic by typing:

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

      The --broker-list flag determines the list of message brokers to send the message to, in this case localhost:9092. --topic designates the topic as TutorialTopic.

      Next, you can create a Kafka consumer using the kafka-console-consumer.sh script. It expects the ZooKeeper server’s hostname and port and a topic name as arguments.

      The following command consumes messages from TutorialTopic. Note the use of the --from-beginning flag, which allows the consumption of messages that were published before the consumer was started:

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

      --bootstrap-server provides a list of ingresses into the Kafka cluster. In this case, you are using localhost:9092.

      You will see Hello, World in your terminal:

      Output

      Hello, World

      The script will continue to run, waiting for more messages to be published to the topic. Feel free to open a new terminal and start a producer to publish a few more messages. You should be able to see them all in the consumer’s output. If you’d like to learn more about how to use Kafka, see the official Kafka documentation.

      When you are done testing, press CTRL+C to stop the consumer script. Now that you have tested the installation, you can move on to installing KafkaT in order to better administer your Kafka cluster.

      Step 6 — Installing KafkaT (Optional)

      KafkaT is a tool from Airbnb that makes it easier for you to view details about your Kafka cluster and perform certain administrative tasks from the command line. Because it is a Ruby gem, you will need Ruby to use it. You will also need the build-essential package to be able to build the other gems it depends on. Install them using apt:

      • sudo apt install ruby ruby-dev build-essential

      You can now install KafkaT using the gem command:

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

      The CFLAGS=-Wno-error=format-overflow option disables format overflow warnings and is required for the ZooKeeper gem, which is a dependency of KafkaT.

      KafkaT uses .kafkatcfg as the configuration file to determine the installation and log directories of your Kafka server. It should also have an entry pointing KafkaT to your ZooKeeper instance.

      Create a new file called .kafkatcfg:

      Add the following lines to specify the required information about your Kafka server and Zookeeper instance:

      ~/.kafkatcfg

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

      You are now ready to use KafkaT. For a start, here’s how you would use it to view details about all Kafka partitions:

      You will see the following output:

      Output

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

      This output shows TutorialTopic, as well as __consumer_offsets, an internal topic used by Kafka for storing client-related information. You can safely ignore lines starting with __consumer_offsets.

      To learn more about KafkaT, refer to its GitHub repository.

      Now that you have installed KafkaT, you can optionally set up Kafka on a cluster of Debian 10 servers to make a multi-node cluster.

      Step 7 — Setting Up a Multi-Node Cluster (Optional)

      If you want to create a multi-broker cluster using more Debian 10 servers, repeat Step 1, Step 4, and Step 5 on each of the new machines. Additionally, make the following changes in the ~/kafka/config/server.properties file for each:

      • Change the value of the broker.id property such that it is unique throughout the cluster. This property uniquely identifies each server in the cluster and can have any string as its value. For example, "server1", "server2", etc., would be useful as identifiers.

      • Change the value of the zookeeper.connect property such that all nodes point to the same ZooKeeper instance. This property specifies the ZooKeeper instance’s address and follows the <HOSTNAME/IP_ADDRESS>:<PORT> format. For this tutorial, you would use your_first_server_IP:2181, replacing your_first_server_IP with the IP address of the Debian 10 server you already set up.

      If you want to have multiple ZooKeeper instances for your cluster, the value of the zookeeper.connect property on each node should be an identical, comma-separated string listing the IP addresses and port numbers of all the ZooKeeper instances.

      Note: If you have a firewall activated on the Debian 10 server with Zookeeper installed, make sure to open up port 2181 to allow for incoming requests from the other nodes in the cluster.

      Step 8 — Restricting the Kafka User

      Now that all of the installations are done, you can remove the kafka user’s admin privileges. Before you do so, log out and log back in as any other non-root sudo user. If you are still running the same shell session you started this tutorial with, simply type exit.

      Remove the kafka user from the sudo group:

      To further improve your Kafka server’s security, lock the kafka user’s password using the passwd command. This makes sure that nobody can directly log into the server using this account:

      At this point, only root or a sudo user can log in as kafka by typing in the following command:

      In the future, if you want to unlock it, use passwd with the -u option:

      You have now successfully restricted the kafka user’s admin privileges.

      Conclusion

      You now have Apache Kafka running securely on your Debian server. You can make use of it in your projects by creating Kafka producers and consumers using Kafka clients, which are available for most programming languages. To learn more about Kafka, you can also consult the Apache Kafka documentation.



      Source link

      Como instalar o Apache Kafka no Ubuntu 18.04


      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 message broker popularmente distribuído projetado para lidar de forma eficiente com grandes volumes de dados em tempo real. Um cluster Kafka é não só altamente escalável e tolerante a falhas, mas ele também tem uma taxa de transferência muito mais alta comparada com outros message brokers como o ActiveMQ e 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ê instalará e usará o Apache Kafka 2.1.1 no Ubuntu 18.04.

      Pré-requisitos

      Para acompanhar, você precisará de:

      • Um servidor Ubuntu 18.04 e um usuário que não seja o root com privilégios sudo. Siga os passos especificados neste guia se não tiver um usuário que não seja root configurado.
      • Pelo menos 4GB de RAM no servidor. As instalações sem essa quantidade de RAM podem fazer com que o serviço Kafka falhe, com a máquina virtual Java (JVM) que lança uma exceção “Fora de Memória” durante a inicialização.
      • OpenJDK 8 instalado no seu servidor. Para instalar essa versão, siga essas instruções sobre a instalação de versões específicas do OpenJDK. O Kafka está escrito em Java, de modo que ele exige um JVM; no entanto, o script de inicialização shell possui um erro de detecção de versão que faz com que ele não comece com versões JVM acima de 8.

      Passo 1 — Criando um Usuário para o Kafka

      Uma vez que o Kafka pode lidar com pedidos em uma rede, você deve criar um usuário dedicado para ele. Isso minimiza os danos na sua máquina Ubuntu caso o servidor Kafka seja comprometido. Criaremos um usuário *kafka *dedicado neste passo, mas você deve criar um usuário que não seja root para executar outras tarefas neste servidor uma vez que você tenha terminado de configurar o Kafka.

      Logado como usuário sudo que não seja root, crie um usuário chamado kafka com o comando useradd:

      A flag -m garante que um diretório home seja criada para o usuário. Este diretório home, /home/kafka, agirá como nossa pasta de trabalho para executar comandos nas seções abaixo.

      Defina a senha usando passwd:

      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. Logue nesta conta usando su:

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

      Vamos baixar e extrair os binários Kafka em pastas dedicadas no diretório home do nosso usuário kafka.

      Para começar, crie uma pasta em /home/kafka chamada Downloads para armazenar os seus downloads:

      Use curl para baixar os binários Kafka:

      • curl "https://www.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

      Especificamos a flag --strip 1 para garantir que o conteúdo do arquivo seja extraído efetivamente em ~/kafka/ e não em outro diretório (como ~/kafka/kafka_2.11-2.1.1/) dentro dele.

      Agora que baixamos e extraímos os binários com sucesso, podemos começar a configurar para que o Kafka permita que deletemos 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, vamos editar o arquivo de configuração.

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

      • nano ~/kafka/config/server.properties

      Vamos adicionar um valor que nos permitirá excluir tópicos do Kafka. Adicione o seguinte ao final do arquivo:

      ~/kafka/config/server.properties

      delete.topic.enable = true
      

      Salve o arquivo e saia do nano. Agora que configuramos o Kafka, podemos seguir para a criação de arquivos de unidade systemd para a executá-lo e permiti-lo na inicialização.

      Passo 4 — Criando Arquivos de Unidade Systemd e Iniciando o Servidor do Kafka

      Nesta seção, criaremos arquivos de unidade systemd para o serviço do Kafka. Isso nos ajudará a realizar 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 configurações. É geralmente usado em muitos sistemas distribuídos como um componente integral. Se você quer saber mais sobre isso, visite os documentos Zookeeper oficiais.

      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-start.sh para começar e parar o serviço. Ele também especifica que o Zookeeper deve ser reiniciado automaticamente se ele fechar 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.sh e kafka-server-stop.sh para começar e parar o serviço. Ele também especifica que o Zookeeper deve ser reiniciado automaticamente se ele fechar inexplicavelmente.

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

      • sudo systemctl start kafka

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

      Você deve ver um resultado similar ao seguinte:

      Output

      Jul 17 18:38:59 kafka-ubuntu systemd[1]: Started kafka.service.

      Agora, você tem um servidor do Kafka escutando na porta 9092.

      Enquanto inicializávamos o serviço kafka, se nós pudéssemos reiniciar nosso servidor, ele não seria iniciado automaticamente. Para ativar o kafka na inicialização do servidor, execute:

      • sudo systemctl enable kafka

      Agora que começamos e ativamos os serviços, vamos verificar a instalação.

      Passo 5 — Testando a Instalação

      Vamos publicar e consumir uma mensagem “Hello World” para garantir que o servidor do Kafka está se comportando corretamente. Publicando mensagens no Kafka exige:

      • Um produtor que permite a publicação de registros e dados em tópicos.
      • Um consumidor que lê mensagens e dados de 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. Ele recebe o nome do host do servidor do Kafka, porta e um nome de tópico como argumentos.

      Publique o 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

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

      O comando a seguir consome mensagens do TutorialTopic. Observe o uso da flag --from-beginning que permite o consumo de mensagens que foram publicadas antes do início do consumidor:

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

      Se não houver problemas de configuração, você deve 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ê deve poder ver todas elas na saída do consumidor.

      Quando você acabar os testes, pressione CTRL+C para parar o script do consumidor. Agora que testamos a instalação, vamos prosseguir para a instalação do KafkaT.

      Passo 6 — Instalar 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 Ruby, você precisará do Ruby para usá-la. Você também precisará do pacote build-essential para poder construir outras gems das quais ele depende. Instale-os usando o apt:

      • sudo apt install ruby ruby-dev build-essential

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

      O KafkaT usa .kafkatcfg como o arquivo de configuração para determinar os diretórios e registro da instalação do seu servidor do Kafka. Ele também deve ter uma entrada apontando o KafkaT para a sua instância 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 um começo, veja como você usaria ele para ver os detalhes sobre 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] ... ...

      Você verá 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.

      Passo 7 — Configurando um Cluster Multi-Nodal (Opcional)

      Se você quer criar um cluster multi-broker usando mais máquinas Ubuntu 18.04, você deve repetir o passo 1, passo 4, e o passo 5 em cada uma das novas máquinas. Além disso, você deve fazer as seguintes alterações no arquivo server.properties para cada um deles:

      • O valor da propriedade broker.id deve ser alterado de modo que ele seja único ao longo do cluster. Esta propriedade identifica separadamente cada servidor no cluster e pode ter qualquer string como seu valor. Por exemplo, "server1", "server2", etc.

      • O valor da propriedade zookeeper.connect deve ser alterado de modo que todos os nós apontem para a mesma instância do ZooKeeper. Esta propriedade especifica o endereço da instância do Zookeeper e segue o formato :<PORT>. Por exemplo, "203.0.113.0:2181", "203.0.113.1:2181" etc.

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

      Passo 8 — Restringindo o Utilizador 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, saia e logue novamente como se fosse qualquer outro usuário sudo que não seja root. Se você ainda estiver executando a mesma sessão de shell com a qual você tenha iniciado este tutorial, simplesmente digite exit.

      Remova o usuário kafka do grupo sudo:

      Para melhorar ainda mais a segurança do seu servidor Kafka, trave a senha do usuário kafka usando o comando passwd. Isso faz com que ninguém possa logar diretamente no servidor usando essa conta:

      Neste ponto, apenas root ou um usuário sudo pode logar como kafka digitando o comando a seguir:

      No futuro, se você quer destravá-lo, use 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 funcionando com segurança no seu servidor Ubuntu. Você pode usar isso nos seus projetos criando produtores do Kafka e consumidores usando clientes do Kafka, que estão disponíveis para a maioria das linguagens de programação. Para saber mais sobre o Kafka, você também pode consultar a sua documentação.



      Source link

      Cómo instalar Apache Kafka en Ubuntu 18.04


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

      Introducción

      Apache Kafka es un intermediario de mensajes de distribución popular diseñado para gestionar de manera eficaz grandes volúmenes de datos en tiempo real. Un clúster Kafka no solo es escalable y tolerante a fallas, sino también tiene un rendimiento mucho más alto 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.

      En este tutorial, instalará y usará Apache Kafka 2.1.1 en Ubuntu 18.04.

      Requisitos previos

      Para continuar, necesitará lo siguiente:

      • Un servidor Ubuntu 18.04 y un usuario no root con privilegios sudo. Siga los pasos especificados en esta guía si no dispone de un usuario no root configurado.
      • Al menos 4 GB de RAM en el servidor. En instalaciones que no cuenten con esta cantidad de RAM, el servicio de Kafka puede fallar; la máquina virtual Java (JVM) muestra una excepción de “memoria insuficiente” durante el inicio.
      • OpenJDK 8 instalado en su servidor. Para instalar esta versión, siga estas instrucciones sobre la instalación de versiones específicas de OpenJDK. Kafka está escrito en Java, de forma que requiere una JVM; sin embargo, el script de su shell de arranque tiene un error de detección de versión que le impide iniciarse con las versiones de JVM posteriores a la 8.

      Paso 1: Creación de un usuario para Kafka

      Dado que Kafka puede gestionar las solicitudes a través de una red, debería crear un usuario dedicado para ella. Esto minimizará el daño al que se exponga su máquina con Ubuntu si el servidor Kafka se ve comprometido. En este paso, crearemos un usuario kafka dedicado. Sin embargo, debería crear un usuario no root diferente para realizar otras tareas en este servidor una vez que termine de configurar Kafka.

      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 nuestro directorio de espacios de trabajo para ejecutar comandos en las secciones que se muestran a continuación.

      Establezca la contraseña usando passwd:

      Añada el usuario kafka al grupo sudo con el comando adduser, de manera 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 creamos el usuario específico de Kafka, podemos descargar y extraer los archivos binarios de Kafka.

      Procederemos a descargar los archivos binarios de Kafka y extraerlos en carpetas dedicadas, en el directorio de inicio de nuestro usuario kafka.

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

      Utilice curl para descargar los archivos binarios de Kafka:

      • curl "https://www.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

      Especificamos el indicador --strip 1 para asegurarnos de que los contenidos del archivo se extraigan en ~/kafka/ y no en otro directorio (como ~/kafka/kafka_2.11-2.1.1/) dentro de él.

      Ahora que descargamos y extrajimos los archivos binarios de forma correcta, podemos proceder con la configuración de 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, editemos 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 lo siguiente a la parte inferior del archivo:

      ~/kafka/config/server.properties

      delete.topic.enable = true
      

      Guarde el archivo y cierre nano. Ahora que configuramos Kafka, podemos crear archivos de unidad systemd para ejecutarlo y habilitarlo en el inicio.

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

      En esta sección, crearemos archivos de unidad systemd para el servicio Kafka. Esto nos ayudará a 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 utiliza Kafka para administrar el estado de sus clústeres y sus configuraciones. Se utiliza comúnmente en muchos sistemas distribuidos como componente integral. Si desea obtener más información más sobre él, consulte los documentos oficiales de Zookeeper.

      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 sistemd 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 se cierra de forma anormal.

      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:

      El resultado debe ser similar al siguiente:

      Output

      Jul 17 18:38:59 kafka-ubuntu systemd[1]: Started kafka.service.

      Ahora tiene un servidor Kafka que escucha en el puerto 9092.

      Aunque iniciamos el servicio kafka, si reiniciáramos nuestro servidor este no se iniciaría de forma automática. Para habilitar kafka en el arranque del servidor, ejecute lo siguiente:

      • sudo systemctl enable kafka

      Ahora que iniciamos y habilitamos los servicios, revisemos la instalación.

      Paso 5: Pruebas de instalación

      Publicaremos y consumiremos un mensaje “Hello World” para asegurarnos de que el comportamiento del servidor 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 el script 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

      A continuación, puede crear un consumidor de Kafka usando el script 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

      Si no hay problemas de configuración, verá Hello, World en su terminal:

      Output

      Hello, World

      El script continuará ejecutándose y esperando a 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.

      Cuando termine de realizar pruebas, presione CTRL+C para detener el script de consumidor. Ahora que probamos la instalación, procederemos a instalar KafkaT.

      Paso 6: Instalación de 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:

      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] ... ...

      Verá TutorialTopic, así como __consumer_offsets, un tema interno que Kafka utiliza 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.

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

      Si desea crear un clúster multibroker usando más máquinas Ubuntu 18.04, debe repetir los pasos 1, 4 y 5 en cada una de los nuevas máquinas. Además, debe realizar los siguientes cambios en el archivo server.properties para cada una:

      • El valor de la propiedad broker.id debe cambiarse de modo 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”, “server2”, etc.

      • El valor de la propiedad de zookeeper.connect debe cambiarse de forma que todos los nodos apunten a la misma instancia de ZooKeeper. Esta propiedad especifica la dirección de la instancia de Zookeeper y sigue formato :<PORT>. Por ejemplo, "203.0.113.0:2181", "203.0.113.1:2181", etc.

      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.

      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

      Con esto, ha logrado hacer funcionar Apache Kafka de forma segura en su servidor Ubuntu. 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 este.



      Source link