Wskazówki dotyczące dostrajania wydajności Kafka

When dealing with high-volume data streams, default Kafka configurations might not be enough. Performance tuning helps you get the most out of your Kafka setup.

• Throughput: How many messages can be processed per second?
• Latency: How long does it take for a message to travel from producer to consumer?

We'll explore key adjustments for producers and consumers to balance these factors.

Kafka producers don't send every message individually. They group messages into batches. The batch.size configuration (default 16KB) controls the maximum size of these batches.

• Increase batch.size: Sends fewer, larger requests to brokers.
• Benefit: Reduces network overhead, improving overall throughput.
• Trade-off: Can slightly increase latency for individual messages if batches fill slowly.

Find a size that works well with your typical message size and volume.

The linger.ms setting (default 0ms) tells the producer how long to wait for more messages to arrive before sending a batch, even if batch.size isn't met.

• Works with batch.size to optimize batching.
• A small positive value (e.g., 5-50ms) can significantly boost throughput.
• It allows batches to accumulate more messages, reducing network calls.

This introduces a slight delay but often leads to a better throughput-latency balance.

Compressing message batches before sending can drastically reduce network bandwidth usage and disk space on Kafka brokers. The compression.type property controls this.

• Types: snappy, lz4, gzip, zstd.
• snappy and lz4: Good balance of compression and CPU efficiency.
• gzip and zstd: Offer higher compression ratios but use more CPU.

Choose based on your network constraints and available CPU resources.

Proper buffer management prevents producers from blocking and ensures large messages can be sent.

• buffer.memory (default 32MB): Total memory for producer records waiting to be sent. Increase for high-throughput bursts to prevent blocking send() calls.
• max.request.size (default 1MB): Max size of a single request (batch) the producer sends. Ensure it accommodates your largest messages or compressed batches.

Tune these to match your application's message characteristics.

Consumers fetch messages in batches from brokers. The fetch.min.bytes setting (default 1 byte) determines the minimum amount of data a broker should return for a fetch request.

• Increase fetch.min.bytes: Reduces the number of fetch requests made by the consumer.
• Benefit: Less network overhead, improving consumer throughput.
• Trade-off: Can slightly increase latency as the consumer waits for more data to accumulate.

Useful for high-throughput consumers where immediate message delivery isn't the top priority.

fetch.max.wait.ms (default 500ms) specifies the maximum time a broker will wait for fetch.min.bytes to be available before sending data to the consumer. It works alongside fetch.min.bytes.

• A higher value allows brokers to aggregate more data before responding.
• This reduces network round trips, further boosting throughput.
• Directly impacts latency, as consumers might wait longer for data.

Adjust these two fetch settings together to find your optimal balance.

The max.poll.records setting (default 500) defines the maximum number of records returned in a single call to the consumer's poll() method.

• Processing messages in larger batches can significantly improve application throughput.
• It reduces the overhead of frequent poll() calls and commit operations.
• Your application must be designed to efficiently handle these larger sets of messages.

Tune this based on your application's processing capacity.

While manual offset committing offers fine-grained control, using auto-commit (enable.auto.commit=true) with a tuned auto.commit.interval.ms can simplify consumer management.

• Default interval is 5000ms (5 seconds).
• Shorter interval: Reduces the risk of reprocessing messages on failure (smaller 'at-least-once' window).
• Longer interval: Reduces the frequency of commit requests to Kafka, potentially improving throughput slightly but increasing reprocessing risk.

Consider the trade-off between reprocessing risk and commit overhead.

We've explored several key Kafka producer and consumer configurations for performance tuning:

• Producers: Adjust batch.size, linger.ms, compression.type, buffer.memory, and max.request.size to optimize message sending.
• Consumers: Tune fetch.min.bytes, fetch.max.wait.ms, and max.poll.records for efficient message retrieval and processing.

Remember, optimal settings are workload-dependent. Always test changes in your specific environment to find the best balance between throughput, latency, and resource usage.