Microservice communication basics in Express - Mini Project: Build & Apply

📋 What You'll Learn

💡 Why This Matters

🌍 Real World

💼 Career

Make a synchronous HTTP call between services

In the order service, call the user service at http://localhost:3001/users/:id to verify the user exists before creating an order. Return 404 if user not found.

Express

Hint

Use fetch to call the user service. Check userRes.ok for success. Wrap in try/catch to handle connection failures with a 502 response.

Add a circuit breaker to the HTTP call

Wrap the user service call with the opossum circuit breaker. If 3 requests fail within 30 seconds, open the circuit and return a fallback response instead of calling the service.

Express

Hint

Create a function that fetches the user. Pass it to new CircuitBreaker with options for timeout and thresholds. Add a fallback with breaker.fallback(). Call with breaker.fire().

Publish an event after order creation

After successfully creating an order, publish an order_created event to a RabbitMQ queue so other services (notification, analytics) can react to it.

Express

Hint

Connect to RabbitMQ once at startup. Use channel.assertQueue to create the queue. Use channel.sendToQueue to publish the order as a JSON buffer. Set persistent: true so messages survive restarts.

Create a notification service that consumes events

Create a separate Express service that consumes order_created events from RabbitMQ and logs a notification for each order.

Express

Hint

Use channel.consume to listen for messages. Parse the JSON from msg.content. Always call channel.ack(msg) after processing so RabbitMQ removes the message from the queue. Use prefetch(1) to process one message at a time.

Practice

1. Which of the following is a common way for microservices to communicate synchronously in an Express-based system?

easy

A. Sharing global variables in memory

B. Direct database access by all services

C. Using HTTP REST API calls between services

D. Using local file system for message passing

Solution

1. Step 1: Understand synchronous communication in microservices

   Synchronous communication means one service waits for a response from another before continuing.

2. Step 2: Identify common synchronous methods in Express

   HTTP REST API calls are widely used for synchronous communication between microservices in Express.

3. Final Answer:

   Using HTTP REST API calls between services -> Option C

4. Quick Check:

   Synchronous communication = HTTP REST API calls [OK]

Hint: Sync communication usually uses HTTP requests [OK]

Common Mistakes:

• Thinking direct DB access is common for microservices
• Assuming shared memory works across services
• Using file system for communication

2. Which Express code snippet correctly sends a JSON response from one microservice to another?

easy

A. res.json({ data: 'value' })

B. res.write({ data: 'value' })

C. res.send("{ data: 'value' }")

D. res.render({ data: 'value' })

Solution

1. Step 1: Identify Express method for JSON response

   Express provides res.json() to send JSON formatted responses easily.

2. Step 2: Compare other methods

   res.send() can send JSON but res.json() is preferred for clarity; res.write() is low-level and res.render() is for templates.

3. Final Answer:

   res.json({ data: 'value' }) -> Option A

4. Quick Check:

   Express JSON response = res.json() [OK]

Hint: Use res.json() to send JSON responses in Express [OK]

Common Mistakes:

• Using res.send() without JSON stringification
• Confusing res.render() with JSON response
• Using res.write() incorrectly

3. Consider two microservices where Service A calls Service B using HTTP GET. What will Service A receive if Service B responds with res.status(200).json({ message: 'Success' })?

medium

A. A JSON object { message: 'Success' }

B. A plain text 'Success' string

C. An HTTP 404 error

D. An empty response

Solution

1. Step 1: Understand Service B's response

   Service B sends HTTP status 200 with JSON body { message: 'Success' }.

2. Step 2: Determine what Service A receives

   Service A receives the JSON object exactly as sent, since status 200 means OK and body is JSON.

3. Final Answer:

   A JSON object { message: 'Success' } -> Option A

4. Quick Check:

   HTTP 200 + res.json() = JSON object response [OK]

Hint: HTTP 200 with res.json() returns JSON object [OK]

Common Mistakes:

• Assuming plain text instead of JSON
• Confusing status codes with response body
• Expecting empty or error response

4. In an Express microservice, the following code is used to call another service asynchronously. What is the main issue?

fetch('http://service-b/api/data')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.log(error))

medium

A. Missing await keyword for fetch call

B. fetch is not defined in Node.js by default

C. No error handling for non-JSON responses

D. Using console.log instead of res.send

Solution

1. Step 1: Check environment support for fetch

   Node.js versions before 18 do not have fetch globally defined by default.

2. Step 2: Identify the main issue in Express microservice

   Without importing or enabling fetch, this code will cause a ReferenceError in Node.js.

3. Final Answer:

   fetch is not defined in Node.js by default -> Option B

4. Quick Check:

   Node.js needs fetch polyfill or version 18+ [OK]

Hint: Node.js needs fetch polyfill or v18+ for fetch [OK]

Common Mistakes:

• Thinking await is mandatory with then() chains
• Ignoring fetch availability in Node.js
• Confusing console.log with response sending

5. You want to design communication between two Express microservices where Service A sends a task to Service B and does not wait for a response. Which approach is best to ensure reliable, scalable communication?

hard

A. Use WebSocket connection for real-time two-way communication

B. Use HTTP POST with immediate response from Service B

C. Use direct database writes by Service A for Service B to poll

D. Use a message queue like RabbitMQ for asynchronous messaging

Solution

1. Step 1: Understand asynchronous communication needs

   Service A sends a task and does not wait, so async messaging is needed.

2. Step 2: Evaluate options for reliability and scalability

   Message queues like RabbitMQ provide reliable, scalable async communication with delivery guarantees.

3. Final Answer:

   Use a message queue like RabbitMQ for asynchronous messaging -> Option D

4. Quick Check:

   Async + reliable + scalable = message queue [OK]

Hint: Async tasks use message queues for reliability [OK]

Common Mistakes:

• Using HTTP POST expecting async without waiting
• Relying on database polling which is inefficient
• Using WebSocket for one-way async tasks