nginx

关注公众号 jb51net

关闭
首页 > 网站技巧 > 服务器 > nginx > Nginx虚拟主机配置

Nginx中虚拟主机的三种配置方式详解

作者：知远漫谈

本文将深入探讨如何通过 Nginx 实现基于域名、端口、IP 地址的多站点部署,覆盖从基础配置到高阶实战的完整路径,并结合 Java 应用场景提供可运行的示例代码,帮助你构建一个稳定、可扩展、安全的多站点服务架构

在现代 Web 架构中，单一服务器承载多个网站已成为常态。无论是小型创业公司还是大型企业，都希望在有限的硬件资源下最大化服务效率。Nginx 作为高性能、轻量级的反向代理与 Web 服务器，凭借其出色的并发处理能力与灵活的虚拟主机配置机制，成为众多开发者的首选。本文将深入探讨如何通过 Nginx 实现基于域名、端口、IP 地址的多站点部署，覆盖从基础配置到高阶实战的完整路径，并结合 Java 应用场景提供可运行的示例代码，帮助你构建一个稳定、可扩展、安全的多站点服务架构。

什么是虚拟主机（Virtual Host）？

虚拟主机（Virtual Host）是 Web 服务器通过单一 IP 地址或端口，为多个不同域名或站点提供服务的技术。它允许你在一台服务器上运行多个网站，每个网站拥有独立的根目录、配置文件、SSL 证书和访问日志，对用户而言，就像各自运行在独立的物理服务器上一样。

Nginx 的虚拟主机机制基于 server 块定义，每个 server 块代表一个独立的站点。Nginx 通过解析客户端请求中的 Host 头、目标端口和绑定 IP 地址，匹配最合适的 server 块进行响应。

小知识：Apache 也有类似机制，称为“Name-based Virtual Hosts”，但 Nginx 在高并发场景下的内存占用与响应速度更具优势，尤其适合现代微服务架构。

Nginx 配置文件结构概览

在开始配置之前，我们先了解 Nginx 的核心配置文件结构。通常，Nginx 的主配置文件位于：

主配置文件中，通常包含以下关键部分：

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    tcp_nopush      on;
    tcp_nodelay     on;
    keepalive_timeout  65;
    types_hash_max_size 2048;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}

关键点：include /etc/nginx/conf.d/*.conf; 表示 Nginx 会加载 conf.d 目录下所有 .conf 文件，这是推荐的多站点管理方式，便于模块化与版本控制。

我们将在 conf.d 目录下为每个站点创建独立的配置文件，如：

基于域名的虚拟主机（Name-based Virtual Host）

这是最常见的虚拟主机类型。多个域名共享同一个 IP 地址和端口（通常是 80 或 443），Nginx 通过 Host 请求头区分请求属于哪个站点。

场景说明

假设你有一台服务器，IP 为 192.168.1.10，你想部署三个网站：

它们都监听 80 端口，但内容完全不同。

配置文件示例

在 /etc/nginx/conf.d/ 下创建三个文件：

1.www.example.com.conf

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

    root /var/www/www.example.com/html;
    index index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }

    access_log /var/log/nginx/www.example.com.access.log;
    error_log /var/log/nginx/www.example.com.error.log;
}

2.blog.example.com.conf

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

    root /var/www/blog.example.com/html;
    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
    }

    access_log /var/log/nginx/blog.example.com.access.log;
    error_log /var/log/nginx/blog.example.com.error.log;
}

3.shop.example.com.conf

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

    root /var/www/shop.example.com/html;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # 静态资源缓存
    location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
        expires 30d;
        add_header Cache-Control "public, no-transform";
    }

    access_log /var/log/nginx/shop.example.com.access.log;
    error_log /var/log/nginx/shop.example.com.error.log;
}

Java 应用集成示例

虽然 Nginx 本身是静态服务器，但常作为 Java Web 应用（如 Spring Boot）的反向代理。我们来模拟一个场景：

你有一个 Spring Boot 应用，运行在 localhost:8081，希望通过 api.example.com 访问。

Java 代码：Spring Boot REST API

package com.example.apiserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
@SpringBootApplication
@RestController
public class ApiServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiServerApplication.class, args);
    }
    @GetMapping("/health")
    public Map<String, Object> healthCheck() {
        Map<String, Object> response = new HashMap<>();
        response.put("status", "UP");
        response.put("service", "API Server v1.2");
        response.put("timestamp", System.currentTimeMillis());
        response.put("message", "✅ Nginx + Java integration working!");
        return response;
    }
    @GetMapping("/user/{id}")
    public Map<String, Object> getUser(@PathVariable("id") Long id) {
        Map<String, Object> user = new HashMap<>();
        user.put("id", id);
        user.put("name", "张三");
        user.put("email", "zhangsan@example.com");
        user.put("role", "admin");
        return user;
    }
}

Nginx 配置：反向代理到 Java 应用

在 /etc/nginx/conf.d/api.example.com.conf 中：

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

    location / {
        proxy_pass http://127.0.0.1:8081;
        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 5s;
        proxy_send_timeout 30s;
        proxy_read_timeout 30s;
    }

    access_log /var/log/nginx/api.example.com.access.log;
    error_log /var/log/nginx/api.example.com.error.log;
}

重启 Nginx 后，访问 http://api.example.com/health 将返回 Java 应用的 JSON 响应。

DNS 与本地测试

为了在本地测试，你需要修改 /etc/hosts（Linux/macOS）或 C:\Windows\System32\drivers\etc\hosts（Windows）：

192.168.1.10 www.example.com
192.168.1.10 blog.example.com
192.168.1.10 shop.example.com
192.168.1.10 api.example.com

然后在浏览器中访问：

提示：若你使用 Docker，可将 Java 应用部署在容器中，Nginx 通过 proxy_pass http://app-container:8081; 进行代理，实现真正的隔离部署。

基于端口的虚拟主机（Port-based Virtual Host）

当多个站点需要共享同一个域名，但提供不同服务时，端口绑定成为理想方案。例如：

这种配置常用于内部系统、测试环境或微服务架构中。

场景说明

假设你有一个主站 example.com，同时部署了：

配置文件示例

1. 主站（端口 80）

server {
    listen 80;
    server_name example.com;

    root /var/www/example.com/main;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    access_log /var/log/nginx/example.com-main.access.log;
    error_log /var/log/nginx/example.com-main.error.log;
}

2. 管理后台（端口 8080）

server {
    listen 8080;
    server_name example.com;

    root /var/www/example.com/admin;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # 限制访问来源（仅允许内网）
    allow 192.168.1.0/24;
    deny all;

    access_log /var/log/nginx/example.com-admin.access.log;
    error_log /var/log/nginx/example.com-admin.error.log;
}

3. Swagger API 文档（端口 9000）

server {
    listen 9000;
    server_name example.com;

    root /var/www/example.com/swagger;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # 允许跨域访问（前端调用）
    add_header Access-Control-Allow-Origin "*";
    add_header Access-Control-Allow-Methods "GET, POST, OPTIONS";
    add_header Access-Control-Allow-Headers "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Authorization";

    access_log /var/log/nginx/example.com-swagger.access.log;
    error_log /var/log/nginx/example.com-swagger.error.log;
}

Java 应用：部署 Swagger UI

如果你使用 Spring Boot，只需引入依赖：

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.3.0</version>
</dependency>

然后启动应用，监听 8081 端口：

@SpringBootApplication
public class SwaggerApp {
    public static void main(String[] args) {
        System.setProperty("server.port", "8081");
        SpringApplication.run(SwaggerApp.class, args);
    }
}

Nginx 反向代理配置：

server {
    listen 9000;
    server_name example.com;

    location / {
        proxy_pass http://127.0.0.1:8081/v3/api-docs;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /swagger-ui/ {
        proxy_pass http://127.0.0.1:8081/swagger-ui/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    access_log /var/log/nginx/example.com-swagger.access.log;
    error_log /var/log/nginx/example.com-swagger.error.log;
}

注意事项

基于 IP 的虚拟主机（IP-based Virtual Host）

当多个站点使用相同域名和端口，但需要绑定不同 IP 地址时，使用 IP-based 虚拟主机。这在以下场景非常有用：

场景说明

你有两块网卡，或通过 VLAN 分配了两个 IP：

两个站点都使用 example.com，但通过不同 IP 访问。

配置文件示例

1. 外网官网（IP: 192.168.1.10）

server {
    listen 192.168.1.10:80;
    server_name example.com;

    root /var/www/public-site;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    access_log /var/log/nginx/public-site.access.log;
    error_log /var/log/nginx/public-site.error.log;
}

2. 内部后台（IP: 192.168.1.11）

server {
    listen 192.168.1.11:80;
    server_name example.com;

    root /var/www/internal-admin;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # 仅允许内网访问
    allow 192.168.1.0/24;
    deny all;

    access_log /var/log/nginx/internal-admin.access.log;
    error_log /var/log/nginx/internal-admin.error.log;
}

如何测试

在客户端机器上，分别访问：

若你在浏览器中访问 http://example.com，Nginx 会匹配 server_name example.com，但不会区分 IP，除非你显式绑定 IP。

安全建议

location / {
    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/.htpasswd;
    try_files $uri $uri/ =404;
}

生成密码文件：

sudo apt install apache2-utils
htpasswd -c /etc/nginx/.htpasswd admin

多种方式组合：高级虚拟主机策略

现实世界中，很少只使用单一方式。优秀的架构往往是域名 + 端口 + IP的组合策略。

案例：企业级多租户系统

你是一家 SaaS 平台提供商，为多个客户（客户A、客户B）提供独立子域名服务，同时：

架构如下：

服务类型域名端口IP说明
客户前端customerA.yourcompany.com80192.168.1.10静态 HTML + JS
客户前端customerB.yourcompany.com80192.168.1.10静态 HTML + JS
管理后台admin.yourcompany.com8081192.168.1.10Java Spring Boot
内部服务internal.yourcompany.com80192.168.1.11仅限内网访问

Nginx 配置文件集合

customerA.yourcompany.com.conf

server {
    listen 80;
    server_name customerA.yourcompany.com;

    root /var/www/customers/customerA;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # 缓存静态资源
    location ~* \.(css|js|png|jpg|jpeg|gif|ico)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    access_log /var/log/nginx/customerA.access.log;
    error_log /var/log/nginx/customerA.error.log;
}

customerB.yourcompany.com.conf

server {
    listen 80;
    server_name customerB.yourcompany.com;

    root /var/www/customers/customerB;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # 自定义响应头（用于客户品牌识别）
    add_header X-Customer-ID "B-2024";

    access_log /var/log/nginx/customerB.access.log;
    error_log /var/log/nginx/customerB.error.log;
}

admin.yourcompany.com.conf

server {
    listen 8081;
    server_name admin.yourcompany.com;

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

    # 限制仅公司内网访问
    allow 192.168.1.0/24;
    allow 10.0.0.0/8;
    deny all;

    access_log /var/log/nginx/admin.access.log;
    error_log /var/log/nginx/admin.error.log;
}

internal.yourcompany.com.conf

server {
    listen 192.168.1.11:80;
    server_name internal.yourcompany.com;

    root /var/www/internal;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # 禁止外部访问
    deny all;

    access_log /var/log/nginx/internal.access.log;
    error_log /var/log/nginx/internal.error.log;
}

Mermaid 架构图：多租户系统拓扑

此图清晰展示了流量如何根据域名、端口、IP 被路由到不同后端服务。在实际运维中，这种拓扑结构能极大提升系统弹性与安全性。

SSL/TLS 加密：HTTPS 虚拟主机配置

安全是现代 Web 的基石。为每个虚拟主机配置 HTTPS，不仅能保护用户数据，还能提升 SEO 排名。

使用 Let’s Encrypt 免费证书

我们使用 certbot 自动申请证书（以 Ubuntu 22.04 为例）：

sudo apt update
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d www.example.com -d blog.example.com -d shop.example.com

Certbot 会自动修改 Nginx 配置，添加 SSL 监听与证书路径。

生成的 HTTPS 配置示例

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

    ssl_certificate /etc/letsencrypt/live/www.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/www.example.com/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512;
    ssl_prefer_server_ciphers off;

    root /var/www/www.example.com/html;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    access_log /var/log/nginx/www.example.com.ssl.access.log;
    error_log /var/log/nginx/www.example.com.ssl.error.log;
}

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

Java 应用 HTTPS 集成

如果你的 Java 应用也启用 HTTPS（如 Spring Boot），你需要：

生成 keystore：

keytool -genkey -alias tomcat -keyalg RSA -keystore keystore.jks

在 application.properties 中配置：

server.port=8443
server.ssl.key-store=classpath:keystore.jks
server.ssl.key-store-password=changeit
server.ssl.key-password=changeit
server.ssl.key-store-type=JKS

Nginx 反向代理：

server {
    listen 443 ssl;
    server_name api.example.com;

    ssl_certificate /etc/letsencrypt/live/api.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/api.example.com/privkey.pem;

    location / {
        proxy_pass https://127.0.0.1:8443;
        proxy_ssl_verify off; # 仅在自签名证书时使用，生产环境请开启
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

重要提示：生产环境请关闭 proxy_ssl_verify off，并配置 proxy_ssl_trusted_certificate 指向 CA 证书链。

性能优化与最佳实践

1.启用 Gzip 压缩

gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

2.缓存静态资源

location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff|woff2|ttf|svg)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
    access_log off;
}

3.限制请求速率（防刷）

limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;

server {
    location /api/ {
        limit_req zone=api_limit burst=20 nodelay;
        proxy_pass http://backend;
    }
}

4.启用 HTTP/2

listen 443 ssl http2;

HTTP/2 支持多路复用，显著提升页面加载速度，尤其适合多资源站点。

5.日志分离与轮转

为每个站点配置独立日志，便于排查问题：

# 编辑 /etc/logrotate.d/nginx
/var/log/nginx/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 www-data adm
    sharedscripts
    postrotate
        [ -f /var/run/nginx.pid ] && kill -USR1 `cat /var/run/nginx.pid`
    endscript
}

Java + Nginx + Docker 实战演练

我们构建一个完整的多站点 Docker 环境，包含：

项目结构

nginx-multi-site/
├── nginx/
│   ├── nginx.conf
│   └── sites-available/
│       ├── frontend.conf
│       └── api.conf
├── java-api/
│   ├── src/
│   │   └── main/java/com/example/ApiApplication.java
│   └── Dockerfile
├── frontend/
│   ├── index.html
│   └── Dockerfile
└── docker-compose.yml

docker-compose.yml

version: '3.8'
services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/sites-available:/etc/nginx/conf.d
      - ./frontend:/var/www/frontend
    depends_on:
      - java-api
    restart: unless-stopped
  java-api:
    build: ./java-api
    ports:
      - "8081:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
    restart: unless-stopped
  frontend:
    build: ./frontend
    ports:
      - "8082:80"
    restart: unless-stopped

java-api/Dockerfile

FROM openjdk:17-jre-slim

WORKDIR /app

COPY target/api-1.0.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java","-jar","app.jar"]

frontend/Dockerfile

FROM nginx:alpine

COPY index.html /usr/share/nginx/html/index.html
COPY index.html /usr/share/nginx/html/404.html

EXPOSE 80

frontend/index.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>前端站点</title>
</head>
<body>
    <h1>🎉 欢迎访问前端站点</h1>
    <p>调用 API：<a href="http://localhost/api/health" rel="external nofollow" >/api/health</a></p>
    <script>
        fetch('http://nginx/api/health')
            .then(r => r.json())
            .then(data => console.log('API 响应:', data))
            .catch(e => console.error('调用失败:', e));
    </script>
</body>
</html>

nginx/sites-available/frontend.conf

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

    root /var/www/frontend;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

nginx/sites-available/api.conf

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

    location /api/ {
        proxy_pass http://java-api:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

启动服务

cd nginx-multi-site
docker-compose up --build

访问：

这是一个完整可运行的多站点架构，支持未来扩展：添加数据库、缓存、负载均衡器等。

常见错误与调试技巧

问题原因解决方案
404 Not Foundroot 路径错误或文件不存在使用 ls -la /var/www/site 检查文件是否存在
502 Bad GatewayJava 应用未启动或端口错误curl http://localhost:8081/health 测试后端
SSL_ERROR_BAD_CERT_DOMAIN证书域名不匹配使用 openssl x509 -in cert.pem -text -noout 查看证书域名
nginx: [emerg] bind() to 0.0.0.0:80 failed端口被占用sudo lsof -i :80，sudo kill -9 <PID>
server_name 不生效缺少 listen 或域名拼写错误检查大小写、是否包含 www、是否用通配符 *.example.com

调试命令

# 检查配置语法
sudo nginx -t

# 重载配置（不中断服务）
sudo nginx -s reload

# 查看正在监听的端口
sudo ss -tuln | grep nginx

# 查看访问日志实时流
tail -f /var/log/nginx/www.example.com.access.log

# 模拟请求测试
curl -H "Host: blog.example.com" http://192.168.1.10

监控与自动化

使用 Prometheus + Grafana 监控 Nginx

在 Nginx 中启用 stub_status：

location /nginx_status {
    stub_status;
    allow 127.0.0.1;
    deny all;
}

然后使用 nginx-prometheus-exporter 导出指标：

# docker-compose.yml 添加
nginx-exporter:
  image: nginx/nginx-prometheus-exporter:0.10.0
  ports:
    - "9113:9113"
  command: -nginx.scrape-uri=http://nginx/nginx_status
  depends_on:
    - nginx

在 Grafana 中导入 Nginx Dashboard 即可可视化 QPS、连接数、响应时间。

与其他技术的对比

方案优点缺点适用场景
Nginx 虚拟主机高性能、低内存、配置灵活无内置负载均衡（需 upstream）多站点、静态资源、反向代理
Apache VirtualHost模块丰富、.htaccess 支持内存占用高、线程模型效率低传统 PHP 网站、共享主机
Traefik自动发现、Docker 集成好配置复杂、学习曲线陡峭微服务、Kubernetes
HAProxy专业负载均衡、TCP/HTTP 代理无静态文件服务能力高并发 API 网关、TCP 转发

推荐：中小型项目用 Nginx，大型微服务用 Traefik + Nginx 组合。

未来趋势：云原生与 Nginx Ingress

随着 Kubernetes 的普及，Nginx Ingress Controller 成为标准组件。它本质上是 Nginx 的 Kubernetes 插件，支持：

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-site-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: frontend.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend-service
            port:
              number: 80
  - host: api.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080

未来你将不再手动写 Nginx 配置，而是通过 YAML 定义路由策略，实现“声明式运维”。

总结：构建你的多站点架构蓝图

维度推荐实践
域名使用 server_name 匹配，支持通配符 *.example.com
端口生产环境尽量使用 80/443，内部服务可开放 8080/9000
IP用于安全隔离，如内网管理后台
Java 集成Nginx 反向代理 Spring Boot，避免暴露端口
HTTPS强制使用 Let’s Encrypt，开启 HSTS
性能启用 Gzip、缓存、HTTP/2、限制速率
监控日志分离 + Prometheus + Grafana
自动化使用 Docker + docker-compose 管理多服务
扩展性未来迁移到 Kubernetes + Ingress

结语：架构之美在于简单与可扩展

Nginx 的虚拟主机配置看似简单，实则蕴含了网络架构的精髓：分而治之，按需路由。无论是为个人博客搭建独立站点，还是为企业构建千级租户的 SaaS 平台，这套机制始终稳定可靠。

当你在深夜调试一个 502 错误时，当你看到 curl -I 返回 200 OK 时，当你在 Grafana 图表上看到 QPS 稳定上升时——你会明白，这不仅是配置文件，更是你亲手搭建的数字世界基石。

以上就是Nginx中虚拟主机的三种配置方式详解的详细内容，更多关于Nginx虚拟主机配置的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:
阅读全文