基于Express.js与Docker理解微服务架构：新手技术咨询

Hey there! Let's walk through how this example connects to microservices concepts, and how you can expand it with Docker to get hands-on with real-world implementation.

First, let's fill in the missing part of your index.js to make it functional, then break down what it's doing:

var express = require("express");
var app = express();
var service1 = require("./service1");
var service2 = require("./service2");

app.use("/serviceonerequest", service1);
app.use("/servicetwo", service2);

app.listen(3000, function() {
  console.log("API Gateway running on port 3000");
});

1. What This Code Already Does (Gateway Pattern Basics) #

• You’ve built a simple API gateway (the main Express app in index.js)—a core microservices component that acts as a single entry point for clients, routing requests to separate services.
• Right now, service1 and service2 are Express routers imported into the gateway. This is the first step toward splitting functionality into independent units: for example, service1 could handle user authentication, while service2 manages order processing.

2. Turning Routers into Truly Independent Microservices #

To make these proper microservices (each running as its own separate server), adjust your setup:

Step 1: Rewrite each service as a standalone Express app #

Example service1.js:

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

app.get("/", (req, res) => {
  res.send("Service 1 response: Handles user profile data");
});

app.listen(3001, () => {
  console.log("Service 1 running on port 3001");
});

Example service2.js:

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

app.get("/", (req, res) => {
  res.send("Service 2 response: Handles order processing");
});

app.listen(3002, () => {
  console.log("Service 2 running on port 3002");
});

Step 2: Update the gateway to forward requests via HTTP #

Use a package like axios to send requests to the independent services (install it with npm install axios):

const express = require("express");
const axios = require("axios");
const app = express();

app.use("/serviceonerequest", async (req, res) => {
  try {
    const serviceResponse = await axios.get("http://localhost:3001/");
    res.send(serviceResponse.data);
  } catch (err) {
    res.status(500).send("Service 1 is temporarily unavailable");
  }
});

app.use("/servicetwo", async (req, res) => {
  try {
    const serviceResponse = await axios.get("http://localhost:3002/");
    res.send(serviceResponse.data);
  } catch (err) {
    res.status(500).send("Service 2 is temporarily unavailable");
  }
});

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

Now each service runs independently—if one fails, the other keeps working, and you can scale them separately.

3. Containerizing with Docker (Production-Grade Setup) #

To ensure consistent deployment across environments, wrap each service in a Docker container:

Step 1: Create Dockerfiles for each service #

Place each service (gateway, service1, service2) in its own folder, with a Dockerfile like this (adjust ports and filenames as needed):

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000 # Use 3001 for service1, 3002 for service2
CMD ["node", "index.js"] # Use service1.js/service2.js for respective services

Step 2: Orchestrate with Docker Compose #

Create a docker-compose.yml file at the root to run all containers together:

version: '3.8'
services:
  gateway:
    build: ./gateway
    ports:
      - "3000:3000"
    depends_on:
      - service1
      - service2
  service1:
    build: ./service1
    ports:
      - "3001:3001"
  service2:
    build: ./service2
    ports:
      - "3002:3002"

Run docker-compose up to start all services—now the gateway can communicate with other services using their service names (e.g., http://service1:3001/ instead of localhost).

4. Key Microservices Concepts You’re Practicing #

• Service Isolation: Each service has its own codebase, dependencies, and runtime.
• API Gateway: Single entry point that simplifies client interactions and handles routing.
• Fault Isolation: A failure in one service doesn’t take down the entire system.
• Containerization: Consistent deployment across development, staging, and production.

内容的提问来源于stack exchange，提问作者user1261913