메시지 큐 및 이벤트

In microservices, different parts of your application often need to communicate. Sometimes, they don't need an instant reply or to wait for each other to finish tasks.

Asynchronous communication means services can send messages and continue their work without waiting for a response. This improves performance, responsiveness, and overall system reliability.

A message queue is like a temporary storage buffer for messages. Imagine a post office box where services can drop off and pick up mail.

• One service (the producer) sends a message.
• Another service (the consumer) retrieves and processes it later.

This pattern helps services avoid direct, real-time dependencies.

The producer is the service that creates a message and sends it to the message queue. It doesn't need to know who will process the message or when; it simply puts the message into the queue.

Once the message is sent, the producer is free to continue with other tasks, making the operation non-blocking.

The consumer is the service that listens to the message queue. When a new message arrives, the consumer retrieves it, performs its designated task, and then acknowledges that it has processed the message.

Upon acknowledgment, the message is typically removed from the queue. Multiple consumers can often work together to process messages from the same queue, distributing the workload.

Using message queues provides several key advantages for microservices:

• Decoupling: Services don't need to know about each other's existence or availability.
• Resilience: If a consumer service is temporarily unavailable, messages wait in the queue until it recovers.
• Scalability: You can add more consumers to handle increased message load without affecting producers.
• Load Leveling: Queues smooth out spikes in traffic, preventing consumers from being overwhelmed.

Event-Driven Architecture (EDA) is a design pattern where services communicate by producing and consuming events. Message queues are a fundamental component often used to implement EDA.

An event is a notification that 'something important has happened' within your system, like UserRegistered or OrderShipped.

It's crucial to understand the difference between events and commands:

• Event: Describes something that has already occurred (e.g., ProductUpdated). Events are facts and are typically immutable. Consumers react to events.
• Command: An instruction to do something (e.g., UpdateProduct). Commands are directed to a specific service to perform an action.

Events are often broadcast, while commands target a specific recipient.

Here's a simplified Java example demonstrating the producer-consumer concept using an in-memory queue. In a real application, you'd use a dedicated message broker.

Try running this example:

For robust, production-grade microservices, you'll integrate with a specialized message broker. These systems handle message persistence, routing, and delivery guarantees.

• RabbitMQ: A widely used, general-purpose message broker with flexible routing.
• Apache Kafka: A distributed streaming platform, excellent for high-throughput data streams and event logging.
• AWS SQS/SNS: Amazon's managed queue (SQS) and topic (SNS) services, ideal for cloud-native applications.

Consider a microservice architecture where a 'User Service' needs to inform an 'Email Service' whenever a new user registers, without waiting for the email to be sent.

You've learned how message queues enable asynchronous communication in microservices, leading to decoupled, resilient, and scalable systems. We also explored Event-Driven Architecture (EDA), understanding the role of events and their distinction from commands. These patterns are essential for building robust, distributed applications.