Kommunikation zwischen Diensten

In a microservices architecture, your application isn't one big program. Instead, it's many smaller, independent services working together. For these services to achieve a common goal, they need to communicate with each other.

Imagine an e-commerce system: one service handles user accounts, another manages product inventory, and a third processes orders. When a user places an order, the order service needs to talk to the inventory service to check stock and the user service to get payment details.

The most common way for microservices to communicate is through HTTP requests. This is like one service directly calling another service's API endpoint.

• Synchronous: The calling service waits for a response before continuing.
• Simple: Easy to understand and implement, especially for request-response patterns.
• Familiar: Uses the same HTTP protocol you're already familiar with for web browsing.

FastAPI services naturally expose HTTP endpoints, making this a straightforward method.

In Python, the requests library is excellent for making HTTP calls. Here's how one FastAPI service might call another to get user data.

Assume Service B exposes a /users/{user_id} endpoint, and Service A calls it:

After making an HTTP request, it's crucial to handle the response properly. This includes checking the HTTP status code and parsing the response body.

• Status Codes: 200 OK means success, 404 Not Found means the resource wasn't there, 500 Internal Server Error indicates a problem on the server side.
• Response Body: Often contains data in JSON format, which you can parse using response.json().
• Error Handling: Always wrap your requests in try-except blocks to catch network issues or server errors.

Network issues or slow services can cause your HTTP calls to hang or fail. Building resilience into your communication is vital.

• Timeouts: Set a maximum duration to wait for a response. If the service doesn't respond within this time, the request fails, preventing your service from hanging indefinitely.
• Retries: If a request fails due to a transient error (e.g., network glitch, temporary service overload), you can automatically retry the request a few times with a delay. Libraries like tenacity can help implement this easily.

These strategies improve the robustness of your microservices.

Sometimes, direct HTTP calls aren't the best fit. For tasks that don't require an immediate response, or when you want to reduce direct dependencies between services, message queues are powerful.

A message queue acts as an intermediary, storing messages until a consumer service is ready to process them. Popular examples include RabbitMQ and Apache Kafka.

• Asynchronous: The sender (producer) doesn't wait for the receiver (consumer) to process the message.
• Decoupled: Services don't need to know about each other's direct network locations.
• Scalable: Easily handle spikes in load by adding more consumers.

Message queues operate on a simple principle:

• Producer: A service that creates and sends messages to a queue. It "fires and forgets" the message.
• Queue: A temporary storage buffer that holds messages until they are processed.
• Consumer: A service that listens to a queue, retrieves messages, and processes them.

This model allows for robust, scalable, and fault-tolerant communication, especially for background tasks or event-driven architectures.

While a full, runnable message queue example is complex, here's a conceptual Python function illustrating how a service might "send" a message to a queue. In reality, this would involve a client library like pika (for RabbitMQ) or confluent-kafka.

Notice that the sender doesn't wait for the message to be processed; it just places it in the queue.

HTTP communication is generally preferred for:

• Synchronous Requests: When the calling service needs an immediate response to continue its workflow (e.g., getting user profile data, checking inventory before confirming an order).
• Request-Response Patterns: Simple queries, data retrieval, or operations where the client expects a direct result.
• Tight Coupling is Acceptable: When services are designed to work closely together and direct calls are efficient.
• Real-time User Interactions: Often used for front-end to back-end communication, or when an immediate UI update is needed.

You've seen two primary ways services communicate. Each has its strengths. Consider the scenario:

A user submits a complex report generation request that might take several minutes to complete. The user doesn't need to wait for it, but wants to be notified when it's done.

Which communication pattern is best suited for the initial request submission?

Great job! You've explored the fundamental ways microservices communicate.

• HTTP: Best for synchronous, request-response interactions where immediate feedback is needed. It's direct and easy to implement using libraries like requests.
• Message Queues: Ideal for asynchronous, decoupled communication, handling long-running tasks, and enabling event-driven architectures. They use a producer-consumer model for robust message delivery.

Choosing the right pattern depends on your specific needs for coupling, latency, and reliability. In the next lesson, we'll dive into building an API Gateway!