查看: 326|回复: 0

Nginx 介绍

[复制链接]
发表于 2020-3-6 08:45:58 | 显示全部楼层 |阅读模式
前言

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电脑
  1. [[email protected] ~] vim /usr/local/nginx-1.12.1/conf/nginx.confserver {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;   }}[[email protected] ~] /usr/local/nginx-1.12.1/sbin/nginx -s reload
复制代码
Linux客户端访问测试:
  1. [[email protected] ~] curl -I --proxy 192.168.10.10:80 www.baidu.comHTTP/1.1 200 OKServer: nginx/1.12.1Date: Mon, 11 Jun 2018 15:37:47 GMTContent-Type: text/htmlContent-Length: 612Last-Modified: Thu, 31 May 2018 09:28:16 GMTConnection: keep-aliveETag: "5b0fc030-264"Accept-Ranges: byteshttps的访问测试[[email protected] ~] curl -I --proxy 192.168.10.10:443 www.baidu.comHTTP/1.1 200 OKServer: nginx/1.12.1Date: Mon, 11 Jun 2018 15:38:07 GMTContent-Type: text/htmlContent-Length: 277Connection: keep-aliveAccept-Ranges: bytesCache-Control: private, no-cache, no-store, proxy-revalidate, no-transformEtag: "575e1f5c-115"Last-Modified: Mon, 13 Jun 2016 02:50:04 GMTPragma: no-cache
复制代码
设置Linux客户端全局代理:
  1. [[email protected] ~] vim /etc/profileexport http_proxy='192.168.10.10:80'export http_proxy='192.168.10.10:443'export ftp_proxy='192.168.10.10:80'[[email protected] ~] source /etc/profile[[email protected] ~] curl -I www.baidu.com:80HTTP/1.1 200 OKServer: nginx/1.12.1Date: Mon, 11 Jun 2018 16:10:18 GMTContent-Type: text/htmlContent-Length: 277Connection: keep-aliveAccept-Ranges: bytesCache-Control: private, no-cache, no-store, proxy-revalidate, no-transformEtag: "575e1f5c-115"Last-Modified: Mon, 13 Jun 2016 02:50:04 GMTPragma: no-cache[[email protected] ~]# curl -I www.baidu.com:443HTTP/1.1 200 OKServer: nginx/1.12.1Date: Mon, 11 Jun 2018 16:10:27 GMTContent-Type: text/htmlContent-Length: 277Connection: keep-aliveAccept-Ranges: bytesCache-Control: private, no-cache, no-store, proxy-revalidate, no-transformEtag: "575e1f59-115"Last-Modified: Mon, 13 Jun 2016 02:50:01 GMTPragma: 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)

设置反向代理:
  1. [[email protected] conf] vim Nginx.conf
复制代码
在server段里面的location加上proxy_pass http://ip:端口
  1. 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. # 命令大全1、查找nginx路径:whereis nginx2、启动 service nginx start3、查看Nginx的版本号:nginx -V4、停止 nginx -s stop5、退出 nginx -s quit6、重启加载设置 nginx -s reload /etc/init.d/nginx -s reload 也可以
复制代码
重启没报错阐明设置文件没问题:
使用浏览器进行访问

简单的反向代理已经完成
设置代理多个网站及服务:
  1. [[email protected] conf] vim Nginx.conf
复制代码
设置多个反向代理实现方式,是通过差异的端口代理访问。这里复制一个server段,将两个server段nginx的端口更改,使用nginx的差异端口访问。
第一个server段设置tomcat1(192.168.161.189:8070)

第二个server段设置(192.168.161.189:8080)

设置完成后,重启nginx代理。
  1. [[email protected] 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服务缓存的基本原理是对客户请求过的资源建立本地副本,在一段合理时期内任何用户再次请求该资源时,Nginx服务器无需要再次向后端服务器发出请求,而是直策应答缓存的副本。因此,缓存技术可以显着降低后端服务器的负载,减轻网络传输负担,极大地提升响应速度。
tornado的吞吐能力

我们用一个最简单的例子,测试一下tornado的吞吐能力:
  1. # -*- coding: utf-8 -*-import osimport sysimport tornado.webimport tornado.ioloopimport tornado.httpserverfrom tornado.options import parse_command_lineclass 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的使用方法为:
  1. ab -n 请求数 -c 并发数 URL
复制代码
下面是并发10个请求共计100个请求的压力测试:
  1. ab -n 100 -c 10 http://127.0.0.1/This is ApacheBench, Version 2.3 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).....doneServer Software: TornaDOServer/6.0.3Server Hostname: 127.0.0.1Server Port: 9001Document Path: /Document Length: 22 bytesConcurrency Level: 10Time taken for tests: 0.107 secondsComplete requests: 100Failed requests: 0Total transferred: 21700 bytesHTML transferred: 2200 bytesRequests 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] receivedConnection Times (ms)min mean[+/-sd] median maxConnect: 0 1 0.6 0 2Processing: 4 9 3.0 9 18Waiting: 2 9 3.2 8 18Total: 4 10 3.1 9 19WARNING: The median and mean for the initial connection time are not within a normal deviationThese results are probably not that reliable.Percentage of the requests served within a certain time (ms)50% 966% 1075% 1380% 1490% 1595% 1598% 1899% 19100% 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是一款优秀的反向代理服务器,可以从官网下载压缩包,解压后直接使用。
首先,我们修改一下服务器的代码,使之可以同时启动多个进程:
  1. # -*- coding: utf-8 -*-import osimport sysimport multiprocessingimport tornado.webimport tornado.ioloopimport tornado.httpserverfrom 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()
复制代码
在命令行中输入如下命令,启动两个服务器进程,每个进程使用差异的端口
  1. python server.py 9001-9002
复制代码
接下来,设置ngnix。nginx的设置并不复杂,可以复制解压目次下的conf/ngnix.conf,进行修改即可。
在http部分中添加upstream,语法为:
  1. http {upstream 名称 {负载均衡策略server IP地址:端口 其它参数;  }}
复制代码
其中可选的负载均衡策略有:

  • ip_hash: 这种策略会把某一ip映射到一个固定的服务器,其优点是容易保持session的一致性,缺点是当该服务器负载过重后,也不能分流到其他服务器
  • least_conn: 这种策略根据服务器连接的数量,选择连接数量最小的服务器,同一客户端差异的请求有可能会进入差异的服务器
  • least_time: 这种策略盘算每个服务器的响应时间,选择响应时间小短的服务器,同一客户端差异的请求有可能会进入差异的服务器
我选择least_time,设置如下:
  1. upstream serv {least_conn;server 127.0.0.1:9001;server 127.0.0.1:9002;}
复制代码
将原来的location /的内容修改为如下内容:
  1. 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的名称。
修改并删除了原来设置文件中的注释会,设置文件如下:
  1. 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;
  2.     }
  3.   }
  4. }
复制代码
启动tornado,并进入设置文件的目次,使用如下命令启动nginx:
  1. nginx -c nginx.conf
复制代码
OK,反向代理设置完成。再次用ab进行压力测试, 效果并不像我们期望的那样,吞吐量成倍增长。这是因为tornado的IO几乎已经做到了极致,几乎比肩nginx,wondows平台上单台PC的吞吐量大致也就如此了。当tornado需要进行文件读写、数据库读写等耗时的操作时,多进程的反向代理才能表现出上风。

使用缓存技术

除了反向代理,nginx还可以启用缓存技术,进一步提高服务能力。当客户端第一次请求某url时,nginx将请求转发给服务器,服务器返回后,nginx在本地创建缓存。在缓存未失效前,nginx不再转发请求,而是直接将缓存的内容返回给客户端,服务器的负载被转嫁到nginx上,而nginx的性能黑白常出色的。
在nginx设置文件中设置缓存,语法为:
  1. 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的设置文件为:
  1. 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,输出服务器当前的时间:
  1. # -*- coding: utf-8 -*-import osimport sysimport timeimport datetimeimport multiprocessingimport tornado.webimport tornado.ioloopimport tornado.httpserverfrom 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,分别指定是否启用缓存即可:
  1. 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掉,能自动剔除。
简单设置:
  1. 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;        }    }
复制代码
负载均衡的核心代码为:
  1. upstream test {        server localhost:8080;        server localhost:8081;    }
复制代码
这里我设置了2台服务器,当然实际上是一台,只是端口不一样而已,而8081的服务器是不存在的,也就是说访问不到,但是我们访问http://localhost 的时间,也不会有问题,会默认跳转到http://localhost:8080
具体是因为Nginx会自动判断服务器的状态,如果服务器处于不能访问(服务器挂了),就不会跳转到这台服务器,以是也避免了一台服务器挂了影响使用的情况,由于Nginx默认是RR策略,以是我们不需要其他更多的设置。
权重
指定轮询几率,weight和访问比率成正比,用于后端服务器性能不均的情况。例如
  1. 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的问题。
  1. upstream test {        ip_hash;        server localhost:8080;        server localhost:8081;    }
复制代码
fair(第三方)
按后端服务器的响应时间来分配请求,响应时间短的优先分配。
  1. upstream backend {        fair;        server localhost:8080;        server localhost:8081;    }
复制代码
url_hash(第三方)
按访问url的hash效果来分配请求,使每个url定向到同一个后端服务器,后端服务器为缓存时比较有效。在upstream中参加hash语句,server语句中不能写入weight等其他的参数,hash_method是使用的hash算法
  1. 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做静态资源服务器
  1. server {        listen       80;        server_name  localhost;        client_max_body_size 1024M;        location / {               root   e:\wwwroot;               index  index.html;           }    }
复制代码
如许如果访问http://localhost 就会默认访问到E盘wwwroot目次下面的index.html,如果一个网站只是静态页面的话,那么就可以通过这种方式来实现摆设。
动静分离
动静分离是让动态网站里的动态网页根据肯定规则把稳定的资源和常常变的资源区分开来,动静资源做好了拆分以后,我们就可以根据静态资源的特点将其做缓存操作,这就是网站静态化处理的核心思路
  1. 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重新读取设置的命令是
  1. nginx -s reload
复制代码
windows下面就是:
  1. nginx.exe -s reload
复制代码

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?用户注册

x

天涯海角也要找到Ni:Nginx 介绍

中发现Ni: Nginx 介绍
中发现Ni: Nginx 介绍
中发现Ni: Nginx 介绍
中发现Ni: Nginx 介绍
中发现Ni: Nginx 介绍
中发现Ni: Nginx 介绍
相关技术服务需求,请联系管理员和客服QQ:2753533861或QQ:619920289
您需要登录后才可以回帖 登录 | 用户注册

本版积分规则

帖子推荐:
客服咨询

QQ:2753533861

服务时间 9:00-22:00

快速回复 返回顶部 返回列表