Chinaunix首页 | 论坛 | 博客
  • 博客访问: 7160254
  • 博文数量: 3857
  • 博客积分: 6409
  • 博客等级: 准将
  • 技术积分: 15948
  • 用 户 组: 普通用户
  • 注册时间: 2008-09-02 16:48
个人简介

迷彩 潜伏 隐蔽 伪装

文章分类

全部博文(3857)

文章存档

2017年(5)

2016年(63)

2015年(927)

2014年(677)

2013年(807)

2012年(1241)

2011年(67)

2010年(7)

2009年(36)

2008年(28)

分类: 服务器与存储

2015-11-12 14:35:24

安装配置Nginx

[日期:2015-11-12] 来源:Linux社区  作者:wangfeng7399 [字体:  ]

一、简介

传统上基于进程或线程模型架构的web服务通过每进程或每线程处理并发连接请求,这势必会在网络和I/O操作时产生阻塞,其另一个必然结果则是对内存或CPU的利用率低下。生成一个新的进程/线程需要事先备好其运行时环境,这包括为其分配堆内存和栈内存,以及为其创建新的执行上下文等。这些操作都需要占用CPU,而且过多的进程/线程还会带来线程抖动或频繁的上下文切换,系统性能也会由此进一步下降。

在设计的最初阶段,nginx的主要着眼点就是其高性能以及对物理计算资源的高密度利用,因此其采用了不同的架构模型。受启发于多种操作系统设计中基于“事件”的高级处理机制,nginx采用了模块化、事件驱动、异步、单线程及非阻塞的架构,并大量采用了多路复用及事件通知机制。在nginx中,连接请求由为数不多的几个仅包含一个线程的进程worker以高效的回环(run-loop)机制进行处理,而每个worker可以并行处理数千个的并发连接及请求。

如果负载以CPU密集型应用为主,如SSL或压缩应用,则worker数应与CPU数相同;如果负载以IO密集型为主,如响应大量内容给客户端,则worker数应该为CPU个数的1.5或2倍。

Nginx会按需同时运行多个进程:一个主进程(master)和几个工作进程(worker),配置了缓存时还会有缓存加载器进程(cache loader)和缓存管理器进程(cache manager)等。所有进程均是仅含有一个线程,并主要通过“共享内存”的机制实现进程间通信。主进程以root用户身份运行,而worker、cache loader和cache manager均应以非特权用户身份运行。

主进程主要完成如下工作:

1. 读取并验正配置信息;

2. 创建、绑定及关闭套接字;

3. 启动、终止及维护worker进程的个数;

4. 无须中止服务而重新配置工作特性;

5. 控制非中断式程序升级,启用新的二进制程序并在需要时回滚至老版本;

6. 重新打开日志文件,实现日志滚动;

7. 编译嵌入式perl脚本;

worker进程主要完成的任务包括:

1. 接收、传入并处理来自客户端的连接;

2. 提供反向代理及过滤功能;

3. nginx任何能完成的其它任务;

cache loader进程主要完成的任务包括:

1. 检查缓存存储中的缓存对象;

2. 使用缓存元数据建立内存数据库;

cache manager进程的主要任务:

1. 缓存的失效及过期检验;

Nginx的配置有着几个不同的上下文:main、http、server、upstream和location(还有实现邮件服务反向代理的mail)。配置语法的格式和定义方式遵循所谓的C风格,因此支持嵌套,还有着逻辑清晰并易于创建、阅读和维护等优势。

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

在nginx内部,进程间的通信是通过模块的pipeline或chain实现的;换句话说,每一个功能或操作都由一个模块来实现。例如,压缩、通过FastCGI或uwsgi协议与upstream服务器通信,以及与memcached建立会话等。

二、安装配置

1.nginx的安装与配置

①、解决依赖关系

编译安装nginx需要实现安装开发包组“Development tools”和“Server Platform Development”、“Desktop Platform Development”

②、下载、编译、安装nginx

[root@node1 ~]# wget http://nginx.org/download/nginx-1.6.0.tar.gz

[root@node1 ~]# tar xf nginx-1.6.0.tar.gz

[root@node1 ~]# cd nginx-1.6.0

首先添加用于nginx,使其来运行nginx的服务进程

[root@node1 nginx-1.6.0]# useradd -r nginx

[root@node1 nginx-1.6.0]# ./configure  \

>  --prefix=/usr/local/nginx \

>  --sbin-path=/usr/local/nginx/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 \

>  --with-pcre

说明:

1.Nginx可以使用Tmcalloc(快速、多线程的malloc库及优秀性能分析工具)来加速内存分配,使用此功能需要实现安装gperftools,而后在编译nginx时添加--with-google_prtftools_module选项即可

2.如果想使用nginx的prel模块,可以通过为configure脚本添加--with-http_perl_module选项来实现,但目前此模块仍处于实验性使用阶段,可能会在运行中出现意外,因此,其实现方式这里不再介绍。如果想使用基于nginx的cgi功能,也可以基于FCGI来实现,具体实现方法请参照网上的文档。   

 ③、为nginx提供SysV init脚本: 

[root@node1 ~]# vi /etc/init.d/nginx

#!/bin/bash

#

# 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/local/nginx/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


  为此脚本赋予执行权限,并添加至服务列表中,并让其能够开机自动启动

 


1
2
3
 

[root@node1 ~]# chmod +x /etc/init.d/nginx

[root@node1 ~]# chkconfig --add nginx

[root@node1 ~]# chkconfig nginx on


  2、配置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的上下文,每个端的定义格式如下所示,需要注意的是,其每一个指令都必须使用分号(;)结束,否则为语法错误


     

{

          ;

          }


      ①、配置main模块


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


      a、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

      b、timer_reslution

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

      time_resolution  interval

      c、worker_cpu_affinity cpumask .....

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


                worker_processes    4

              worker_cpu_affinity 0001 0010 0100 1000;

        d、worker_priority


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

          worker_priority  number

        e、worker_processes


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

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


          maxclients = work_processes * work_connections

        f、worker_rlimit_nofile

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


          worker_rlimit_nofile number


      ②、配置Events模块


          a、worker_connections


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

          maxclients = work_processes * work_connections

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


          maxclients = work_processes * work_connections/4

          b、use


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


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


      ③、虚拟服务器相关配置


          server {

          ;

          }


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


      ④、location相关的配置


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

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


  3、Nginx的反向代理


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


      location /uri {

          proxy_pass http://www.linuxidc.com:8080/newuri;

        }


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

        location ~^/bbs {

          proxy_pass http://www.linuxidc.com;

        }


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

      server www2.linuxidc.com:8080      max_fails=3  fail_timeout=30s;

    }


          upstream模块的负载均衡算法主要有三种,轮询(round-robin)、ip哈希(ip_hash)和最少连接(least_conn)三种


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

upstream memcachesrvs {

    server 192.168.1.200:11211;

    server 192.168.1.201: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 192.168.1.202:80 weight 2;

    server 192.168.1.203:80 weight 3;

}


        a、if语句中的判断条件


          正则表达式匹配


          ==:等值比较


          ~: 与指定正则表达式模式匹配时返回“真”,判断匹配与否时区分字符大小写


          ~*: 与指定正则表达式模式匹配时返回“真”,判断匹配与否时不区分字符大小写

          !~: 与指定正则表达式模式不匹配时返回“真”,判断匹配与否时区分字符大小写

          !~*: 与指定正则表达式模式不匹配时返回“真”,判断匹配与否时区分字符大小写

          文件及目录匹配判断


          -f,!-f:判断指定的路径是否存在且为文件


          -d,!-d:判断指定的路径是否存在且为目录


          -e,!-e: 判断指定的路径是否存在,文件或路径均可


          -x,!-x:判断指定的路径文件是否存在且可执行


      b、nginx常用的全局变量


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

            1.$uri:当前请求的uri,不带参数

            2.$request_uri:请求的uri,带完整参数


            3.$host:http请求报文中host首部,如果请求中没有host首部,则以处理此请求的主机的主机名代替


            4.$hostname:nginx服务运行所在主机的主机名


            5.$remote_addr:客户端ip


            6.$remote_port:客户端port


            7.$remote_user:使用用户认证时客户端用户输入的用户名


            8.$request_filename:用户请求中的URI经过本地root或alias转换后映射的本地的文件路径


            9.$request_method:请求方法


          10.$server_addr:服务器地址


          11.$server_name: 服务器名称


          12.$server_port: 服务器端口


          13.$server_protocol:服务器想客户端发送响应时的协议,如http/1.1 http/1.0

            14.$scheme: 在请求中使用的scheme映射协议本身的协议


          15.$http_HEADER:匹配请求报文中指定的HEADER  例如:$http_host匹配请求报文中的host首部

          16.$sent_http_HEADER:响应报文中指定的HERADER,例如:$http_content_type匹配相应报文中的content-type首部


          17.$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”表示关闭压缩功能

 6.2实战部署Nginx+MySQL+PHP 

使用Nginx搭建WEB服务器 

搭建基于Linux6.3+Nginx1.2+PHP5+MySQL5.5的Web服务器全过程 

CentOS 6.3下Nginx性能调优 

CentOS 6.3下配置Nginx加载ngx_pagespeed模块 

CentOS 6.4安装配置Nginx+Pcre+php-fpm 

Nginx安装配置使用详细笔记 

Nginx日志过滤 使用ngx_log_if不记录特定日志 

Nginx 的详细介绍
Nginx 的下载地址

本文永久更新链接地址

阅读(1186) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~