Nginx编译安装和配置详解

一、Nginx简介

   Nginx官网:http://nginx.org/

   1、简介

   Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器,也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的,第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布,因它的稳定性、丰富的功能集、示例配置文件和低系统资源的消耗而闻名。2011年6月1日,nginx 1.0.4发布。


   2、优点

   Nginx 可以在大多数 Unix like OS 上编译运行,并有 Windows 移植版。 Nginx 的1.4.0稳定版已经于2013年4月24日发布,一般情况下,对于新建站点,建议使用最新稳定版作为生产版本,已有站点的升级急迫性不高。Nginx 的源代码使用 2-clause BSD-like license。

Nginx 是一个很强大的高性能Web和反向代理服务器,它具有很多非常优越的特性:

在高连接并发的情况下,Nginx是Apache服务器不错的替代品:Nginx在美国是做虚拟主机生意的老板们经常选择的软件平台之一。能够支持高达 50,000 个并发连接数的响应,感谢Nginx为我们选择了 epoll and kqueue作为开发模型。


   3、nginx特性

   非阻塞、事件驱动、一个master多个worker,一个worker响应多个用户请求


       基本功能:

静态资源的web服务器,能缓存打开的文件描述符;
反向代理服务器,缓存、负载均衡;
支持FastCGI
模块化,非DSO机制,过滤器gzip,SSI和图像大小调整等
支持SSL


   扩展功能:

基于名称和IP做虚拟主机
支持keepalive
支持平滑配置更新或程序版本升级
定制访问日志,支持使用日志缓存以提高性能
支持url rewrite
支持路径别名
支持基于IP及用户的认证;
支持速率限制,并发限制等;


   nginx的基本架构:

一个master, 生成一个或多个worker
事件驱动:kqueue, epoll, /dev/poll
消息通知:select, poll, rt signals
支持sendfile, sendfile64
文件AIO
支持mmap



二、编译安装Nginx

解决依赖环境:

yum groupinstall -y "Server Platform Development"
yum groupinstall -y "Development tools"
yum install pcre-devel -y


   下载安装包:nginx-1.4.7.tar.gz

nginx.vim :配置Vim的Nginx配置文件语法高亮的脚本


1、编译安装

[root@nfs ~]# groupadd -r nginx
[root@nfs ~]# useradd -r -g nginx nginx
[root@nfs nginx-1.4.7]# chown -R nginx.nginx /var/tmp/nginx/
[root@nfs ~]# tar xf nginx-1.4.7.tar.gz
[root@nfs ~]# cd nginx-1.4.7
[root@nfs nginx-1.4.7]# ./configure --help | less    //查看编译安装提示信息
[root@nfs nginx-1.4.7]# ./configure   --prefix=/usr   --sbin-path=/usr/sbin/nginx   --conf-path=/etc/nginx/nginx.conf   --error-log-path=/var/log/nginx/error.log   --http-log-path=/var/log/nginx/access.log   --pid-path=/var/run/nginx/nginx.pid    --lock-path=/var/lock/nginx.lock   --user=nginx   --group=nginx   --with-http_ssl_module   --with-http_flv_module   --with-http_stub_status_module   --with-http_gzip_static_module   --http-client-body-temp-path=/var/tmp/nginx/client/   --http-proxy-temp-path=/var/tmp/nginx/proxy/   --http-fastcgi-temp-path=/var/tmp/nginx/fcgi/   --http-uwsgi-temp-path=/var/tmp/nginx/uwsgi   --http-scgi-temp-path=/var/tmp/nginx/scgi
[root@nfs nginx-1.4.7]# make && make install


       参数解释:

--prefix=PATH            //安装路径
  --sbin-path=PATH         //二进制文件路径名,执行文件路径
  --conf-path=PATH         //配置文件路径
  --error-log-path=PATH    //错误日志路径
  --http-log-path=PATH     //访问日志路径
  --pid-path=PATH          //pid文件路径
  --lock-path=PATH         //锁文件路径
  --user=USER             //以哪个用户执行nginx
  --group=GROUP           //以哪个组执行nginx
  --builddir=DIR          //建立文件夹
//
//下面是指加载那种模块            
  --with-http_ssl_module    //ssl模块             
  --with-http_flv_module    //flash流媒体模块
  --with-http_stub_status_module    //状态模块
  --with-http_gzip_static_module    //压缩模块,能够实现压缩功能
  --http-client-body-temp-path=/var/tmp/nginx/client/    //处理http请求时,如果请求的包体需要临时暂存在磁盘上的暂存路径
  --http-proxy-temp-path=/var/tmp/nginx/proxy/    //nginx作为反向代理服务时,上游服务器产生的http包体需要临时暂存在磁盘上的路径
  --http-fastcgi-temp-path=/var/tmp/nginx/fcgi/    //fcgi相关的临时暂存路径
  --http-uwsgi-temp-path=/var/tmp/nginx/uwsgi    //uwsgi相关的临时暂存路径
  --http-scgi-temp-path=/var/tmp/nginx/scgi    //scgi相关的临时暂存路径
  --with-pcre    //启用正则表达式及rewrite模块


2、为nginx提供服务脚本

[root@nfs ~]# vim /etc/rc.d/init.d/nginx
//添加如下内容
#!/bin/sh
#
# nginx - this script starts and stops the nginx daemon
#
# chkconfig:   - 85 15
# description:  Nginx is an HTTP(S) server, HTTP(S) reverse \
#               proxy and IMAP/POP3 proxy server
# processname: nginx
# config:      /etc/nginx/nginx.conf
# config:      /etc/sysconfig/nginx
# pidfile:     /var/run/nginx.pid
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
# Source function library.
. /etc/rc.d/init.d/functions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
# Source networking configuration.
. /etc/sysconfig/network
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
# Check that networking is up.
[ "$NETWORKING" = "no" ] && exit 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
nginx="/usr/sbin/nginx"
prog=$(basename $nginx)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
NGINX_CONF_FILE="/etc/nginx/nginx.conf"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
[ -f /etc/sysconfig/nginx ] && . /etc/sysconfig/nginx
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
lockfile=/var/lock/subsys/nginx
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
make_dirs() {
   # make required directories
   user=`nginx -V 2>&1 | grep "configure arguments:" | sed 's/[^*]*--user=\([^ ]*\).*/\1/g' -`
   options=`$nginx -V 2>&1 | grep 'configure arguments:'`
   for opt in $options; do
       if [ `echo $opt | grep '.*-temp-path'` ]; then
           value=`echo $opt | cut -d "=" -f 2`
           if [ ! -d "$value" ]; then
               # echo "creating" $value
               mkdir -p $value && chown -R $user $value
           fi
       fi
   done
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
start() {
    [ -x $nginx ] || exit 5
    [ -f $NGINX_CONF_FILE ] || exit 6
    make_dirs
    echo -n $"Starting $prog: "
    daemon $nginx -c $NGINX_CONF_FILE
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
stop() {
    echo -n $"Stopping $prog: "
    killproc $prog -QUIT
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
restart() {
    configtest || return $?
    stop
    sleep 1
    start
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
reload() {
    configtest || return $?
    echo -n $"Reloading $prog: "
    killproc $nginx -HUP
    RETVAL=$?
    echo
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
force_reload() {
    restart
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
configtest() {
  $nginx -t -c $NGINX_CONF_FILE
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
rh_status() {
    status $prog
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
rh_status_q() {
    rh_status >/dev/null 2>&1
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
case "$1" in
    start)
        rh_status_q && exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart|configtest)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
            ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
        exit 2
esac
[root@nfs ~]# chmod +x /etc/rc.d/init.d/nginx


3、加入服务列表,开机启动

[root@nfs ~]# chkconfig --add nginx
[root@nfs ~]# chkconfig nginx on
[root@nfs ~]# chkconfig --list nginx
nginx           0:off   1:off   2:on    3:on    4:on    5:on    6:off


 4、启动并测试

[root@nfs ~]# service nginx start
[root@nfs ~]# curl -I  http://172.16.12.103
HTTP/1.1 200 OK
Server: nginx/1.4.7
Date: Wed, 30 Apr 2014 11:45:05 GMT
Content-Type: text/html
Content-Length: 612
Last-Modified: Wed, 30 Apr 2014 10:19:41 GMT
Connection: keep-alive
ETag: "5360ce3d-264"
Accept-Ranges: bytes



三、配置Nginx

    Nginx的代码是有一个核心和一系列的模块组成,核心主要用于提供Web Server的基本功能,以及Web和Mail反向代理的功能,还用于启用网络协议,创建必要的运行环境以及确保不同的模块之间平滑的进行交互,不过,大多数跟协议相关的功能和某应用特有的功能都是由nginx的模块实现的,这些功能模块大致可以分为事件模块、阶段性处理器、输出过滤器、变量处理器、协议、upstream和负载均衡几个类别,这些共同组成了nginx的http功能。事件模块主要用于提高OS独立的(不同操作系统的时间机制有所不同)事件通知机制如kqueue或epoll等。协议模块则负责实现nginx通过http、tls/ssl、smtp、pop3已经imap与对应的客户端建立会话

   Nginx的核心模块为Main和Events,此外还包括标准的HTTP模块,可选HTTP模块和邮件模块,其还可以支持诸多的第三方模块,Main用于配置错误日志、进程及权限等相关参数,Event用于配置I/O模型,如eopll、kqueue、select或poll等,他们是必备模块

   Nginx的主配置文件有几个端组成,这个端通常也被称为nginx的上下文,每个端的定义格式如下所示,需要注意的是,其每一个指令都必须使用分号(;)结束,否则为语法错误    

<section>{
          <directive> <parmenters>;
          }


   1、配置main模块

      下面说明main模块中的几个关键参数

①、error_log

      用于配置错误日志,可以用于main、http、server、及location上下文中:

       语法格式:        

error_log file | stderr [ debug | info | notice | warn | error | crit | alert | emerg ]


       如果在编译时使用--with-debug选项,还可以使用调试功能:    

error_log LOGFILE [debug_core | debug_alloc | debug_mutex | debug_event | debug_http | debug_imap];


       要禁用错误日志,不能使用“error_log off”,而是使用类似如下选项

error_log /dev/null crit


  ②、timer_reslution

      用来降低gettomeofday()系统调用的次数,默认情况下,每次从kevnet()、epoll、/dev/poll、select()或者poll()返回时都会执行此系统调用。x86-64系统上,gettimeday()代价已经很小,可以忽略此配置。语法格式为      

time_resolution  interval


③、worker_cpu_affinity cpumask .....

             用来绑定cpu的,只能用于main上下文。比如            

worker_processes    4
worker_cpu_affinity 0001 0010 0100 1000;


      ④、worker_priority

          为worker进程设定优先级(指定nice),此参数只能用于main上下文,默认为0:

   语法格式为:          

worker_priority  number


⑤、worker_processes

          worker进程是单线程进程。如果nginx用于cpu密集性的场景中,如SSL或gzip,且主机上的CPU个数至少有两个,那么应该将此参数值设定为与CPU核心数相同;如果Nginx用于大量静态文件访问的场景中,且所有文件的总大小大于可用内存时,应该将此参数的值设定的足够大以充分利用磁盘宽带

//此参数与Events上下文中的work_connections变量一起决定了maxclient的值:
maxclients = work_processes * work_connections


⑥、worker_rlimit_nofile

          设定worker进程能够打开文件描述符个数的最大值。语法格式为:          

worker_rlimit_nofile number


2、配置Events模块

①、worker_connections

          设定每个worker所处理的最大连接数,它与来自main上下文的worker_processes变量一起决定了maxclient的值:          

maxclients = work_processes * work_connections


       而在反向代理场景中,其计算方法与上述公式不同,因为默认情况下,浏览器将打开2个连接,而Nginx会为每一个连接打开2个文件描述符,因此,其maxclients的计算方法为:

maxclients = work_processes * work_connections/4


②、use

             在有着多于一个的事件模型IO的应用场景中,可以使用此指令设定nginx所使用的I/O机制,默认为./configure脚本设定的各机制中最适合当前OS的版本。建议由nginx自动选择。

   语法格式为:          

use [ kqueue|rtsig|epoll|/dev/poll|select|poll|eventport ]


③、虚拟服务器相关配置

server {
          <directive> <parmenters>;
          }

          用于指定虚拟机服务器相关的属性,常见的指令有backlog、rcvbuf、bind及sndbuf等


           ④、location相关的配置          

location [modeifier] uri {...} 或者location @name {...}

          通常用于server上下文中,用于定义某URI的访问属性。location可以嵌套。



四、Nginx的反向代理

     Nginx通过proxy模块实现反向代理功能。在作为web反向代理服务器时,nginx负责接受客户端请求,并能够根据URI、客户端参数或其他的处理逻辑将用户请求调度至上游服务器上(upstream server)。nginx在实现反向代理功能时的最重要的指令为porxy_pass,它能够将location定义在某URI代理至上游服务器(组)上。如下面的实例中,location的/uri将被替换为上游服务器上的/newuri  

location /uri {
       proxy_pass http://www.test.com:8080/newuri;
    }


     不过,这种处理机制中有两个例外,一个是如果location的URI是通过模式匹配定义的,其URI将直接传递至上游服务器,而不能为其指定转换为另外一个URI。例如下面实例中的/bbs将被代理为htt://www.test.com/bbs


location ~^/bbs {
          proxy_pass http://www.test.com;
       }


    第二个例外是,如果在location中使用URL重定向,那么nginx将使用重定向后的URL处理请求,而不再考虑上游服务器上定义的URI。如下面所示的例子中,传送给上游服务器的URI为index.php?page=<match>,而不是/index。


location / {
          rewrite /(.*)$ /index.php?page=$1 break;
          proxy_pass http://localhost:8080/index;
        }


①、proxy模块的指令

   proxy模块的可用配置指令非常多,他们分别用于定义proxy模块工作时的诸多属性;如连接超时时长、代理时使用http的协议版本等,下面对常用的指令做一个简单说明:


proxy_connect_timeout: nginx将一个请求发送至upstream server之前等待的最长时长
proxy_cookie_demain: 将upstream server通过Set-Cookie首部设定的path属修改为指定的值,其值可以作为一个字符串、正则表达式的模式或一个引用的变量
proxy_hide_header: 设定发送给客户端的报文中需要隐藏的首部
proxy_pass:指定将请求代理制upstream server的URL路径
proxy_set_header: 将发送至upstream server的报文某首部进行重写
proxy_rediect:重写location并刷新从upstream server收到的报文的首部
proxy_send_timeout:在连接断开之前两次发送至upstream server的写操作的最长间隔时长
proxy_read_timeout: 在连接断开之前两次从接受upstream server接受读操作的最长间隔时长


   如下面的一个示例:

proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
client_max_body_size 10m;
client_body_buffer_size 128k;
proxy_connect_timeout 30;
proxy_send_timeout 15;
proxy_read_timeout 15;


②、upstream模块

   与proxy模块结合使用的模块中,常用的当属upstream模块,upstream模块可以定义一个新的上下文,他包含了一组上游upstream服务器,这些服务器可以赋予不同的权重、不同的类型设置可以基于维护等原因标记为down

upstream模块常用的指令有:


ip_hash:基于客户端IP地址完成请求的分发,它可以保证来自于同一个客端的请求始终被转发至同一个upstream服务器
keepalive:每个worker进程为发送到奥upstream服务器的连接所缓存的个数
least_conn:最少连接调度算法
server:定义一个upstream服务器的地址,还可以包括一系列可选参数,如
wegiht: 权重
max_fail:最大失败连接次数,失败连接的超时时长有fail_timeout指定
fail_timeout: 等待请求的目标服务器发送响应的时长
backup: 用于fallback的目的,所有服务均故障时才启动此服务器
down:手动标记其不在处理任何请求


例如:

upstream backend {
     server www.test1.com weight=5;
     server www.test2.com:8080       max_fails=3  fail_timeout=30s;
   }


upstream模块的负载均衡算法主要有三种:

       轮询(round-robin)、ip哈希(ip_hash)和最少连接(least_conn)三种


          此外,upstream模块也能为非http的应用实现负载均衡,如下面的实例定义了nginx为memcached服务实现负载均衡的目的  


upstream memcachesrvs {
    server 172.16.12.101:11211;
    server 172.16.12.102:11211;
}
server {
    location / {
    set $memcached_key "$uri?$args";
    memcached_pass memcachesrvs;
    error_page 404 = @fallback;
    }
    location @fallback {
         proxy_pass http://127.0.0.1:8080;
    }
}


③、if判断语句

   在location中使用if语句可以实现条件判断,其通常有一个return语句,其一般与有着last或break标记的额rewrite规则一同使用,但其也可以按照需要使用的多种场景下,需要注意的时,不当的使用可以会导致不可预料的结果      

location / {
    if ($request_method == “PUT”) {
        proxy_pass http://upload.magedu.com:8080;
    }
    if ($request_uri ~ "\.(jpg|gif|jpeg|png)$") {
        proxy_pass http://imageservers;
        break;
    }
}
upstream imageservers {
    server 172.16.12.103:80 weight 2;
    server 172.16.12.104:80 weight 3;
}


a、if语句中的判断条件

//正则表达式匹配
==:等值比较
~: 与指定正则表达式模式匹配时返回“真”,判断匹配与否时区分字符大小写
~*: 与指定正则表达式模式匹配时返回“真”,判断匹配与否时不区分字符大小写
!~: 与指定正则表达式模式不匹配时返回“真”,判断匹配与否时区分字符大小写
!~*: 与指定正则表达式模式不匹配时返回“真”,判断匹配与否时区分字符大小写
//文件及目录匹配判断
-f,!-f:判断指定的路径是否存在且为文件
-d,!-d:判断指定的路径是否存在且为目录
-e,!-e: 判断指定的路径是否存在,文件或路径均可
-x,!-x:判断指定的路径文件是否存在且可执行


b、nginx常用的全局变量

         下面是nginx常用的全局变量中的一部分,他们通常用于of语句中实现条件判断          

$uri:当前请求的uri,不带参数
$request_uri:请求的uri,带完整参数
$host:http请求报文中host首部,如果请求中没有host首部,则以处理此请求的主机的主机名代替
$hostname:nginx服务运行所在主机的主机名
$remote_addr:客户端ip
$remote_port:客户端port
$remote_user:使用用户认证时客户端用户输入的用户名
$request_filename:用户请求中的URI经过本地root或alias转换后映射的本地的文件路径
$request_method:请求方法
$server_addr:服务器地址
$server_name: 服务器名称
$server_port: 服务器端口
$server_protocol:服务器想客户端发送响应时的协议,如http/1.1 http/1.0
$scheme: 在请求中使用的scheme映射协议本身的协议
$http_HEADER:匹配请求报文中指定的HEADER  例如:$http_host匹配请求报文中的host首部
$sent_http_HEADER:响应报文中指定的HERADER,例如:$http_content_type匹配相应报文中的content-type首部
$document_root:当前请求映射到的root配置



五、反向代理性能优化

    在反向代理场景中,nginx有一系列指定用于定义其工作特性,如缓冲区大小等,给这些指定设定一个合理的值,可以有效提高其系能


1、缓存区设定

      nginx在默认情况下再其响应给客户端之前尽可能在接来自upstream服务器的响应报文,它会将这些响应报文暂存于本地并尽量一次性的响应给客户端。然而,在来自于客户端的响应过多时,nginx会视图将之存储与本地磁盘中,这将大大降低nginx的性能,因此,在有着更多可用内存的场景中,应该将用于暂存这些报文的缓存区调大至一个合理的值


proxy_buffer_size size: 设定用于暂存来自于upstream服务器的每一个响应报文的缓冲区大小
proxy_buffering on|off:  启动缓存upstream服务器的响应报文,否则,如果proxy_max_temp_file_size指令的值为0,来自upstream服务器的响应报文在接受到的那一刻将同步发送给客户端;一般情况下,启用proxy_buffering并将proxy_max_temp_file_size设定为0并能够避免缓存响应报文的功能,并能够避免将其缓存至磁盘中
proxy_buffers 8 4k|8k:用以缓存来自upstream服务器的响应报文的缓存区大小


2、缓存

      nginx作为反向代理时,能够将来自upstream的响应缓存至本地,并在后续的客户端请求内容同样时直接从本地构建响应报文


     proxy_cache zone|off:定义一个用户缓存的共享内存区域,其可被多个地方调用,缓存将遵从upstream服务器的响应报文首部关于缓存的设定,如“Expires”、“Cache-Contol:no-cache”、“Cache-Control:max-age=XXX”、“private”和“no-store”等,但nginx设定proxy_cache_key必须包含用户特定数据如$cookir_xxx的方式实现,但最后这种方式在公共缓存上使用可能会有风险,因此,在响应报文中含有一下首部或指定标志的报文将不会被缓存  

Set-Cookie
    Cache-Control containing "no-cache", "no-store", "private", or a "max-age" with a non-numeric or 0 value
    Expires with a time in the past
    X-Accel-Expires: 0


     proxy_cahce_key:设定在存储及检索缓存时用于“键”的字符串,可以使用变量为其值,但使用不当时有可能会为同一个内容缓存多次;另外,将用户私有信息用于键可以避免将用户的私有信息发回给其他用户

proxy_cache_lock:启用此项,可在缓存未命中中阻止多个相同的请求同时发送upstream,其生效返回为worker级别

proxy_cache_lock_timeout: proxy_cache_lock功能的锁定时长

proxy_cache_main_uses:某响应报文被缓存之前至少应该被请求的次数

proxy_cache_path:定义一个用于保存缓存响应报文的路径,及一个保存缓存对象的键及相应元数据的共享内存区域(key_zone=name:size),其可选参数有:

levels:每级子目录名称的长度,有效值为1或者2,每级之间使用冒号分隔,最多为3级

inactive: 非活动缓存项从缓存中剔除之前的最大缓存时长

max_size:缓存空间大小的上限,当需要缓存的对象超出此空间时,缓存管理器将给予LRU算法对其进行清理

loader_files: 缓存加载器(cache_loader)的每次工作过程最多为多少个文件加载元数据

loader_threashold:缓存加载器的最大睡眠时长:

       例如:

proxy_cache_path  /data/nginx/cache/one    levels=1      keys_zone=one:10m;
proxy_cache_path  /data/nginx/cache/two    levels=2:2    keys_zone=two:100m;
proxy_cache_path  /data/nginx/cache/three  levels=1:1:2  keys_zone=three:1000m;


proxy_cache_usr_stale: 在无法联系到upstream服务器时的那种情形下(如error、timeout或http_500等)让nginx使用本地的缓存对象直接响应客户端请求:

   其格式为:

proxy_cache_use_stale error | timeout | invalid_header | updating | http_500 | http_502 | http_503 | http_504 | http_404 | off


proxy_cache_valid [code ....]time:用于为不同的响应设定不同市场的有效缓存时长,如

proxy_cache_valid  200 302  10m;


proxy_cache_menthods [GET HEAD POST]:为那些请求方法开启缓存功能

proxy_cache_bypass string:设定在那种情形下,nginx将不会缓存数据:

       例如

proxy_cache_bypass $cookie_nocache $arg_nocache $arg_comment;
proxy_cache_bypass $http_pragma $http_authorization;


使用案例


http {
    proxy_cache_path  /data/nginx/cache  levels=1:2    keys_zone=STATIC:10m
                                         inactive=24h  max_size=1g;
    server {
        location / {
            proxy_pass             http://www.magedu.com;
            proxy_set_header       Host $host;
            proxy_cache            STATIC;
            proxy_cache_valid      200  1d;
            proxy_cache_valid      301 302 10m;
            proxy_cache_vaild      any 1m;
            proxy_cache_use_stale  error timeout invalid_header updating
                                   http_500 http_502 http_503 http_504;
        }
    }
}


3、压缩

  nginx将响应报文发送至客户端之前可以使用启用压缩功能,这能够有效的节约代理。并提高响应至客户端的速度。通常编译nginx默认会附带gzip压缩的功能,因此,可以之间启用    


http {
    gzip on; //开启压缩功能
    gzip_http_version 1.0;
    gzip_comp_level 2;  //压缩比
    gzip_types text/plain text/css application/x-javascript text/xml application/xml application/xml+rss text/javascript application/javascript application/json; //对那些文件进行压缩
    gzip_disable msie6;  //不对那些浏览器压缩
}


   gzip_proxied指令可以定义对客户端请求的哪类对象启用压缩功能,如“expire”首部定义而无法缓存的对象启用压缩功能,其他可接受的值还有“no-cache”、“no-store”、“private”、“no_last_modified”、“no_etag”和“auto”等,而“off”表示关闭压缩功能




你可能感兴趣的:(nginx)