💻 IT & Coding concepts,
clear in 60 seconds.

Microservices can communicate using five key patterns based on their needs.

gRPC supports four communication patterns: Unary, Server Streaming, Client Streaming, and Bidirectional Streaming.

Message queues allow services to communicate asynchronously, improving scalability and reliability.

Request-Response asks for a result, while Events notify that something has happened.

Poison messages in Kafka can cause infinite retries, risking system stability.

The Transactional Outbox Pattern ensures database updates and event publishing are synchronized to avoid losing events.

Kafka uses retries and Dead Letter Queues to manage message processing failures.

Queues distribute tasks to one consumer, while Pub/Sub broadcasts events to multiple subscribers.

The Saga Pattern manages distributed transactions using local transactions and compensating actions.

Kafka uses state stores to remember previous events in stateful stream processing.

Kafka can help ensure messages are processed once, but requires careful design.

Kafka uses retry topics and delayed retries to manage message failures efficiently.

Kafka uses Dead Letter Topics to handle messages that repeatedly fail processing.

Message delivery semantics define how messages are sent in distributed systems and handle failures.

Kafka's commitSync waits for confirmation, while commitAsync continues immediately.

Kafka commit strategies determine how offsets are managed during message processing.

Kafka uses partitions to allow multiple consumers to process messages in parallel.

Older offsets can overwrite newer ones in Kafka if not handled properly.

The retry pattern helps systems recover from temporary failures but can cause overload if misused.

Kafka consumers can use multiple threads to speed up message processing, but it complicates ordering and offset management.

Kafka consumer reprocessing involves safely replaying events to correct system states.

Kafka consumers can pause and resume message processing to handle backpressure effectively.

Kafka's `seek()` lets you replay only specific messages, saving time.

Kafka allows safe message reprocessing by resetting consumer positions without altering data.

Kafka maintains message order within partitions using keys for routing.

Backpressure helps manage message flow in Kafka during traffic spikes.

Classifying failures and using controlled retries in Kafka prevents outages.

Kafka consumers have three important states: Position, Committed Offset, and Application State.

Kafka uses partitions to allow parallel processing while ensuring message order with keys.

Kafka Streams uses tumbling and hopping windows for time-based data aggregation.

Kafka Streams offers higher-level abstractions, while Kafka Consumer provides direct control.

Kafka's parallel processing depends on partitions, not just consumers or threads.

The Bulkhead Pattern isolates resources to protect critical workloads from failures.

Kafka consumer offsets help track message processing to avoid loss and duplication.

Synchronous communication waits for a response, while asynchronous continues without waiting.

You can replay Kafka events safely by separating live and replay processes.

Kafka producers use ACKs, retries, and idempotence to ensure reliable message delivery.

Kafka consumers can fetch data in batches to improve throughput and reduce latency.

Paxos is a protocol that helps distributed systems agree on one value despite failures.

Backpressure prevents system overload by managing message processing rates in Kafka.

Kafka uses heartbeats and timeouts to check if consumers are alive.

Kafka Schema Evolution allows safe changes to message structures without breaking existing consumers.

The Circuit Breaker pattern controls service calls to prevent failures from spreading.

Kafka consumers resume processing from the last committed offset after a crash.

Token Bucket allows burst traffic, while Leaky Bucket smooths out traffic flow.

Graceful shutdown in Kafka ensures no data loss during consumer termination.