Kafka et Docker expliqués : configuration, bonnes pratiques et conseils

Dans l’univers des pipelines de données modernes et des microservices, Apache Kafka s’impose comme la solution incontournable pour gérer les flux d’événements en temps réel et intégrer des systèmes distribués. À mesure que les équipes d’ingénierie adoptent des architectures extensibles et pilotées par les événements, Kafka devient central pour des échanges de données fiables. 

Parallèlement, Docker s’est imposé comme le moyen privilégié pour développer, partager et déployer des services complexes sans craindre les écarts d’environnements ou les problèmes locaux. 

En utilisant Docker pour exécuter Kafka, les équipes peuvent lancer rapidement des clusters proches de la production pour des tests, des démonstrations de preuve de concept, voire des charges de travail en production. 

Cet article s’adresse aux développeurs back-end intermédiaires, aux ingénieurs DevOps et à toute personne impliquée dans la gestion de plateformes de données, souhaitant rendre l’utilisation de Kafka simple et reproductible.

Si vous débutez avec Kafka ou Docker, consultez notre Introduction to Apache Kafka ou Docker for Beginners: A Practical Guide to Containers.

Qu’est-ce que Kafka et pourquoi utiliser Docker ?

Apache Kafka est une plateforme de streaming distribuée conçue pour une messagerie à haut débit, tolérante aux pannes et hautement scalable. 

Elle agit comme un pipeline durable et rapide entre producteurs et consommateurs de données. Dès que vous devez connecter des microservices, orchestrer des flux de données ou traiter de l’analytique en temps réel, Kafka est souvent l’outil de référence.

Vous pouvez apprendre à créer des applications de traitement en temps réel avec Kafka Streams grâce à notre Kafka Streams Tutorial. Le tutoriel couvre les concepts clés, des implémentations en Java et Python, ainsi que des exemples pas à pas pour concevoir des applications de streaming à l’échelle.

Mettre en place Kafka peut être complexe. Même des ingénieurs expérimentés sont confrontés à la complexité des brokers, topics, partitions et composants nécessaires comme Zookeeper ou KRaft, ce qui peut être frustrant. 

Docker simplifie l’ensemble en regroupant binaires, dépendances et configurations dans des conteneurs. 

Avec Docker, les ingénieurs peuvent démarrer un cluster Kafka sur n’importe quelle machine, partager des configurations identiques avec leurs collègues et éviter le sempiternel « ça marche chez moi ». Kafka conteneurisé est particulièrement prisé pour :

• Le développement et les tests locaux, où la rapidité de démarrage et d’arrêt est cruciale
• Des environnements d’intégration isolés dans les pipelines CI/CD
• La simulation de clusters multi-brokers sur un seul hôte
• La formation et les démonstrations

Explorez Apache Kafka avec notre guide Apache Kafka for Beginners. Apprenez les bases, lancez-vous et découvrez les fonctionnalités avancées et cas d’usage concrets de cette puissante plateforme d’événements.

Les fondamentaux de Kafka avec Docker

Avant d’aborder l’orchestration, il est utile de décomposer les composants techniques de Kafka et la façon dont Docker aide à recréer sa nature distribuée sur un ordinateur portable ou un serveur. 

Comme vous le verrez dans notre tutoriel Learn Docker from Scratch, Docker est un outil populaire pour simplifier le déploiement, la mise à l’échelle et la gestion d’applications comme Kafka via la conteneurisation.

Bases de l’architecture Kafka

La colonne vertébrale de Kafka est son broker : un processus serveur qui stocke, reçoit et sert les messages. Chaque cluster peut comporter plusieurs brokers pour répartir données et charge. 

À l’intérieur de chaque broker, on trouve des topics (canaux nommés pour organiser les messages) et des partitions (sous-canaux qui répartissent les événements sur plusieurs serveurs pour le parallélisme et la durabilité). Les producteurs écrivent dans les topics, tandis que les consommateurs s’y abonnent et traitent ces messages.

La coordination est essentielle. Historiquement, Kafka s’appuyait sur Zookeeper pour gérer les métadonnées des brokers, le leadership des partitions et la santé du cluster. Les déploiements récents peuvent utiliser le mode KRaft, qui internalise cette coordination dans Kafka lui-même et supprime la dépendance à Zookeeper. ZooKeeper a été déprécié en 3.5 et sa suppression est prévue pour 4.0.

Apprenez à conteneuriser des applications de machine learning avec Docker et Kubernetes grâce à notre tutoriel How to Containerize an Application Using Docker. 

Le mode KRaft : simplifier l’architecture de Kafka

À partir de la version 2.8, Kafka a introduit le mode KRaft, qui lui permet de gérer ses métadonnées en interne sans Zookeeper, déclaré prêt pour la production en version 3.3. Ce changement simplifie les déploiements et réduit le nombre de composants à gérer.

Pour configurer Kafka en mode KRaft avec Docker Compose :

version: '3.8'
services:
  kafka:
    image: apache/kafka:latest
    container_name: kafka
    ports:
      - "9092:9092"
      - "9093:9093"
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker,controller
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092,CONTROLLER://0.0.0.0:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@localhost:9093
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_LOG_DIRS: /var/lib/kafka/data
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_LOG_RETENTION_HOURS: 168
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      CLUSTER_ID: "Mk3OEYBSD34fcwNTJENDM2Qk"
    volumes:
      - ./data:/var/lib/kafka/data

Cette configuration met en place un cluster Kafka monoposte en mode KRaft, supprimant le besoin de Zookeeper.

L’essentiel de Docker

Pour exécuter Kafka avec Docker, il suffit de quelques éléments : Docker Engine (le runtime) et souvent Docker Compose pour gérer plusieurs conteneurs. 

Les fichiers Compose vous permettent de définir plusieurs services (Kafka, Zookeeper, Kafka UI, etc.), leurs réseaux, variables d’environnement et montages de stockage. Le réseau Docker permet d’émuler des clusters multi-brokers, même sur une seule machine, en attribuant à chaque broker son conteneur, son nom d’hôte et ses ports.

L’une des meilleures façons de se familiariser avec Docker, c’est par la pratique. Entraînez-vous avec ces 10 idées de projets Docker. 

Configurer Kafka avec Docker Compose

Docker Compose est souvent la méthode privilégiée pour exécuter des applications nécessitant plusieurs conteneurs qui interagissent. Plutôt que d’empiler des scripts shell ou des commandes manuelles, Compose vous permet de définir tous les services et leurs liens dans un unique fichier YAML. 

Cette approche réduit la dérive de configuration, accélère l’onboarding et garantit que chacun utilise la même pile pour le développement.

Configuration Compose minimale

Voici un docker-compose.yml de base qui démarre Kafka et Zookeeper pour le développement local :

version: '3'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
    ports:
      - "2181:2181"
  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    ports:
      - "9092:9092"
    volumes:
      - kafka_data:/var/lib/kafka/data
volumes:
  kafka_data:

Cette configuration minimale publie les ports nécessaires, relie Kafka à Zookeeper et monte un volume Docker afin que les messages ne disparaissent pas si les conteneurs redémarrent. Utilisez bien les variables d’environnement pour définir l’identité du broker, les adresses des listeners et les points de connexion entre services.

Une solide compréhension de Kafka est essentielle pour réussir un entretien d’ingénierie des données. Préparez votre prochain entretien avec notre liste de questions-réponses Kafka grâce à ces 20 Kafka Interview Questions for Data Engineers. 

Configuration étendue

Les configurations professionnelles ajoutent souvent des outils comme Kafka UI, Schema Registry ou REST Proxy pour faciliter l’administration et l’inspection des messages. Vous pouvez les ajouter au bloc services de votre fichier Compose. Par exemple :

kafka-ui:
  image: provectuslabs/kafka-ui:latest
  ports:
    - "8080:8080"
  environment:
    KAFKA_CLUSTERS_0_NAME: "Local"
    KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: "kafka:9092"

La persistance des topics et des logs Kafka entre les redémarrages est essentielle pour tester la reprise ou exécuter des tâches longues. Montez toujours des volumes Docker sur /var/lib/kafka/data pour chaque broker et /var/lib/zookeeper pour Zookeeper, si utilisé.

Le choix de l’image est déterminant. Voici un résumé rapide :

Le tutoriel How to Learn Apache Kafka in 2025 entre dans plus de détails sur Kafka, notamment 

• Pourquoi Apache Kafka est-il si populaire ?
• Les principales fonctionnalités d’Apache Kafka
• Les différents cas d’usage d’Apache Kafka

Interagir avec Kafka dans Docker

Une fois Kafka lancé via Docker Compose, vous pouvez immédiatement créer des topics et envoyer des données, comme avec tout déploiement standard.

Accès CLI et commandes Kafka

Utilisez docker-compose exec ou docker exec pour exécuter les outils CLI de Kafka. Par exemple, pour créer un topic, vous pouvez exécuter :

docker-compose exec kafka kafka-topics.sh --create --topic demo --bootstrap-server localhost:9092

Vous pouvez également utiliser kafka-console-producer.sh et kafka-console-consumer.sh de la même manière. Cela offre une boucle de retour rapide pour les tests d’intégration ou l’expérimentation sans polluer votre environnement local.

Accès programmatique depuis des applications

Vos applications et scripts peuvent se connecter à votre Kafka conteneurisé via les bootstrap servers annoncés par l’hôte. Pour les applis locales, définissez bootstrap.servers=localhost:9092 ou l’équivalent. 

Parmi les clients courants : les bibliothèques Kafka officielles pour Python, Java, NodeJS et Go. Assurez-vous que la pile réseau de votre application atteint les bons ports et adresses.

Réseau Docker et connectivité Kafka

La configuration réseau de Kafka pose fréquemment des défis. Comprendre les listeners internes et externes et comment exposer les services est vital.

Listeners internes vs externes

Les brokers Kafka utilisent des listeners pour contrôler les connexions des clients. Deux configurations habituelles :

• PLAINTEXT://:9092 pour le trafic local non sécurisé, surtout en dev
• SSL ou SASL_SSL pour des connexions chiffrées et/ou authentifiées

Dans docker-compose, exposez les bons ports et veillez à ce que KAFKA_ADVERTISED_LISTENERS corresponde bien à l’hôte et au port réellement utilisés par vos applications. Si vous exécutez dans une VM ou dans le cloud, définissez cette configuration avec l’IP publique et le port mappé.

Configurer plusieurs listeners pour des accès clients variés

Dans des environnements Docker, il est courant de définir plusieurs listeners pour gérer différents scénarios d’accès client :

environment:
  KAFKA_LISTENERS: INTERNAL://0.0.0.0:29092,EXTERNAL://0.0.0.0:9092
  KAFKA_ADVERTISED_LISTENERS: INTERNAL://kafka:29092,EXTERNAL://localhost:9092
  KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT
  KAFKA_INTER_BROKER_LISTENER_NAME: INTERNAL

Cette configuration permet aux clients internes à Docker de se connecter via le listener INTERNAL et aux clients externes de se connecter via le listener EXTERNAL.

Dépannage de la connectivité

Les erreurs fréquentes incluent « broker not available », « connection refused » ou des timeouts côté client. Vérifiez :

• Que les ports sont correctement exposés et mappés
• Que les advertised listeners du broker correspondent à l’adresse visée par votre client
• Que tous les conteneurs sont sains via docker-compose ps
• Que la résolution DNS fonctionne entre conteneurs (utilisez le nom du service, par ex. kafka:9092)
• Utilisez docker network inspect pour diagnostiquer les liens inter-conteneurs

Kafka et Docker dans des environnements proches de la production

Au-delà des tests locaux, des environnements Kafka conteneurisés aident aussi pour la préproduction et le CI/CD.

Stratégies d’orchestration de conteneurs

Des orchestrateurs comme Docker Swarm et Kubernetes peuvent gérer des clusters Kafka multi-brokers, les mises à jour progressives et la découverte de services. Chaque broker dispose de son conteneur et d’un stockage persistant associé. 

Sous Kubernetes, les StatefulSets assurent des déploiements ordonnés et créent des noms DNS stables pour chaque broker.

Journalisation et supervision

Redirigez les logs Kafka vers le driver de logs Docker ou un stockage externe pour analyse. Beaucoup d’équipes envoient les logs vers Elasticsearch, Loki ou Splunk pour le dépannage. Associez Kafka sous Docker à Prometheus et Grafana pour superviser le cluster.

Conseils d’optimisation pour Kafka dans Docker

Les performances de Kafka dépendent d’une gestion soignée des ressources et du stockage.

Allocation des ressources

Allouez à chaque conteneur broker suffisamment de CPU, RAM et disque pour se rapprocher au mieux de la production. Réglez les limites de ressources Docker et passez des options JVM avec KAFKA_JVM_PERFORMANCE_OPTS pour le heap et le garbage collector.

Stockage persistant

Utilisez toujours des volumes Docker ou des bind mounts pour /var/lib/kafka/data et /var/lib/zookeeper. Stocker les données dans le conteneur signifie les perdre au redémarrage, ce qui fausse tout test de durabilité. Un débit disque élevé est crucial pour des performances soutenues, notamment en tests de charge CI/CD.

Bonnes pratiques et pièges courants

La stabilité, la maintenabilité et la productivité d’équipe bénéficient de quelques bonnes pratiques.

Gestion de la configuration

Gérez secrets et configurations en externe avec des fichiers .env ou des répertoires de configuration montés. Ne mettez jamais de données sensibles en dur dans votre YAML compose. Pour des configurations réutilisées, pensez aux outils de templating ou aux frameworks de gestion de configuration.

Erreurs fréquentes

Éviter les erreurs courantes

• Ne stockez pas les données dans les conteneurs : montez toujours des volumes
• Vérifiez les conflits de ports sur votre hôte
• Évitez les mots de passe admin par défaut ; sécurisez les ports exposés, même en local
• Maintenez vos images Docker à jour : corrigez les CVE et dépendances obsolètes

Renforcer la sécurité de Kafka

Pour sécuriser votre déploiement Kafka :

• Activez le chiffrement TLS : protégez les données en transit en configurant SSL/TLS pour toutes les connexions.
• Mettez en place l’authentification : utilisez des mécanismes SASL (p. ex. SCRAM, GSSAPI) pour authentifier les clients.
• Configurez l’autorisation : définissez des listes de contrôle d’accès (ACL) pour gérer les permissions des clients.
• Faites tourner régulièrement les secrets : changez périodiquement mots de passe et clés pour réduire les risques.
• Surveillez et auditez : activez les logs d’audit pour tracer les accès et les changements dans le cluster

Conclusion

Docker facilite remarquablement le démarrage, l’ajustement et l’expérimentation de clusters Apache Kafka pour l’intégration, l’apprentissage ou des tests proches de la production. Les conteneurs vous isolent des problèmes liés à l’OS hôte et aux incompatibilités de dépendances, et vous donnent l’assurance que vos environnements de dev et de test correspondent à vos attentes. À mesure que vous passez de petits clusters locaux à des plateformes Kafka orchestrées, investir dans des configurations Docker robustes et des bonnes pratiques vous fera gagner du temps et épargnera des frustrations à votre équipe. 

Découvrez davantage d’informations sur Kafka et Docker dans l’un de nos cours complets :

• Introduction to Apache Kafka
• Professional Data Engineer in Python
• Containerization and Virtualization Concepts
• Containerization and Virtualization with Docker and Kubernetes
• Intermediate Docker