Nginx 与 BFF 架构

┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐
│  Apache 称霸    │ → │  C10K 问题爆发  │ → │  Nginx 诞生     │ → │  现代基础设施    │
│  (1995-2000)    │   │  (2000-2004)    │   │  (2004-2010)    │   │  (2010-至今)    │
│  同步阻塞模型   │   │  万级并发瓶颈   │   │  事件驱动模型   │   │  反向代理标配    │
└─────────────────┘   └─────────────────┘   └─────────────────┘   └─────────────────┘

问题：Apache 的进程/线程模型无法应对万级并发

Apache：每个连接 = 一个进程（2-10MB 内存）
         1 万连接 = 20-100GB 内存 → OOM 崩溃

解决：事件驱动 + 异步非阻塞 I/O

Nginx：一个工作进程 + epoll 事件循环 = 同时管理数千连接
       1 万连接 ≈ 几十 MB 内存 → 轻松应对

┌──────────┐         ┌───────────────────────┐         ┌──────────────┐
│  浏览器   │ ──请求──→│       Nginx           │ ──转发──→│  后端服务器   │
│          │ ←─响应──│  (反向代理层)          │ ←─返回──│  (API 服务)  │
└──────────┘         └───────────────────────┘         └──────────────┘
                      ① 接收请求 ② 路由决策 ③ 转发

# /etc/nginx/conf.d/proxy.conf

server {
    listen 80;
    server_name api.example.com;

    # 反向代理：将所有请求转发到后端 Node.js 服务
    location / {
        proxy_pass http://127.0.0.1:3000;

        # 关键 Header：把客户端真实信息传递给后端
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # 超时配置
        proxy_connect_timeout 60s;
        proxy_read_timeout 60s;
        proxy_send_timeout 60s;

        # WebSocket 支持
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

# Host：客户端请求的域名（后端用于虚拟主机判断）
proxy_set_header Host $host;

# X-Real-IP：客户端的真实 IP 地址
proxy_set_header X-Real-IP $remote_addr;

# X-Forwarded-For：代理链路上所有 IP 的列表（用于追踪请求路径）
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

# X-Forwarded-Proto：客户端使用的协议（http 或 https）
proxy_set_header X-Forwarded-Proto $scheme;

// Express 中获取客户端真实 IP
app.get("/api/user", (req, res) => {
  // 被 Nginx 代理后，req.ip 拿到的是 127.0.0.1（Nginx 的 IP）
  // 需要从 X-Forwarded-For 中获取真实客户端 IP
  const realIP = req.headers["x-forwarded-for"] || req.socket.remoteAddress;
  console.log("客户端真实 IP:", realIP);
  res.json({ ip: realIP });
});

// Express 内置的信任代理设置
app.set("trust proxy", true); // 信任 Nginx 代理，req.ip 自动解析 X-Forwarded-For

# 定义后端服务器组
upstream backend_servers {
    # IP Hash：保证同一用户的请求打到同一台服务器（解决 Session 问题）
    ip_hash;

    # 权重分配：server1 处理 3 倍于 server2 的请求
    server 192.168.1.10:3000 weight=3;
    server 192.168.1.11:3000 weight=1;

    # 备用服务器：只有当主服务器全部不可用时才启用
    server 192.168.1.12:3000 backup;

    # 健康检查配置（被动检查）
    server 192.168.1.10:3000 max_fails=3 fail_timeout=30s;
}

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://backend_servers;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

# 被动健康检查（开源版）
upstream backend {
    server 192.168.1.10:3000 max_fails=3 fail_timeout=30s;
    # max_fails=3：连续 3 次请求失败则标记为不可用
    # fail_timeout=30s：标记为不可用后，30 秒后重新尝试
}

server {
    listen 443 ssl http2;
    server_name static.example.com;

    # SSL 证书配置
    ssl_certificate /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;

    # 静态资源目录
    root /var/www/frontend/dist;

    # 带 hash 的静态资源：长期缓存（1年）
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff2?)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";

        # 开启 sendfile 零拷贝，内核直接传输文件，不经过用户态缓冲
        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;
    }

    # HTML 文件：协商缓存，每次验证新鲜度
    location ~* \.html$ {
        add_header Cache-Control "no-cache";
        etag on;
        last_modified on;
    }

    # SPA 应用的 fallback：找不到文件时返回 index.html
    location / {
        try_files $uri $uri/ /index.html;
    }
}

# 全局开启 gzip
gzip on;
gzip_vary on;                    # 添加 Vary: Accept-Encoding 响应头
gzip_proxied any;                # 代理请求也压缩
gzip_comp_level 6;               # 压缩级别 1-9，6 是性能与压缩率的平衡点
gzip_min_length 1024;            # 小于 1KB 的文件不压缩（压缩后可能更大）
gzip_types
    text/plain
    text/css
    text/javascript
    application/javascript
    application/json
    application/xml
    image/svg+xml;

server {
    listen 443 ssl http2;          # 同时开启 SSL 和 HTTP/2
    server_name www.example.com;

    ssl_certificate /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;

    # TLS 安全配置
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers on;

    # HSTS：强制浏览器使用 HTTPS 访问
    add_header Strict-Transport-Security "max-age=63072000" always;

    # HTTP/2 Server Push（推送关键资源）
    location / {
        root /var/www/frontend/dist;
        http2_push /assets/main.css;
        http2_push /assets/main.js;
    }
}

# HTTP 自动跳转 HTTPS
server {
    listen 80;
    server_name www.example.com;
    return 301 https://$server_name$request_uri;
}

浏览器: https://www.example.com  ──请求──→  https://api.example.com:3000/api/users
         ↑ 同源：协议+域名+端口一致          ↑ 不同源 → CORS 错误

解决方案：让请求先到同源的 Nginx，再由 Nginx 转发到后端

浏览器: https://www.example.com/api/users
         ↓ 同源请求（无跨域问题）
Nginx:   /api/users  ──转发──→  http://127.0.0.1:3000/api/users

// webpack.config.js 或 vite.config.js
// 原理：开发服务器内置了一个反向代理，将指定路径的请求转发到后端
module.exports = {
  devServer: {
    proxy: {
      "/api": {
        target: "http://localhost:3000", // 转发目标
        changeOrigin: true, // 修改 Origin 为目标地址
        pathRewrite: { "^/api": "" }, // 路径重写：/api/users → /users
      },
    },
  },
};

// Vite 配置
export default defineConfig({
  server: {
    proxy: {
      "/api": {
        target: "http://localhost:3000",
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/api/, ""),
      },
    },
  },
});

server {
    listen 443 ssl http2;
    server_name www.example.com;

    ssl_certificate /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;

    # 前端静态资源
    location / {
        root /var/www/frontend/dist;
        try_files $uri $uri/ /index.html;
    }

    # API 请求代理到后端 —— 消除跨域
    location /api/ {
        proxy_pass http://127.0.0.1:3000/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

// ❌ 错误做法：生产环境用 CORS 代替代理
// 后端直接设置 Access-Control-Allow-Origin: *
// 问题：安全风险高，暴露后端真实地址，无法统一管控
app.use((req, res, next) => {
  res.header("Access-Control-Allow-Origin", "*");
  next();
});

// ✅ 正确做法：生产环境用 Nginx 反向代理
// 前端和 API 在同一个域名下，不存在跨域问题
// /api/users → Nginx → http://localhost:3000/users
// 安全、可控、统一管理

┌──────────┐  ┌──────────┐  ┌──────────┐
│  Web 前端 │  │ 移动端    │  │ 小程序    │
└─────┬────┘  └─────┬────┘  └─────┬────┘
      │             │             │
      ▼             ▼             ▼
┌──────────┐  ┌──────────┐  ┌──────────┐
│ Web BFF  │  │ Mobile   │  │ Mini BFF │  ← 每个前端一个专属 BFF
│ (Node.js)│  │ BFF      │  │ (Node.js)│
└─────┬────┘  └─────┬────┘  └─────┬────┘
      │             │             │
      └──────────┬──┴─────────────┘
                 ▼
     ┌───────────────────────┐
     │    后端微服务集群       │
     │  用户服务 | 订单服务    │
     │  商品服务 | 支付服务    │
     └───────────────────────┘

// bff-server.js —— 基于 Express 的 BFF 服务
const express = require("express");
const axios = require("axios");

const app = express();

// 接口聚合：前端只需一次请求，BFF 聚合多个后端服务
app.get("/api/home", async (req, res) => {
  try {
    const userId = req.headers["x-user-id"];

    // 并行请求多个后端微服务
    const [userInfo, recommendations, notifications] = await Promise.all([
      axios.get(`http://user-service:3001/users/${userId}`),
      axios.get(`http://recommend-service:3002/recommendations`, {
        params: { userId, limit: 10 },
      }),
      axios.get(`http://notify-service:3003/notifications/unread`, {
        params: { userId },
      }),
    ]);

    // 数据裁剪 + 格式转换：按前端需要的结构组装
    res.json({
      user: {
        name: userInfo.data.name,
        avatar: userInfo.data.avatar_url,
        // 移除前端不需要的 internal_id、permissions 等字段
      },
      recommendations: recommendations.data.items.map((item) => ({
        id: item.product_id,
        title: item.product_name,
        price: item.current_price,
        image: item.cover_url,
      })),
      unreadCount: notifications.data.count,
    });
  } catch (error) {
    // 统一错误处理
    res.status(502).json({
      error: "BFF 聚合请求失败",
      detail: error.message,
    });
  }
});

// 数据裁剪：移动端专用接口，只返回必要字段
app.get("/api/mobile/product/:id", async (req, res) => {
  const { data } = await axios.get(
    `http://product-service:3004/products/${req.params.id}`,
  );

  // 移动端只保留核心字段，减少传输体积
  res.json({
    id: data.id,
    title: data.name,
    price: data.current_price,
    thumbnail: data.images[0],
    rating: data.average_rating,
  });
});

app.listen(4000, () => {
  console.log("BFF 服务运行在 http://localhost:4000");
});

// Nginx 事件循环核心逻辑（极度简化）
void ngx_process_events_and_timers(ngx_cycle_t *cycle) {
    // 1. 调用 epoll_wait，阻塞等待事件（带超时）
    //    超时时间由最近的定时器决定
    ngx_int_t n = epoll_wait(ep, events, nevents, timer);

    // 2. 遍历就绪事件，逐个处理
    for (i = 0; i < n; i++) {
        ev = events[i].data.ptr;

        // 3. 根据事件类型调用对应的 handler
        if (ev->accept) {
            ngx_event_accept(ev);      // 新连接事件
        } else {
            ngx_event_recvmsg(ev);     // 读事件
            ngx_event_sendmsg(ev);     // 写事件
        }
    }

    // 4. 处理超时事件（定时器）
    ngx_event_expire_timers();
}

// sendfile 零拷贝的核心流程
// 传统方式：磁盘 → 内核缓冲区 → 用户缓冲区 → 内核 socket 缓冲区 → 网卡
// sendfile：  磁盘 → 内核缓冲区 → 网卡（跳过用户态拷贝）

sent = sendfile(c->fd,       // 目标 socket 文件描述符
                file_fd,      // 源文件文件描述符
                &offset,      // 文件偏移量
                size);        // 发送字节数