Nginx安装与布署,安装配备Nginx

By admin in 美高梅手机版4858 on 2019年4月2日

Nginx

Nginx是一款面向质量设计的HTTP服务器,相较于Apache、lighttpd具有占有内部存款和储蓄器少,稳定性高等优势,全体采纳模块化设计,有丰盛的模块库和第三方模块库,配置灵活。
在Linux操作系统下,Nginx使用epoll事件模型,在OpenBSD或FreeBSD操作系统上利用类似于epoll的立刻事件模型kqueue。Nginx在合法测试的结果中,能够援救伍万个互相连接,而在实际上的运作中,能够扶助30000至50000个相互连接。Nginx除了是一个轻量级的异步框架的Web服务器,仍可以用作反向代理和负载平衡器。
Nginx工作时有多少个主线程和多少个工作线程,主线程的目标是加载和验证配置文件、维护理工科人作线程;工作线程用来拍卖实际的呼吁,其数据可安顿,也能够自动调整为服务器CPU数量。Nginx主配置文件:
/etc/nginx/nginx.conf,及/etc/nginx/conf.d/*.conf。Nginx由不相同的模块组合,那一个模块由安顿文件中钦点的通令控制。


Nginx安装

设置配备Nginx

一、简介

守旧上基于经过或线程模型框架结构的web服务通过每经过或每线程处理并发连接请求,那势必会在网络和I/O操作时发出鸿沟,其另2个必然结果则是对内部存款和储蓄器或CPU的利用率低下。生成1个新的历程/线程要求事先备好其运作时环境,那包罗为其分配堆内存和栈内部存款和储蓄器,以及为其创制新的施行上下文等。这么些操作都亟需占用CPU,而且过多的经过/线程还会拉动线程抖动或频仍的上下文切换,系统品质也会由此越发下滑。

在规划的初期阶段,nginx的关键观点便是其高品质以及对物理总括能源的高密度利用,因而其利用了分歧的架构模型。受启发于各个操作系统设计中基于“事件”的高级处理体制,nginx选择了模块化、事件驱动、异步、单线程及非阻塞的架构,并大方行使了多路复用及事件通报机制。在nginx中,连接请求由为数不多的多少个仅包罗三个线程的进程worker以飞快的环绕(run-loop)机制举行处理,而各样worker能够并行处理数千个的产出连接及请求。

若是负载以CPU密集型应用为主,如SSL或收缩应用,则worker数应与CPU数1样;假如负载以IO密集型为主,如响应大量内容给客户端,则worker数应该为CPU个数的1.5或二倍。

Nginx会按需同时运维多少个经过:1个主进程(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的代码是由三个着力和1一日千里的模块组成, 宗旨关键用以提供Web
Server的基本功效,以及Web和Mail反向代理的机能;还用于启用网络协议,成立须要的周转时环境以及有限协助分化的模块之间平滑地开始展览相互。不过,大多跟协议相关的成效和某应用特有的功能都以由nginx的模块达成的。这几个功效模块大致能够分为事件模块、阶段性处理器、输出过滤器、变量处理器、协议、upstream和负载均衡多少个项目,这么些共同整合了nginx的http功用。事件模块主要用于提供OS独立的(差异操作系统的事件机制有所差别)事件通报机制如kqueue或epoll等。协议模块则负责落到实处nginx通过http、tls/ssl、smtp、pop三以及imap与相应的客户端建立会话。

在nginx内部,进程间的通讯是经过模块的pipeline或chain完结的;换句话说,每1个效果或操作都由一个模块来落到实处。例如,压缩、通过法斯特CGI或uwsgi协议与upstream服务器通讯,以及与memcached建立会话等。

二、安装配备

1.nginx的安装与布局

一、化解重视关系

编写翻译安装nginx要求贯彻设置开发包组“Development tools”和“Server Platform
Development”、“Desktop Platform Development”

②、下载、编译、安装nginx

[[email protected]
~]# wget

[[email protected]
~]# tar xf nginx-1.6.0.tar.gz

[[email protected]
~]# cd nginx-1.6.0

率先添加用于nginx,使其来运作nginx的劳动进程

[[email protected]
nginx-1.6.0]# useradd -r nginx

[[email protected]
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

说明:

壹.Nginx得以行使Tmcalloc(火速、十二线程的malloc库及完美质量分析工具)来加速内部存款和储蓄器分配,使用此意义要求贯彻设置gperftools,而后在编写翻译nginx时添加–with-google_prtftools_module选项即可

贰.比方想使用nginx的prel模块,能够通过为configure脚本添加–with-http_perl_module选项来落实,但日前此模块仍处于实验性使用阶段,恐怕会在运维中出现意外,由此,其促成格局那里不再介绍。假如想使用基于nginx的cgi成效,也能够依照FCGI来贯彻,具体贯彻方式请参见网上的文书档案。 
 

 ③、为nginx提供SysV init脚本: 

[[email protected]
~]# 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=`Nginx安装与布署,安装配备Nginx。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
 

[[email protected]
~]# chmod +x /etc/init.d/nginx

[[email protected]
~]# chkconfig –add nginx

[[email protected]
~]# 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和伊夫nts,其它还包蕴专业的HTTP模块,可选HTTP模块和邮件模块,其还能协理广大的第3方模块,Main用于配置错误日志、进度及权限等连锁参数,伊芙nt用于配置I/O模型,如eopll、kqueue、select或poll等,他们是必需模块

 
Nginx的主配置文件有多少个端组成,那个端日常也被号称nginx的上下文,每一个端的定义格式如下所示,必要小心的是,其每3个命令都必须选择分号(;)甘休,不然为语法错误

      <section>{

          <directive> <parmenters>;

          }

      ①、配置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()再次回到时都会实施此系统调用。x八陆-6四种类上,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用于大气静态文件访问的情景中,且富有文件的总大小大于可用内部存款和储蓄器时,应该将此参数的值设定的丰硕大以充足利用磁盘宽带

         
此参数与伊芙nts上下文中的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

         
而在反向代理场景中,其计算方式与上述公式分化,因为默许景况下,浏览器将开辟三个三番五次,而Nginx会为每二个总是打开一个公文描述符,由此,其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 {

          <directive> <parmenters>;

          }

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

      肆、location相关的计划

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

         
平时用于server上下文中,用于定义某U兰德酷路泽I的拜会属性。location能够嵌套。

  三、Nginx的反向代理

     
Nginx通过proxy模块达成反向代理成效。在作为web反向代理服务器时,nginx负责接受客户端请求,并能够依照U帕杰罗I、客户端参数或别的的处理逻辑将用户请求调度至上游服务器上(upstream
server)。nginx在完毕反向代理作用时的最根本的吩咐为porxy_pass,它亦可将location定义在某ULX570I代理至上游服务器(组)上。如上边包车型地铁实例中,location的/uri将被轮换为上游服务器上的/newuri

      location /uri {

          proxy_pass

使用Nginx搭建WEB服务器

搭建基于Linux陆.三+Nginx壹.二+PHP五+MySQL伍.5的Web服务器全经过

CentOS 陆.三下Nginx品质调优

CentOS 6.3下配置Nginx加载ngx_pagespeed模块

CentOS 陆.四安装配置Nginx+Pcre+php-fpm

Nginx安装配置使用详细笔记

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

Nginx 的详实介绍:请点那里
Nginx 的下载地址:请点那里

正文永久更新链接地址:

一、简介
古板上基于经过或线程模型架构的web服务通过每经过或每线程处理并发连接请求,这势必会在网络和I/O操作时爆发阻…

常见模块及布局指令

1. Nginx安装

首先须要事先安装gcc-g++、PCRE,
zlib。PCRE用于重写rewrite,zlib用于gzip压缩

到安装目录下,
下载nginx

wget http://nginx.org/download/nginx-1.5.9.tar.gz

解压

tar -zxvf nginx-1.5.9.tar.gz

进去到新的目录下

cd nginx-1.5.9

编译安装

首先安装贫乏的信赖包

yum -y install gcc gcc-c++ make libtool zlib zlib-devel openssl openssl-devel pcre pcre-devel

下一场在官网上下载Nginx的安装包
http://nginx.org/en/download.html。
也足以设置多个插件模块,援助检查Nginx难点nginx_upstream_check_module-0.三.0.tar.gz
——
检查后端服务器的情状;nginx-goodies-nginx-sticky-module-ng-bd31贰d58675二.tar.gz(提出在/usr/local/src下解压后将引得重命名称叫nginx-sticky-module-ng-一.2.5)
—— 后端做负载均衡消除session sticky难点
解压到/usr/local/src下解压

在下载Nginx时要留意不要最新,要最平静的,插件壹般越新越好,不过一定要留心包容难点。

  ./configure -prefix=/usr/local/nginx-1.6 --with-pcre \
> --with-http_stub_status_module --with-http_ssl_module \
> --with-http_gzip_static_module --with-http_realip_module \
> --add-module=../nginx_upstream_check_module-0.3.0

make && make install

Core functionality

主配置文件/etc/nginx/nginx.conf格式:

main block
event {
    ...
}        
http {
    ...
    server {
        ...
    }
    server {
        ...
        listen
        server_name
        root
        location /uri/ {
            ...
            if CONDITION {
                ...
            }
        }
    }
}

内部 main block 配置段常见的布署指令:

分类:
    正常运行必备的配置
    优化性能相关的配置
    用于调试及定位问题相关的配置
    事件驱动相关的配置
正常运行必备的配置:
1、user USERNAME [GROUP];
    指定worker processes所属用户及用户组
2、pid /PATH/TO/PID_FILE;
    指定存储nginx主进程进程号码的文件路径
3、include file | mask;
    指明包含进来的其它配置文件片断
4、load_module file;
    指明要装载的动态模块
性能优化相关的配置:
1、worker_processes number | auto;
    worker进程的数量:通常应该等于小于当前主机的cpu的物理核心数
    auto:当前主机物理CPU核心数
2、worker_cpu_affinity cpumask ...; 或 worker_cpu_affinity auto [cpumask];
    绑定CPU核心与worker进程,默认不绑定
    cpumask示例:8核
        00000001:0号CPU
        00000010:1号CPU
3、worker_priority number;
    指定worker进程的nice值,设定worker进程优先级;[-20,20]
4、worker_rlimit_nofile number;
    worker进程所能够打开的文件数量上限
调试、定位问题:
1、daemon on|off;    
    是否以守护进程方式运行Nignx
2、master_process on|off;
    是否以master/worker模型运行nginx;默认为on
3、error_log file [level];
    定义错误日志记录级别
事件驱动相关的配置:
events {
    ...
}
1、worker_connections number;
    每个worker进程所能够打开的最大并发连接数数量
    启动nginx后最大并发连接数量: worker_processes * worker_connections
2、use method;
    指明并发连接请求的处理方法,不指定时nginx会自动选择最高效的处理方法
    use epoll;
3、accept_mutex on | off;
    处理新的连接请求的方法:on意味着由各worker轮流处理新请求,Off意味着每个新请求的到达都会通知所有的worker进程

Nginx的设置配置

进展安装配置configure
在configure命令前面加上相应陈设项:

  • –prefix=path 定义三个索引,存放服务器上的文书
    ,也正是nginx的装置目录。默许使用 /usr/local/nginx。

  • –prefix=path 定义贰个索引,存放服务器上的文书
    ,相当于nginx的设置目录。暗许使用 /usr/local/nginx。

  • –sbin-path=path 设置nginx的可执行文件的路线,暗中认可为
    prefix/sbin/nginx.

  • –conf-path=path
    设置在nginx.conf配置文件的途径。nginx允许利用不一致的配置文件启动,通过命令行中的-c选项。私下认可为prefix/conf/nginx.conf.

  • –pid-path=path
    设置nginx.pid文件,将积存的主进度的进度号。安装到位后,能够每15日变动的公文名
    , 在nginx.conf配置文件中使用 PID指令。默许意况下,文件名称为prefix/logs/nginx.pid.

  • –error-log-path=path
    设置主错误,警告,和确诊文件的称号。安装实现后,能够随时变动的文本名
    ,在nginx.conf配置文件中 使用 的error_log指令。暗中认可景况下,文件名叫prefix/logs/error.log.

  • –http-log-path=path
    设置主请求的HTTP服务器的日记文件的称谓。安装达成后,能够随时变动的文本名
    ,在nginx.conf配置文件中 使用 的access_log指令。暗中认可情状下,文件名字为prefix/logs/access.log.

  • –user=name
    设置nginx工作进度的用户。安装到位后,能够随时变动的名号在nginx.conf配置文件中
    使用的user指令。私下认可的用户名是nobody。

  • –group=name
    设置nginx工作经过的用户组。安装到位后,能够天天变动的名目在nginx.conf配置文件中
    使用的 user指令。私下认可的为非特权用户。

  • –with-select_module –without-select_module
    启用或剥夺构建一个模块来允许服务器使用select()方法。该模块将活动建立,假若平台不扶助的kqueue,epoll,rtsig或/dev/poll。

  • –with-poll_module
    –without-poll_module启用或剥夺营造一个模块来允许服务器使用poll()方法。该模块将自行建立,假如平台不帮助的kqueue,epoll,rtsig或/dev/poll。

  • –without-http_gzip_module —
    不编译压缩的HTTP服务器的响应模块。编译并运维此模块须要zlib库。

  • –without-http_rewrite_module
    不编写翻译重写模块。编译并运营此模块必要PCRE库援助。

  • 美高梅手机版4858,–without-http_proxy_module — 不编译http_proxy模块。

  • –with-http_ssl_module —
    使用https协议模块。暗中认可意况下,该模块未有被创设。建立并运转此模块的OpenSSL库是少不了的。

  • –with-pcre=path — 设置PCRE库的源码路径。PCRE库的源码(版本四.4 –
    八.30)供给从PCRE网址下载并解压。其他的做事是Nginx的./
    configure和make来形成。正则表明式使用在location指令和
    ngx_http_rewrite_module 模块中。

  • –with-pcre-jit —编译PCRE包含“just-in-time compilation”(1.1.12中,
    pcre_jit指令)。

  • –with-zlib=path —设置的zlib库的源码路径。要下载从 zlib(版本一.1.三

    一.贰.5)的并解压。别的的办事是Nginx的./
    configure和make达成。ngx_http_gzip_module模块须要选用zlib 。

  • –with-cc-opt=parameters —
    设置额外的参数将被添加到CFLAGS变量。例如,当你在FreeBSD上使用PCRE库时要求动用:–with-cc-opt=”-I
    /usr/local/include。.如需求必要追加
    select()帮衬的文本数量:–with-cc-opt=”-D FD_SETSIZE=2048″.

  • –with-ld-opt=parameters
    —设置附加的参数,将用来在链接时期。例如,当在FreeBSD下接纳该体系的PCRE库,应钦点:–with-ld-opt=”-L
    /usr/local/lib”.

例如

./configure --sbin-path=/usr/local/nginx/nginx \
--conf-path=/usr/local/nginx/nginx.conf \
--pid-path=/usr/local/nginx/nginx.pid \
--without-http_rewrite_module \
--without-http_gzip_module \
--user=nginx \
--group=nginx  

(那里由于笔者从未装pcre, zlib,所以选的是without)

事业有成后,能够观望目录中出现了Makefile文件。
先后使用make和make install,安装到位。

可以用 nginx –V来查看版本号。

编译常见的采用

小编们能够用 ./configure –help查看

  • –prefix=PATH : 钦赐nginx的设置目录。暗中同意 /usr/local/nginx
  • –conf-path=PATH :
    设置nginx.conf配置文件的门道。nginx允许利用不一样的配置文件运转,通过命令行中的-c选项。暗许为prefix/conf/nginx.conf
  • –user=name:
    设置nginx工作进度的用户。安装完毕后,能够随时在nginx.conf配置文件更改user指令。暗中同意的用户名是nobody。–group=name类似
  • –with-pcre :
    设置PCRE库的源码路径,若是已通过yum情势安装,使用–with-pcre自动找到库文件。使用–with-pcre=PATH时,须求从PCRE网址下载pcre库的源码(版本肆.四–
    8.30)并解压,剩下的就付给Nginx的./configure和make来形成。perl正则表明式使用在location指令和
    ngx_http_rewrite_module模块中。
  • –with-zlib=PATH : 钦命 zlib(版本一.壹.3 –
    一.贰.伍)的源码解压目录。在私下认可就启用的网络传输压缩模块ngx_http_gzip_module时索要利用zlib
  • –with-http_ssl_module :
    使用https协议模块。暗中认可景况下,该模块未有被营造。前提是openssl与openssl-devel已安装
  • –with-http_stub_status_module : 用来监督 Nginx 的当前情景
    –with-http_realip_module :
    通过那么些模块允许大家改变客户端请求头中型地铁户端IP地址值(例如X-Real-IP

    X-Forwarded-For),意义在于能够使得后台服务器记录原始客户端的IP地址
  • –add-module=PATH :
    添加第1方外部模块,如nginx-sticky-module-ng或缓存模块。每趟添加新的模块都要重新编写翻译(Tengine能够在新进入module时无需另行编写翻译)

ngx_http_core_module

配备格式:

http {
    ... ...
    server {
        ...
        server_name
        root
        location [OPERATOR] /uri/ {
        ...
        }
    }
    server {
        ...
    }
}

普遍配置指令:

与套接字相关的配置:
1、server { ... }
虚拟主机配置字段
安全上下文:http
示例:
    server {
        listen address[:PORT]|PORT;
        server_name SERVER_NAME;
        root /PATH/TO/DOCUMENT_ROOT;                            
    }
2、listen address[:port] [default_server] [ssl] [http2|spdy]  [backlog=number] [rcvbuf=size] [sndbuf=size];
指定监听的地址和端口等,常用选项:
    default_server:设定为默认虚拟主机
    ssl:限制仅能够通过ssl连接提供服务
    backlog=number:后援队列长度
    rcvbuf=size:接收缓冲区大小
    sndbuf=size:发送缓冲区大小
安全上下文:server
示例:
    # 监听指定的IP及端口
    listen 192.168.4.119:80;
    # 监听指定端口只能通过SSL
    listen 443 ssl;
3、server_name name ...;
指明虚拟主机的主机名称,后可跟多个由空白字符分隔的主机名称;
安全上下文:server
示例:
    # 支持*通配任意长度的任意字符
    server_name *.test.com www.test.*;
    # 支持~起始的字符做正则表达式模式匹配
    server_name ~^www\d+\.test\.com$
4、tcp_nodelay on | off;
在keepalived模式下的连接是否启用tcp_nodelay选项
安全上下文:http,server,location
5、tcp_nopush on|off;
在sendfile模式下,是否启用选项
安全上下文:http,server,location    
6、sendfile on | off;
是否启用sendfile功能
安全上下文:http,server,location,if in location
定义路径相关的配置:
7、root path; 
设置web资源路径映射,用于指明用户请求的url所对应的本地文件系统上的文档所在目录路径
安全上下文:http,server,location,if in location
8、location [ = | ~ | ~* | ^~ ] uri { ... }
设置请求的uri对应的资源。在一个server中location配置段可存在多个,用于实现从uri到文件系统的路径映射;ngnix会根据用户请求的uri来检查定义的所有location,并找出一个最佳匹配,而后应用其配置。其中:
    =:对uri做精确匹配
    ^~:对uri的左半部分做匹配检查,不区分字符大小写
    ~:对uri做正则表达式模式匹配,区分字符大小写
    ~*:对uri做正则表达式模式匹配,不区分字符大小写
    不带符号:匹配起始于此uri的所有的url
    @:定义位置名称,实现资源跳转
匹配优先级:=, ^~, ~/~*,不带符号;
安全上下文:server,location
示例:
server {
    listen 192.168.4.119:80;
    server_name www.test.com;
    root /data/web;    #设置虚拟主机的web根目录
    # = 精确匹配/data/web/test目录下的test.html文件
    location = /test.html {
        root /data/web/test;  #指定location的web根目录
    }
    # ~ 正则匹配/data/web/aaa目录下带有AAA字符串的文件(区分大小写)
    location ~ .*AAA.* {
        root /data/web/aaa;
    }
    # ~* 正则匹配/data/web/bbb目录下带有bbb字符串的文件(不区分大小写)
    location ~* .*bbb.* {
        root /data/web/bbb;
    }
    # ^~ 匹配/data/web/www目录下的文件
    location ^~ /www {
        root /data/web/www
    }
}
9、alias path;
定义路径别名,文档映射的另一种机制
安全上下文:location
注意:root指令和alias指令的意义不同,并且不能同时用在同一个location中。
    (1) root,给定的路径对应于location中的/uri/左侧的/
    (2) alias,给定的路径对应于location中的/uri/右侧的/
10、error_page code ... [=[response]] uri;
指定错误的uri路径
安全上下文:http,server,location,if in location
示例:
    #当网页的状态码为404时,跳转到指定的404.html页面
    error_page 404    /404.html;
11、try_files file ... uri;
如果指定路径下文件不存在,则跳转到指定的uri或者返回指定状态码。
安全上下文:server,location
示例:
location ~ .*test.* {
        try_files test.html /404.html;
}
#尝试打开test.html,如果没有此文件,则返回状态码500
location = /test.html {
        try_files test.html =500;
}
定义客户端请求的相关配置
12、keepalive_timeout timeout [header_timeout];
设定保持连接的超时时长,0表示禁止长连接;默认为75s
安全上下文:http,server,location
13、keepalive_requests number;
在一次长连接上所允许请求的资源的最大数量,默认为100
安全上下文:http,server,location
14、keepalive_disable none | browser ...;
对哪种浏览器禁用长连接
安全上下文:http,server,location
15、send_timeout time;
向客户端发送响应报文的超时时长,此处指两次连续写操作之间的间隔时长
安全上下文:http,server,location
16、client_body_buffer_size size;
用于接收客户端请求报文的body部分的缓冲区大小,默认为16k;超出此大小时,其将被暂存到磁盘上的由client_body_temp_path指令所定义的位置
安全上下文:http,server,location
17、client_body_temp_path path [level1 [level2 [level3]]];
设定用于存储客户端请求报文的body部分的临时存储路径及子目录结构和数量,其中level表示存储目录的数量,用16进制表示
安全上下文:http,server,location
示例:
    client_body_temp_path /var/tmp/client_body  2 1 1
        2:表示用2位16进制数字表示一级子目录:00-ff,共256个一级子目录
        1:表示用1位16进制数字表示二级子目录;0-f,共16个二级子目录
        1:表示用1位16进数制字表示三级子目录:0-f,共16个二级子目录
对客户端进行限制的相关配置:
18、limit_rate rate;
限制响应给客户端的传输速率,单位是bytes/second,0表示无限制
安全上下文:http,server,location,if in location
19、limit_except method ... { ... }
限制客户端除指定的请求方法之外不能访问服务器
安全上下文:location
示例:
    # 限制192.168.4.0/24的客户端只能通过GET请求
    limit_except GET {
        allow 192.168.4.0/24;
        deny  all;
    }
文件操作优化的配置
20、aio on|off | threads[=pool];
是否启用aio功能
安全上下文:http,server,location
21、directio size | off;
当文件大于等于给定的大小时启用O_DIRECT标记,例如directio 4m;
安全上下文:http,server,location
22、open_file_cache off; 或 open_file_cache max=N [inactive=time];
    nginx可以缓存以下三种信息:
        (1) 文件的描述符、文件大小和最近一次的修改时间
        (2) 打开的目录结构
        (3) 没有找到的或者没有权限访问的文件的相关信息
    max=N:可缓存的缓存项上限;达到上限后会使用LRU算法实现缓存管理
    inactive=time:缓存项的非活动时长,在指定的时长内未被命中的或命中的次数少于open_file_cache_min_uses所指定的次数的缓存项即为非活动项
安全上下文:http,server,location
23、open_file_cache_valid time;
缓存项有效性的检查频率;默认为60s;
安全上下文:http,server,location
24、open_file_cache_min_uses number;
在open_file_cache指令的inactive参数指定的时长内,至少应该被命中多少次方可被归类为活动项,默认为1
安全上下文:http,server,location
25、open_file_cache_errors on | off;
是否缓存查找时发生错误的文件一类的信息,默认为off
安全上下文:http,server,location

2. Nginx的启动、停止

初阶代码:
格式:nginx安装目录地址 -c nginx配置文件地址
如:/usr/sbin/nginx -c /root/zhangxiao/nginx-1.5.9/conf/nginx.conf

查看进程:

ps -ef|grep nginx

停下进度:

kill -QUIT 进程号

开始和倒闭

  /usr/local/nginx-1.6/sbin/nginx -t   ## 检查配置文件是否正确
 ./sbin/nginx -V # 可以看到编译选项
 ./sbin/nginx # 默认配置文件 conf/nginx.conf,-c 指定
 ./sbin/nginx -s stop
或 pkill nginx    #启动、关闭
 ./sbin/nginx -s reload
或 kill -HUP `cat /usr/local/nginx-1.6/logs/nginx.pid`# 重启,不会改变启动时指定的配置文件

也足以把Nginx下载到/etc/init.d/,修改路径和实践权限使其看成系统服务管理。

  service nginx {start|stop|status|restart|reload|configtest}

ngx_http_index_module

此模块用于实现基于IP的访问控制功能。

index file...;
定义默认的web网页资源,默认为index index.html
安全上下文:http,server,location
示例:
    location / {
        index index.html;
    }

Nginx的nginx.conf配置文件

默许生成的公文为:

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

文本结构:

...              #全局块

events {         #events块
   ...
}

http      #http块
{
    ...   #http全局块
    server        #server块
    { 
        ...       #server全局块
        location [PATTERN]   #location块
        {
            ...
        }
        location [PATTERN] 
        {
            ...
        }
    }
    server
    {
      ...
    }
    ...     #http全局块
}

其中:

1、全局块:配置影响nginx全局的命令。一般有运营nginx服务器的用户组,nginx进度pid存放路径,日志存放路径,配置文件引入,允许生成worker
process数等。
贰、events块:配置影响nginx服务器或与用户的互连网连接。有种种进度的最奥斯汀接数,采用哪个种类事件驱动模型处理连接请求,是还是不是同意同时接受七个网路连接,开启多少个网络连接系列化等。
3、http块:能够嵌套三个server,配置代理,缓存,日志定义等多数效率和第三方模块的配备。如文件引入,mime-type定义,日志自定义,是或不是选用sendfile传输文件,连接超时时间,单连接请求数等。
四、server块:配置虚拟主机的相干参数,3个http中能够有八个server。
五、location块:配置请求的路由,以及种种页面包车型客车拍卖情形。

yum安装

yum -y install nginx

ngx_http_access_module

allow|deny address|CIDR|unix:|all;
允许或拒绝访问的Ip网段,匹配顺序为从上往下匹配。
安全上下文: http,server,location,limit_except
示例:
    location / {
        deny  192.168.4.1;
        allow 192.168.4.0/24;
        deny  all;
    }

Nginx极度消除

安顿文件

Nginx配置文件分为4部分:

  • main 全局配置
  • server 主机 配置
  • upstream 上游服务器配置
  • location 区域安装

ngx_http_auth_basic_module

此模块用于实现基于用户的访问控制功能。

1、auth_basic string|off
配置auth_basic提示的信息
安全上下文:http,server,location,limit_except
2、auth_basic_user_file file;
指定保存用户账户密码的file文件,该文件由htpasswd生成
安全上下文:http,server,location,limit_except
示例:
    #生成保存认证用户信息的文件
    [root@nginx ~]# htpasswd -c /etc/nginx/nginxpasswd test1
    New password: 
    Re-type new password: 
    Adding password for user test1
    [root@nginx ~]# htpasswd /etc/nginx/nginxpasswd test2
    New password: 
    Re-type new password: 
    Adding password for user test2

    #添加nginxbasic认证配置
    location ^~ /auth {
        auth_basic "nginx auth_basic";
        auth_basic_user_file /etc/nginx/nginxpasswd;
    }

启动nginx报错:

nginx: [emerg] getpwnam(“nginx”) failed in
/usr/local/nginx/conf/nginx.conf:2

是因为配制文件中利用的运转账户在系统中并未有找到
化解办法:

useradd -G groupname username

main全局配置

分类

  • 健康运作必备配置
  • 运营品质相关安排
  • 用以调节和测试及定位难题相关安排
  • 事件驱动相关配置

ngx_http_stub_status_module

此模块用于输出nginx的基本状态信息。

stub_status;
用于输出nginx的基本状态信息
安全上下文:server,location。
示例:
    location /status {
        stub_status;
    }
  访问http://192.168.4.119/status可获取nginx服务器的状态信息,如下:
    Active connections: 291 
    server accepts handled requests
        16630948 16630948 31070465 
    Reading: 6 Writing: 179 Waiting: 106     
  各项释义:
  Active connections: 活动状态的连接数;
  accepts:已经接受的客户端请求的总数;
  handled:已经处理完成的客户端请求的总数;
  requests:客户端发来的总的请求数;
  Reading:处于读取客户端请求报文首部的连接的连接数;
  Writing:处于向客户端发送响应报文过程中的连接数;
  Waiting:处于等待客户端发出请求的空闲连接数

启动nginx报错:

Starting nginx: nginx: [emerg] mkdir() “/var/tmp/nginx/client/”
failed
(2: No such file or directory)

权力不足,化解办法:

cd /var/tmp/
mkdir -p /var/tmp/nginx/{client,proxy,fastcgi,uwsgi,scgi}

好端端运作必备配置

  1. user

     Syntax: user user [group];
     Default:    user nobody nobody;
     Context:    main
    

概念工作历程使用的用户和组凭据。假诺省略group,则应用其名目等于user的

  1. pid /PATH/TO/PID_FILE;
    点名存款和储蓄nginx主进度经过号码的公文路径;
  2. include file | mask;指明包涵进来的别的配置文件片断;
  3. load_module file;指明要装载的动态模块;

ngx_http_log_module

1、access_log path [format [buffer=size] [gzip[=level]] [flush=time] [if=condition]];
  access_log off;
用于设置访问日志文件路径,格式及相关的缓冲的配置。默认情况下,access_log预定义了combined的日志格式,用户可在format中直接调用。
安全上下文:http,server,location,if in location,limit_except
示例:
    #将日志以combined格式记录在指定路径
    access_log  /var/log/nginx/access.log  combined;
    #将访问nginx的status的页面以指定的test格式存放在指定的路径中
    location /status {
        stub_status;
        access_log /data/log/access_log test;
    }
2、log_format name [escape=default|json|none] string ...;
在string中可使用nginx核心模块及其它模块内嵌的变量来生成log日志,默认日志的格式为combined格式。
安全上下文:http
示例:
    #定义名为test的日志格式
    log_format test '$remote_addr    $status    "$request"'
3、open_log_file_cache max=N [inactive=time] [min_uses=N] [valid=time];
  open_log_file_cache off;
用于缓存各日志文件相关的元数据信息。
安全上下文:http,server,location
各项释义:
    max:缓存的最大文件描述符数量;
    min_uses:在inactive指定的时长内访问大于等于此值方可被当作活动项,默认为1
    inactive:非活动时长;
    valid:验正缓存中各缓存项是否为活动项的时间间隔,默认为60s
示例:
    open_log_file_cache max=1000 inactive=20s valid=1m min_uses=2;

References:

  • http://www.cnblogs.com/knowledgesea/p/5175711.html
  • http://blog.csdn.net/a2796749/article/details/50492664
  • http://blog.csdn.net/tjcyjd/article/details/50695922

运行品质相关陈设

  1. worker_processes number | auto;
    worker进程的数据;经常应该相等小于当前主机的cpu的情理宗旨数;
    auto:当前主机物理CPU主旨数;

  2. worker_cpu_affinity cpumask …;
    worker_cpu_affinity auto [cpumask];
    nginx进程的CPU亲缘性;

    CPU MASK:
    00000000:
    0000 0001:0号CPU
    0000 0010:1号CPU
    0000 0100:2号CPU
    … …
    0000 0011:0和1号CPU;

  3. worker_priority number;
    点名worker进度的nice值,设定worker进度优先级;[-20,20]

  4. worker_rlimit_nofile number;
    worker进度所能够开拓的文书数量上限;

  5. time_resolution
    计算器解析度,下落此值可削减gettimeofday()系统调用次数

ngx_http_gzip_module

此模块能够使用gzip压缩响应报文的大小,通过能够将需要传输的数据减少一半或者更多

1、gzip on|off;
是否开启压缩响应
安全上下文:http,server,location,if in location
2、gzip_comp_level level;
设置压缩响应的等级,从1到9,默认为1
安全上下文:http,server,location
3、gzip_disable regex ...;
根据正则表达式匹配浏览器类型来关闭响应压缩
安全上下文:http,server,location
4、gzip_min_length length;
指定被压缩的响应报文的最小长度,默认为20个字节
安全上下文:http,server,location
5、gzip_buffers number size;
设置压缩响应报文时的缓冲区数量及每个缓冲区大小
安全上下文:http,server,location
6、gzip_proxied off|expired|no-cache|no-store|private|no_last_modified|no_etag|auth|any ...;
nginx作为代理服务器接收到从被代理服务器发送的响应报文后,在何种条件下启用压缩功能,默认为off
释义:
off:对代理的请求不启用;
no-cache,no-store,private:表示从被代理服务器收到的响应报文首部的Cache-Control的值为此三者中任何一个,则启用压缩功能
安全上下文:http,server,location
7、gzip_types mime-type ...;
压缩过滤器,仅对此处设定的MIME类型的内容启用压缩功能,默认压缩text/html
安全上下文:http,server,location
示例:
    gzip on;
    gzip_comp_level 6;
    gzip_min_length 64;
    gzip_proxied any;
    gzip_types text/xml text/css  application/javascript;

用于调节和测试及定位难题相关配置

  1. daemon on|off;
    是或不是以守护进程方式运营Nignx;调节和测试时为off
  2. master_process on|off;
    是还是不是以master/worker模型运转nginx;暗中同意为on;
  3. error_log file |stderr
    |syslog:server=address[,parameter=value]|memory;size[debug|info|notice|warn|error|crit|alert|emerg]
    ([level]);
  • error_log 位置 级别;
  • 若采纳debug级别,要求在编译nginx时选拔了–with-debug选项

ngx_http_ssl_module

1、ssl on|off;
在虚拟服务器上启动https协议
安全上下文:http,server
2、ssl_certificate file;
指定当前https协议使用的SSL证书,证书需为pem格式。
安全上下文: http,server
3、ssl_certificate_key file;
指定当前https协议所使用证书的私钥文件
安全上下文: http,server
4、ssl_protocols [SSLv2] [SSLv3] [TLSv1] [TLSv1.1] [TLSv1.2];
指定支持的ssl协议的版本,默认为后三个
安全上下文: http,server
5、ssl_session_cache off|none|[builtin[:size]] [shared:NAME:size];
用于设置存储ssl会话参数的缓存类型及大小
释义:
builtin[:size]:使用OpenSSL内建的缓存,此缓存为每worker进程私有;
shared:NAME:size:在各worker之间使用一个共享的缓存
安全上下文: http,server
6、ssl_session_timeout time;
设置客户端可复用缓存的会话参数的时间
安全上下文: http,server
示例:
    server {
        listen 192.168.0.83:443 ssl;
        server_name www2.abc.com;
        root /data/https;
        ssl on;
        ssl_certificate /etc/nginx/ssl/nginx.crt;
        ssl_certificate_key /etc/nginx/ssl/nginx.key;
        ssl_session_cache shared:SSLCACHE:20m;
    }

事件驱动相关配置

  1. worker_connections number;
    每一种worker进度所能够开拓的最大并发连接数数量;
    worker_processes * worker_connections
  2. use method[epoll|rtsig|poll];
    指明并发连接请求的处理办法;指明时间模型,提出Linux自行选拔
  3. accept_mutex on | off;
    处理新的连日请求的格局;on意味着由各worker轮流处理新请求,Off意味着种种新请求的抵达都会通报全数的worker进度;

ngx_http_rewrite_module

此模块用于将用户请求的URI基于regex所描述的模式进行检查,而后完成替换,使得用户访问替换后的URI

1、rewrite regex replacement [flag];
此指令将用户请求的URI基于regex所描述的模式进行检查,匹配到时将其替换为replacement指定的新的URI。如果replacement是以http://或https://开头,则替换结果会直接以重定向返回给客户端。另外如果在同一级配置块中存在多个rewrite规则,则会自下而下逐个检查;被某条件规则替换完成后,会新起一轮的替换检查,因此隐含有循环机制;[flag]所表示的标志位用于控制此循环机制,包括以下标志:
    last:重写完成后停止对当前URI在当前location中后续的其他重写操作,而后对新的URI启动新一轮重写检查,即提前重启新一轮的重写循环;
    break:重写完成后停止对当前URI在当期location中的后续的其他重写操作,而后直接跳转至重写规则配置块之后的其他配置,结束重写循环;
    redirect:重写完成后以临时重定向方式直接返回重写后生成的新URI给客户端,由客户端重新发起请求;此flag所重写的URI不能以http://或https://开头;
    permanent:重写完成后以永久重定向的方式直接返回重写后生成的新的URI给客户端,由客户端重新发起请求
安全上下文:server,location,if
示例:
    location /users/ {
        rewrite ^/users/profile/(.*)$ /show?user=$1? break;
    }
2、return code [text];
  return code URL;
  return URL;
停止处理请求,并返回指定的文本信息、状态码或URL给客户端
安全上下文:server,location,if
示例:
    location ~ .*test.* {
        return 404 "test";
    }
3、rewrite_log on | off;
是否开启重写日志
安全上下文:http,server,location,if
4、if (condition) { ... };
条件判断配置段,当满足条件时,执行配置段中的指令
其中condition中的比较符有以下几种:
    字符串比较操作符:
        =:匹配
        !=:不匹配
        ~:模式匹配,区分字符大小写;
        !~:模式不匹配,区分字符大小写;
        ~*:模式匹配,不区分字符大小写;
        !~*:模式不匹配,不区分字符大小写
    文件及目录存在性判断:
        -e,!-e:文件是否存在;
        -f,!-f:文件是否为普通文件;
        -d,!-d:文件是否为目录;
        -x,!-x:文件是否可执行
安全上下文:server,location
示例:
    if ($http_user_agent ~ MSIE) {
        rewrite ^(.*)$ /msie/$1 break;
    }
5、set $variable value;
自定义用户变量
安全上下文:server,location,if
示例:
    set $newindex "index.html";
    if ($host = "www.sina.com") {
        set $newindex "index.php";
    }
    index $newindex;

ngx_http_referer_module

valid_referers none|blocked|server_names|string ...;
定义referer首部的合法可用值
释义:
none:请求报文首部没有referer首部;
blocked:请求报文的referer首部没有值;
server_names:参数,其可以有值作为主机名或主机名模式;
    arbitrary_string:直接字符串,但可使用*作通配符
    regular_expression:被指定的正则表达式模式匹配到的字符串,要使用~开头,如 ~.*\.test\.com
安全上下文: server,location
示例:
    valid_referers none blocked server_names *.teest.com tesst.* ~\.test\.;
    if($invalid_referer) {
        return http://www.test.com/test.jpg;
    }

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有