Node.js Backend Development Bootcamp · 课时

实现 API 网关

设计并设置 API 网关，使其成为客户端请求微服务的统一入口

实现 API 网关 是 CoddyKit 上的免费 Node.js Backend Development Bootcamp 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Node.js Backend Development Bootcamp 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Node.js Backend Development Bootcamp 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

API Gateway: The Front Door

In a microservices architecture, clients often need to interact with many different services. An API Gateway acts as a single, unified entry point for all client requests.

Think of it as the front desk of a large hotel. Instead of guests having to find specific rooms (microservices) themselves, they go to the front desk which directs them to the right place and handles common requests.

Why Use an API Gateway?

API Gateways solve several challenges that arise when using microservices:

Simplifies Clients: Clients only need to know one endpoint (the gateway) instead of many microservice URLs.
Request Routing: Directs incoming requests to the correct backend service.
Common Concerns: Handles cross-cutting concerns like authentication, rate limiting, and logging at a single point.
Service Aggregation: Can combine responses from multiple services into a single client-friendly response.

Gateway vs. Load Balancer

It's easy to confuse an API Gateway with a Load Balancer, but they serve different purposes:

Load Balancer: Operates at the network layer (Layer 4) or application layer (Layer 7) to distribute traffic across multiple instances of the same service for high availability and performance.
API Gateway: Operates at the application layer (Layer 7) and focuses on API-specific concerns. It routes requests to different services and can perform transformations or security checks.

They often work together, with a load balancer sitting in front of the API Gateway.

Key Responsibilities of a Gateway

An API Gateway takes on several crucial roles:

Request Routing: Mapping specific API paths (e.g., /users) to the appropriate microservice.
Authentication & Authorization: Verifying user identity and permissions before forwarding requests.
Rate Limiting: Controlling the number of requests a client can make within a certain timeframe.
Caching: Storing frequently accessed data to reduce load on backend services and improve response times.
Logging & Monitoring: Centralizing logs for all incoming requests and outgoing responses.

Building a Simple Gateway

You can build a custom API Gateway using Node.js and frameworks like Express.js. A popular library for proxying HTTP requests in Express is http-proxy-middleware.

This library makes it easy to forward requests from your gateway to your backend microservices, acting as a reverse proxy.

Basic Proxy Setup

Let's set up a simple Express.js server that acts as a proxy. This gateway will listen on port 3000 and forward all requests starting with /api to a mock 'users' microservice on port 3001.

Remember, for full functionality, you'd need an actual microservice running at http://localhost:3001.

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

const app = express();
const GATEWAY_PORT = 3000;

// Proxy all requests starting with /api to the users microservice
app.use(
  '/api',
  createProxyMiddleware({
    target: 'http://localhost:3001', // Target URL of your users microservice
    changeOrigin: true, // Needed for virtual hosted sites
    logLevel: 'debug' // Optional: for seeing proxy activity in console
  })
);

// Simple root route for gateway status
app.get('/', (req, res) => {
  res.send('API Gateway is running. Try /api/users (if microservice is active).');
});

app.listen(GATEWAY_PORT, () => {
  console.log(`API Gateway listening on port ${GATEWAY_PORT}`);
  console.log('Proxying /api to http://localhost:3001');
});

Routing to Multiple Services

The power of an API Gateway comes from its ability to route requests to different microservices based on the request path, HTTP method, or other criteria.

You can define multiple proxy rules, each pointing to a different backend service. For example, /users goes to the user service, and /products goes to the product service.

Multi-Service Routing Example

Here, we extend our gateway to route requests for /users to a 'users-service' on port 3001 and requests for /products to a 'products-service' on port 3002.

The pathRewrite option is important: it removes the path prefix (e.g., /users) before forwarding the request to the target service.

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

const app = express();
const GATEWAY_PORT = 3000;

// Proxy for user-related requests
app.use(
  '/users',
  createProxyMiddleware({
    target: 'http://localhost:3001', // Users Microservice URL
    changeOrigin: true,
    pathRewrite: { '^/users': '' }, // Remove /users prefix
    logLevel: 'debug'
  })
);

// Proxy for product-related requests
app.use(
  '/products',
  createProxyMiddleware({
    target: 'http://localhost:3002', // Products Microservice URL
    changeOrigin: true,
    pathRewrite: { '^/products': '' }, // Remove /products prefix
    logLevel: 'debug'
  })
);

app.get('/', (req, res) => {
  res.send('API Gateway is running. Try /users or /products (if microservices are active).');
});

app.listen(GATEWAY_PORT, () => {
  console.log(`API Gateway listening on port ${GATEWAY_PORT}`);
  console.log('Proxying /users to http://localhost:3001');
  console.log('Proxying /products to http://localhost:3002');
});

Centralized Middleware for Gateway

One of the biggest advantages of an API Gateway is applying middleware for common concerns before requests even reach your microservices.

You can implement Express middleware functions globally or for specific routes within your gateway to handle tasks like:

Authentication: Verify JWTs or session tokens.
Logging: Log every incoming request.
Rate Limiting: Prevent abuse by limiting request frequency.
Input Validation: Basic validation before forwarding.

Quick Check on Gateway

An API Gateway serves as a crucial component in a microservices setup. Let's test your understanding of its primary purpose.

Gateway Summary

You've learned about API Gateways, their importance in microservices, and how to implement a basic one using Express.js and http-proxy-middleware.

Key takeaways:

API Gateways simplify client interactions by providing a single entry point.
They handle routing, authentication, rate limiting, and other cross-cutting concerns.
Express.js with http-proxy-middleware is a flexible way to build custom gateways.

Mastering API Gateways is essential for building robust and scalable microservices!

常见问题解答

「实现 API 网关」课时是免费的吗？

是的 — 「实现 API 网关」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Node.js Backend Development Bootcamp 课程的其余内容，请升级到 CoddyKit PRO。 Node.js Backend Development Bootcamp 课程共包含 4 节课。

「实现 API 网关」这节课中我会学到什么？

设计并设置 API 网关，使其成为客户端请求微服务的统一入口你通过在浏览器中直接运行的动手代码来练习 Node.js Backend Development Bootcamp，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Node.js Backend Development Bootcamp 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Node.js Backend Development Bootcamp 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「实现 API 网关」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Node.js Backend Development Bootcamp 课中编写并运行代码吗？

能。每节 Node.js Backend Development Bootcamp 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Node.js Backend Development Bootcamp