Sur cette page
L'optimisation en un paragraphe
L'optimisation en un paragraphe
Commencez par un benchmark avec kafka-producer-perf-test.sh et kafka-consumer-perf-test.sh, puis optimisez dans cet ordre : batching et compression côté producteur, nombre de partitions et clés, threads, disques et réseau des brokers, et enfin paramètres de fetch et de poll des consommateurs. Depuis Kafka 4.0, la valeur par défaut de linger.ms côté producteur est 5 et non plus 0 : les anciens conseils d'optimisation qui partent de 0 sont donc obsolètes. Les limites de débit ont trois origines, et chacune se calcule avant de toucher à la configuration : les débits par partition des producteurs et des consommateurs fixent le nombre de partitions, la réplication multiplie chaque octet sur le réseau des brokers, et la rétention multipliée par la réplication détermine le disque.
Si les consommateurs prennent sans cesse du retard, passez directement au tableau du consumer lag en section 5 : la répartition du lag entre partitions désigne la cause de façon plus fiable que n'importe quelle métrique isolée.
Mesurer d'abord : benchmark et métriques de performance avant toute modification
Optimiser sans référence revient à deviner : enregistrez donc le débit et la latence des producteurs, le temps d'inactivité des brokers et le consumer lag sous une charge reproductible avant de modifier un paramètre. Kafka fournit les outils : kafka-producer-perf-test.sh et kafka-consumer-perf-test.sh, ainsi que des métriques JMX sur chaque client et chaque broker. Exportez ces métriques vers Prometheus ou vers l'outil de monitoring déjà alimenté par Kafka, afin de conserver la référence et chaque exécution ultérieure.
bin/kafka-producer-perf-test.sh --topic perf-test --num-records 5000000 \
--record-size 1024 --throughput -1 \
--producer-props bootstrap.servers=host:9092 acks=all linger.ms=5
bin/kafka-consumer-perf-test.sh --bootstrap-server host:9092 \
--topic perf-test --messages 5000000Pour un pipeline temps réel, mesurez aussi la latence de bout en bout, de la production à la consommation, et pas seulement la latence côté producteur. Utilisez un topic de test avec le même nombre de partitions et le même facteur de réplication qu'en production. Kafka 4.4 ajoute à l'outil producteur les options --record-key-range, --key-distribution et --random-seed, pour qu'un benchmark reproduise une distribution de clés déséquilibrée au lieu de répartir les enregistrements uniformément.
Surveillez ces indicateurs pendant le test. La documentation de monitoring d'Apache donne des valeurs idéales pour les deux premiers : RequestHandlerAvgIdlePercent et NetworkProcessorAvgIdlePercent au-dessus de 0,3, partitions sous-répliquées à 0. Côté clients : record-queue-time-avg, batch-size-avg et request-latency-avg pour les producteurs, records-lag-max, fetch-latency-avg et records-consumed-rate pour les consommateurs.
Producteurs : configurer batching, compression et acquittements
Le débit des producteurs dépend surtout du batching : des lots plus gros signifient moins de requêtes, une meilleure compression et moins de travail pour le broker, au prix d'un peu de latence. Quatre paramètres de la configuration des producteurs Kafka le contrôlent ; les valeurs par défaut ci-dessous proviennent de la documentation producteur d'Apache Kafka 4.4.
| Paramètre | Défaut (4.4) | À modifier quand | Contrepartie |
|---|---|---|---|
linger.ms | 5 (0 avant Kafka 4.0) | batch-size-avg est très inférieur à batch.size et la latence tolère une attente plus longue | Exemple d'Apache : linger.ms=50 envoie moins de requêtes et ajoute jusqu'à 50 ms de latence hors charge |
batch.size | 16384 octets | Les lots partent pleins avant l'expiration de linger.ms, ou les enregistrements sont volumineux | Plus de mémoire par partition dans buffer.memory |
compression.type | none | Le réseau ou le disque est la limite et le CPU est disponible ; testez lz4 et zstd | CPU producteur et broker ; Apache note que le ratio s'améliore avec davantage de batching |
buffer.memory | 33554432 (32 Mio) | bufferpool-wait-ratio est supérieur à zéro, ce qui signifie que send() bloque | Heap utilisé par le client |
Les acquittements relèvent d'un choix de durabilité, pas d'un réglage de performance. acks=all est la valeur par défaut en 4.4 et c'est le paramètre qui, avec min.insync.replicas=2 sur un facteur de réplication de 3, préserve les écritures acquittées après la perte d'un broker. Passer à acks=1 gagne de la latence en acceptant que le leader puisse tomber avant que les followers aient copié l'enregistrement. Ne le modifiez qu'avec l'accord du propriétaire des données. Laissez l'idempotence activée : elle exige acks=all et au plus 5 requêtes en vol par connexion, ce qui correspond au défaut.
Les nouvelles tentatives sont activées par défaut (retries vaut 2147483647, borné en pratique par delivery.timeout.ms, avec retry.backoff.ms à 100) : un broker lent se traduit donc par de la latence et un temps d'attente croissant plutôt que par des erreurs, jusqu'à expiration du timeout de livraison. Modifiez un seul paramètre producteur à la fois et relancez le même test de performance. La compression en particulier doit être testée sur vos propres enregistrements, car JSON, Avro et les charges déjà compressées se compressent très différemment.
Partitions et clés : d'où vient le parallélisme
Le nombre de partitions plafonne le nombre de consommateurs parallèles et constitue le principal levier de débit ; il peut être augmenté mais jamais réduit, dimensionnez-le donc à partir de mesures. Mesurez ce qu'une partition soutient pour vos producteurs (P) et pour vos consommateurs (C) sur votre matériel : pour un débit cible T, il faut au moins T divisé par P et au moins T divisé par C partitions. Il en faut aussi au moins autant que d'instances consommatrices en pic. Retenez le plus grand des trois et ajoutez une marge de capacité.
Les clés décident si ce calcul tient. Tous les enregistrements d'une même clé arrivent sur une même partition : une clé déséquilibrée y concentre la charge, quel que soit le nombre de partitions. Comparez les octets entrants et le lag par partition : une partition très au-dessus de la médiane signale un problème de clé, à corriger par une meilleure clé, une clé salée si l'ordre le permet, ou un partitioner personnalisé. Si la partition chaude se trouve aussi sur un broker surchargé, kafka-reassign-partitions.sh peut la déplacer, avec un throttling pour que la copie n'affame pas le trafic de production, mais cela corrige le placement, pas le skew. Ajouter des partitions à un topic à clés change aussi la partition associée à chaque clé, ce qui rompt l'ordre par clé au moment du changement.
Retour de nos missions. Les missions Kafka d'AceMQ couvrent l'optimisation des performances et la réduction de clusters surdimensionnés, sur Kafka autogéré, Amazon MSK et Confluent Platform. Le plafond atteint par un client est presque toujours un plafond de conception, un topic chaud ou un topic surdimensionné, et non celui du broker ; la solution consiste généralement à repartitionner la charge plutôt qu'à changer de broker.
Brokers Kafka, disques et bande passante réseau : le calcul de capacité
La capacité d'un broker se calcule à partir de quatre données : l'ingestion des producteurs, le facteur de réplication, le nombre de consumer groups qui lisent tout, et la rétention. La réplication multiplie chaque octet et chaque consumer group multiplie le trafic sortant : c'est pourquoi, dans la plupart des architectures de cluster Kafka, la bande passante réseau et le disque s'épuisent avant le CPU. Comparez le résultat à la bande passante réseau et au débit disque de chaque broker, et fixez vos seuils d'alertes en conséquence.
Avec une ingestion cluster I (Mo/s), B brokers, un facteur de réplication r et c consumer groups lisant chacun la totalité du flux, et des leaders répartis uniformément :
- Entrant par broker : r × I / B, car chaque broker est leader de I / B et copie les (r - 1) autres parts en tant que follower.
- Sortant par broker : (r - 1 + c) × I / B, réplication vers les followers plus lectures des consommateurs.
- Disque, cluster entier : I × 86 400 secondes × jours de rétention × r, divisé par votre ratio de compression.
- Page cache par broker : la règle empirique d'Apache est le débit d'écriture multiplié par 30 secondes de mise en tampon, soit le débit entrant de chaque broker multiplié par 30.
| Exemple chiffré (données illustratives) | Calcul | Résultat |
|---|---|---|
| Ingestion 50 Mo/s, 6 brokers, r = 3, 2 consumer groups, 7 jours, sans compression | Entrant par broker : 3 × 50 / 6 | 25 Mo/s |
| Mêmes données | Sortant par broker : (3 - 1 + 2) × 50 / 6 | 33,3 Mo/s |
| Mêmes données | Disque : 50 × 86 400 × 7 × 3, en Go décimaux | 90 720 Go, soit 15 120 Go par broker |
| Mêmes données | Page cache par broker : 25 Mo/s × 30 s | 750 Mo, hors heap et OS |
Ces données sont illustratives, pas une recommandation : remplacez-les par les vôtres. Le résultat est un plancher : un consommateur en retard lit sur disque au lieu du page cache, donc de la mémoire disponible protège tout le cluster d'un lecteur lent.
Threads et fetchers des brokers. num.network.threads (défaut 3), num.io.threads (défaut 8) et num.replica.fetchers (défaut 1) sont les paramètres à augmenter quand les pourcentages d'inactivité passent sous 0,3 ou que des followers sortent de l'ensemble in-sync. Augmenter les replica fetchers accroît le parallélisme entre brokers, au prix de CPU et de mémoire. Si des followers sont en retard, vérifiez replica.lag.time.max.ms (défaut 30 secondes) avant de conclure à un disque lent.
JVM et mise à l'échelle. Gardez un heap JVM modeste : l'exemple d'Apache est -Xmx6g -Xms6g -XX:+UseG1GC -XX:MaxGCPauseMillis=20, qui laisse le reste de la RAM au page cache. Ajouter des brokers ne déplace pas à lui seul les partitions existantes : planifiez une réassignation avant d'attendre d'un nouveau broker qu'il prenne de la charge.
Disques et système d'exploitation. Dédiez des disques à Kafka, maintenez les descripteurs de fichiers à 100 000 ou plus et vérifiez vm.max_map_count au regard du nombre de partitions, comme le détaille la checklist de mise en production aux points 17 à 20.
Consommateurs et lag : surveiller les offsets Kafka et diagnostiquer par motif
Le consumer lag, écart entre l'offset de fin de log d'une partition et l'offset validé du groupe, a un petit nombre de causes, et la répartition du lag entre partitions et dans le temps indique laquelle vous concerne. Dans un parc de microservices, chaque service est généralement son propre consumer group : lisez donc le lag par groupe. Examinez d'abord le motif : bin/kafka-consumer-groups.sh --bootstrap-server host:9092 --describe --group my-group affiche le lag par partition, et --members indique quelle instance possède chacune.
| Motif | Cause probable | Vérification | Correction |
|---|---|---|---|
| Le lag croît uniformément sur toutes les partitions | Les consommateurs sont plus lents que les producteurs | Temps de traitement par enregistrement au regard de records-consumed-rate | Accélérer le traitement, ou ajouter des instances consommatrices jusqu'au nombre de partitions |
| Une partition très en retard sur les autres | Skew de clé ou partition chaude | Octets entrants par partition au regard de la médiane | Changer la clé ou le partitioner ; plus de consommateurs n'y changera rien |
| Le lag fait des dents de scie au rythme des rééquilibrages du groupe | Le traitement dépasse max.poll.interval.ms (défaut 300000) | État du groupe et nombre de rééquilibrages | Réduire max.poll.records (défaut 500) ou augmenter l'intervalle ; utiliser le static membership ou group.protocol=consumer |
| Du lag apparaît à chaque déploiement | Un rééquilibrage complet à chaque redémarrage de pod | Événements de rééquilibrage alignés sur les heures de release | Static membership avec group.instance.id, ou le nouveau protocole consommateur |
| Lag après redémarrage d'un broker qui ne se résorbe jamais | Leaders non revenus sur les réplicas préférés | PreferredReplicaImbalanceCount supérieur à 0 | bin/kafka-leader-election.sh --bootstrap-server host:9092 --election-type preferred --all-topic-partitions |
| Fetches nombreux et petits | Paramètres de fetch réglés pour la latence, pas pour le volume | fetch-size-avg très inférieur au défaut de 1 Mio de max.partition.fetch.bytes | Augmenter fetch.min.bytes (défaut 1) en tenant compte de fetch.max.wait.ms (défaut 500) |
Ajouter des consommateurs n'aide que jusqu'à ce que le nombre d'instances égale celui des partitions. Au-delà, les consommateurs supplémentaires restent inactifs : c'est le constat habituel chez une équipe qui a augmenté son déploiement sans voir de changement. Les share groups, prêts pour la production depuis Kafka 4.2, permettent d'avoir plus de consommateurs que de partitions pour des tâches indépendantes, mais renoncent à l'ordre par partition.
Ce qui change dans Kafka 4.x pour l'optimisation
Quatre changements de la 4.x modifient les conseils d'optimisation, tous documentés par Apache. La valeur par défaut de linger.ms côté producteur est passée de 0 à 5 en 4.0, car des lots plus gros donnent généralement une latence similaire ou inférieure. Le protocole de rééquilibrage consommateur de nouvelle génération (KIP-848) est en disponibilité générale depuis la 4.0 et s'active côté client avec group.protocol=consumer ; entièrement incrémental, il n'a pas de barrière de synchronisation globale, et il déplace heartbeat, timeout de session et assignation vers le broker, si bien que session.timeout.ms, heartbeat.interval.ms et partition.assignment.strategy ne s'appliquent plus. Les brokers exigent Java 17. Enfin, la 4.4, publiée le 22 octobre 2026, ajoute des options de distribution des clés à l'outil de test de performance producteur.
Vérifiez votre version au regard des versions maintenues avant d'optimiser : au 28 octobre 2026, Apache maintient les versions 4.4, 4.3 et 4.2. Un cluster en 3.x ne peut y accéder que par une migration KRaft, c'est pourquoi l'optimisation et la planification de la migration sont souvent cadrées ensemble.
Quand l'optimisation ne suffit plus, et qui contacter
L'optimisation cesse d'aider quand la limite vient de la conception : une clé chaude, un topic qui porte des charges sans rapport entre elles, un nombre de partitions choisi pour le trafic de l'an dernier, ou un consommateur qui fait un appel bloquant par enregistrement. Il faut alors repenser l'architecture ; les signes en sont un benchmark qui bouge à peine après trois changements de paramètres et un lag concentré sur une partition.
AceMQ travaille avec plus de 160 clients et traite plus de 40 incidents Sev 1 par an sur les plateformes qu'elle prend en charge. Pour Kafka, le point d'entrée habituel est le bilan de santé Kafka, qui couvre le skew des partitions, le comportement des consommateurs, la réplication et la capacité, et livre des constats hiérarchisés, avec un support 24/7 et des objectifs de réponse à partir de 15 minutes, selon le plan, pour les incidents. Quand AceMQ n'est pas le bon choix : un benchmark ponctuel sur un cluster que vous maîtrisez déjà demande une journée avec les outils ci-dessus, pas un contrat ; et un service entièrement managé comme Confluent Cloud ou Amazon MSK vous décharge de l'optimisation des brokers et des disques, mais vous laisse le partitionnement, les clés et les consommateurs.
Questions fréquentes
Comment augmenter le débit de Kafka ?
Mesurez une référence avec kafka-producer-perf-test.sh, puis optimisez dans l'ordre : batching producteur (linger.ms, batch.size) et compression, nombre de partitions et clés, threads, disques et réseau des brokers, et paramètres de fetch des consommateurs. Modifiez un paramètre à la fois et relancez le même test. Si le benchmark bouge à peine, la limite est la conception, généralement une clé déséquilibrée ou trop peu de partitions.
Quelle est la valeur par défaut de linger.ms dans Kafka 4.x ?
5 millisecondes. La valeur par défaut est passée de 0 à 5 dans Apache Kafka 4.0, car des lots plus gros donnent généralement une latence producteur similaire ou inférieure malgré l'attente supplémentaire. Les conseils d'optimisation qui partent de 0 sont antérieurs à ce changement.
Combien de partitions faut-il pour un topic Kafka ?
Au moins le débit cible divisé par ce qu'une partition soutient pour vos producteurs, au moins le même calcul pour vos consommateurs, et au moins le nombre d'instances consommatrices en pic. Mesurez les débits par partition sur votre propre matériel, retenez le plus grand résultat et ajoutez une marge de capacité, car les partitions peuvent être ajoutées mais jamais supprimées.
Pourquoi mes consommateurs Kafka prennent-ils sans cesse du retard ?
Quatre causes couvrent la plupart des cas : des consommateurs plus lents que les producteurs, une partition chaude due à une clé déséquilibrée, des rééquilibrages déclenchés par un traitement qui dépasse max.poll.interval.ms, et des leaders non revenus sur leurs réplicas préférés après un redémarrage. Un lag sur toutes les partitions oriente vers la première, un lag sur une seule partition vers la deuxième.
La compression améliore-t-elle les performances de Kafka ?
Oui, lorsque le réseau ou le disque est la limite et que le CPU est disponible, car des lots compressés réduisent les octets transférés et stockés. Par défaut, il n'y a pas de compression. Testez lz4 et zstd sur vos propres enregistrements, car le ratio dépend de la charge utile et s'améliore avec des lots plus gros.