Comment installer kafka sur RHEL 8

Apache Kafka est une plateforme de streaming distribuée. Avec son riche ensemble d'API (Application Programming Interface), nous pouvons connecter presque n'importe quoi à Kafka en tant que source de données, et à l'autre extrémité, nous pouvons configurer un grand nombre de consommateurs qui recevront le flux d'enregistrements à traiter. Kafka est hautement évolutif et stocke les flux de données de manière fiable et tolérante aux pannes. Du point de vue de la connectivité, Kafka peut servir de pont entre de nombreux systèmes hétérogènes, qui à leur tour peuvent compter sur ses capacités pour transférer et conserver les données fournies.

Dans ce tutoriel, nous allons installer Apache Kafka sur une Red Hat Enterprise Linux 8, créer le systemd fichiers d'unité pour faciliter la gestion et tester la fonctionnalité avec les outils de ligne de commande fournis.

Dans ce didacticiel, vous apprendrez :

Comment installer Apache Kafka
Comment créer des services systemd pour Kafka et Zookeeper
Comment tester Kafka avec des clients en ligne de commande

Consommer des messages sur le sujet Kafka à partir de la ligne de commande.

Configuration logicielle requise et conventions utilisées

Configuration logicielle requise et conventions de ligne de commande Linux
Catégorie	Exigences, conventions ou version du logiciel utilisée
Système	Red Hat Enterprise Linux 8
Logiciel	Apache Kafka 2.11
Autre	Accès privilégié à votre système Linux en tant que root ou via le `sudo` commande.
Conventions	# - nécessite que les commandes linux données soient exécutées avec les privilèges root soit directement en tant qu'utilisateur root, soit en utilisant `sudo` commande $ – nécessite que les commandes linux données soient exécutées en tant qu'utilisateur normal non privilégié

Comment installer kafka sur Redhat 8 instructions étape par étape

Apache Kafka est écrit en Java, il nous suffit donc d'installer OpenJDK 8 pour procéder à l'installation. Kafka s'appuie sur Apache Zookeeper, un service de coordination distribué, également écrit en Java, et livré avec le package que nous allons télécharger. Bien que l'installation de services HA (haute disponibilité) sur un seul nœud tue leur objectif, nous installerons et exécuterons Zookeeper pour le bien de Kafka.

Pour télécharger Kafka depuis le miroir le plus proche, nous devons consulter le site de téléchargement officiel. Nous pouvons copier l'URL du .tar.gz fichier à partir de là. Nous utiliserons wget , et l'URL collée pour télécharger le package sur la machine cible :
```
# wget https://www-eu.apache.org/dist/kafka/2.1.0/kafka_2.11-2.1.0.tgz -O /opt/kafka_2.11-2.1.0.tgz
```
Nous saisissons le /opt et extrayez l'archive :
```
# cd /opt
# tar -xvf kafka_2.11-2.1.0.tgz
```
Et créez un lien symbolique appelé /opt/kafka qui pointe vers le /opt/kafka_2_11-2.1.0 maintenant créé annuaire pour nous faciliter la vie.
```
ln -s /opt/kafka_2.11-2.1.0 /opt/kafka
```
Nous créons un utilisateur non privilégié qui exécutera à la fois zookeeper et kafka service.
```
# useradd kafka
```
Et définissez le nouvel utilisateur comme propriétaire de l'ensemble du répertoire que nous avons extrait, de manière récursive :
```
# chown -R kafka:kafka /opt/kafka*
```

Nous créons le fichier unité /etc/systemd/system/zookeeper.service avec le contenu suivant :

[Unit]
Description=zookeeper
After=syslog.target network.target

[Service]
Type=simple

User=kafka
Group=kafka

ExecStart=/opt/kafka/bin/zookeeper-server-start.sh /opt/kafka/config/zookeeper.properties
ExecStop=/opt/kafka/bin/zookeeper-server-stop.sh

[Install]
WantedBy=multi-user.target

Notez que nous n'avons pas besoin d'écrire le numéro de version trois fois à cause du lien symbolique que nous avons créé. Il en va de même pour le fichier d'unité suivant pour Kafka, /etc/systemd/system/kafka.service , qui contient les lignes de configuration suivantes :

[Unit]
Description=Apache Kafka
Requires=zookeeper.service
After=zookeeper.service

[Service]
Type=simple

User=kafka
Group=kafka

ExecStart=/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/server.properties
ExecStop=/opt/kafka/bin/kafka-server-stop.sh

[Install]
WantedBy=multi-user.target

Nous devons recharger systemd pour l'obtenir, lisez les nouveaux fichiers d'unité :
```
# systemctl daemon-reload
```

Nous pouvons maintenant démarrer nos nouveaux services (dans cet ordre) :

# systemctl start zookeeper
# systemctl start kafka

Si tout va bien, systemd doit signaler l'état d'exécution sur l'état des deux services, similaire aux sorties ci-dessous :

# systemctl status zookeeper.service
  zookeeper.service - zookeeper
   Loaded: loaded (/etc/systemd/system/zookeeper.service; disabled; vendor preset: disabled)
   Active: active (running) since Thu 2019-01-10 20:44:37 CET; 6s ago
 Main PID: 11628 (java)
    Tasks: 23 (limit: 12544)
   Memory: 57.0M
   CGroup: /system.slice/zookeeper.service
            11628 java -Xmx512M -Xms512M -server [...]

# systemctl status kafka.service
  kafka.service - Apache Kafka
   Loaded: loaded (/etc/systemd/system/kafka.service; disabled; vendor preset: disabled)
   Active: active (running) since Thu 2019-01-10 20:45:11 CET; 11s ago
 Main PID: 11949 (java)
    Tasks: 64 (limit: 12544)
   Memory: 322.2M
   CGroup: /system.slice/kafka.service
            11949 java -Xmx1G -Xms1G -server [...]

En option, nous pouvons activer le démarrage automatique au démarrage pour les deux services :
```
# systemctl enable zookeeper.service
# systemctl enable kafka.service
```
Pour tester les fonctionnalités, nous allons nous connecter à Kafka avec un client producteur et un client consommateur. Les messages fournis par le producteur doivent apparaître sur la console du consommateur. Mais avant cela, nous avons besoin d'un support sur lequel ces deux messages d'échange s'échangent. Nous créons un nouveau canal de données appelé topic selon les termes de Kafka, où le fournisseur publiera et où le consommateur s'abonnera. Nous appellerons le sujet
FirstKafkaTopic . Nous utiliserons le kafka utilisateur pour créer le sujet :
```
$ /opt/kafka/bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic FirstKafkaTopic
```
Nous démarrons un client consommateur à partir de la ligne de commande qui s'abonnera au sujet (à ce stade vide) créé à l'étape précédente :
```
$ /opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic FirstKafkaTopic --from-beginning
```
Nous laissons la console et le client qui s'y exécute ouverts. Cette console est l'endroit où nous recevrons le message que nous publions avec le client producteur.
Sur un autre terminal, nous démarrons un client producteur et publions des messages sur le sujet que nous avons créé. Nous pouvons interroger Kafka pour les sujets disponibles :
```
$ /opt/kafka/bin/kafka-topics.sh --list --zookeeper localhost:2181
FirstKafkaTopic
```
Et connectez-vous à celui auquel le consommateur est abonné, puis envoyez un message :
```
$ /opt/kafka/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic FirstKafkaTopic
> new message published by producer from console #2
```
Sur le terminal consommateur, le message devrait apparaître sous peu :
```
$ /opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic FirstKafkaTopic --from-beginning
 new message published by producer from console #2
```
Si le message apparaît, notre test est réussi et notre installation de Kafka fonctionne comme prévu. De nombreux clients peuvent fournir et utiliser un ou plusieurs enregistrements de sujet de la même manière, même avec une configuration de nœud unique que nous avons créée dans ce didacticiel.