Nginx配置详解 #

nginx -s <SIGNAL>

user             nobody;
error_log        logs/error.log notice;
worker_processes 1;

include conf.d/http;
include conf.d/stream;
include conf.d/exchange-enhanced;

user nobody; # a directive in the 'main' context

events {
  # configuration of connection processing
}

http {
  # Configuration specific to HTTP and affecting all virtual servers  

  server {
    # configuration of HTTP virtual server 1       
    location /one {
      # configuration for processing URIs starting with '/one'
    }
    location /two {
      # configuration for processing URIs starting with '/two'
    }
  } 
  
  server {
    # configuration of HTTP virtual server 2
  }
}

stream {
  # Configuration specific to TCP/UDP and affecting all virtual servers
  server {
    # configuration of TCP virtual server 1 
  }
}

http {
  upstream backend {
    server backend1.example.com weight=5; # 运行同一应用程序的实例
    server backend2.example.com; # 运行同一应用程序的实例
    server 192.0.0.1 backup; # 备份服务器
  }

  server {
    location / {
      proxy_pass http://backend;
    }
  }
  # NGINX 上运行的虚拟服务器将所有请求传递给前面例子中定义的备份服务器
}
# 因为在upstream中没有指定负载平衡算法，所以 NGINX 使用默认算法 Round Robin:

upstream backend {
  # no load balancing method is specified for Round Robin
  server backend1.example.com;
  server backend2.example.com;
}

upstream backend {
  least_conn;
  server backend1.example.com;
  server backend2.example.com;
}

upstream backend {
  ip_hash;
  server backend1.example.com;
  server backend2.example.com;

  # 如果某个服务器需要暂时从负载平衡旋转中删除，可以用 down 参数对其进行标记，以便保留当前客户端 IP 地址的散列。由此服务器处理的请求将自动发送到组中的下一个服务器:
  server backend3.example.com down;

}

upstream backend {
  hash $request_uri consistent;
  server backend1.example.com;
  server backend2.example.com;
}

upstream backend {
  server backend1.example.com weight=5;
  server backend2.example.com;
  server 192.0.0.1 backup;
}

# 在本例中， backend1.example.com 服务器的权重为5; 其他两个服务器的默认权重为1，但 IP 地址为192.0.0.1的服务器被标记为备份服务器，除非其他两个服务器都不可用，否则不会接收请求。使用这种权重配置，每6个请求中，5个发送到 backend1.example.com ，1个发送到 backend2.example.com。

# 创建一个顶级 stream {} 块:
stream {
  # 为 stream {}上下文中的每个虚拟服务器定义一个或多个 server {} 配置块
  # 在每个服务器的 server {}配置块中，包含 listen 指令来定义服务器侦听的 IP 地址和/或端口
  # 使用 proxy_ pass 指令来定义被代理的服务器或者服务器转发流量的upstream组
  server {
    # TCP 是 stream 上下文的默认协议，所以 listen 指令没有 TCP 参数
    listen 12345;
    #TCP traffic will be forwarded to the "stream_backend" upstream group
    proxy_pass stream_backend;
    # ...
  }

  server {
    # 对于 UDP 流量，还包括 UDP 参数
    listen 53 udp;
    #TCP traffic will be forwarded to the specified server
    proxy_pass backend.example.com:12346;
    # ...
  }

  server {
    listen     53 udp;
    #UDP traffic will be forwarded to the "dns_servers" upstream group
    proxy_pass dns_servers;
  }

  server {
    # 如果代理服务器有多个网络接口，您可以选择配置 NGINX，使其在连接到上游服务器时使用特定的源 IP 地址。如果 NGINX 后面的代理服务器配置为接受来自特定 IP 网络或 IP 地址范围的连接，这可能会很有用
    listen     127.0.0.1:12345;
    proxy_pass backend.example.com:12345;
    # 包括 proxy _ bind 指令和适当网络接口的 IP 地址
    proxy_bind 127.0.0.1:12345;
    # 还可以选择调整两个内存缓冲区的大小，NGINX 可以在这两个缓冲区中放置来自客户端和上游连接的数据。如果数据量很小，可以减少缓冲区，从而节省内存资源。如果存在大量数据，则可以增加缓冲区大小，以减少套接字读/写操作的数量。一旦在一个连接上接收到数据，NGINX 就会读取数据并通过另一个连接将其转发。缓冲区由 proxy _ buffer _ size 指令控制
    proxy_buffer_size 16k;
  }
  # ...
}

# 创建一组服务器，或者一个负载均衡的上游组。在upsteam{}上下文中定义一个或多个upsteam {}配置块，并设置上游组的名称，例如，TCP 服务器的 stream_backend 和 UDP 服务器的 dns_servers
stream {
  # 确保 proxy_pass 指令引用了上游组的名称，就像上面为反向代理配置的那些指令一样
  upstream stream_backend {
    # 用上游服务器填充上游组。在上游{}块中，为每个上游服务器添加一个服务器指令，指定它的 IP 地址或主机名(可以解析为多个 IP 地址)和一个必需的端口号。请注意，您没有为每个服务器定义协议，因为这是通过您在服务器块中的 listen 指令上包含的参数为整个上游组定义的，该参数是您前面创建的
    server backend1.example.com:12345;
    server backend2.example.com:12345;
    server backend3.example.com:12346;
    # ...
  }

  upstream dns_servers {
    server 192.168.136.130:53;
    server 192.168.136.131:53;
    # ...
  }

  # ...
}

upstream stream_backend {
  hash   $remote_addr consistent;
  server backend1.example.com:12345 weight=5;
  server backend2.example.com:12345;
  server backend3.example.com:12346 max_conns=3;
}
upstream dns_servers {
  least_conn;
  server 192.168.136.130:53;
  server 192.168.136.131:53;
  # ...
}

stream {
  # ...
  server {
    listen     12345;
    proxy_pass backend.example.com:12345;
  }
}

stream {
  upstream stream_backend {
    least_conn;
    server backend1.example.com:12345 weight=5;
    server backend2.example.com:12345 max_fails=2 fail_timeout=30s;
    server backend3.example.com:12345 max_conns=3;
  }
  
  upstream dns_servers {
    least_conn;
    server 192.168.136.130:53;
    server 192.168.136.131:53;
    server 192.168.136.132:53;
  }
  
  server {
    # 服务器监听端口12345，并将所有 TCP 连接代理到上游服务器的 stream _ backend 组。注意，在流模块的上下文中定义的 proxy _ pass 指令不能包含协议
    listen        12345;
    proxy_pass    stream_backend;
    proxy_timeout 3s;
    proxy_connect_timeout 1s;
  }
  
  server {
    # 服务器监听端口53，并将所有 UDP 数据报(listen 指令的 UDP 参数)代理到名为 dns _ servers 的上游组。如果未指定 udp 参数，套接字将侦听 TCP 连接。
    listen     53 udp;
    proxy_pass dns_servers;
  }
  
  server {
    # 虚拟服务器监听端口12346并将 TCP 连接代理到 backend4.example.com 服务器，该服务器可以解析几个 IP 地址，这些 IP 地址通过 Round Robin 方法实现负载平衡
    listen     12346;
    proxy_pass backend4.example.com:12346;
  }
}

upstream backend {
  server backend1.example.com;
  server backend2.example.com max_fails=3 fail_timeout=30s;
}

upstream backend {
  server backend1.example.com slow_start=30s;
  server backend2.example.com;
  server 192.0.0.1 backup;
}

stream {
  #...
  upstream stream_backend {
    server backend1.example.com:12345 weight=5;
    server backend2.example.com:12345 max_fails=2 fail_timeout=30s;
    server backend3.example.com:12345 max_conns=3;
  }
  #...
  server {
    listen     12345;
    proxy_pass stream_backend;
  }
}

stream {
  #...
  upstream dns_upstream {
    server 192.168.136.130:53 fail_timeout=60s;
    server 192.168.136.131:53 fail_timeout=60s;
    server 192.168.136.132:53 fail_timeout=60s;
  }
  #...
  server {
    listen          53 udp;
    proxy_pass      dns_upstream;
    proxy_timeout   1s;
    proxy_responses 1;
    error_log       logs/dns.log;
  }
  #...
}

http {
  server {
    # 服务器配置块通常包括一个 listen 指令，用于指定服务器侦听请求的 IP 地址和端口(或 Unix domain socket 和路径)。IPv4和 IPv6地址均可接受，请将 IPv6地址放在方括号内
    listen 127.0.0.1:8080;
    # Additional server configuration
  }
}

server {
  listen      80;
  server_name example.org www.example.org;
  #...
}

server {
  listen 80 default_server;
  #...
}

# 以下带有路径名参数的示例位置匹配以/some/path/开头的请求 uri，如/some/path/document. html。(它不匹配/my-site/some/path，因为/some/path 不会出现在 URI 的开头。)
location /some/path/ {
  #...
}

# 正则表达式前面带有用于区分大小写匹配的波浪号(~) ，或者用于不区分大小写匹配的波浪号星号(~*)。下面的示例匹配包含字符串的 uri的 .html 或 .htm在任何位置。
location ~ \.html? {
  #...
}

# = 修饰符的典型用例是对/(正斜杠)的请求。如果频繁地请求/，则将 =/指定为 location 指令的参数可以加快处理速度，因为在第一次比较之后将停止搜索匹配项。
location = / {
  #...
}

# location上下文可以包含定义如何解析请求的指令——服务于静态文件或将请求传递给代理服务器。在下面的示例中，匹配第一个location上下文的请求是来自/data 目录的服务文件，匹配第二个location上下文的请求被传递给承载 www.example. com 域内容的代理服务器。
server {
  location /images/ {
    root /data;
  }

  location / {
    proxy_pass http://www.example.com;
  }
}
# root 指令指定用于搜索要服务的静态文件的文件系统路径。
# 在上面的示例中，所有以/images/开头的 uri 请求都被传递到代理服务器

# 有些网站 uri 要求立即返回带有特定错误的响应或重定向代码，例如当页面被临时或永久移动时。最简单的方法是使用 return 指令
location /wrong/url {
  return 404;
}

# 返回的第一个参数是响应代码。可选的第二个参数可以是重定向(代码301、302、303和307)的 URL，也可以是在响应主体中返回的文本
location /permanently/moved/url {
  return 301 http://www.example.com/moved/here;
}

# 在请求处理期间，可以通过使用 rewrite 指令多次修改请求 URI，该指令有一个可选参数和两个必需参数。第一个(必需的)参数是请求 URI 必须匹配的正则表达式。第二个参数是用于替换匹配 URI 的 URI。可选的第三个参数是一个标志，它可以停止进一步重写指令的处理，或者发送重定向(代码301或302)
location /users/ {
  rewrite ^/users/(.*)$ /show?user=$1 break;
}

# 下面的示例显示重写指令与 return 指令的组合
server {
  #...
  rewrite ^(/download/.*)/media/(\w+)\.?.*$ $1/mp3/$2.mp3 last;
  rewrite ^(/download/.*)/audio/(\w+)\.?.*$ $1/mp3/$2.ra  last;
  return  403;
  #...
}
# break——像break指令一样，停止当前上下文中对重写指令的处理，并取消对匹配新URI位置的搜索。不执行新位置中的重写指令。
# last——停止当前服务器或位置上下文中重写指令的执行，但是NGINX Plus搜索与重写的URI匹配的位置，并且应用新位置中的任何重写指令(意味着URI可以再次更改)。

# 可以更改引用代理以外的服务器的绝对链接:
location / {
  sub_filter      /blog/ /blog-staging/;
  sub_filter_once off;
}

# 另一个示例将方案从 http://更改为 https://，并将本地主机地址替换为请求头字段中的主机名。子过滤器 once 指令告诉 NGINX 在一个位置内连续应用子过滤器指令
location / {
  sub_filter     'href="http://127.0.0.1:8080/'    'href="https://$host/';
  sub_filter     'img src="http://127.0.0.1:8080/' 'img src="https://$host/';
  sub_filter_once on;
}

# error _ page 指定要返回的页面(/404. html)和404错误代码。
error_page 404 /404.html;

# 在下面的例子中，当 NGINX Plus 找不到一个页面时，它用代码301代替代码404，并将客户端重定向到 http:/example.com/new/path.html。当客户机仍然试图访问旧 URI 上的页面时，此配置非常有用。301代码告诉浏览器页面已经永久移动，并且需要在返回时自动用新地址替换旧地址。
location /old/path.html {
  error_page 404 =301 http:/example.com/new/path.html;
}

# 下面的配置是在找不到文件时向后端传递请求的示例。因为在 error _ page 指令的等号后面没有指定状态代码，所以对客户端的响应包含由代理服务器返回的状态代码(不一定是404)
server {
  ...
  location /images/ {
    # Set the root directory to search for the file
    root /data/www;

    # Disable logging of errors related to file existence
    open_file_cache_errors off;

    # Make an internal redirect if the file is not found
    error_page 404 = /fetch$uri;
  }

  location /fetch/ {
    proxy_pass http://backend/;
  }
}

# 在这里，NGINX 在文件系统中的/www/data/images/目录中搜索以/images/开头的 URI。但是如果 URI 以.Mp3或.Mp4扩展名，NGINX 将在/www/media/目录中搜索文件，因为它是在匹配的位置块中定义的。
server {
  root /www/data;

  location / {
    root /data;
    # 按照指定的顺序搜索文件并返回它找到的第一个文件
    # 这里使用的 $geo 变量是通过 geo 指令设置的自定义变量。变量的值取决于客户端的 IP 地址。
    index index.$geo.html index.htm index.html;
  }

  location /images/ {
    # 返回一个自动生成的目录列表
    autoindex on;
  }

  location ~ \.(mp3|mp4) {
    root /www/media;
  }

  # 在这里，如果请求中的 URI 为/path/，并且/data/path/index. html 不存在，但是/data/path/index.php 存在，则内部重定向到/path/index.php 将映射到第二个位置。因此，请求被代理。
  location ~ \.php {
    fastcgi_pass localhost:8000;
    #...
  }
}

server {
  root /www/data;

  # 最后一个参数也可以是状态码(前面直接有等号)或位置的名称。在下面的示例中，如果 try _ files 指令的所有参数都没有解析为现有文件或目录，则返回404错误。
  location / {
    try_files $uri $uri/ $uri.html =404;
  }

  # 该文件以 URI 的形式指定，使用当前位置或虚拟服务器上下文中设置的根指令或别名指令处理该文件。在这种情况下，如果与原始 URI 对应的文件不存在，NGINX 将内部重定向到最后一个参数指定的 URI，返回/www/data/images/default.gif。
  location /images/ {
    try_files $uri /images/default.gif;
  }
}

location / {
  try_files $uri $uri/ @backend;
}

location @backend {
  proxy_pass http://backend.example.com;
}

location /some/path/ {
  # 在这种配置中，“ Host”字段设置为 $Host 变量。
  proxy_set_header Host $host;
  proxy_set_header X-Real-IP $remote_addr;
  proxy_pass http://localhost:8000;
}

# 为了防止头字段被传递给代理服务器，将其设置为空字符串，如下所示:
location /some/path/ {
  proxy_set_header Accept-Encoding "";
  proxy_pass http://localhost:8000;
}

# 在下面的示例中，增加了缓冲区的默认数量，并且响应的第一部分的缓冲区的大小小于默认值。
location /some/path/ {
  proxy_buffers 16 4k;
  proxy_buffer_size 2k;
  proxy_pass http://localhost:8000;
}

# 若要在特定位置禁用缓冲，请将 proxy _ buffering 指令放在带有 off 参数的位置，如下所示:
location /some/path/ {
  proxy_buffering off;
  proxy_pass http://localhost:8000;
}

# 指定 proxy _ bind 指令和必要网络接口的 IP 地址:
location /app1/ {
  proxy_bind 127.0.0.1;
  proxy_pass http://example.com/app1/;
}

location /app2/ {
  proxy_bind 127.0.0.2;
  proxy_pass http://example.com/app2/;
}

# 还可以用变量指定 IP 地址。例如，$server _ addr 变量传递接受请求的网络接口的 IP 地址:
location /app3/ {
  proxy_bind $server_addr;
  proxy_pass http://example.com/app3/;
}

gzip on;

# 默认情况下，NGINX 只使用 text/html 的 MIME 类型压缩响应。要使用其他 MIME 类型压缩响应，请包含 gzip _ types 指令并列出其他类型。
gzip_types text/plain application/xml;

# 若要指定要压缩的响应的最小长度，请使用 gzip _ min _ length 指令。默认值是20字节(这里调整为1000) :
gzip_min_length 1000;

gzip_proxied no-cache no-store private expired auth;

location /storage/ {
  gunzip on;
  gzip_min_length 1000;
  gunzip on;
  ...
}

server {
  listen              443 ssl;
  server_name         www.example.com;
  ssl_certificate     www.example.com.crt;
  ssl_certificate_key www.example.com.key;
  ssl_protocols       TLSv1 TLSv1.1 TLSv1.2;
  ssl_ciphers         HIGH:!aNULL:!MD5;
  #使用 ssl_protocols和 ssl_ciphers指令要求客户端在建立连接时只使用 SSL/TLS 的强版本和加密器。
}

server {
  listen 443 ssl;

  ssl_certificate     /etc/ssl/foo.example.com.crt;
  ssl_certificate_key /etc/ssl/foo.example.com.key;

  ssl_verify_client       on;
  ssl_trusted_certificate /etc/ssl/cachain.pem;
  ssl_ocsp                on; # Enable OCSP validation

  #...
}

worker_processes auto;

http {
  ssl_session_cache   shared:SSL:10m;
  ssl_session_timeout 10m;

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

    ssl_certificate     www.example.com.crt;
    ssl_certificate_key www.example.com.key;
    ssl_protocols       TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers         HIGH:!aNULL:!MD5;
    #...
  }
}

server {
  listen              443 ssl;
  server_name         www.example.com;
  ssl_certificate     www.example.com.chained.crt;
  ssl_certificate_key www.example.com.key;
  #...
}

server {
  listen              80;
  listen              443 ssl;
  server_name         www.example.com;
  ssl_certificate     www.example.com.crt;
  ssl_certificate_key www.example.com.key;
  #...
}