Partie 1 : Commencer avec Kafka
Chapitre 1 : Qu'est-ce que Kafka ?
1.1 Contexte de la naissance de Kafka
1.2 Fonctionnement et principes de Kafka
1.3 Fonctionnalités de Kafka
1.4 Expansion et développement de Kafka
1.5 Résumé

Chapitre 2 : Installation de Kafka et ZooKeeper
2.1 Gestion de ZooKeeper pour Kafka
2.2 Installation de Zookeeper
__2.2.1 Téléchargement de Zookeeper
__2.2.2 Exécution de Zookeeper
2.3 Installation de Kafka
__2.3.1 Télécharger Kafka
__2.3.2 Configuration de Kafka
__2.3.3 Exécution de Kafka
2.4 Vérification de l'état de Kafka
__2.4.1 Vérifier le port TCP
__2.4.2 Vérification des informations Kafka à l'aide d'un nœud ZooKeeper
__2.4.3 Vérifier les journaux Kafka
2.5 Premiers pas avec Kafka
2.6 Résumé

Partie 2 : Concepts de base et guide d'utilisation
Chapitre 3 : Conception kafkaïenne
3.1 Fonctionnalités de conception de Kafka
3.1.1 Systèmes distribués
__3.1.2 Cache de page
__3.1.3 Traitement par lots
3.2 Modèle de données Kafka
3.2.1 Comprendre le sujet
3.2.2 Comprendre les partitions
3.2.3 Décalage et ordre des messages
3.3 Haute disponibilité et réplication de Kafka
3.3.1 Facteur de réplication et rôle des leaders et des suiveurs
3.3.2 Gestion des leaders et des suiveurs
3.4 Si tous les courtiers sont hors service
3.5 Rôle du nœud ZooKeeper utilisé dans Kafka
3.6 Résumé

Chapitre 4 : Le producteur de Kafka
4.1 Envoi d'un message au producteur de la console
4.2 Producteur utilisant Java et Python
4.2.1 Envoyez un message sans le confirmer.
4.2.2 Transmission synchrone
4.2.3 Transfert asynchrone
4.3 Exemples d'utilisation par les producteurs
4.4 Principales options du producteur
4.5 Comment envoyer un message
4.5.1 Lorsque la transmission rapide est requise mais qu'il existe un risque élevé de perte de message
__4.5.1 Lorsqu'il existe une faible possibilité de perte de message et qu'une transmission à une vitesse raisonnable est requise.
4.5.2 Lorsque la vitesse de transmission est lente, mais qu'aucune perte de message ne doit se produire.
4.6 Résumé

Chapitre 5 : Le consommateur Kafka
5.1 Principales options pour les consommateurs
5.2 Récupération des messages avec le consommateur de la console
5.3 Consommateurs utilisant Java et Python
5.4 Partitions et ordre des messages
__5.4.1 peter-01 : ordre des sujets et des messages avec 3 partitions
__5.4.2 peter-02 Ordre des sujets et des messages avec une partition
5.5 Groupe de consommateurs
5.6 Engagement et décalage
__5.6.1 Validation automatique
__5.6.2 Validation manuelle
5.6.3 Attribution d'une partition spécifique
5.6.4 Récupération des messages à partir d'un décalage spécifique
5.7 Résumé

Chapitre 6 : Guide des opérations Kafka
6.1 Commandes Kafka essentielles
__6.1.1 Création d'un sujet
6.1.2 Consultez la liste des sujets
__6.1.3 Détails du sujet
6.1.4 Modification des paramètres du sujet
6.1.5 Modification du nombre de partitions dans un sujet
6.1.6 Modification du facteur de réplication d'un sujet
6.1.7 Consulter la liste des groupes de consommateurs
6.1.8 Vérification du statut et de la compensation du consommateur
6.2 Zookeeper Scale Out
6.3 Mise à l'échelle de Kafka
6.4 Surveillance de Kafka
6.4.1 Configuration de Kafka JMX
__6.4.2 Métriques de surveillance JMX
6.5 Gestionnaire Kafka
6.5.1 Installation du gestionnaire Kafka
6.5.2 Enregistrement d'un cluster Kafka
__6.5.3 Description du menu de Kafka Manager
6.6 Questions et réponses sur les opérations Kafka
6.7 Résumé

Partie 3 : Extensions et applications de Kafka
Chapitre 7 : Création d’un pipeline de données avec Kafka
7.1 Diagramme de flux de données utilisant Kafka
7.2 Envoi de messages via Filebeat
__7.2.1 Installation de Filebeat
__7.2.2 Paramètres de Filebeat
7.2.3 Vérification du flux de messages entrants dans le sujet Kafka
7.3 Récupération des messages à l'aide de NiFi
__7.3.1 Installation de NiFi
__7.3.2 Paramètres NiFi
__7.3.3 Configuration du consommateur avec NiFi
7.4 Stockage des messages dans Elasticsearch pour une analyse en temps réel
__7.4.1 Installation d'Elasticsearch
__7.4.2 Configuration d'Elasticsearch
7.4.3 Envoi de données à Elasticsearch via NiFi
7.5 Vérification des données stockées dans Elasticsearch à l'aide de Kibana
__7.5.1 Installation de Kibana
__7.5.2 Configuration de Kibana
7.6 Reproduction des messages du sujet actuel vers un nouveau sujet
7.6.1 Ajout d'un consommateur Kafka avec NiFi
7.6.2 Routage spécifique au sujet à l'aide de NiFi
7.7 Résumé

Chapitre 8 : API Kafka Streams
8.1 Principes de base du traitement de flux
8.1.1 Traitement en flux continu et traitement par lots
8.1.2 Traitement de flux avec et sans état
8.2 Flux Kafka
8.2.1 Fonctionnalités et concepts de Kafka Streams
8.2.2 Architecture de Kafka Streams
8.3 Configuration de Kafka Streams
8.4 Création d'un programme d'exemple de pipeline
8.5 Création d'un programme d'exemple de fractionnement de lignes
8.6 Création d'un exemple de programme de comptage de fréquence des mots
8.7 Résumé

Chapitre 9 : Traitement de flux avec Kafka SQL
9.1 Contexte de l'émergence de KSQL
9.2 Architecture KSQL et Kappa
9.3 Architecture KSQL
Serveur KSQL __9.3.1
Client KSQL __9.3.2
9.4 Installation d'un cluster KSQL à l'aide de Docker
9.5 Analyse de flux avec KSQL
9.5.1 Préparation des données
__9.5.2 Création de flux et de tables de base
__9.5.3 Création de nouveaux flux et tables à l'aide de requêtes
9.6 Résumé

Chapitre 10 : Autres services de messagerie basés sur le cloud
10.1 Présentation du service Pub/Sub de Google
10.2 Intégration du service Pub/Sub de Google
__10.2.1 Installation du SDK Google
__10.2.2 Utilisation des sujets avec l'interface de ligne de commande Google Pub/Sub
10.3 Utilisation du SDK Python Pub/Sub
__10.3.1 Installation de la bibliothèque Python Pub/Sub
__10.3.2 Créer des identifiants de compte de service Google
__10.3.3 Utilisation du SDK Python
10.4 Présentation du service Amazon Kinesis
10.5 Intégration d'Amazon Kinesis
__10.5.1 Installation de l'interface de ligne de commande Amazon
__10.5.2 Utilisation de Kinesis avec l'interface de ligne de commande Amazon
10.6 Utilisation du SDK Java Amazon Kinesis
__10.6.1 Exemple de code consommateur
__10.6.2 Exemple de code producteur
10.7 Comparaison de Kafka et des services cloud
10.8 Résumé

Annexe : Installation de Kafka avec Docker
A.1 Installation de Docker
__A.1.1 Installation de Docker sous Linux
__A.1.2 Installation de Docker sur Mac
__A.1.3 Installation de Docker sous Windows
A.2 Installation de Kafka avec Docker

La caractéristique la plus importante de l'architecture informatique moderne est qu'il s'agit d'une architecture informatique « faiblement couplée ».
Avec l'avènement du cloud, les ressources informatiques ne sont plus permanentes.
Elle peut disparaître sans que vous le sachiez, ou augmenter soudainement de plusieurs fois, voire de dizaines de fois, grâce à la mise à l'échelle automatique.
Par conséquent, les composants qui constituent un service ne peuvent plus être « fortement couplés » comme auparavant.
Pour donner un exemple simple, dans les environnements informatiques modernes, si l'on s'en tient à l'architecture serveur/client traditionnelle et que l'on communique directement, le serveur avec lequel on communique peut disparaître à tout moment. C'est pourquoi, de nos jours, la communication informatique se fait par échange indirect de données via une messagerie asynchrone, plutôt que par communication directe.


Une autre caractéristique est la centralisation des données au sein de l'entreprise.
Dans les générations précédentes, chaque service d'une entreprise exploitait une couche de pipeline de données (ETL : Extraction, Transformation, Chargement) ou un système d'analyse de données distinct, ce qui rendait les données de l'ensemble de l'entreprise fragmentées et l'analyse complète des données très difficile.
Dans les services précédents, un certain niveau de satisfaction des utilisateurs pouvait être atteint en analysant uniquement les données de chaque service.
Mais dans le monde d'aujourd'hui, où les services sont hautement interconnectés, les choses ont radicalement changé.
Par exemple, pour analyser les clients utilisant le service de messagerie d'une entreprise, il est nécessaire d'analyser non seulement leurs données d'utilisation de ce service, mais aussi leurs données d'utilisation des blogs, des réseaux sociaux et des services photo proposés par cette même entreprise. Vous obtiendrez ainsi des données sur le service client permettant d'évaluer la satisfaction des utilisateurs.


Auparavant, c'était difficile car il n'existait aucun système de bus de services capable de supporter la charge lors de la collecte de tous les événements générés par de nombreux services, mais récemment, avec l'introduction de Kafka, qui est également une application de bus d'événements basée sur un débit élevé, une évolutivité horizontale rapide et une tolérance aux pannes, un niveau satisfaisant de technologie d'analyse est devenu possible.
Par conséquent, un nombre croissant de grandes entreprises spécialisées dans l'analyse de données adoptent Kafka et l'utilisent comme un pipeline de données central essentiel.

Kafka est un système de messagerie traditionnel utilisé non seulement pour le traitement des messages, mais aussi comme pipeline pour le suivi de l'activité des utilisateurs sur un site web et pour l'agrégation des statistiques d'application à utiliser comme données de surveillance.
Auparavant, lorsque des données étaient nécessaires, le temps d'analyse augmentait et l'efficacité diminuait car le travail de demande et d'attente des données auprès de l'organisation chargée de leur gestion était répété d'innombrables fois. Mais grâce à Kafka, l'environnement d'analyse des données évolue rapidement : les événements qui se produisent par ordre chronologique, comme l'event sourcing, sont stockés dans un bus de données appelé Kafka, permettant ainsi aux organisations ou au personnel concernés d'utiliser immédiatement ces données dès qu'ils en ont besoin.


Apache Kafka est une application développée pour gérer la communication asynchrone à très grande échelle et très rapidement.
Depuis sa sortie début 2011, il a été adopté et utilisé comme framework asynchrone dédié par de nombreuses entreprises qui nécessitent une analyse approfondie en temps réel des données des utilisateurs, telles que Netflix, LinkedIn, Airbnb, Microsoft, Uber, Kakao et Line.


Alors que de plus en plus d'entreprises adoptent Kafka comme plateforme centrale au sein de leurs activités, allant au-delà d'un simple service de messagerie, j'espère que ce livre sera d'une grande aide à ceux qui souhaitent comprendre Kafka et construire des systèmes asynchrones et des pipelines de données à l'aide de Kafka.


[Structure de ce livre]
Partie 1 : Commencer avec Kafka
Dans le chapitre 1, Introduction à Kafka, nous examinerons l'histoire de Kafka en analysant les changements survenus dans les systèmes de traitement des données à travers la situation de LinkedIn au moment de la naissance de Kafka.
Nous examinerons également de plus près le fonctionnement de base des systèmes de messagerie et les fonctionnalités de Kafka.

Dans le « Chapitre 2, Installation de Kafka », nous en apprendrons davantage sur ZooKeeper, une application de coordination fiable pour Kafka, une application distribuée représentative, et nous examinerons la relation entre ZooKeeper et Kafka.
Ce livre explique le processus d'installation de ZooKeeper, qui est le plus difficile pour les utilisateurs car il n'est traité en détail dans aucun autre ouvrage, avec des images et du code, et explique en détail, étape par étape, le processus d'installation, d'exécution et de vérification de l'état de Kafka.


Partie 2 : Concepts de base et guide d'utilisation
Le chapitre 3, Kafka Design, couvre les caractéristiques de Kafka, notamment les systèmes distribués, le cache de pages et le traitement par lots, ainsi que le concept de réplication Kafka, caractérisé par des performances et une disponibilité élevées, et les rôles des leaders et des suiveurs.
Nous apprendrons également les termes essentiels utilisés dans Kafka et découvrirons les gnodes de ZooKeeper utilisées dans Kafka.

Dans le « Chapitre 4, Producteur Kafka », nous découvrirons les principales options du producteur, exécuterons un exemple de code du producteur à l'aide du producteur de console, des langages Java et Python, et apprendrons les méthodes de transmission de messages synchrones et asynchrones.
Nous examinerons également de plus près comment transmettre des messages sans perte, en fonction des options du producteur.

Dans le « Chapitre 5, Consommateur Kafka », nous examinerons les principales options du consommateur, implémenterons un consommateur simple et discuterons des précautions à prendre lors de la récupération des messages en fonction du nombre de partitions, ainsi que de la validation automatique, de la validation manuelle et du décalage.

Dans le chapitre 6, « Guide d'utilisation de Kafka », nous examinerons en détail les commandes Kafka essentielles à connaître pour utiliser Kafka et pour surveiller son instance. Nous apprendrons également à installer et à utiliser Kafka Manager, un outil de gestion graphique qui simplifie l'administration de Kafka.
Nous avons également compilé une foire aux questions sur l'exécution de Kafka.

Partie 3 : Extensions et applications de Kafka
Dans le chapitre 7, « Utilisation de Kafka », vous apprendrez à envoyer, récupérer, stocker et analyser des messages à l'aide d'exemples concrets utilisant Elasticsearch, Kibana, Filebeat et d'autres outils populaires. Vous découvrirez également un exemple de configuration d'un pipeline de données avec Apache NiFi.

Dans le chapitre 8 « API Kafka Streams », vous découvrirez le concept du traitement de flux et comment effectuer des analyses en temps réel à l'aide de Kafka sans moteur de streaming séparé tel que Spark ou Storm, grâce à des exemples pratiques.
De plus, nous créerons des programmes qui utiliseront l'API Kafka Streams pour acheminer les flux, diviser les lignes et compter les fréquences des mots.

Dans le chapitre 9, Traitement de flux avec KSQL, nous en apprendrons davantage sur l'historique et l'architecture de KSQL, et examinerons les méthodes d'analyse de flux utilisant KSQL, qui permettent diverses analyses de données en flux continu en temps réel avec de simples requêtes KSQL sans développer d'application séparée.

Dans le chapitre 10, « Autres services de messagerie basés sur le cloud », nous explorerons la présentation, l'intégration et l'utilisation de chaque service, permettant aux entreprises qui ont des difficultés à utiliser Kafka ou à exploiter leurs propres services de messagerie de tirer parti des services de messagerie basés sur le cloud comme alternative à Kafka.
Enfin, nous comparons Kafka à d'autres services de messagerie basés sur le cloud.

Dans l'« Annexe, Installation de Kafka à l'aide de Docker », nous examinerons la méthode d'installation de Kafka utilisant Docker, récemment devenue populaire, pour les versions Linux, Mac et Windows, comme moyen d'utiliser Kafka sans l'installer directement sur le serveur.

[À qui ce livre est destiné]
- Des débutants souhaitant apprendre Kafka aux administrateurs qui utilisent directement Kafka
-Développeurs soucieux de la normalisation des données et du traitement en temps réel
- Les développeurs qui souhaitent utiliser le traitement de données via l'event sourcing
-Développeurs souhaitant collecter, traiter et analyser efficacement des données
Architectes et développeurs qui conçoivent des pipelines de données en temps réel et développent des applications.
- Tous les développeurs responsables du développement de systèmes asynchrones événementiels

[Contenu et caractéristiques de ce livre]
- Contexte de naissance et principes de fonctionnement de Kafka
- Instructions détaillées pour l'installation de ZooKeeper et Kafka et la configuration du cluster.
- Exemple de code et d'utilisation des producteurs et consommateurs Kafka en Java et Python
- Description des commandes clés nécessaires au fonctionnement de Kafka
- Guide pour ajouter des nœuds et faire évoluer ZooKeeper et Kafka
-Installation et utilisation de Kafka Manager, un outil GUI pratique
- Architecture majeure de Kafka expliquée à l'aide de schémas faciles à comprendre
Guide complet de l'analyse de flux en temps réel avec Kafka
Exemple de configuration d'un pipeline de données utilisant Elasticsearch et Apache NiFi

[Note de l'auteur]
Il y a plusieurs années, Kakao a commencé à utiliser Kafka comme pipeline de données pour chaque service.
Puis, une proposition est parvenue à l'équipe d'infrastructure à laquelle j'appartenais pour exploiter Kafka pour un service spécifique, et « par hasard », j'ai accepté l'offre sans hésiter et j'ai commencé à étudier et à me former sérieusement à Kafka.
Mais à l'époque, ce que je trouvais sur Internet était très simple, et la plupart du temps il ne s'agissait que d'instructions d'installation ou de guides de démarrage rapide.
Au fur et à mesure que j'apprenais à utiliser Kafka et que je l'appliquais à mon travail, j'ai été complètement captivé par le charme et les hautes performances de Kafka.
Plutôt que de me contenter d'utiliser Kafka au sein de l'équipe, j'ai eu l'idée de mettre en place un service Kafka partagé à l'échelle de l'entreprise, qui intégrerait les instances Kafka réparties entre les différents départements. Grâce au soutien et aux encouragements de nombreuses personnes de mon entourage, j'ai rapidement concrétisé cette idée.

Tout en étudiant Kafka en autodidacte et en travaillant dans ce domaine, j'ai commencé à penser qu'il serait judicieux de partager les connaissances et l'expérience que j'avais acquises avec d'autres développeurs. Sur la recommandation d'un collègue, j'ai alors commencé à contribuer à la plateforme de partage de connaissances Popit (popit.kr) en rédigeant des articles sur Kafka, ce qui a abouti à la rédaction d'un livre.
- Go Seung-beom (Pierre)

S'il fallait choisir l'élément le plus important de la conception de l'architecture informatique moderne, ce serait le pipeline de données.
Même s'il ne s'agit pas d'une plateforme cloud populaire, il est crucial de collecter les données provenant de diverses ressources virtuelles et les informations sur l'activité des utilisateurs (telles que le nombre de clics, le temps passé sur la page, le panier d'achat, les informations d'achat et l'heure d'achat) générées par les services fournis par ces ressources, de les traiter de manière appropriée, puis de fournir aux utilisateurs les informations appropriées.

L'un des plus grands défis auxquels j'ai été confronté au fil des années de développement de plateformes de données a été de créer une plateforme logicielle capable de gérer d'énormes quantités de données avec une grande agilité et tolérante aux pannes.
C'est comme créer une sorte d'épine dorsale dans le réseau de canalisations.
J'avais déjà créé une solution à cet effet en utilisant uniquement ZooKeeper, mais ses performances n'étaient pas à la hauteur de mes attentes, ce qui m'inquiétait. Cependant, après avoir découvert la solution open source Kafka, la création de ce pipeline de données est devenue beaucoup plus simple.
J'ai écrit ce livre pour partager mes expériences de cette époque avec mes lecteurs.

La plupart des dispositifs qui prennent des décisions à l'aide d'algorithmes, qu'il s'agisse d'intelligence artificielle ou de voitures autonomes, suivent un flux qui se compose d'une série de processus : la collecte d'informations externes (Sense), l'analyse de ces informations pour prendre une décision (Plan), et l'application de la décision (Act).
Ce livre est spécifiquement consacré à la section « Planification des données », qui vous permet de collecter des données et d'effectuer certaines analyses.
Si vous êtes curieux de connaître l'aspect Plan-Act de l'analyse des données dans le cloud, je vous recommande la lecture de mon livre « Big Data Analysis Using Cloud APIs » (Acorn Publishing, 2015).
- Andrew Gong