Nginx 介绍

Posted 2020-11-27 yangmaosen

前言

nginx是一款自由的、开源的、高性能的HTTP服务器和 反向代理 服务器；同时也是一个IMAP、POP3、SMTP代理服务器；Nginx可以作为一个HTTP服务器进行网站的发布处理，另外Nginx可以作为反向代理进行负载均衡的实现。

• Nginx使用基于事件驱动架构，使得其可以支持数以百万级别的TCP连接
• 高度的模块化和自由软件许可证使得第三方模块层出不穷（开源）
• Nginx是一个跨平台服务器，可以运行在Linux，Windows，FreeBSD，Solaris，AIX，Mac OS等操作系统上
• 稳定性极高

Nginx 解决高并发

• Nginx高并发原理（ 多进程+epoll实现高并发 ）
• Nginx 在启动后，会有一个 master 进程和多个相互独立的 worker 进程。
• 每个子进程只有一个线程(协程)，采用的 IO多路复用模型epoll，实现高并发。

epoll能实现高并发原理

• epoll() 中内核则维护一个链表，epoll_wait 方法可以获取到链表长度，不为0就知道文件描述符准备好了。
• 在内核实现中 epoll 是根据每个 sockfd 上面的与设备驱动程序建立起来的回调函数实现的。
• 某个 sockfd 上的事件发生时，与它对应的回调函数就会被调用，来把这个 sockfd 加入链表，其他处于“空闲的”状态的则不会。
• epoll上面链表中获取文件描述，这里使用内存映射（mmap）技术， 避免了复制大量文件描述符带来的开销

内存映射（mmap）：内存映射文件，是由一个文件到一块内存的映射，将不必再对文件执行I/O操作

nginx和apache比较

  nginx相对于apache的优点

• 轻量级，同样起web 服务，比apache 占用更少的内存及资源
• 抗并发，nginx 处理请求是异步非阻塞的，而apache 则是阻塞型的，在高并发下nginx 能保持低资源低消耗高性能
• 高度模块化的设计，编写模块相对简单，社区活跃，各种高性能模块出品迅速啊

  apache 相对于nginx 的优点

• apache 更为成熟，少 bug ，稳定性好
• rewrite ，比nginx 的rewrite 强大
• 模块超多，基本想到的都可以找到

Nginx 代理

• 说到代理，首先我们要明确一个概念，所谓代理就是一个代表、一个渠道此时就涉及到两个角色，一个是被代理角色 (A_)，一个是目标角色 (B_)，A_ 通过这个代理访问 B_ 完成一些任务的过程称为代理 (C_) 操作过程；比如客人去买双鞋，这个店铺就是 (C_)，(A_) 就是厂家，(B_) 就是用户。代理呢又分为正向代理和反向代理

正向代理：

• 首先我们先举个例子：比如说我们在 YouTob 上查找学习资料，大家会发现很慢；这个时候就会需要到正向代理，最明显的例子(1FQ)，FQ的方式主要是找到一个可以访问国外网站的代理服务器，我们将请求发送给代理服务器，代理服务器去访问国外的网站，然后将访问到的数据传递给我们
• 这就是正向代理，正向代理最大的特点是客户端非常明确要访问的服务器地址；服务器只清楚请求来自哪个代理服务器，而不清楚来自哪个具体的客户端；正向代理模式屏蔽或者隐藏了真实客户端信息。
• 总结来说：正向代理，“它代理的是客户端，代客户端发出请求”，是一个位于客户端和原始服务器(origin server)之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)，然后代理向原始服务器转交请求并将获得的内容返回给客户端。客户端必须要进行一些特别的设置才能使用正向代理。

正向代理的用途：

• 访问原来无法访问的资源，如Google
• 可以做缓存，加速访问资源
• 对客户端访问授权，上网进行认证
• 代理可以记录用户访问记录（上网行为管理），对外隐藏用户信息

正向代理配置：

• 现在的网站基本上都是https，要解决既能访问http80端口也能访问https443端口的网站，需要配置两个SERVER节点，一个处理HTTP转发，另一个处理HTTPS转发，而客户端都通过HTTP来访问代理，通过访问代理不同的端口，来区分HTTP和HTTPS请求。

环境介绍：

• 代理服务器系统环境为：centos
• nginx代理服务器为：192.168.10.10
• 测试客户端为局域网内任意windows电脑或Linux电脑

[root@localhost ~] vim /usr/local/nginx-1.12.1/conf/nginx.conf
server {
resolver 114.114.114.114; #指定DNS服务器IP地址 
listen 80;
location / {
proxy_pass http://$host$request_uri; #设定代理服务器的协议和地址 
proxy_set_header HOST $host;
proxy_buffers 256 4k;
proxy_max_temp_file_size 0k;
proxy_connect_timeout 30;
proxy_send_timeout 60;
proxy_read_timeout 60;
proxy_next_upstream error timeout invalid_header http_502;
   }
}
server {
resolver 114.114.114.114; #指定DNS服务器IP地址 
listen 443;
location / {
proxy_pass https://$host$request_uri; #设定代理服务器的协议和地址 
proxy_buffers 256 4k;
proxy_max_temp_file_size 0k;
proxy_connect_timeout 30;
proxy_send_timeout 60;
proxy_read_timeout 60;
proxy_next_upstream error timeout invalid_header http_502;
   }
}
[root@localhost ~] /usr/local/nginx-1.12.1/sbin/nginx -s reload

Linux客户端访问测试：

[root@localhost ~] curl -I --proxy 192.168.10.10:80 www.baidu.com
HTTP/1.1 200 OK
Server: nginx/1.12.1
Date: Mon, 11 Jun 2018 15:37:47 GMT
Content-Type: text/html
Content-Length: 612
Last-Modified: Thu, 31 May 2018 09:28:16 GMT
Connection: keep-alive
ETag: "5b0fc030-264"
Accept-Ranges: bytes
https的访问测试

[root@localhost ~] curl -I --proxy 192.168.10.10:443 www.baidu.com
HTTP/1.1 200 OK
Server: nginx/1.12.1
Date: Mon, 11 Jun 2018 15:38:07 GMT
Content-Type: text/html
Content-Length: 277
Connection: keep-alive
Accept-Ranges: bytes
Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform
Etag: "575e1f5c-115"
Last-Modified: Mon, 13 Jun 2016 02:50:04 GMT
Pragma: no-cache

设置Linux客户端全局代理：

[root@localhost ~] vim /etc/profile
export http_proxy=‘192.168.10.10:80‘
export http_proxy=‘192.168.10.10:443‘
export ftp_proxy=‘192.168.10.10:80‘

[root@localhost ~] source /etc/profile

[root@localhost ~] curl -I www.baidu.com:80
HTTP/1.1 200 OK
Server: nginx/1.12.1
Date: Mon, 11 Jun 2018 16:10:18 GMT
Content-Type: text/html
Content-Length: 277
Connection: keep-alive
Accept-Ranges: bytes
Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform
Etag: "575e1f5c-115"
Last-Modified: Mon, 13 Jun 2016 02:50:04 GMT
Pragma: no-cache
[root@localhost ~]# curl -I www.baidu.com:443
HTTP/1.1 200 OK
Server: nginx/1.12.1
Date: Mon, 11 Jun 2018 16:10:27 GMT
Content-Type: text/html
Content-Length: 277
Connection: keep-alive
Accept-Ranges: bytes
Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform
Etag: "575e1f59-115"
Last-Modified: Mon, 13 Jun 2016 02:50:01 GMT
Pragma: no-cache

上面结果就说明我们的服务端nginx正向代理和客户端使用nginx做为全局代理设置成功。

反向代理：

• 举例：我国的某宝网站，每天同时连接到网站的访问人数已经爆表，单个服务器远远不能满足用户访问量了，此时就出现了分布式部署；也就是通过部署多台服务器来解决访问人数限制的问题；某宝网站中大部分功能也是直接使用Nginx进行反向代理实现的，并且通过封装Nginx和其他的组件之后起了个高大上的名字：Tengine，有兴趣的童鞋可以访问Tengine的官网查看具体的信息http://tengine.taobao.org/。
• 多个客户端给服务器发送的请求，Nginx服务器接收到之后，按照一定的规则分发给了后端的业务处理服务器进行处理了。 此时~请求的来源也就是客户端是明确的，但是请求具体由哪台服务器处理的并不明确了，Nginx扮演的就是一个反向代理角色。
• 客户端是无感知代理的存在的，反向代理对外都是透明的，访问者并不知道自己访问的是一个代理。 因为客户端不需要任何配置就可以访问。
• 反向代理，“它代理的是服务端，代服务端接收请求”，主要用于服务器集群分布式部署的情况下，反向代理隐藏了服务器的信息。

反向代理的作用：

• 保证内网的安全，通常将反向代理作为公网访问地址，Web服务器是内网
• 负载均衡，通过反向代理服务器来优化网站的负载

反向代理配置：

• 本文主要配置Nginx的反向代理，及公司有多台服务器都需要公司一台主Nginx代理配置。使用Nginx+Tomcat实现此项目的反向代理，至于Nginx，tomcat如何搭建百度一大把。此案例是在一台服务器上面实现，一台虚拟机安装了两个tomcat。

虚拟机环境介绍：

• 服务器ip：192.168.161.189
• Nginx端口：80
• Tomcat1端口：8070
• Tomcat2端口：8080
• 一台服务器安装了两个Tomcat，使用不同端口实现。

测试搭建的nginx，tomcat是否正常访问：
先测试一下访问搭建好的nginx有没有问题。

Nginx访问正常。
测试一下搭建的tomcat，（自己编辑了一个用于测试的简单页面，端口是8070）

配置反向代理：

[root@localhost conf] vim Nginx.conf

在server段里面的location加上proxy_pass http://ip:端口

server{
listen 80;
server_name 192.168.161.189;

# charset koi8-r;
# access_log logs/host.access.log main;

location / {

proxy_pass http://192.168.161.189:8070; `注意这里`
root html;
idnex index.html index.htm;
  }
}

Nginx配置完成后重启一下nginx：

# 命令大全
1、查找nginx路径：whereis nginx

2、启动 service nginx start

3、查看Nginx的版本号：nginx -V

4、停止 nginx -s stop

5、退出 nginx -s quit

6、重启加载配置 nginx -s reload 
/etc/init.d/nginx -s reload 也可以

重启没报错说明配置文件没问题：

使用浏览器进行访问

简单的反向代理已经完成

配置代理多个网站及服务：

[root@localhost conf] vim Nginx.conf

配置多个反向代理实现方式，是通过不同的端口代理访问。这里复制一个server段，将两个server段nginx的端口更改，使用nginx的不同端口访问。

第一个server段配置tomcat1（192.168.161.189：8070）

第二个server段配置（192.168.161.189：8080）

配置完成后，重启nginx代理。

[root@localhost conf] /etc/init.d/nginx -s reload

先访问nginx代理的第一个tomcat1。（通过nginx的8081代理的tomcat1。）

访问nginx代理的第二个tomcat2。（通过nginx的8082代理的tomcat2。）

总结：

• 以上配置就是通过nginx的不同端口代理多个地址，若还要代理更多通过nginx的不同端口，增加server段即可。访问量大的网站不建议代理太多。
• 正向代理是代理客户端，为客户端收发请求，使真实客户端对服务器不可见；而反向代理是代理服务器端，为服务器收发请求，使真实服务器对客户端不可见。

基于上文的一些简单配置，大概能知道Nginx的一个流程，我们继续往下看：

• 在B/S应用中，页面缓存技术是提升服务能力的重要手段。页面缓存又分为浏览器缓存和服务端缓存两类，本文仅讨论Nginx服务器的页面缓存。Nginx服务缓存的基本原理是对客户请求过的资源建立本地副本，在一段合理时期内任何用户再次请求该资源时，Ｎginx服务器无需要再次向后端服务器发出请求，而是直接应答缓存的副本。因此，缓存技术可以明显降低后端服务器的负载，减轻网络传输负担，极大地提升响应速度。

tornado的吞吐能力

我们用一个最简单的例子，测试一下tornado的吞吐能力：

# -*- coding: utf-8 -*-

import os
import sys
import tornado.web
import tornado.ioloop
import tornado.httpserver
from tornado.options import parse_command_line

class Handler(tornado.web.RequestHandler):
def get(self):
self.write(‘我是tornado，我够快！‘)

class Application(tornado.web.Application):
def __init__(self):
handlers = [
(r"/", Handler)
]

settings = dict(
title=‘压力测试‘,
debug=True,
)

tornado.web.Application.__init__(self, handlers, **settings)

parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application(), xheaders=True, max_buffer_size=504857600)
http_server.listen(80)

print(‘Web server is started‘)
tornado.ioloop.IOLoop.instance().start()

启动该脚本后，使用浏览器访问127.0.0.1，页面显示“我是tornado，我够快！”。这个例子没有使用文件读写、数据库读写等耗时的操作，更能反应出tornado本身的吞吐能力。

压力测试通常使用Apache自带的ab.exe，ab的使用方法为：

ab -n 请求数 -c 并发数 URL

下面是并发10个请求共计100个请求的压力测试：

ab -n 100 -c 10 http://127.0.0.1/
This is ApacheBench, Version 2.3 <$Revision: 1843412 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient).....done


Server Software: TornadoServer/6.0.3
Server Hostname: 127.0.0.1
Server Port: 9001

Document Path: /
Document Length: 22 bytes

Concurrency Level: 10
Time taken for tests: 0.107 seconds
Complete requests: 100
Failed requests: 0
Total transferred: 21700 bytes
HTML transferred: 2200 bytes
Requests per second: 937.09 [#/sec] (mean)
Time per request: 10.671 [ms] (mean)
Time per request: 1.067 [ms] (mean, across all concurrent requests)
Transfer rate: 198.58 [Kbytes/sec] received

Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 1 0.6 0 2
Processing: 4 9 3.0 9 18
Waiting: 2 9 3.2 8 18
Total: 4 10 3.1 9 19
WARNING: The median and mean for the initial connection time are not within a normal deviation
These results are probably not that reliable.

Percentage of the requests served within a certain time (ms)
50% 9
66% 10
75% 13
80% 14
90% 15
95% 15
98% 18
99% 19
100% 19 (longest request)

它的输出中有以下关键信息：

• Concurrency Level: 并发数，使用-c参数指定的数量
• Time taken for tests: 测试用共用时长
• Complete requests: 完成的请求数
• Failed requests: 失败的请求数
• Total transferred: 共传输的数据量
• HTML transferred: 页面传输的数据量
• Requests per second: 平均每秒响应的请求数（吞吐量）
• Time per request: 用户平均请求等待时间 [ms]
• Time per request: 服务器平均处理时间 [ms]
• Transfer rate: 输入速率

我们发送10000次请求，用不同的并发数，多次进行测试，得到的结果如下表所示：

从数据中可以看出，随着并发数量的增加，服务器平均处理时间和用户平均请求等待时间都在增加；并发小于100时，服务器还没有饱和，吞吐量还在增加；并发大于100后，服务器的处理能力开始受到影响，吞吐量开始下降。

我使用windows平台，在我的测试条件下，tornado每秒最多响应1305次请求。Linux平台上，tornado的表现要比windows平台好得多。

Nginx 反向代理

• 代理服务器是架设在客户端和服务器之间的中间服务器，我们一般所说的代理是正向代理。正向代理是客户端的出口，客户端将请求发送给正向代理服务器，告诉正向代理服务器我要访问哪个服务器，然后正向代理服务器向目标服务器发送请求，并将响应返回给客户端。从服务器的角度看，它并不知道真正的请求是哪个客户端发出来的，有几个客户端，只从代理服务器接受请求。
• 与正向代理相反，反向代理是服务器的入口，客户端并不知道真正的服务器是哪个，有几个服务器，只知道反向代理服务器是哪个。它向反向代理服务器发送请求，反向代理服务器会有选择的把请求发送到其中的一台服务器，并将服务器的响应返回给客户端。
• 反向代理使服务器由一个变为多个，并为多个服务器提供统一的入口，可根据每个服务器的负载向负载最轻的服务器转发请求，这就是负载均衡。
• nginx是一款优秀的反向代理服务器，可以从官网下载压缩包，解压后直接使用。

首先，我们修改一下服务器的代码，使之可以同时启动多个进程：

# -*- coding: utf-8 -*-

import os
import sys
import multiprocessing
import tornado.web
import tornado.ioloop
import tornado.httpserver
from tornado.options import parse_command_line

# 页面句柄
class Handler(tornado.web.RequestHandler):
def get(self):
self.write(‘我是tornado，我够快！‘)

class Application(tornado.web.Application):
def __init__(self):
handlers = [
(r"/", Handler),
]

settings = dict(
title=‘压力测试‘,
debug=True,
)

tornado.web.Application.__init__(self, handlers, **settings)

# 启动服务器
def start_web_server(port):
parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application(), xheaders=True, max_buffer_size=504857600)
http_server.listen(port)

print(‘Web server is started on port %d.‘ % port)
tornado.ioloop.IOLoop.instance().start()


if __name__ == "__main__":
if len(sys.argv) == 1:
start_web_server(80)
else:
try:
ports = [int(port) for port in sys.argv[1].split(‘,‘)]
except:
try:
a, b = sys.argv[1].split(‘-‘)
ports = range(int(a), int(b) + 1)
except:
ports = list()
print (‘Parameter error.‘)

multiprocessing.freeze_support()
for port in ports:
p = multiprocessing.Process(target=start_web_server, args=(port,))
p.start()

在命令行中输入如下命令，启动两个服务器进程，每个进程使用不同的端口：

python server.py 9001-9002

接下来，配置ngnix。nginx的配置并不复杂，可以复制解压目录下的conf/ngnix.conf，进行修改即可。
在http部分中添加upstream，语法为：

http {
upstream 名称 {
负载均衡策略
server IP地址:端口 其它参数;
　　}
}

其中可选的负载均衡策略有：

• ip_hash: 这种策略会把某一ip映射到一个固定的服务器，其优点是容易保持session的一致性，缺点是当该服务器负载过重后，也不能分流到其他服务器
• least_conn: 这种策略根据服务器连接的数量，选择连接数量最小的服务器，同一客户端不同的请求有可能会进入不同的服务器
• least_time: 这种策略计算每个服务器的响应时间，选择响应时间小短的服务器，同一客户端不同的请求有可能会进入不同的服务器

我选择least_time，配置如下：

upstream serv {
least_conn;
server 127.0.0.1:9001;
server 127.0.0.1:9002;
}

将原来的location /的内容修改为如下内容：

proxy_pass http://serv$request_uri;

#以下三行，目的是将代理服务器收到的用户的信息传到真实服务器上
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_pass后面的http://serv$request_uri中，serv为刚才配置的upstream的名称。
修改并删除了原来配置文件中的注释会，配置文件如下：

worker_processes 1;

events {
worker_connections 1024;
}


http {
sendfile on;
keepalive_timeout 65;

upstream serv {
least_conn;
server 127.0.0.1:9001;
server 127.0.0.1:9002;
}

server {
listen 80;
server_name localhost;

location / {
proxy_pass http://serv$request_uri;

#以下三行，目的是将代理服务器收到的用户的信息传到真实服务器上
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
　　　　}
　　}
}

启动tornado，并进入配置文件的目录，使用如下命令启动nginx:

nginx -c nginx.conf

OK，反向代理配置完成。再次用ab进行压力测试, 结果并不像我们期望的那样，吞吐量成倍增长。这是因为tornado的IO几乎已经做到了极致，几乎比肩nginx，wondows平台上单台PC的吞吐量大致也就如此了。当tornado需要进行文件读写、数据库读写等耗时的操作时，多进程的反向代理才能体现出优势。

 

使用缓存技术

除了反向代理，nginx还可以启用缓存技术，进一步提高服务能力。当客户端第一次请求某url时，nginx将请求转发给服务器，服务器返回后，nginx在本地创建缓存。在缓存未失效前，nginx不再转发请求，而是直接将缓存的内容返回给客户端，服务器的负载被转嫁到nginx上，而nginx的性能是非常出色的。
在nginx配置文件中设置缓存，语法为：

http {
proxy_cache_path 缓存路径 keys_zone=缓存名称:缓存大小 levels=一级缓存名长度:二级缓存名长度 inactive=失活时间 max_size=最大大小;

server {
location url {
proxy_cache 缓存名称;
proxy_cache_min_uses 访问次数（url被访问多少次后进行缓存）;
proxy_cache_valid any 有效期;
　　　　}
　　}
}

修改后nginx的配置文件为：

worker_processes 1;

events {
worker_connections 1024;
}

http {
sendfile on;
keepalive_timeout 65;

upstream serv {
least_conn;
server 127.0.0.1:9001;
server 127.0.0.1:9002;
server 127.0.0.1:9003;
server 127.0.0.1:9004;
}

# 设置缓存路径
proxy_cache_path cache keys_zone=CACHE:10m levels=1:4 inactive=1m max_size=1g;

server {
listen 80;
server_name localhost;

location / {
proxy_pass http://serv$request_uri;

#以下三行，目的是将代理服务器收到的用户的信息传到真实服务器上
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_cache CACHE;
proxy_cache_min_uses 1;
proxy_cache_valid any 1m;
　　　　}
　　}
}

重启nginx，此时使用浏览器访问127.0.0.1，第一次nginx没有缓存，服务器端打印出了访问日志，再以后的访问，服务器不再打印日志，说明nginx缓存起到了作用。

我们在tornado服务器的代码中加入100毫秒的sleep，来模拟访问数据库的操作，对不启用缓存和启用缓存进行压力测试：

可以看出，缓存技术对吞吐量的提升非常有效！

 

缓存的副作用及解决方案

缓存，意味着不是最新的，如果某页面的内容的变化很快，使用缓存技术将导致客户端接收到错误的结果。如我增加一个url，输出服务器当前的时间：

# -*- coding: utf-8 -*-

import os
import sys
import time
import datetime
import multiprocessing
import tornado.web
import tornado.ioloop
import tornado.httpserver
from tornado.options import parse_command_line

# 页面句柄
class StaticHandler(tornado.web.RequestHandler):
def get(self):
time.sleep(0.1)
self.write(‘我是tornado，我够快！‘)

class VariableHandler(tornado.web.RequestHandler):
def get(self):
now = datetime.datetime.now()
self.write(now.strftime("%Y-%m-%d %H:%M:%S"))


class Application(tornado.web.Application):
def __init__(self):
handlers = [
(r"/", StaticHandler), # 可以缓存的页面
(r"/variable", VariableHandler), # 禁止缓存的页面
]

settings = dict(
title=‘压力测试‘,
debug=True,
)

tornado.web.Application.__init__(self, handlers, **settings)

# 启动服务器
def start_web_server(port):
parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application(), xheaders=True, max_buffer_size=504857600)
http_server.listen(port)

print(‘Web server is started on port %d.‘ % port)
tornado.ioloop.IOLoop.instance().start()


if __name__ == "__main__":
if len(sys.argv) == 1:
start_web_server(80)
else:
try:
ports = [int(port) for port in sys.argv[1].split(‘,‘)]
except:
try:
a, b = sys.argv[1].split(‘-‘)
ports = range(int(a), int(b) + 1)
except:
ports = list()
print (‘Parameter error.‘)

multiprocessing.freeze_support()
for port in ports:
p = multiprocessing.Process(target=start_web_server, args=(port,))
p.start()

此时浏览器访问127.0.0.1/variable，第一次出现了正确的时间，以后的1分钟以内，时间不再变化，等1分钟以后缓存过期，再访问出能得到新的时间。为了解决这个问题，可以在nginx配置中添加多个location，分别指定是否启用缓存即可：

worker_processes 1;

events {
worker_connections 1024;
}


http {
sendfile on;
keepalive_timeout 65;

upstream serv {
least_conn;
server 127.0.0.1:9001;
server 127.0.0.1:9002;
server 127.0.0.1:9003;
server 127.0.0.1:9004;
}

proxy_cache_path cache keys_zone=CACHE:1m levels=1:2 inactive=1m max_size=1g;

server {
listen 80;
server_name localhost;

location / {
proxy_pass http://serv$request_uri;

#以下三行，目的是将代理服务器收到的用户的信息传到真实服务器上
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_cache CACHE;
proxy_cache_min_uses 1;
proxy_cache_valid any 1m;
}

# 只转发请求，不进行缓存
location /variable {
proxy_pass http://serv$request_uri;

#以下三行，目的是将代理服务器收到的用户的信息传到真实服务器上
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
　　　　}　　
　　}
}

重启nginx后，再访问127.0.0.1/variable，每次都可以得到最新的时间。

 

负载均衡

• 负载均衡也是Nginx常用的一个功能，负载均衡其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。
• 简单而言就是当有2台或以上服务器时，根据规则随机的将请求分发到指定的服务器上处理，负载均衡配置一般都需要同时配置反向代理，通过反向代理跳转到负载均衡。而Nginx目前支持自带3种负载均衡策略，还有2种常用的第三方策略。

RR（默认）

每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。

简单配置：

upstream test {
        server localhost:8080;
        server localhost:8081;
    }
    server {
        listen       81;
        server_name  localhost;
        client_max_body_size 1024M;

        location / {
            proxy_pass http://test;
            proxy_set_header Host $host:$server_port;
        }
    }

负载均衡的核心代码为：

upstream test {
        server localhost:8080;
        server localhost:8081;
    }

这里我配置了2台服务器，当然实际上是一台，只是端口不一样而已，而8081的服务器是不存在的,也就是说访问不到，但是我们访问http://localhost 的时候,也不会有问题，会默认跳转到http://localhost:8080

具体是因为Nginx会自动判断服务器的状态，如果服务器处于不能访问（服务器挂了），就不会跳转到这台服务器，所以也避免了一台服务器挂了影响使用的情况，由于Nginx默认是RR策略，所以我们不需要其他更多的设置。

权重

指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况。例如

upstream test {
        server localhost:8080 weight=9;
        server localhost:8081 weight=1;
    }

那么10次一般只会有1次会访问到8081，而有9次会访问到8080

ip_hash

上面的2种方式都有一个问题，那就是下一个请求来的时候请求可能分发到另外一个服务器，当我们的程序不是无状态的时候（采用了session保存数据），这时候就有一个很大的很问题了，比如把登录信息保存到了session中，那么跳转到另外一台服务器的时候就需要重新登录了，所以很多时候我们需要一个客户只访问一个服务器，那么就需要用iphash了，iphash的每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题。

upstream test {
        ip_hash;
        server localhost:8080;
        server localhost:8081;
    }

fair（第三方）

按后端服务器的响应时间来分配请求，响应时间短的优先分配。

upstream backend {
        fair;
        server localhost:8080;
        server localhost:8081;
    }

url_hash（第三方）

按访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，后端服务器为缓存时比较有效。在upstream中加入hash语句，server语句中不能写入weight等其他的参数，hash_method是使用的hash算法

upstream backend {
        hash $request_uri;
        hash_method crc32;
        server localhost:8080;
        server localhost:8081;
    }

以上5种负载均衡各自适用不同情况下使用，所以可以根据实际情况选择使用哪种策略模式,不过fair和url_hash需要安装第三方模块才能使用，由于本文主要介绍Nginx能做的事情，所以Nginx安装第三方模块不会再本文介绍

 

HTTP服务器

Nginx本身也是一个静态资源的服务器，当只有静态资源的时候，就可以使用Nginx来做服务器，同时现在也很流行动静分离，就可以通过Nginx来实现，首先看看Nginx做静态资源服务器

server {
        listen       80;
        server_name  localhost;
        client_max_body_size 1024M;


        location / {
               root   e:wwwroot;
               index  index.html;
           }
    }

这样如果访问http://localhost 就会默认访问到E盘wwwroot目录下面的index.html，如果一个网站只是静态页面的话，那么就可以通过这种方式来实现部署。

动静分离

动静分离是让动态网站里的动态网页根据一定规则把不变的资源和经常变的资源区分开来，动静资源做好了拆分以后，我们就可以根据静态资源的特点将其做缓存操作，这就是网站静态化处理的核心思路

upstream test{
       server localhost:8080;
       server localhost:8081;
    }

    server {
        listen       80;
        server_name  localhost;

        location / {
            root   e:wwwroot;
            index  index.html;
        }

        # 所有静态请求都由nginx处理，存放目录为html
        location ~ .(gif|jpg|jpeg|png|bmp|swf|css|js)$ {
            root    e:wwwroot;
        }

        # 所有动态请求都转发给tomcat处理
        location ~ .(jsp|do)$ {
            proxy_pass  http://test;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   e:wwwroot;
        }
    }

这样我们就可以吧HTML以及图片和css以及js放到wwwroot目录下，而tomcat只负责处理jsp和请求，例如当我们后缀为gif的时候，Nginx默认会从wwwroot获取到当前请求的动态图文件返回，当然这里的静态文件跟Nginx是同一台服务器，我们也可以在另外一台服务器，然后通过反向代理和负载均衡配置过去就好了，只要搞清楚了最基本的流程，很多配置就很简单了，另外localtion后面其实是一个正则表达式，所以非常灵活

总结

Nginx是支持热启动的，也就是说当我们修改配置文件后，不用关闭Nginx，就可以实现让配置生效，当然我并不知道多少人知道这个，反正我一开始并不知道，导致经常杀死了Nginx线程再来启动…..Nginx重新读取配置的命令是

nginx -s reload

windows下面就是：

nginx.exe -s reload