Microservice communication basics in Express

Introduction

Microservices need to talk to each other to work together. Communication basics help them share data and tasks smoothly.

When building a shopping app where the cart service talks to the product service.

When a user service needs to check permissions from an auth service.

When an order service sends payment info to a billing service.

When a notification service sends alerts after an event happens.

When scaling parts of an app independently but they still need to work together.

Syntax

Express

HTTP request example:
GET /service-endpoint HTTP/1.1
Host: service-host

OR

Message queue example:
Producer sends message to queue
Consumer listens and processes message

Microservices often use HTTP or messaging to communicate.

HTTP is simple and synchronous; messaging is good for async tasks.

Examples

This shows a microservice calling another via HTTP GET to get product info.

Express

GET /products/123 HTTP/1.1
Host: product-service

Response: 200 OK
{
  "id": 123,
  "name": "Shoes",
  "price": 50
}

This shows async communication using a message queue between services.

Express

Producer sends message:
{
  "orderId": 456,
  "status": "paid"
}

Consumer listens and updates order status.

Sample Program

This example shows two microservices in one app: a product service and an order service. The order service calls the product service using HTTP to get product details.

Express

const express = require('express');
const app = express();
const port = 3000;

// Product service
app.get('/product/:id', (req, res) => {
  const product = { id: req.params.id, name: 'Book', price: 20 };
  res.json(product);
});

// Order service calls product service
const fetch = require('node-fetch');

app.get('/order/:id', async (req, res) => {
  const productId = 1;
  const response = await fetch(`http://localhost:3000/product/${productId}`);
  const product = await response.json();
  res.json({ orderId: req.params.id, product });
});

app.listen(port, () => {
  console.log(`Services running on port ${port}`);
});

Important Notes

Use REST or messaging based on your app needs.

Keep communication simple and clear to avoid confusion.

Handle failures gracefully, like retries or fallbacks.

Summary

Microservices communicate mainly via HTTP or messaging.

Choose sync or async communication based on task needs.

Design communication to be reliable and easy to maintain.

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