API gateway concept in Express

Introduction

An API gateway acts like a front door for all client requests to your backend services. It helps manage, secure, and route these requests easily.

When you have multiple backend services and want a single entry point for clients.

When you want to add security like authentication and rate limiting in one place.

When you need to transform or aggregate data from different services before sending to clients.

When you want to reduce the number of requests clients make by combining them.

When you want to monitor and log all incoming requests centrally.

Syntax

Express

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

// Middleware to handle authentication
app.use((req, res, next) => {
  // check auth
  next();
});

// Route to service A
app.use('/serviceA', (req, res) => {
  // forward request to service A
});

// Route to service B
app.use('/serviceB', (req, res) => {
  // forward request to service B
});

app.listen(3000);

This example shows a simple API gateway using Express.js.

Middleware can be used to add common features like authentication or logging.

Examples

Routes requests starting with /users to the user service.

Express

app.use('/users', (req, res) => {
  // forward to user service
});

Routes requests starting with /orders to the order service.

Express

app.use('/orders', (req, res) => {
  // forward to order service
});

Logs every request URL before forwarding.

Express

app.use((req, res, next) => {
  console.log(`Request to ${req.url}`);
  next();
});

Sample Program

This is a simple API gateway using Express and http-proxy.

It logs every request, then forwards requests starting with /users to a user service on port 4000, and requests starting with /orders to an order service on port 5000.

Express

const express = require('express');
const httpProxy = require('http-proxy');

const app = express();
const apiProxy = httpProxy.createProxyServer();

// Middleware for simple logging
app.use((req, res, next) => {
  console.log(`Incoming request: ${req.method} ${req.url}`);
  next();
});

// Route /users to User Service
app.all('/users/*', (req, res) => {
  apiProxy.web(req, res, { target: 'http://localhost:4000' });
});

// Route /orders to Order Service
app.all('/orders/*', (req, res) => {
  apiProxy.web(req, res, { target: 'http://localhost:5000' });
});

app.listen(3000, () => {
  console.log('API Gateway listening on port 3000');
});

Important Notes

API gateways help keep backend services simple by handling common tasks centrally.

Use proxy libraries like http-proxy to forward requests easily.

Be careful to handle errors and timeouts in the gateway to avoid client confusion.

Summary

An API gateway is a single entry point for multiple backend services.

It helps with routing, security, logging, and request management.

Express with proxy middleware is a common way to build a simple API gateway.

Practice

1. What is the primary role of an API gateway in a system using Express?

easy

A. It directly serves static files to users.

B. It stores all the data for the application.

C. It acts as a single entry point to route requests to multiple backend services.

D. It replaces the database in the backend.

Solution

1. Step 1: Understand the role of API gateway

   An API gateway acts as a single entry point that routes client requests to appropriate backend services.

2. Step 2: Eliminate incorrect roles

   Storing data, replacing databases, or serving static files are not responsibilities of an API gateway.

3. Final Answer:

   It acts as a single entry point to route requests to multiple backend services. -> Option C

4. Quick Check:

   API gateway = single entry point [OK]

Hint: API gateway routes requests centrally [OK]

Common Mistakes:

• Thinking API gateway stores data
• Confusing API gateway with database
• Assuming it serves static files directly

2. Which Express middleware is commonly used to forward requests in an API gateway setup?

easy

A. http-proxy-middleware

B. express.static()

C. body-parser

D. cors

Solution

1. Step 1: Identify middleware for proxying requests

   The http-proxy-middleware package is used to forward requests from the gateway to backend services.

2. Step 2: Differentiate from other middleware

   express.static() serves static files, body-parser parses request bodies, and cors manages cross-origin requests, none forward requests.

3. Final Answer:

   http-proxy-middleware -> Option A

4. Quick Check:

   Proxy middleware = http-proxy-middleware [OK]

Hint: Proxy requests with http-proxy-middleware [OK]

Common Mistakes:

• Using express.static() to proxy requests
• Confusing body-parser with proxying
• Assuming cors forwards requests

3. Given this Express API gateway code snippet, what will be the output when a client requests /api/users?

const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const app = express();

app.use('/api/users', createProxyMiddleware({ target: 'http://localhost:5000', changeOrigin: true }));

app.listen(3000);

medium

A. The request results in a 404 error

B. The request is served by Express app on port 3000

C. The request is blocked by CORS policy

D. The request is forwarded to http://localhost:5000/api/users

Solution

1. Step 1: Analyze the proxy middleware setup

   The middleware forwards requests matching /api/users to http://localhost:5000, preserving the path.

2. Step 2: Understand request forwarding behavior

   The request /api/users on port 3000 is proxied to http://localhost:5000/api/users.

3. Final Answer:

   The request is forwarded to http://localhost:5000/api/users -> Option D

4. Quick Check:

   Proxy forwards /api/users to target URL [OK]

Hint: Proxy forwards matching paths to target server [OK]

Common Mistakes:

• Assuming Express serves the request itself
• Expecting 404 without backend running
• Confusing CORS blocking with proxy behavior

4. Identify the error in this Express API gateway code snippet:

const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const app = express();

app.use('/api', createProxyMiddleware({ target: 'http://localhost:4000' }));

app.listen(3000);

// Client requests /api/users but gets no response

medium

A. Missing changeOrigin: true causes backend to reject requests

B. The target URL is incorrect and unreachable

C. The middleware is not mounted on the correct path

D. Express app is not listening on port 3000

Solution

1. Step 1: Check proxy middleware options

   Without changeOrigin: true, the Host header sent to backend remains the gateway's, which may cause backend to reject requests.

2. Step 2: Verify other parts

   The target URL and path are correct, and app listens on port 3000, so those are not errors.

3. Final Answer:

   Missing changeOrigin: true causes backend to reject requests -> Option A

4. Quick Check:

   changeOrigin fixes Host header issues [OK]

Hint: Add changeOrigin: true to fix backend rejection [OK]

Common Mistakes:

• Ignoring changeOrigin option
• Assuming wrong target URL without checking
• Thinking app.listen is missing

5. You want to design an Express API gateway that routes requests to multiple backend services and also logs each request's method and URL. Which approach best fits this requirement?

hard

A. Use only express.static() to serve all backend services and log requests.

B. Use http-proxy-middleware for routing and add a custom middleware before it to log requests.

C. Implement routing logic inside each backend service and skip the gateway.

D. Use body-parser middleware to route and log requests.

Solution

1. Step 1: Identify routing and logging needs

   The API gateway must route requests to multiple backends and log method and URL of each request.

2. Step 2: Choose appropriate middleware

   http-proxy-middleware handles routing, and a custom Express middleware can log requests before proxying.

3. Step 3: Eliminate incorrect options

   express.static() serves static files only, backend routing skips gateway, and body-parser parses bodies but does not route or log.

4. Final Answer:

   Use http-proxy-middleware for routing and add a custom middleware before it to log requests. -> Option B

5. Quick Check:

   Proxy + custom middleware = routing + logging [OK]

Hint: Log requests before proxying with custom middleware [OK]

Common Mistakes:

• Using express.static() for routing
• Skipping gateway for routing
• Confusing body-parser with routing