รูปแบบการสื่อสารของไมโครเซอร์วิส

Microservices are small, independent services that work together. Think of them as tiny, specialized apps.

A big challenge in microservices is how they talk to each other. They need to share data and coordinate actions without becoming tightly coupled.

There are two main ways services communicate:

• Synchronous: Service A calls Service B and waits for a reply. Like a phone call.
• Asynchronous: Service A sends a message and doesn't wait. Service B picks it up later. Like sending an email.

Asynchronous communication is often preferred for microservices because it:

• Reduces dependencies
• Improves fault tolerance
• Allows services to scale independently

Apache Kafka shines as an event backbone for microservices. It acts as a central nervous system where services can publish and subscribe to events.

This means services don't talk directly. Instead, they communicate by sending and receiving messages (events) through Kafka topics.

Using Kafka for microservice communication brings several key advantages:

• Decoupling: Services don't need to know about each other. They only know about Kafka.
• Scalability: Kafka handles high volumes of messages, allowing services to scale independently.
• Reliability: Messages are durably stored in Kafka, ensuring they aren't lost even if a service is down.
• Real-time Processing: Enables immediate reaction to events across your system.

Kafka is foundational for Event-Driven Architecture (EDA). In an EDA, services communicate by emitting, detecting, and reacting to events.

An event is a change in state or an occurrence. For example, 'OrderCreated', 'UserRegistered', or 'PaymentProcessed'.

Microservices publish events to Kafka, and other microservices subscribe to those events to react accordingly.

Here's a simplified Java example of a microservice producing an 'OrderCreated' event to a Kafka topic. In a real application, this would use Kafka client libraries.

Try running this example:

Now, let's look at a simplified Java example of another microservice consuming that 'OrderCreated' event. It subscribes to the topic and processes the event.

Try running this example:

Sometimes, a microservice needs a response from another. With Kafka, you can achieve an asynchronous request-reply pattern.

Instead of a direct call, Service A sends a 'request' event to Topic A and includes a 'reply-to' topic and a unique correlation ID.

Service B processes the request, sends a 'response' event to the 'reply-to' topic (Topic B), including the original correlation ID. Service A then listens on Topic B for its specific response.

For microservices to communicate effectively, they need to agree on the format of their messages. This is called a message contract or schema.

A contract defines what fields an event should contain and their data types. Tools like Confluent Schema Registry (covered in another lesson) help enforce these contracts.

This prevents issues when one service updates its event structure, ensuring others can still understand it.

Which of the following are key benefits of using Apache Kafka as an event backbone for microservices communication?

You've learned how Apache Kafka serves as a powerful event backbone for microservices.

• Kafka enables asynchronous communication, leading to more resilient and scalable systems.
• Microservices publish events to topics and consume events from topics, without direct dependencies.
• Patterns like asynchronous request-reply can be built using Kafka and correlation IDs.
• Maintaining clear message contracts is crucial for interoperability.

This approach transforms a collection of services into a cohesive, event-driven ecosystem.