서비스 간 통신 패턴

In a microservices architecture, your application is broken into many small, independent services. For these services to work together and deliver a complete user experience, they must communicate with each other.

This communication is called inter-service communication. It's how one service requests data or triggers actions in another.

Synchronous communication is like a direct phone call. When Service A needs data from Service B, it sends a request and then waits for Service B to respond before continuing its own work.

• Request-Response Model: Service A waits for a response from Service B.
• Blocking: Service A is blocked (cannot do other work) until the response arrives.

The most common way to achieve synchronous communication between microservices is using HTTP (Hypertext Transfer Protocol) and RESTful APIs.

A REST API defines a set of rules for how services can interact using standard HTTP methods (like GET, POST, PUT, DELETE) over URLs.

While simple, synchronous communication has downsides:

• Tight Coupling: Services become dependent on each other's availability. If Service B is down, Service A might fail.
• Latency: The total response time includes the sum of all individual service call times.
• Cascading Failures: A failure in one service can quickly spread to others.

Asynchronous communication is like sending a letter or an email. Service A sends a message to Service B and doesn't wait for an immediate reply.

Service A can continue its own work, and Service B will process the message whenever it's ready, potentially replying later or triggering another action.

A common way to implement asynchronous communication is using a message queue or message broker. Think of it as a post office for your services.

• Service A sends a message to the queue.
• The queue stores the message reliably.
• Service B picks up and processes the message when it's available.

Asynchronous patterns offer significant advantages:

• Loose Coupling: Services are less dependent. If Service B is temporarily down, messages wait in the queue.
• Improved Responsiveness: Service A doesn't wait, so it can respond to clients faster.
• Scalability: You can add more instances of Service B to process messages from the queue in parallel.

Choosing between synchronous and asynchronous depends on your use case:

• Synchronous: Best for immediate requests where a client needs an instant response (e.g., getting user profile data).
• Asynchronous: Ideal for background tasks, long-running processes, or when high fault tolerance and decoupling are critical (e.g., processing an order, sending email notifications).

While HTTP/REST and message queues are primary, other technologies exist:

• gRPC: A high-performance, language-agnostic RPC (Remote Procedure Call) framework. It often uses Protocol Buffers for efficient data serialization.
• Event-Driven Architectures: Services communicate by publishing and subscribing to events, often leveraging message brokers.

Consider a microservices system where a "User Service" needs to notify an "Email Service" whenever a new user registers. The "User Service" should not wait for the email to be sent before confirming registration to the user.

We've explored how microservices communicate. Synchronous communication involves direct, blocking calls, often using HTTP/REST, but can lead to tight coupling and cascading failures.

Asynchronous communication uses indirect methods like message queues, offering loose coupling, better responsiveness, and resilience. Choosing the right pattern is crucial for a robust microservices architecture.