雷恩Layne
雷恩Layne

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离

写这篇文章花费了我近一周的时间，参考网上许多优秀的博客文章，我不敢说写的很好，至少很全很详细。本文先介绍原理部分，然后再进行实战操作，我认为这样才会有更深的理解，不过这也导致了文章篇幅很长。但是，如果你耐心看下去，会有很多收获。

文章目录

    • 1. 问题引入
      • 1.1 为什么需要Nginx
      • 1.2 Nginx和Apache比较
      • 1.3 什么是Tengine
    • 2. Nginx下载与安装
    • 3. Nginx工作模型
      • 3.1 Master-Worker模式
      • 3.2 worker_cpu_affinity
      • 3.3 accept_mutex
      • 3.4 使用进程而不用线程
      • 3.5 处理高并发请求
    • 4. Nginx参数详解
      • 4.1 nginx.conf全览
        • 4.1.1 全局块
        • 4.1.2 events块
        • 4.1.3 http块
      • 4.2 连接数上限
      • 4.3 开启零拷贝
      • 4.4 nginx虚拟主机
      • 4.5 nginx日志配置
      • 4.6 Location详解
      • 4.7 重新安装nginx
    • 5. 反向代理
      • 5.1 正向代理服务器
      • 5.2 反向代理服务器
      • 5.3 反向代理之负载均衡
      • 5.4 负载均衡进阶
    • 6. session共享
      • 6.1 session共享的解决方案
      • 6.2 memcache实现session共享
    • 7. 动静分离

1. 问题引入

1.1 为什么需要Nginx

tomcat作为javaweb服务器非常流行，为什么还需要Nginx呢？我们先来看看单个tomcat的并发测试数据：

并发人数 响应时间 说明
100人 0.8s 完美
150人 1s 完美
200人 1.5s 响应时间有微小波动
250人 1.8s 理想情况下最大的并发用户数量
280人 约2.5s 开始出现连接丢失问题
300人 3s 响应时间有较大波动
350人 3s 连出现接丢失问题，连接很不稳地
400人 3.8s 连接丢失数量达到3000次以上
450人 4s 连接丢失数量达到6000次以上
500人 4s 连接丢失数量达到11000次以上
550人 6s 连接丢失数量达21000次以上
600人 - 系统出现异常，停止测试

上述的并发人数是指同一时刻请求连接的人数，如果并发达到600，基本上能支持几万人的请求。

可以看到，单个tomcat在600并发请求下，系统出现异常， 理想情况下最大的并发用户数量为250，那么怎么解决高并发问题呢？

这就需要用到Nginx，Nginx作为一个轻量级Web服务器，可以支持近50000个并发，并且消耗的资源却非常少，是现代Web平台的首选服务器。

1.2 Nginx和Apache比较

Nginx是俄罗斯人Igor Sysoev编写的轻量级Web服务器，它不仅是一个高性能的静态HTTP和反向代理服务器，也是一个 IMAP/POP3/SMTP 代理服务器。Apache httpd也是一个Web服务器，但这两者的适应场景不同，专注于解决不同的问题。总的来说，apache httpd：稳定、对动态请求处理强，但同时高并发时性能较弱，耗费资源多。nginx：高并发处理能力强、擅长处理静态请求、反向代理、均衡负载。下面详细说明Nginx和Apache区别：

  1. nginx是轻量级的web服务，比apache占用更少的内存及资源，且并发能力更强，在高并发下nginx能保持低资源、低消耗、高性能。另外，nginx具有高度模块化的设计，编写模块相对简单，社区活跃，高性能模块出品迅速。

  2. apche的rewrite能力比nginx强大，且模块超多，基本想到的都可以找到。此外，apache的bug相比于nginx较少，比较稳定。一般来说，在性能方面，nginx更有优势，如果不需要性能只求稳定，那就用apache。

    Rewrite是一种服务器的重写脉冲技术，它可以使得服务器可以支持 URL 重写，还可以实现限制特定IP访问网站的功能。

  3. nginx处理请求是异步非阻塞模式，而apache则是同步阻塞模式。

    • 同步：所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。
    • 异步：异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。
    • 阻塞：阻塞调用是指调用结果返回之前，当前线程会被挂起，函数只有在得到结果之后才会返回。有人也许会把阻塞调用和同步调用等同起来，实际上它们是不同的。对于同步调用来说，很多时候当前线程还是激活的，只是当前函数没有返回而已。
    • 非阻塞：非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回。

  4. nginx配置简单，apache配置复杂，nginx静态处理性能比apache高3倍以上，但对动态处理请求弱。apache对PHP支持比较简单，nginx需要配合其他后端使用。

  5. 最核心的区别在于apache是同步多进程模式，一个连接对应一个进程，而nginx是异步的，多个连接（万级别）可以对应一个进程。两者处理请求模式的不同，导致了nginx的抗并发能力强，对资源需求更少。

  6. nginx配置文件简洁，正则配置让很多事情变得简单，运行效率高，占用资源少，代理功能强大，很适合做前端响应服务器。

  7. nginx处理动态请求是鸡肋，一般动态请求要apache去做，nginx只适合静态HTTP请求和反向代理。

1.3 什么是Tengine

Tengine是由淘宝网发起的Web服务器项目。它在Nginx的基础上，针对大访问量网站的需求，添加了很多高级功能和特性。Tengine的性能和稳定性已经在大型的网站如淘宝、天猫等得到了很好的检验。它的最终目标是打造一个高效、稳定、安全、易用的Web平台。

Tengine和nginx官方性能测试网址为http://tengine.taobao.org/document_cn/benchmark_cn.html，测试结果：

  • Tengine相比Nginx默认配置，提升200%的处理能力。
  • Tengine相比Nginx优化配置，提升60%的处理能力。

Tengine详细参数解释详见：http://tengine.taobao.org/nginx_docs/cn/docs/

2. Nginx下载与安装

Nginx官方网址http://nginx.org/en/download.html提供了三个类型的版本：

  • Mainline Version：主线版，是最新版，但未经过过多的生产测试。
  • Stable Version：稳定版，生产环境使用版本。
  • Legacy Version：老版本。

这里下载Stable Version，稳定版又分为Linux 版与 Windows 版，本文下载Linxu版的nginx-1.16.1

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第1张图片

在安装Nginx前，最好先配置好Linxu系统，并克隆两台以上虚拟机，因为后面的反向代理和负载均衡、Session共享配置，要用到多台虚拟机。可以参考我之前的文章Linux切换运行级别、关闭防火墙、禁用selinux、关闭sshd、时间同步、修改时区、拍摄快照、克隆操作。

接下来，采用源码编译的方式安装Nginx！

（1）安装Nginx依赖的库

yum install gcc gcc-c++ pcre  pcre-devel openssl openssl-devel zlib  zlib-devel vim -y

推荐使用yum的清华源和东北大学源，可参考把Linux系统中的yum替换为清华源进行配置。

（2）创建存放源文件的文件夹

cd /opt # 进入opt目录下
mkdir apps # 创建apps目录，用于存放源文件以及解压后的文件

（3）通过Xftp上传nginx-1.16.1.tar.gz文件到Linux虚拟机的opt/apps目录下，可参考使用Xftp和lrzsz在Linxu与Windows之间互传文件上传文件。

（4）解压 Nginx压缩包

cd /opt/apps
tar -zxvf nginx-1.16.1.tar.gz # 解压

（5）配置configure

配置configure可理解为预编译，主要用于检测系统基准环境库是否满足gcc环境，生成makefile文件，可以使用 configure 命令可以生成该文件。那么，configure 命令需要配置些什么参数呢？使用./configure --help可以查看到可以使用的参数说明。

[root@nginx1 apps]# cd /opt/apps/nginx-1.16.1
[root@nginx1 nginx-1.16.1]# ./configure  --help

  --help                             print this message

  --prefix=PATH                      set installation prefix
  --sbin-path=PATH                   set nginx binary pathname
  --modules-path=PATH                set modules path
  --conf-path=PATH                   set nginx.conf pathname
  --error-log-path=PATH              set error log pathname
  --pid-path=PATH                    set nginx.pid pathname
  --lock-path=PATH                   set nginx.lock pathname

  --user=USER                        set non-privileged user for
                                     worker processes
  --group=GROUP                      set non-privileged group for
                                     worker processes
##. . .(内容太长，这里只展示部分内容). . . ##

这些参数可以分为三类：

  • 第一类：基本信息的配置。
  • 第二类：默认没有安装，可以指定安装的模块，使用--with开头。Nginx 的高扩展性就体现在这里。
  • 第三类：默认已经安装，可以指定卸载的模块，使用--without 开头。

这里简单介绍基本信息配置的含义：

  • prefix：Nginx 安装目录
  • sbin-path：sbin即binary file，为Nginx 命令文件存放目录
  • modules-path：Nginx 模块存放路径
  • conf-path：Nginx 配置文件存放路径
  • error-log-path：错误日志文件存放路径
  • pid-path：Nginx 的进程 id 存放路径
  • user：为Nginx的工作进程创建所属用户，如果不创建，则默认为nobody用户
  • group：为Nginx的工作进程创建所属用户组，如果不创建，则默认为nobody用户组

下面，我给出两种配置方案，一种简单版，一种详细版，这里使用简单版进行配置：

### 1. 首先创建/var/tmp/nginx/client目录
[root@nginx1 nginx-1.16.1]# mkdir –p /var/tmp/nginx/client
### 2. 进入/opt/apps/nginx-1.16.1目录下
[root@nginx1 nginx-1.16.1]# pwd
/opt/apps/nginx-1.16.1
### 3. 执行配置命令，简单版（当前使用）：
./configure --prefix=/opt/nginx --with-http_ssl_module --with-http_gzip_static_module --error-log-path=/var/log/nginx/nginx.log --pid-path=/var/log/nginx/pid

### 详细版（留着以后备用）：
### 下面的 \ 意思是这个命令还没完，可以继续往下写
[root@nginx1 nginx-1.16.1]# ./configure \
  --prefix=/opt/nginx \
  --sbin-path=/usr/sbin/nginx\
  --conf-path=/etc/nginx/nginx.conf \
  --error-log-path=/var/log/nginx/error.log \
  --http-log-path=/var/log/nginx/access.log \
  --pid-path=/var/run/nginx/nginx.pid \
  --lock-path=/var/lock/nginx.lock \
  --user=nginx \
  --group=nginx \
  --with-http_ssl_module \
  --with-http_flv_module \
  --with-http_stub_status_module \
  --with-http_gzip_static_module \
  --http-client-body-temp-path=/var/tmp/nginx/client/ \
  --http-proxy-temp-path=/var/tmp/nginx/proxy/ \
  --http-fastcgi-temp-path=/var/tmp/nginx/fcgi/ \
  --http-uwsgi-temp-path=/var/tmp/nginx/uwsgi \
  --http-scgi-temp-path=/var/tmp/nginx/scgi \
  --with-pcre

注意：详细版还需要执行useradd nginx 添加nginx用户。

在执行过 configure 命令后并不会立即生成/opt/nginx目录，也不会马上开始安装指定的模块，而仅仅是将命令中指定的参数及默认配置写入到即将要生成的 Makefile文件中。

配置成功后，再次查看 Nginx 解压目录，发现其中多出了一个文件 Makefile，后面的编译就是依靠该文件进行的。

[root@nginx1 nginx-1.16.1]# ls
auto  CHANGES  CHANGES.ru  conf  configure  contrib  html  LICENSE  Makefile  man  objs  README  src

（6）编译

make clean命令用来清除上一次编译生成的目标文件（清除上次的make命令所产生的object文件，即后缀为.o的文件及可执行文件）。这个步骤可有可无，但为了确保编译的成功，还是加上为好。防止由于软件中含有残留的目标文件导致编译失败。

生成脚本及配置文件：make （根据Makefile文件编译源代码、连接、生成目标文件、可执行文件）

所以一般先输入make clean清除编译再输入make进行编译。

（7）安装

输入make install，将编译成功的可执行文件安装到系统目录中。

（8）添加nginx进程到服务列表

安装之后进入nginx的安装目录/opt/nginx，查看包含哪些文件：

[root@nginx1 nginx]# cd /opt/nginx
[root@nginx1 nginx]# ls
client_body_temp  conf  fastcgi_temp  html  logs  proxy_temp  sbin  scgi_temp  uwsgi_temp
  • conf：保存nginx所有的配置文件，其中nginx.conf是nginx服务器的最核心最主要的配置文件，其他的.conf则是用来配置nginx相关的功能的，例如fastcgi功能使用的是fastcgi.conf和fastcgi_params两个文件，配置文件一般都有个样板配置文件，以文件名.default结尾，使用的时候将其复制并将default去掉即可。
  • html：目录中保存了nginx服务器的web文件，但是可以更改为其他目录保存web文件，另外还有一个50x的web文件是默认的错误提示页面。
  • logs：用来保存nginx服务器访问的错误日志等，logs目录可以放在其他路径，比如/var/logs/nginx里面。
  • sbin：保存nginx二进制启动脚本，可以接受不同的参数以实现不同的功能。

默认情况下，想要启动nginx ，必须在/opt/nginx/sbin 目录中输入./nginx启动nginx进程，使用起来很不方便。为了能够在任意目录下均可直接执行 nginx 命令，可通过以下三种方式完成：

方式一（推荐采用）

添加安装的nginx到服务列表，步骤如下：

  1. 将如下内容添加到/etc/init.d/nginx脚本中
[root@nginx1 nginx]# vim /etc/init.d/nginx  # 所有开机启动的进程都在/etc/init.d下

#!/bin/sh
#
# nginx - this script starts and stops the nginx daemon
#
# chkconfig:   - 85 15 
# description:  Nginx is an HTTP(S) server, HTTP(S) reverse \
#               proxy and IMAP/POP3 proxy server
# processname: nginx
 
# 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="/opt/nginx/sbin/nginx"
prog=$(basename $nginx)
 
NGINX_CONF_FILE="/opt/nginx/conf/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. 然后，修改nginx文件的执行权限。
chmod +x /etc/init.d/nginx
  1. 最后，添加该文件到系统服务中去。
chkconfig --add /etc/init.d/nginx

查看服务列表中的nginx进程：

[root@nginx1 nginx]# chkconfig --list nginx
nginx          	0:off	1:off	2:off	3:off	4:off	5:off	6:off

这样，就完成了添加nginx进程到服务列表，可以使用service命令来管理nginx进程：

  • service nginx start|stop|reload：设置nginx进程启动|停止|重新加载
  • service nginx restart ：重启nginx进程
  • service nginx on ：设置nginx进程开机启动

现在，我们设置nginx进程当前启动和开机启动：

[root@nginx1 nginx]# chkconfig nginx on #设置nginx进程开机启动
[root@nginx1 nginx]# chkconfig --list nginx
nginx          	0:off	1:off	2:on	3:on	4:on	5:on	6:off
[root@nginx1 nginx]# service nginx start #启动nginx进程
[root@nginx1 nginx]# ps aux | grep nginx
root       1216  0.0  0.1  49400  1292 ?        Ss   Feb14   0:00 nginx: master process /opt/nginx/sbin/nginx -c /opt/nginx/conf/nginx.conf
nobody     1218  0.0  0.2  49920  2348 ?        S    Feb14   0:00 nginx: worker process                              
root       1509  0.0  0.0 103256   864 pts/0    S+   07:16   0:00 grep nginx

方式二

在/etc/profile 文件最后添加以下内容，将安装目录下的 sbin 目录添加到 PATH 系统环境变量中，然后再重新加载该文件即可。

#1. 进入/etc/profile
vim /etc/profile

#2. 在文件末尾添加环境变量配置
export PATH=$PATH:/opt/nginx/sbin  #注意可执行文件的位置，即--prefix的配置位置

#3. 使配置立即生效
source /etc/profile

#4. 启动nginx
nginx  #启动nginx

方式二在系统中的任何位置都可以使用下面方式三的命令。

方式三

直接在/opt/nginx/sbin目录下管理nginx进程

[root@nginx1 sbin]# pwd
/opt/nginx/sbin
[root@nginx1 sbin]# ./nginx # 启动nginx进程
[root@nginx1 sbin]# ./nginx -c /opt/nginx/conf/nginx.conf # 以特定目录下的配置文件启动nginx进程
[root@nginx1 sbin]# ./nginx -s stop # 立即停止服务
[root@nginx1 sbin]# ./nginx -s reload # 执行这个命令后，master进程会等待worker进程处理完当前请求，然后根据最新配置重新创建新的worker进程，完成Nginx配置的热更新。
[root@nginx1 sbin]# ./nginx -s quit # 执行该命令后，Nginx在完成当前工作任务后再停止。
[root@nginx1 sbin]# ./nginx -t  # 检查配置文件是否正确
nginx: the configuration file /opt/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /opt/nginx/conf/nginx.conf test is successful
[root@nginx1 sbin]# ./nginx -t -c /opt/nginx/conf/nginx.conf # 检查特定目录的配置文件是否正确
nginx: the configuration file /opt/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /opt/nginx/conf/nginx.conf test is successful

[root@nginx1 sbin]# ./nginx -v # 查看版本信息
nginx version: nginx/1.16.1

这里，我使用方式一给nginx添加到服务列表，启动nginx进程后，在浏览器中输入虚拟机的ip地址，如http://192.168.50.55/，即可出现如下页面：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第2张图片

3. Nginx工作模型

3.1 Master-Worker模式

当我们启动nginx以后，会有两个nginx进程，一个master进程，一个worker进程，可以输入ps aux | grep nginx查看：

[root@nginx1 nginx]# ps aux | grep nginx
root       1641  0.0  0.1  49400  1292 ?        Ss   09:18   0:00 nginx: master process /opt/nginx/sbin/nginx -c /opt/nginx/conf/nginx.conf
nobody     1643  0.0  0.1  49920  1876 ?        S    09:18   0:00 nginx: worker process                              
root       1645  0.0  0.0 103256   860 pts/0    S+   09:18   0:00 grep nginx

在预编译配置nginx时，我们没有为nginx的wrok进程创建用户，所以默认情况下worker进程是以"nobody"用户的身份运行的，如果想要指定worker进程的运行用户，则可以创建一个用户，并修改/opt/nginx/conf/nginx.conf的配置即可。

现在，我们指定worker进程以nginx用户的身份运行，操作步骤如下：

[root@nginx1 nginx]# useradd nginx  # 添加nginx用户(默认添加一个同名的用户组)
[root@nginx1 nginx]# id nginx  # 查看nginx用户的信息
uid=500(nginx) gid=500(nginx) groups=500(nginx)
[root@nginx1 nginx]# vim /opt/nginx/conf/nginx.conf # 将user nobody注释去掉，并改为user nginx;
[root@nginx1 nginx]# service nginx restart # 重启nginx进程
nginx: the configuration file /opt/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /opt/nginx/conf/nginx.conf test is successful
Stopping nginx:                                            [  OK  ]
Starting nginx:                                            [  OK  ]
[root@nginx1 nginx]# ps aux | grep nginx # 再次查看nginx的work进程所属的用户
root       1698  0.0  0.1  49404  1300 ?        Ss   09:27   0:00 nginx: master process /opt/nginx/sbin/nginx -c /opt/nginx/conf/nginx.conf
nginx      1700  0.0  0.1  49920  1884 ?        S    09:27   0:00 nginx: worker process                              
root       1702  0.0  0.0 103256   860 pts/0    S+   09:27   0:00 grep nginx

master进程和nginx进程各自有什么用呢？见名知意，worker进程天生就是来"干活"的，真正负责处理请求的进程就是你看到的worker进程。master进程其实是负责管理worker进程的，除此之外，master进程还负责读取配置文件、判断配置文件语法的工作。master进程也叫主进程，在nginx中，主进程只能有一个，而worker进程可以有多个，可以由管理员自己进行定义。在nginx.conf下的配置文件中有这样一条配置：

worker_ processes 1;

默认情况下，启动nginx后只有1个worker进程，你想要多少个worker进程，将worker_ processe指令的值设置成多少就好了。

worker_ processes的值通常不会大于服务器中cpu的核心数量，换句话说，worker进程的数通常与服务器有多少
cpu核心有关，比如，nginx所在主机拥有4核cpu，那么worker_ processes的值通常不会大于4，这样做的原因是为了尽力让每个worker进程都有一个cpu可以使用，尽量避免了多个worker进程抢占同一个cpu的情况。我们也可以将worker_ processes的值设置为"auto"，这时nginx会自动检测当前主机的cpu核心数，并启动对应数量的worker进程。

3.2 worker_cpu_affinity

为了避免cpu在切换进程时产生性能损耗，我们也可以将worker进程与cpu核心进行"绑定"，当worker进程与cpu核心绑定以后，worker进程可以更好的专注的使用某个cpu核心上的缓存，从而减少因为cpu切换不同worker进程而带来的缓存失效。此功能，可以通过nginx.conf的worker_ cpu_ affinity配置来完成。不过，若指定 worker_processes 的值为auto，则无法设置 worker_cpu_affinity。

worker_cpu_affinity的设置是通过二进制进行的。每个内核使用一个二进制位表示，0 代表内核关闭，1 代

表内核开启。也就是说，有几个内核，就需要使用几个二进制位。下图是worker_processes的数量与绑定的cpu取值的设定关系：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第3张图片

比如，4核cpu可以设置如下的配置：

user  nginx;
worker_processes  4;
worker_cpu_affinity 1000 0100 0010 0001;

3.3 accept_mutex

accept_mutex机制通过accept锁来避免所有休眠的work子进程被唤醒的情形，从而避免了惊群问题。

所谓的惊群问题，当一个新的连接到达时，所有处于休眠状态的work进程都会被唤醒，但是只有一个wrok进程能获取连接，其它的work进程会重新进入休眠状态。这就导致出现了很多不必要的调度及上下文切换，浪费了系统的资源。

在Linux内核的较新版本中，accept调用本身所引起的惊群问题已经得到了解决，但是在Nginx中，accept是交给epoll机制来处理的，epoll的accept带来的惊群问题并没有得到解决，执行epoll_wait后，所有监听这个事件的进程会被这个epoll_wait唤醒，所以Nginx的accept惊群问题仍然需要定制一个自己的解决方案。

Nginx通过accept锁来解决惊群问题，accept锁本质上这是一个跨进程的互斥锁（共享锁）。在实现上，accept锁是一个全局变量，放在一块进程间共享的内存中，以保证所有进程都能访问这一个实例，加锁、解锁是借由linux的原子变量来做CAS算法，如果加锁失败则立即返回，是一种非阻塞的锁。

Nginx默认激活了accept_mutex，也就是说不会有惊群问题，即每个worker进程在执行accept之前都需要先获取锁（共享锁），获取不到就放弃执行accept()。有了这把锁之后，同一时刻，就只会有一个进程去accpet()，这样就不会有惊群问题了。

实际上Nginx作者Igor Sysoev曾经给过相关的解释：

OS may wake all processes waiting on accept() and select(), this is called thundering herd problem. This is a problem if you have a lot of workers as in Apache (hundreds and more), but this insensible if you have just several workers as nginx usually has. Therefore turning accept_mutex off is as scheduling incoming connection by OS via select/kqueue/epoll/etc (but not accept()).

意思就是说，OS可能会唤醒所有等待的进程，也就是惊群问题。如果像Apache那样有很多work者（几百个甚至更多），会出现这样的问题，但如果像nginx那样只有几个work进程，这就不太可能了。因此，关闭accept_mutex（默认开启）就像操作系统通过select/kqueue/epoll/等来调度传入的请求连接一样（但不是accept）。

Nginx默认激活了accept_mutex，是一种保守的选择。如果关闭accept_mutex，可能会引起一定程度的惊群问题，主要表现为浪费了很多不必要的调度及上下文切换。但是开启accept_mutex，即同时唤醒所有的work进程，让他们主动去抢占式获取连接，整体的效率无疑大大增强了。

如果想要关闭accept_mutex，只要在nginx.conf中加入以下配置即可：

events {
      
accept_mutex off; 
}

select、epoll等都是常用的IO模型，准确的说是IO多路复用，想要更深入的了解，可以参考我的文章详解磁盘IO、网络IO、零拷贝IO、BIO、NIO、AIO、IO多路复用(select、poll、epoll)

3.4 使用进程而不用线程

Nginx使用的进程（即worker process）而不是线程进行工作，为什么使用进程不使用线程呢？

使用进程能够节省锁机制带来的开销。每个worker进程都是独立的进程，独立拥有资源（且拥有独立的内存空间），各进程之间不共享资源。而一个进程的多个线程共享所属进程的资源，线程本身不拥有资源，仅有一点不可缺少的、能保证独立运行的资源。这就导致了一个进程中的某个线程出现问题后（如地址越界），会导致整个进程垮掉。当采用多进程来实现时，可以让互相之间不会影响，一个进程退出后，其它进程还在工作，服务不会中断。在Nginx启动后，会启动相应数量的worker进程，在worker进程在异常情况下退出后，Master进程会自动启动新的 worker 进程，保证worker进程的个数和配置文件里设置的个数相对应。

当一个worker进程在accept()这个连接之后，就开始读取请求、解析请求、处理请求，然后把处理的结果再返回客户端，最后才断开连接，完成一个完整的请求。所以，一个请求，完全由worker进程来处理，而且只能在一个worker进程中处理。每个worker进程之间不会相互影响，就算一个worker进程因为异常挂掉了，也不会影响其他worker进程。

3.5 处理高并发请求

我们知道，worker进程负责处理每个请求，当有多个并发的请求到来时，如何进行处理呢？

当有多个并发的请求到来时，每进来一个请求，会有一个worker进程去处理，但不是全程的处理，处理到什么程度呢？一般处理到可能发生阻塞的地方，比如worker进程转发来自客户端的请求到相应的服务器（如tomcat或apache)后，它不会这么傻等着，而是在发送完请求后，注册一个事件（Nginx以事件驱动的特征就体现在这里）：“如果upstream返回了，告诉我一声，我再接着干”，于是他就休息去了（或者为其他的请求进行处理）。此时，如果再有新的请求进程，worker进程就可以很快再按这种方式处理。一旦服务器返回了，就会触发这个事件，worker才会来接手这个请求，把请求的结果返回给客户端。

一般来说，Nginx服务器只有几个worker进程，但会处理数十万个请求，也就是说每个worker进程会处理多个请求，这个可以在Nginx.conf中进程设置：

events {
     
    worker_connections  1024;
}

由于web server的工作性质决定了每个请求的大部份时间都是在网络传输中，实际上花费在server机器上的时间片不多，并且Nginx主要用来转发请求的，一般不真正处理请求，所以几个worker进程就能解决高并发的请求。

4. Nginx参数详解

4.1 nginx.conf全览

nginx.conf有三部分组成，分别是全局块、events块、http块：

#---全局块开始----
#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块开始====
events {
     
    worker_connections  1024;
}
#====events块结束====
#****http块开始****
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块结束****

Nginx 配置详解可以从参考这里：https://www.runoob.com/w3cnote/nginx-setup-intro.html

4.1.1 全局块

从Nginx.conf的开始到events之间的内容是全局块，主要设置一些nginx服务器整体运行的配置命令。下面我们分别进程理解和配置：

（1）worker进程的用户

在nginx.conf中，worker进程的默认用户为nobody，查看这个用户的信息

[root@nginx1 conf]# id nobody
uid=99(nobody) gid=99(nobody) groups=99(nobody)
[root@nginx1 conf]# cat /etc/passwd
......
nobody:x:99:99:Nobody:/:/sbin/nologin
......

可以看到，该用户对应的程序是/sbin/nologin，所以就算有人通过worker进程黑到了你的服务器，也就是不能做任何事情！

输入ps -ef|grep nginx查看当前nginx进程信息：

可以看到，用之前的配置方法，没有创建nginx用户和用户组，这时maste进程所属的用户是root，worker进程所属的用户是nobody，一般正式开发需要创建一个用户，毕竟root权限太大了。

可以添加一个nginx用户，并修改nginx.conf的配置：

#1.添加用户
useradd nginx  # 添加nginx用户(默认添加一个同名的用户组)
#2.修改nginx.conf配置
user nginx;
#3.默认创建完之后，nginx用户登入后执行的是`/bin/bash`，可以修改为`/opt/nginx/sbin/nginx`
usermod -s /opt/nginx/sbin/nginx nginx

（2）worker进程数

worker_processes用于配置nginx启动后的woker进程数，也可以将worker_ processes的值设置为"auto"，这时nginx会自动检测当前主机的cpu核心数，并启动对应数量的worker进程。

（3）错误配置

error_log配置nginx日志文件的全路径名

（4）进程pid

pid配置进程PID存放路径

如果在nginx中不进行上述配置，默认的配置时nginx.conf注释的配置。

4.1.2 events块

events块主要用于配置每个worker进程所支持的最大连接数。

events {
     
    worker_connections  1024;
}

Nginx服务器总的并发数即最大连接数max_clients = worker_processes * worker_connections。一般。不会达到这么大的连接数，因为要受到物理内存和系统可以打开的最大文件数的限制，这个我们在4.2节介绍。

events除了配置最大连接数，也用于许多其他的配置：

events {
     
    accept_mutex on; #设置网路连接序列化，防止惊群现象发生，默认为on
    multi_accept on; #设置一个进程是否同时接受多个网络连接，默认为off
    use epoll; #事件驱动模型，select|poll|kqueue|epoll|resig|/dev/poll|eventport
    worker_connections 1024; # 最大连接数
}

这里，重点介绍一下use epoll，Nginx服务器提供了多个事件驱动模型来处理网络消息。

与apache类似，nginx针对不同的操作系统，有不同的事件模型。如果你不知道Nginx该使用哪种轮询方法的话，它会选择一个最适合你操作系统的。常用的I/O模型有：

  • 标准事件模型：select、poll属于标准事件模型，如果当前系统不存在更有效的方法，nginx会选择select或poll
  • 高效事件模型：
    • kqueue：使用于FreeBSD 4.1+、OpenBSD 2.9+、NetBSD 2.0 和 MacOS X，但双处理器的MacOS X系统使用kqueue可能会造成内核崩溃
    • epoll：使用于Linux内核2.6版本及以后的系统
    • /dev/poll：使用于Solaris 7 11/99+、HP/UX 11.22+ (eventport)、IRIX 6.5.15+ 和 Tru64 UNIX 5.1A+
    • eventport：使用于Solaris 10，为了防止出现内核崩溃的问题， 有必要安装安全补丁

可以使用uname -a命令查看服务器系统相关的信息。

[root@nginx1 conf]# uname -a
Linux nginx1 2.6.32-431.el6.x86_64 #1 SMP Fri Nov 22 03:15:09 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux

可以看到，我的Linux内核版本是2.6.32，大于2.6版本的内核，故可以选用epoll作为事件驱动模型。

4.1.3 http块

http块是Nginx服务器配置中最频繁的部分，代理、缓存和日志定义等绝大多数功能和第三方模块的配置都在这里。

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;
    #test
    keepalive_timeout  0;
    #keepalive_timeout  65; # 会话的保持时间，默认是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;
        }
        ......
    }
    ......
}

http中几个常用配置：

  • keepalive_timeout 是会话的保持时间，在部署时需要设置合适的数值来提高效率
  • log_format和access_log是http块的日志配置，后面会详细讲解。
  • gzip on指启用压缩，压缩可以有效减少文件的大小，有利于网络传输。

http块中最重要的就属server块，server块和虚拟主机有密切关系，虚拟主机从用户角度看，和一台独立的硬件主机是完全一样的，该技术的产生是为了节省互联网服务器硬件成本。每个http块可以包括多个server块，而每个server块就相当于一个虚拟主机。每个server块可以同时包含多个location块，location主要配置nginx转发的出口。

这里先说个大概，后面会详细介绍这些模块的配置。

4.2 连接数上限

#user  nobody;
worker_processes  1;
events {
     
	use epoll;
	worker_connections 1024;
}

前面也提到了，Nginx服务器总的并发数即最大连接数max_clients = worker_processes * worker_connections。一般，不会达到这么大的连接数，因为：

  • worker_connections值的设置跟物理内存大小有关
  • 因为并发受IO约束，max_clients的值须小于系统可以打开的最大文件数。

系统可以打开的最大文件数和内存大小成正比，一般1GB内存的机器上可以打开的文件数大约是10万左右。假如服务器内存是16G，则可以打开的最大文件数约为16万。

Linux可以打开的最大文件数可以由/proc/sys/fs/file-max和ulimit -n来配置。

  • file-max表示系统级别的能够打开的文件句柄的数量，是对整个系统的限制，并不是针对用户的。
  • ulimit -n是进程级别能够打开的文件句柄的数量，提供shell及其启动的进程的可用文件句柄的控制，是进程级别的。

对于服务器来说，file-max和ulimit都需要设置，否则会出现文件描述符耗尽的问题。

一般如果遇到文件句柄达到上限时，会碰到Too many open files或者Socket/File: Can’t open so many files等错误。

当前，我的Linux虚拟机为1G，来看下可以打开的文件句柄数是多少：

[root@nginx1 conf]# cat /proc/sys/fs/file-max #整个系统能够打开的文件句柄的数量
97319
[root@nginx1 conf]# ulimit -n  #单个用户进程打开的文件句柄的数量
1024

可以看到，虚拟机内存为1G的Linxu系统可以打开的最大文件数是9.7万多个。

可以修改file-max和ulimit，下面我们就来尝试一下！

（1）修改file-max

一般我们不需要主动修改file-max值，Linux系统在安装时会根据物理内存自动生成合适的大小，当然如果你认为它的调小了，也可以进行修改，方法如下：

  1. 第一步：vim /etc/sysctl.conf
  2. 第二步：在文件末尾加入配置内容：fs.file-max = 2000000
  3. 第三步：执行sysctl -p ，使修改配置立即生效

再次查看/proc/sys/fs/file-max的内容，发现已经改变：

[root@nginx1 conf]# cat /proc/sys/fs/file-max
2000000

上述修改永久生效，即重启系统后也不会失效。

（2）修改ulimit

执行vim /etc/security/limits.conf在文件中添加如下两行记录：

* soft nofile 65535
* hard nofile 65535

重启系统后，输入ulimit -n查看单个用户进程打开的文件句柄的数量：

[root@nginx1 ~]# ulimit -n
65535

可以查看，修改已经生效。

如果需要设置当前用户session立即生效，则执行ulimit -n 65535命令即可。

对于服务器，**一般修改进程级的最大打开文件句柄数即可（系统默认1024，有点小），一般不需要调整系统级的最大数。**如果真的出现了达到系统级别最大限制时，也可以调整系统级的最大数。

只要让并发连接总数小于系统可以打开的文件句柄总数，操作系统才可以在承受的范围之内。所以，worker_connections 的值需根据 worker_processes 进程数目和用户进程打开的文件句柄的数量适当地进行设置，使得并发总数小于操作系统可以打开的最大文件数目，实质上也就是根据主机的物理CPU和内存进行配置。

当然，理论上的并发总数可能会和实际有所偏差，因为主机还有其他的工作进程需要消耗系统资源。

4.3 开启零拷贝

sendfile实际上是 Linux2.0+以后的推出的一个系统调用，web服务器可以通过调整自身的配置来决定是否利用 sendfile这个系统调用。

先来看一下不用sendfile的传统网络传输过程，从逻辑上看只需要两行代码即可：

read(file,tmp_buf, len);
write(socket,tmp_buf, len);

一般，一个基于socket的服务，首先读硬盘数据，然后写数据到socket 来完成网络传输的。上面2行用代码解释了这一点，不过上面2行简单的代码掩盖了底层的很多操作。来看看底层是怎么执行上面2行代码的：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第4张图片

执行过程：硬盘 >> kernel buffer >> user buffer>> kernel socket buffer >>协议栈

  • 当应用程序调用read()方法时，通过DMA方式将数据从磁盘拷贝到kernel buffer
  • 由cpu控制，将kernel buffer的数据拷贝到用户空间的User buffer中，供应用程序使用
  • 当应用程序调用write()方法时，cpu会把User buffer的数据copy到内核缓冲区的Socket Buffer中
  • 最后通过DMA方式将内核空间中的Socket Buffer拷贝到Socket协议栈（即网卡设备）中传输。

这里经历了4次上下文切换和4次缓冲区的copy，第一次是从磁盘缓冲区到内核缓冲区（由cpu控制），第二次是内核缓冲区到用户缓冲区（DMA控制），第三次是用户缓冲区到内核缓冲区的Socket Buffer（由cpu控制），第四次是从内核缓冲区的Socket Buffer到网卡设备（由DMA控制）。四次缓冲区的copy工作两次由cpu控制，两次由DMA控制。

我们发现如果能减少切换次数和拷贝次数将会有效提升性能。在kernel2.0+ 版本中，系统调用 sendfile() 就是用来简化上面步骤提升性能的，sendfile() 不但能减少切换次数而且还能减少拷贝次数。

再来看一下用 sendfile()来进行网络传输的过程，逻辑上也就一行代码：

sendfile(socket,file, len);

底层执行过程如下：

硬盘 >> kernel buffer (快速拷贝到kernelsocket buffer) >>协议栈

  • 当应用程序调用read()方法时，通过DMA方式将数据从磁盘拷贝到kernel buffer
  • 由cpu控制，将kernel buffer的数据直接拷贝到另外一个与 socket相关的内核缓冲区，即kernel socket buffer
  • 然后由DMA 把数据从kernel socket buffer直接拷贝给Socket协议栈（网卡设备中）。

这里，只经历了三次缓冲区的拷贝，第一次是从磁盘缓冲区到内核缓冲区，第二次是从内核缓冲区到kernel socket buffer，第三次是从kernel socket buffe到Socket协议栈（网卡设备中）。只发生两次内核态和用户态的切换，第一次是当应用程序调用read()方法时，用户态切换到内核到执行read系统调用，第二次是将数据从网络中发送出去后系统调用返回，从内核态切换到用户态。

需要注意的是，sendfile要求输入的fd必须是文件句柄，不能是socket，输出的fd必须是socket，也就是说，数据的来源必须是从本地的磁盘，而不能是从网络中，如果数据来源于socket，就不能使用零拷贝功能了。我们看一下Linux内核的sendfile接口就知道了：

#include 
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count)
  • out_fd：待写入文件描述符
  • in_fd： 待读出文件描述符
  • offset：从读入文件流的哪个位置开始读，如果为空，则默认从起始位置开始
  • count：指定在文件描述符in_fd 和out_fd之间传输的字节数
  • 返回值：成功时，返回出传输的字节数，失败返回-1

in_fd必须指向真实的文件，不能是socket和管道；而out_fd则必须是一个socket。由此可见，sendfile几乎是专门为在网络上传输文件而设计的。所以，当 Nginx 是作为一个反向代理来使用的时候，SENDFILE 则没什么用了，因为 Nginx 是反向代理的时候，in_fd 就不是文件句柄而是 socket，此时就不符合 sendfile 函数的参数要求了。

fd全称file descriptor，即文件描述符，是内核为了高效管理已被打开的文件所创建的索引，其是一个非负整数（通常是小整数），用于指代被打开的文件，所有执行I/O操作的系统调用都通过文件描述符。in_fd是输入的文件描述符，out_fd是输出的文件描述符。

4.4 nginx虚拟主机

上面也提到了，http块中的server块是用来配置虚拟主机的，所谓的虚拟主机，就是将一台物理服务器虚拟为多个服务器来使用，从而实现在一台服务器上配置多个站点，即可以在一台物理主机上配置多个域名。在Nginx 中，一个 server 标签就是一台虚拟主机，配置多个 server 标签就虚拟出了多台主机。

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第5张图片

Nginx 虚拟主机的实现方式有两种：域名虚拟方式与端口虚拟方式。域名虚拟方式是指不同的虚拟机使用不同的域名，通过不同的域名虚拟出不同的主机；端口虚拟方式是指不同的虚拟机使用相同的域名不同的端口号，通过不同的端口号虚拟出不同的主机。但是，基于端口的虚拟方式不常用。

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第6张图片

现在，就来配置一下吧！

先来看一个重要参数：

autoindex on; #开启目录列表访问，合适下载服务器，默认关闭

在nginx.conf的http块中添加两个server块，配置如下：

server {
     
	listen       80;
	server_name  www.layne.com;
	location / {
     
		root   html;
		index  index.html index.htm;
	}
}
server {
     
	listen       80;
	server_name  www.123.com;
	location / {
     
		root   /mnt;
		autoindex  on;
	}
}

然后，重启Nginx：

[root@nginx1 conf]# service nginx restart
nginx: the configuration file /opt/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /opt/nginx/conf/nginx.conf test is successful
Stopping nginx:                                            [  OK  ]
Starting nginx:                                            [  OK  ]

最后，在windows平台的hosts文件（在C:\Windows\System32\drivers\etc路径下）添加一条域名解析：

192.168.218.55 nginx1 www.123.com  www.layne.com

上述ip就是nginx所在Linux系统的ip，后面是两条刚刚在server块中配置的域名。这样在浏览器中输入网址访问的时候，会先解析本地hosts文件中的记录，如果找不到，才会到相应的域名解析服务器中去找。

在浏览器中输入http://www.layne.com/，可以看到如下界面：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第7张图片

在浏览器中输入http://www.123.com/，会发现里面没有任何东西，这是因为/mnt目录下没有文件。

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第8张图片

如果我们复制一个文件到/mnt目下，再刷新一下http://www.123.com/，会页面中出现一条记录，点击也可以进行下载：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第9张图片

现在，我们为/mnt挂载，并重新测试，可以看到我们挂载的CD或U盘：

[root@nginx1 nginx]# mount /dev/cdrom /mnt #将cdrom挂载到/mnt目录下
mount: block device /dev/sr0 is write-protected, mounting read-only

再次刷新http://www.123.com/

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第10张图片

这样我们就完成了一个下载服务器的搭建工作，是不是感觉自己很强！别急，后面还有更好玩的。

4.5 nginx日志配置

nginx的默认日志在安装目录的logs文件夹下，现在我们输入tail -f access.log持续监控这个文件：

[root@nginx1 logs]# pwd
/opt/nginx/logs
[root@nginx1 logs]# tail -f access.log

刷新http://www.123.com/，会发现日志中多了一条记录：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第11张图片

上图的信息是：

  • 第一列：ip地址为192.168.218.1，这是因为我们采用的NAT连接方式，所以主机访问虚拟机的时候，采用的IP地址是虚拟机同样网段下的192.168.218.1。
  • 第二列：是东八区的时间，即CST时间（北京时间）
  • 第三列：get请求方式，使用的协议是http1.1
  • 第四列：浏览器的相关信息

上述的access.log是http块的日志文件，也就是不管我们请求哪个server下的域名，该日志文件都可以进行记录。如果想要记录某一个server下的日志，我们在该server下进行配置即可。

另外，Nginx也支持日志格式的自定义，现在我们定义一个myfmt日志格式，并在一个server下进行配置，如下所示：

log_format  myfmt  '$remote_addr - $remote_user [$time_local] "$request" ';
server {
     
	listen       80;
	server_name  www.layne.com;
	#access_log  logs/host.access.log  main;
	access_log logs/layne.log myfmt;

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

然后执行service nginx restart重启nginx，并执行tail -f layne.log检测文件，在浏览器中分别输入http://www.layne.com/和http://www.layne.com/assfgf，会发现layne.log中多了两条记录，并且日志的格式就是我们刚刚自定义的格式。

查看access.log，会发现当我们请求http://www.layne.com/时，access.log并不会进行检测。所以，当我们在某个server下配置日志文件时，http块下的日志文件就不会对该server下域名的请求进行检测了，http块下的日志记录的是所有没有配置日志文件的server。

4.6 Location详解

一个server可以有很多location，请求进来之后，server根据location配置将请求转发到哪里，所以location相当于nginx的出口。其语法规则如下：

语法:	location [ = | ~ | ~* | ^~ ] uri { ... }
location @name { ... }
默认值:	—
上下文:	server, location
  • location URI {}:
    • 对当前路径及子路径下的所有对象都生效
  • location = URI {}: 注意，URI最好为具体路径
    • 精确匹配指定的路径，不包括子路径，故只对当前资源生效
  • location ~ URI {}：
    • 模糊匹配URI，此处的URI可使用正则表达式，~表示区分字符大小写
  • location ~* URI {}：
    • 模糊匹配URI，此处的URI可使用正则表达式，~*表示不区分字符大小写
  • location ^~ URI {}:
    • 不使用正则表达式
  • 优先级：= > ^~ > ~|~* > /|/dir/

让我们用一个例子解释上面的说法：

location = / {
     
    [ configuration A ]
}

location / {
     
    [ configuration B ]
}

location /documents/ {
     
    [ configuration C ]
}

location ^~ /images/ {
     
    [ configuration D ]
}

location ~* \.(gif|jpg|jpeg)$ {
      
    [ configuration E ] 
}
  • = / 是等值匹配，故只有域名后面没跟任何东西的时候，才匹配到这个location下面。
  • / 或 /documents/ 是最大前缀匹配，即跟谁相同的地方最多（即匹配的地方最多），就匹配哪个。
  • ^~ /images/ 不使用正则表达式，即如果这里匹配上了，不管后面有没正则，都不找后面的匹配了。
  • ~* \.(gif|jpg|jpeg)$ 是正则表达式的写法，即请求包含.gif、.jpg、.jpeg，都满足这个匹配。

所以，

  • 请求/匹配配置A
  • 请求/index.html匹配配置B
  • 请求/documents/document.html匹配配置C
  • 请求/images/1.gif匹配配置D
  • 请求/documents/1.jpg匹配配置E，这个即和最大前缀匹配，又和正则匹配，当时正则匹配优先级高于最大前缀匹配，所以走正则匹配。

一般来说，location的执行逻辑与location的编辑顺序无关，但需要注意的是：

  • uri前加了^~，即不使用正则表达式，表示本条uri一旦匹配上，则不需要继续正则匹配。
  • uri前加了=，即等值匹配，表示该uri恰好精确匹配上，则不需要继续往下匹配。

而带有正则的匹配是顺序匹配，即多个带正则的location只要第一个满足，就停止后面的正则匹配了。

现在，让我来测试一下吧！

  1. 启动一个新的Linux虚拟机，比如我启动一个ip为192.168.218.52的虚拟机，执行如下命令安装htttp应用：

    yum install httpd -y

  2. 然后进入/var/www/html目下，执行vim index.html加入以下内容：

    from 192.168.218.52

  3. 启动httpd服务：service httpd start。

  4. 在浏览器中执行http://192.168.218.52/，可出现如下页面：

  5. 配置一下nginx服务器的server块，如下：

    server {
       
	listen       80;
	server_name  www.layne.com;
	#access_log  logs/host.access.log  main;
	access_log logs/layne.log myfmt;

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

	location /abc {
       
		proxy_pass http://192.168.218.52/; 
		#在url末尾带上/表示访问该url的首页，不带/则表示把访问的地址与url拼接起来，即访问http://192.168.218.52/abc，可以自己尝试。
	}

}

  6. 执行service nginx restart重启nginx，在浏览器中分别执行http://www.layne.com/和http://www.layne.com/abc，会出现不同的页面。

现在，我们在nginx中模拟一个百度

  1. 在www.layne.com所在的server块中加入以下location，并重启nginx。

    location /aaa {
       
   proxy_pass http://www.baidu.com/;
}

  2. 在浏览器中输入http://www.layne.com/aaa进入百度首页，但是会发现浏览器地址栏中的域名也变成百度的域名了。
    从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第12张图片
    如果我们即想用百度的功能，又不想跳转到其域名下，可以修改配置，让url的重定向尽量在服务器端跳转，不要在客户端跳转。
    把之前的配置改为：

    location /aaa {
       
   proxy_pass https://www.baidu.com/; #把http变为了https，其它的不变
}

  3. 重启nginx，再次输入http://www.layne.com/aaa，会发现地址栏地址栏没有重定向：
    从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第13张图片
    但是当我们在百度搜索框输入我们要查询的内容时，会出现404：
    从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第14张图片

  4. 再次修改配置，在之前的基础上加一个location，如下：

location ~* /s.* {
     
          proxy_pass https://www.baidu.com;
}
  1. 在百度搜索框再次输入我们要查询的内容时，能够出现搜索结果，并且浏览器地址栏也是我们的域名。
    从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第15张图片

进行了上述配置之后，当我们请求http://www.layne.com/aaa时，nginx服务器把请求转发到百度。这是因为location配置的 proxy_pass是https://www.baidu.com/，浏览器地址栏不会跳转到百度域名下，在百度搜索框输入一些内容后，就匹配了location ~* /s.*，这就相当于再次向百度转发了一个https://www.baidu.com/ s.* 的请求，需要注意的是，此时配置的https://www.baidu.com并没有在结尾处加/，所以会把请求的路径拼接到配置的url后面。

这里，就相当于在我们的网站了嵌套了一个百度，在里面搜索的任何内容都将记录到当前server的日志下面，是不是感觉非常的棒。但这个不太稳定，因为百度为预防这个行为，进行了一些处理，导致搜索某些词可能会跳转到其它地方。

4.7 重新安装nginx

当我们在安装nginx的时候，由于忘记某些配置而导致有些功能无法使用，比如当编译的时候没有启用SSL支持，在配置反向代理到 https的网站时，编辑配置文件报错，无法启动nginx，报错内容如下：

[root@nginx1 conf]# service nginx reload
nginx: [emerg] https protocol requires SSL support in /opt/nginx/conf/nginx.conf:45
nginx: configuration file /opt/nginx/conf/nginx.conf test failed

解决办法：先将nginx.conf备份/root/目录下，删除/opt/nginx和/opt/apps/nginx-1.16.1，然后再解压一份，最后编译安装。

[root@nginx1 nginx-1.16.1]# ./configure --prefix=/opt/nginx --with-http_ssl_module
[root@nginx1 nginx-1.16.1]# make && make install
[root@nginx1 nginx-1.16.1]# cd /opt/nginx/conf/
[root@nginx1 conf]# cp /root/nginx.conf  ./
cp: overwrite `./nginx.conf'? yes
[root@nginx1 conf]# service nginx reload
nginx: the configuration file /opt/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /opt/nginx/conf/nginx.conf test is successful
Reloading nginx:

5. 反向代理

所谓的代理其实就是一个中介，比如两台主机A和B，因为某种原因不能直连，在中间插入一个主机C，通过C联通A和B。

早些时候，代理多数是帮助内网client访问外网server用的，这就是正向代理。

后来出现了反向代理，"反向"这个词在这儿的意思其实是指方向相反，即代理将来自外网客户端的请求转发到内网服务器，是从外到内的。

所以，代理服务器根据其代理对象的不同，可以分为正向代理服务器与反向代理服务器。

5.1 正向代理服务器

正向代理是对客户端的代理。客户端 C 想要从服务端 S 获取资源，但由于某些原因不能，直接访问服务端，而是通过另外一台主机 P 向服务端发送请求。当服务端处理完毕请求后，将响应发送给主机 P，主机 P 在接收到来自服务端的响应后，将响应又转给了客户端 C。此时的主机 P，就称为客户端 C 的正向代理服务器。

客户端在使用正向代理服务器时是知道其要访问的目标服务器的地址等信息的。**正向代理服务器是为服务用户（客户端）而架设的主机，与服务端无关，对服务器端透明。**正向代理服务器类似一个跳板机，代理访问外部资源。

比如我们国内访问谷歌，直接访问访问不到，我们可以通过一个正向代理服务器，请求发到代理服，代理服务器能够访问谷歌，这样由代理去谷歌取到返回数据，再返回给我们，这样我们就能访问谷歌了。

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第16张图片

Maven的Nexus私服也是典型的用于“缓存”的正向代理服务器：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第17张图片

正向代理的用途：

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

5.2 反向代理服务器

反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。这个时候，对于客户端来说，感觉不到内部目标服务器的存在。

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第18张图片

反向代理的作用：

  1. 保证内网的安全，阻止web攻击，大型网站，通常将反向代理作为公网访问地址，Web服务器是内网
  2. 负载均衡，通过反向代理服务器来优化网站的负载

总的来说：

  • 正向代理即是客户端代理, 代理客户端, 服务端不知道实际发起请求的客户端
  • 反向代理即是服务端代理, 代理服务端, 客户端不知道实际提供服务的服务端

5.3 反向代理之负载均衡

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第19张图片

由于反向代理服务器处在最终处理请求访问的服务器之前，因此可以在代理服务器上做负载均衡。

所谓的负载均衡（Load Balancing），就是将对请求的处理分摊到多个操作单元上进行。这个均衡是指在大批量访问前提下的一种基本均衡，并非是绝对的平均。对于 Web 工程中的负载均衡，就是将相同的 Web 应用部署到多个不同的 Web 服务器上，形成多个 Web 应用服务器。当请求到来时，由负载均衡服务器负责将请求按照事先设定好的比例向 Web 应用服务器进行分发，从而增加系统的整体吞吐量。

负载均衡可以通过负载均衡软件实现，也可通过硬件负载均衡器实现。

（1）硬件负载均衡

硬件负载均衡器的性能稳定，且有生产厂商作为专业的服务团队。但其成本很高，一台硬件负载均衡器的价格一般都在十几万到几十万，甚至上百万。知名的负载均衡器有 F5、Array、深信服、梭子鱼等。

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第20张图片

（2）软件负载均衡

软件负载均衡成本几乎为零，基本都是开源软件。例如：LVS、HAProxy、Nginx 等。

下面我们Nginx反向代理服务器配置负载均衡。

我准备三台虚拟机，一台是作为Nginx服务器，主机命名为nginx1，ip地址为192.168.218.55，另外两台作为web服务器，主机名分别为layne2和layne3，ip地址分别为192.168.218.52和192.168.218.53。

Nginx配置负载均衡有两种方式，我将分别进行介绍。

方式一

  1. 修改nginx.conf的http块下的内容：

    # 默认负载权重是一样的
upstream rss{
       
	server 192.168.218.52;
	server 192.168.218.53;
}
server {
       
	listen       80;
	server_name  www.layne.com;
	#access_log  logs/host.access.log  main;
	access_log logs/layne.log myfmt;

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

	location /dogs {
       
		proxy_pass http://rss/;
	}
}

  2. 这里最好也把http块下的keepalive_timeout设置为0，即让会话保持时间为0，便于看出负载切换的效果，但部署时需要设置合适的数值来提高效率。

    keepalive_timeout  0;

  3. 执行service nginx restart重启nginx

  4. 分别在layne2和layne3虚拟机安装执行如下命令安装httpd：

    yum install httpd -y

  5. 进入/var/www/html目下，执行vim index.html分别在layne2和layne3里加入from 192.168.218.52、from 192.168.218.53。

  6. 启动两台虚拟机上的httpd服务：service httpd start。

  7. 在浏览中分别输入http://192.168.218.52/和http://192.168.218.53/进行测试，出现from 192.168.218.5x即代表httpd配置成功。

  8. 最后，输入http://www.layne.com/dogs，不断进行刷新，可看到页面内容发生变化，说明负载均衡配置成功。

一般来说，中小企业一般使用方式一。

方式二

在Nginx服务器上配置hosts本地域名解析：

[root@nginx1 logs]# cat /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.218.55 nginx1
192.168.218.50 layne
192.168.218.51 layne1
192.168.218.52 layne2 xxx
192.168.218.53 layne3 xxx
192.168.218.54 layne4

[root@nginx1 logs]#

修改nginx.conf配置文件，在server块中添加如下配置

       location /cats {
     
           proxy_pass http://xxx/;
       }

重启nginx：service nginx restart

浏览器中输入http://www.layne.com/cats不端刷新进行测试。

这种方式一样能够实现负载均衡的目的，该方式下，Nginx服务器会用到域名解析，如果一个域名解析出多个ip地址，会在这些ip地址之间做负载均衡。

一般来说，大型企业使用方式二，如果需要解析的ip地址过多，还会搭建一个DNS域名解析服务器，只需要修改DNS域名解析服务器（中的IP列表）即可。

5.4 负载均衡进阶

在5.3节我们采用两种方式实现了负载均衡，对于方式一还有许多的扩充配置，我们一起来看看吧。

Nginx提供的负载均衡策略有2种：内置策略和扩展策略。内置策略为轮询，加权轮询，Ip hash（ip绑定）。扩展策略，就天马行空，只有你想不到的没有他做不到的啦，最常用的扩展策略为fair、url_hash。扩展策略一般不能直接使用，需要安装安三方扩展包。

轮询：nginx默认就是轮询其权重都默认为1，服务器处理请求的顺序：ABABABABAB…

# 默认负载权重是一样的
upstream rss{
     
	server 192.168.218.52;
	server 192.168.218.53;
}

加权轮询：跟据配置的权重的大小而分发给不同服务器不同数量的请求。如果不设置，则默认为1。下面服务器的请求顺序为：ABBABBABBABBABB…

# 加权轮训
upstream rss{
     
	server 192.168.218.52 weight=1;
	server 192.168.218.53 weight=2;
}

ip_hash：nginx会让相同的客户端ip请求相同的服务器。

upstream rss{
     
	server 192.168.218.52;
	server 192.168.218.53;
	ip_hash;
}

热备：如果你有2台服务器，当一台服务器发生事故时，才启用第二台服务器给提供服务。服务器处理请求的顺序：AAAAAA突然A挂啦，BBBBBBBBBBBBBB…

upstream rss{
     
	server 192.168.218.52;
	server 192.168.218.53 backup;  #热备 
}

fair（第三方）：按后端服务器的响应时间来分配请求，响应时间短的优先分配。

url_hash(第三方)：按访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，后端服务器为缓存时比较有效。

关于第三方的扩展策略，可参考https://www.cnblogs.com/ztlsir/p/8945043.html。

nginx负载均衡配置的几个状态参数：

  • down：表示当前的server暂时不参与负载均衡。
  • backup：预留的备份机器。当其他所有的非backup机器出现故障或者忙的时候，才会请求backup机器，因此这台机器的压力最轻。
  • max_fails：允许请求失败的次数，默认为1。当超过最大次数时，返回proxy_next_upstream 模块定义的错误。
  • fail_timeout：在经历了max_fails次失败后，暂停服务的时间。max_fails可以和fail_timeout一起使用。
upstream rss {
      
    server 192.168.218.52 weight=2 max_fails=2 fail_timeout=2;
    server 192.168.218.53 weight=1 max_fails=2 fail_timeout=1;
    #server  服务器的ip   权重   最大失败次数   暂停服务的时间
}

6. session共享

6.1 session共享的解决方案

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第21张图片

当nginx做了负载均衡之后，同一个ip的url请求服务器的时候，负载均衡会根据每台服务器的权重等一些设置将请求转发到不同的服务器上去进行处理，这样会带来一个很大的问题，即不能保证带有状态的请求的完整性。假如A用户登陆系统，负载均衡机制把A用户的登陆请求分发给了S1服务器，这个时候S1服务器上就会记录A用户登陆的session信息。登陆成功后，当A用户进行相应的操作，比如进入个人中心，这时候这个请求经过反向代理服务器的时候，负载均衡机制根据当前集群中的各个服务器的压力性能等情况可能把请求分发给了S2服务器处理，那么这个时候会去验证用户的状态是否登录，也就是验证session。可是A用户的session保存在了S1服务器上，造成再S2服务器上请求验证状态找不到对应的session，就会认为用户未登录而做的异常操作，提醒用户去登录，从而跳转到登录页面。这就是负载均衡针对带有状态的请求的一个弊端。

本小节引用自负载均衡的session共享，里面加了少部分自己的理解

常用的解决方案有4种。

（1）不使用session，使用cookie

session是存放在服务器端的，cookie是存放在客户端的，我们可以把用户访问页面产生的session放到cookie里面，就是以cookie为中转站。你访问web服务器A，产生了session然后把它放到cookie里面，当你的请求被分配到B服务器时，服务器B先判断服务器有没有这个session，如果没有，再去看看客户端的cookie里面有没有这个session，如果也没有，说明session真的不存，如果cookie里面有，就把cookie里面的sessoin同步到服务器B，这样就可以实现session的同步了。其实session底层原理也是通过cookie实现的，但它是自动实现的，不需要人为进行操作，但是这里我们是通过编程cookie的方式实现session共享。

说明：这种方法实现起来简单，方便，也不会加大数据库的负担，但是如果客户端把cookie禁掉了的话，那么session就无从同步了，这样会给网站带来损失；cookie的安全性不高，虽然它已经加了密，但是还是可以伪造的，所以这种方式也是不推荐的。

（2）session存在数据库mysql

session保存在数据库中，是把session表和其他的数据表存放在一起，那么当用户只要登录后随便操作了些什么就要去数据库验证一下session的状态，这样无疑加重了mysql数据库的压力；如果数据库也做了集群的话，那么也就是说每个数据库集群的节点都得保存这个session表，而且要保证每个集群的节点中数据库的session表的数据保持一致，实时同步。

说明：session保持在数据库，加重了数据库的IO，增大数据库的压力和负担，从而影响数据库的读写性能，而且mysql集群的话也不利于session的实时同步。

（3）session存在缓存memcache或者redis中

这种方式来同步session，不会加大数据库的负担，而且安全性比用cookie保存session大大的提高，把session放到内存里面，比从文件中读取要快很多。但是memcache把内存分成很多种规格的存储块，有块就有大小，这种方式也就决定了，memcache不能完全利用内存，会产生内存碎片，如果存储块不足，还会产生内存溢出。

memcache可以做分布式，php配置文件中设置存储方式就为memcache，这样php自己会建立一个session集群，将session数据存储在memcache中。

（4）ip_hash技术

ip_hash技术，nginx中可以配置，当某个ip下的客户端请求指定（固定，因为根据IP地址计算出一个hash值，根据hash值来判断分配给那台服务器，从而每次该ip请求都分配到指定的服务器）的服务器，这样就可以保证有状态请求的状态的完整性，不至于出现状态丢失的情况。下面是nginx的配置，可以参考一下：

upstream rss{
     
	server 192.168.218.52;
	server 192.168.218.53;
	ip_hash;

说明：ip_hash确实可以保证带有状态的请求的完整性，但是它有一个很大的缺陷，那就是ip_hash方案必须保证Nginx是最前端的服务器（接受真实的ip），如果nginx不是最前端的服务器，还存在中间件（中间服务器什么的），那么nginx获取的ip地址就不是真实的ip地址，那么这个ip_hash就没有任何意义。

（5）tomcat 本身带有复制session的功能，不过由于tomcat的性能有限，这种方案基本不用。

下面我将通过memcache实现session共享。

6.2 memcache实现session共享

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第22张图片

（1）安装jdk、tomcat

在layne2和layne3虚拟机上安装jdk和tomcat。

  1. 首先把相应的软件apache-tomcat-7.0.69.tar.gz 和jdk-7u80-linux-x64.rpm拷贝到两台虚拟机的/opt/apps目录下（可联系博主获取本文所有软件），然后执行下面命令进行安装：

    [root@layne2 ~]# cd /opt/apps
[root@layne2 apps]# ls
apache-tomcat-7.0.69  apache-tomcat-7.0.69.tar.gz  jdk-7u80-linux-x64.rpm
[root@layne apps]# rpm -ivh jdk-7u80-linux-x64.rpm
Preparing...                ########################################### [100%]
   1:jdk                    ########################################### [100%]
Unpacking JAR files...
	rt.jar...
	jsse.jar...
	charsets.jar...
	tools.jar...
	localedata.jar...
	jfxrt.jar...
[root@layne2 apps]# find / -name java
/etc/pki/ca-trust/extracted/java
/etc/pki/java
/usr/bin/java
/usr/java
/usr/java/jdk1.7.0_80/bin/java
/usr/java/jdk1.7.0_80/jre/bin/java
[root@layne2 apps]# ll /usr/java
total 4
lrwxrwxrwx 1 root root   16 Feb 11 18:58 default -> /usr/java/latest
drwxr-xr-x 8 root root 4096 Feb 11 18:57 jdk1.7.0_80
lrwxrwxrwx 1 root root   21 Feb 11 18:58 latest -> /usr/java/jdk1.7.0_80

  2. 配置环境变量，进入vim /etc/profile ，在文件最后加入以下两行代码：

    export JAVA_HOME=/usr/java/default
export PATH=$PATH:$JAVA_HOME/bin

  3. 让配置生效，使用source /etc/profile

  4. 测试安装配置是否成功

    [root@layne ~]# java -version
java version "1.7.0_80"
Java(TM) SE Runtime Environment (build 1.7.0_80-b15)
Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)
[root@layne ~]# jps
1423 Jps

  5. 解压apache-tomcat-7.0.69.tar.gz

    tar -zxvf apache-tomcat-7.0.69.tar.gz

  6. 编辑apache-tomcat-7.0.69/webapps/ROOT/index.jsp

    [root@layne2 apps]# cd apache-tomcat-7.0.69/webapps/ROOT/
[root@layne2 ROOT]# vim index.jsp

    使用:%d删除index.jsp里面的全部内容，并添加：

    from 192.168.218.52 session=<%=session.getId()%>

  7. 在layne3上进行同样的安装配置操作。

  8. 启动tomcat

    [root@layne2 bin]# pwd
/opt/apps/apache-tomcat-7.0.69/bin
[root@layne2 bin]# ./startup.sh 
Using CATALINA_BASE:   /opt/apps/apache-tomcat-7.0.69
Using CATALINA_HOME:   /opt/apps/apache-tomcat-7.0.69
Using CATALINA_TMPDIR: /opt/apps/apache-tomcat-7.0.69/temp
Using JRE_HOME:        /usr/java/default
Using CLASSPATH:       /opt/apps/apache-tomcat-7.0.69/bin/bootstrap.jar:/opt/apps/apache-tomcat-7.0.69/bin/tomcat-juli.jar

  9. 浏览器中输入 http://192.168.218.52:8080/，就可以出现页面了，并显示当前的sessionid，刷新页面，session也不会变。

（2）配置nginx.conf

修改nginx.conf为如下配置

upstream rss{
     
	server 192.168.218.52:8080;
	server 192.168.218.53:8080;
}
# 如果默认不写8080，则默认为80端口，如果ip后面写上8080端口，则请求的是tomcat的服务。
# 当然，也可以通过修改tomcat配置，让tomcat服务端口变为80，这样我们的Ip地址后面就不用加80端口了
# 但是，要把httpd服务关了，因为httpd服务的端口也是80，会占用端口

重启nginx：service nginx restart

访问http://www.layne.com/dogs，不断刷新，会发现session一直在改变，接下来我们就配置session共享了。

（3）nginx服务器安装memcached

  1. 安装libevent

    yum install libevent -y

  2. 安装memcached

    yum install memcached  -y

  3. 启动memcached

    [root@nginx1 conf]# memcached -d -m 128m -p 11211 -l 192.168.218.55 -u root -P /opt/mempid
[root@nginx1 conf]# ps aux |grep  memcached
root       1870  0.0  0.0 330844   884 ?        Ssl  19:45   0:00 memcached -d -m 128m -p 11211 -l 192.168.218.55 -u root -P /opt/mempid
root       1877  0.0  0.0 103256   864 pts/2    S+   19:45   0:00 grep memcached
[root@nginx1 conf]# cat /opt/mempid
1870

    可以看到，/opt/mempid存储的就是memcached进程的pid，对上面memcached的启动命令进行解释：

  • -d：后台启动服务
  • -m：缓存大小
  • -p：启动的端口
  • -l：所在服务器的ip地址
  • -P：服务器启动后的系统进程ID，存储的文件
  • -u：服务器启动是以哪个用户名作为管理用户

（4）配置session共享

  1. 拷贝session共享所需的jar包到两个虚拟机的apache-tomcat-7.0.69/lib目录下，如下所示：
    从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第23张图片
    以上jar包，有需要的可以留言或者直接私信我。

  2. 配置两个的tomcat，在每个apache-tomcat-7.0.69/conf/context.xml的...结点里面加入如下内容：

    <Manager className="de.javakaffee.web.msm.MemcachedBackupSessionManager" 
	memcachedNodes="n1:192.168.218.55:11211" 
    sticky="false" 
    lockingMode="auto"
    sessionBackupAsync="false"
	requestUriIgnorePattern=".*\.(ico|png|gif|jpg|css|js)$"
    sessionBackupTimeout="1000" transcoderFactoryClass="de.javakaffee.web.msm.serializer.kryo.KryoTranscoderFactory" 
/>

    注意：里面的ip地址为nginx服务器的ip地址，不是当前虚拟机的ip地址

  3. 执行以下命令重启两个tomcat

    [root@layne2 bin]# pwd
/opt/apps/apache-tomcat-7.0.69/bin
[root@layne2 bin]# ./shutdown.sh && ./startup.sh

  4. 在浏览器中输入http://www.layne.com/dogs，不断刷新页面，发现session保持不变。显示类似如下的内容：

    from 192.168.218.53 session=4493A2D98EC0934FA892B16BA0D3AAFE-n1

至此，session共享就配置成功了。接下来，我们来配置nginx动静分离。

7. 动静分离

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第24张图片

Nginx动静分离简单来说就是把动态和静态请求分开，不能理解成知识单纯的把动态页面和静态页面物理分离。严格意义上说应该是动态请求和静态请求分开，可以理解成使用Nginx处理静态请求，Tomcat处理动态请求。

动静分离从目前实现方式大致分为两种：

  • 方式一：纯粹的把静态文件独立成单独的域名，放在独立的服务器上，也是目前主流推崇的方案。
  • 方式二：动态和静态文件混合在一起发布，通过nginx分开。通过配置location指定不同的后缀名实现不同的请求转发。

接下来，我通过方式一实现动静分离。下面是我们即将配置动静分离的服务器拓扑图：

从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第25张图片

  • nginx1作为反向代理服务器，负责session共享、负载均衡、反向代理，区分动态请求和静态请求并转发给不同的服务器
  • layne2和layne3作为web服务器，部署了tomcat，负责解析动态请求
  • nginx2中存放的是静态资源，负责解析静态请求。

让我们实现nginx的动静分离吧！

  1. 先在两个tomcat中执行./shutdown.sh关闭

  2. 编辑layne2中tomcat的apache-tomcat-7.0.69/webapps/ROOT/index.jsp文件，修改为以下内容：

    <link rel="stylesheet" type="text/css" href="/css/index.css">
<img src="/image/logo.jpg" ><br/>
<font class="myfont">
from 192.168.218.52 <br/>
 session=<%=session.getId()%></font>

  3. 在apache-tomcat-7.0.69/webapps/ROOT/目下执行如下命令把layne2中的index.jsp拷贝到layne3的相同目录下：

    scp index.jsp 192.168.218.53:`pwd`

  4. 修改layne3中的tomcat，把index.jsp中的ip改为192.168.218.53

  5. 从nginx1克隆nginx2，修改nginx2的/etc/udev/ rules.d/70-persistent-net.rules

    [root@nginx2 rules.d]# pwd
/etc/udev/rules.d
[root@nginx2 rules.d]# vim 70-persistent-net.rules

    将原来的eth0一行删掉，并将eth1改为eth0 。这里参考Linux切换运行级别、关闭防火墙、禁用selinux、关闭sshd、时间同步、修改时区、拍摄快照、克隆操作。

  6. 在nginx2中输入 vim /etc/sysconfig/network修改计算机名称（hostname）为nginx2。然后输入 vim /etc/sysconfig/network-scripts/ifcfg-eth0 配置网络，将ip地址改为192.168.218.56即可。

  7. 在nginx2服务器上创建目录 /data/image和/data/css，然后将logo.jpg和index.css上传到对应的目录。

    [root@nginx2 ~]# mkdir -p /data/image  /data/css

    logo.jpg为：

    从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第26张图片

    index.css内容为：

    .myfont{
       color:#F00;font-size:45px}

  8. 修改nginx2服务器上的nginx.conf配置文件，执行vim /opt/nginx/conf/nginx.conf，加入以下内容：

    server {
       
	listen       80;
	server_name  192.168.218.56;

	location / {
       
		root   /mnt;
		autoindex  on;
	}

	location /image {
       
		root /data;
	}

	location /css {
       
		root /data;
	}
	#不用再路径最后加/，不加/意味着可以拼接路径，加了/意味着直接访问填写的路径
}

  9. 修改nginx1服务器上的nginx.conf配置文件，内容如下：

    upstream rss{
       
	server 192.168.218.52:8080;
	server 192.168.218.53:8080;
}

server {
       
	listen       80;
	server_name  www.layne.com;
	#access_log logs/layne.log myfmt;
	location / {
       
		proxy_pass http://rss/;
	}
	
	location /image {
       
		proxy_pass http://192.168.218.56;
	}
	
	location /css {
       
		proxy_pass http://192.168.218.56;
	}

  10. 重启nginx1、nginx2，重启两个tomcat。

  11. 在nginx1服务器中输入以下命名开启memcached

    memcached -d -m 128m -p 11211 -l 192.168.218.55 -u root -P /opt/mempid

  12. 在浏览器中输入http://www.layne.com/测试，出现如下页面，不断刷新页面，session也不会变。
    从0开始，在Linux中配置Nginx反向代理、负载均衡、session共享、动静分离_第27张图片

你可能感兴趣的:(nginx,nginx,nginx反向代理,负载均衡,session共享,动静分离)

  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • ubuntu安装wordpress lissettecarlr
    1安装nginx网上安装方式很多，这就就直接用apt-get了apt-getinstallnginx不用启动啥，然后直接在浏览器里面输入IP:80就能看到nginx的主页了。如果修改了一些配置可以使用下列命令重启一下systemctlrestartnginx.service2安装mysql输入安装前也可以更新一下软件源，在安装过程中将会让你输入数据库的密码。sudoapt-getinstallmy
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 最简单将静态网页挂载到服务器上(不用nginx) 全能全知者 服务器nginx运维前端html笔记
    最简单将静态网页挂载到服务器上(不用nginx)如果随便弄个静态网页挂在服务器都要用nignx就太麻烦了，所以直接使用Apache来搭建一些简单前端静态网页会相对方便很多检查Web服务器服务状态：sudosystemctlstatushttpd#ApacheWeb服务器如果发现没有安装web服务器：安装Apache：sudoyuminstallhttpd启动Apache：sudosystemctl
  • 鲲鹏 ARM 架构 麒麟 Lylin v10 安装 Nginx (离线) 焚木灵 arm开发架构nginx服务器
    最近做一个银行的项目，银行的服务器是鲲鹏ARM架构的服务器，并且是麒麟v10的系统，这里记录一下在无法访问外网安装Nginx的方法。其他文章：鲲鹏ARM架构麒麟Lylinv10安装Mysql8.3(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装Node和NVM(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装Pm2(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装P
  • shell脚本中sed命令如何使用变量 歪歪的酒壶 linux
    在shell脚本中我们常常需要使用sed命令进行配置文件的更新，但是更新的内容又往往根据环境相关。值并不是固定的。这里我们介绍一种在sed命令中使用变量的方法。比如，在nginx的配置中，我们需要根据环境来更新/etc/nginx/sites-available/default中的目录配置。通常我们采用一个变量，来记录当前环境需要配置的目录比如：dist_dir=/home/dev/code/ui
  • Nginx之代理模块 ngx_http_proxy_module 途径日暮不赏丶 nginxnginx
    正向代理正向代理是指位于客户机（A）和站点服务器（B）之间的代理服务器（C），为了从站点服务器（B）获取资源，客户机（A）向代理服务器（C）发送请求并指定站点服务器（B），然后代理服务器（C）向站点服务器（B）转交请求并将获取的资源返回给客户机（A）。上述这样的代理模式称为正向代理，正向代理最大的特点：客户端非常明确要访问的服务器地址；服务器只清楚请求来自哪个代理服务器，而不清楚来自哪个具体的客户
  • 网关gateway学习总结 猪猪365 学习总结学习总结
    一微服务概述:微服务网关就是一个系统!通过暴露该微服务的网关系统,方便我们进行相关的鉴权,安全控制,日志的统一处理,易于监控的相关功能!实现微服务网关技术都有哪些呢?1nginx:nginx是一个高性能的http和反向代理web的服务器,同事也提供了IMAP/POP3/SMTP服务.他可以支撑5万并发链接,并且cpu,内存等资源消耗非常的低,运行非常的稳定!2Zuul:Zuul是Netflix公司
  • Nginx之ngx_http_proxy_connect_module模块 小米bb Nginxnginxhttp运维
    近期由于项目需要使用到https正向代理，而nginx官方模块仅支持做http正向代理，一番百度学习后发现了该模块，故今日记录下此笔记供大家一起学习交流ngx_http_proxy_connect_module模块主要用于隧道SSL请求的代理服务器GitHub地址：http://www.github.com/chobits/ngx_http_proxy_connect_modulenginx配置：
  • Nginx：高性能的Web服务器与反向代理 张某布响丸辣 nginx前端服务器javaSpringBoot
    在当今的互联网世界中，Web服务器的选择对于网站的性能、稳定性和安全性至关重要。Nginx（发音为“engineX”）凭借其卓越的性能、丰富的功能集和灵活的配置选项，成为了众多网站和应用程序的首选Web服务器和反向代理。本文将深入探讨Nginx的特点、应用场景、基本配置以及它如何助力你的Web项目。Nginx简介Nginx是一个开源的、高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/
  • 编译Windows平台的Nginx+ngx_http_proxy_connect_module Grovvy_Deng windowsnginxhttp
    编译Windows平台的Nginx+ngx_http_proxy_connect_module背景：由于公司的正向出局代理是windows机器。机器上的Squid不稳定，打算替换成nginx+ngx_http_proxy_connect_module实现。通过几天痛苦的尝试，最后参考了github大神项目通过在线CICD工具编译window平台可用的ng。步骤：获取git可识别的patch由于CI
  • Nginx从入门到实践(三) 听你讲故事啊
    动静分离动静分离是将网站静态资源（JavaScript，CSS，img等文件）与后台应用分开部署，提高用户访问静态代码的速度，降低对后台应用访问。动静分离的一种做法是将静态资源部署在nginx上，后台项目部署到应用服务器上，根据一定规则静态资源的请求全部请求nginx服务器，达到动静分离的目标。rewrite规则Rewrite规则常见正则表达式Rewrite主要的功能就是实现URL的重写，Ngin
  • Nginx的使用场景：构建高效、可扩展的Web架构 张某布响丸辣 nginx前端架构
    Nginx，作为当今最流行的Web服务器和反向代理软件之一，凭借其高性能、稳定性和灵活性，在众多Web项目中扮演着核心角色。无论是个人博客、中小型网站，还是大型企业级应用，Nginx都能提供强大的支持。本文将探讨Nginx的几个主要使用场景，帮助读者理解如何在实际项目中充分利用Nginx的优势。1.静态文件服务对于包含大量静态文件（如HTML、CSS、JavaScript、图片等）的网站，Ngin
  • 【nginx】ngx_http_proxy_connect_module 正向代理 等风来不如迎风去 网络服务入门与实战nginxhttp运维
    50.65无法访问服务器，(403错误)50.196可以访问服务器。那么，配置65通过196访问。需要一个nginx作为代理【nginx】搭配okhttp配置反向代理发送原生的nginx是不支持okhttp的CONNECT请求的。大神竟然给出了一个java工程GINX编译ngx_http_proxy_connect_module及做正向代理是linux构建的。是windows构建的：编译Windo
  • Kubernetes Ingress 控制器（Nginx）安装与使用教程 农优影
    KubernetesIngress控制器（Nginx）安装与使用教程kubernetes-ingressNGINXandNGINXPlusIngressControllersforKubernetes项目地址:https://gitcode.com/gh_mirrors/ku/kubernetes-ingress1.项目目录结构及介绍在nginxinc/kubernetes-ingress仓库中，
  • Gobelieve 架构 weixin_34099526 数据库golangjson
    Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
  • 浅谈openresty 爱编码的钓鱼佬 nginxopenresty运维
    熟悉了nginx后再来看openresty，不得不说openresty是比较优秀的。对nginx和openresty的历史等在这此就不介绍了。首先对标nginx，自然有优劣一、开发难度nginx：毫无疑问nginx的开发难度比较高，需要扎实的c/c++基础，而且还需要对nginx源码比较熟悉，开发效率慢，比如实现一个类似echo的功能，至少要上百行代码。而openresty只需要一句ngx.say
  • 页面报错 POST 413错误 (Request Entity Too Large) 小黑屋说YYDS 踩坑nginxjavalinux服务器
    一般来说是服务器使用nginx作为反向代理出现的问题，post请求长度超过了nginx默认的缓存大小和最大客户端最大请求大小。解决方式如下，更该nginx代理配置：在nginx.conf配置文件中，找到http{}代码块，添加如下配置client_max_body_size20m;重启nginx即可。
  • docker 安装、运行nginx shell脚本 三希 dockernginx容器
    以下是一个简单的用于安装和运行DockerNginx的shell脚本：bash#!/bin/bash#安装Docker（如果还未安装）#请根据实际情况调整安装命令#拉取Nginx镜像dockerpullnginx#运行Nginx容器dockerrun-d--namemynginx-p80:80nginx
  • 老生常谈：MySQL高可用架构 我有一头小花驴 mysql架构数据库
    引言“高可用”是互联网一个永恒的话题，先避开MySQL不谈，为了保证各种服务的高可用有几种常用的解决方案。服务冗余：把服务部署多份，当某个节点不可用时，切换到其他节点。服务冗余对于无状态的服务是相对容易的。服务备份：有些服务是无法同时存在多个运行时的，比如说：Nginx的反向代理，一些集群的leader节点。这时可以存在一个备份服务，处于随时待命状态。自动切换：服务冗余之后，当某个节点不可用时，要
  • docker项目切换（nginx）、重启shell 脚本 懒惰的小蜗牛 dockerdockernginx容器
    docker项目切换、重启脚本背景具体操作nginx配置配置文件1配置文件2编写nginx替换脚本(用来执行端口替换)编写启动脚本dockerfile文件正常编写给脚本授权执行./start脚本背景项目部署docker中，更新项目时，需要将原原来的容器停止，再启动新的容器，这样会有一个空窗期，导致不可用解决方案：映射不同的端口并启动新的容器，将nginx转发到新容器，停止旧容器具体操作说明ngin
  • Spring Boot 请求处理流程：从负载均衡到多实例并发 - 电子商务网站实例 烟雨国度 springboot负载均衡后端
    SpringBoot请求处理流程：从负载均衡到多实例并发-电子商务网站实例SpringBoot请求处理流程：从负载均衡到多实例并发SpringBoot作为一个强大的Java应用开发框架，能够有效地处理高并发请求。本文将基于三个关键流程图，详细分析SpringBoot应用如何从负载均衡到请求处理，再到多实例并发处理的整个过程。1.负载均衡和多实例处理首先，让我们看一下描述负载均衡和多实例处理的流程图
  • FastCGI结合docker下的Nginx执行shell脚本 南波波 nginxdocker
    1使用docker下载Nginx下面展示一些内联代码片。a.#dockerpullnginx#dockerrun--namerunoob-php-nginx-p8088:80-d\-v~/nginx/www:/usr/share/nginx/html:ro\-v~/nginx/conf/conf.d:/etc/nginx/conf.d:ro\nginxb.在~/nginx/conf/conf.d创
  • Open Feign 实战笔记 自强-X spring-cloudjavaspring微服务ribbonspringcloud
    OpenFeign笔记概念声明式的web服务客户端。使用接口加注解的形式编程。它是对RestTemplate和ribbon做了进一步封装。Feign已经停更，OpenFeign是在Feign的基础上又做了进一步的封装。Feign：Feign是SpringCloud组件中的一个轻量级RESTful的HTTP服务客户端Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Fei
  • 主流行架构 rainbowcheng 架构架构
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
  • 面试题篇: 跨域问题如何处理(Java和Nginx处理方式) guicai_guojia javanginx开发语言
    1.服务器端解决方案最常见的解决方案是在服务器端配置CORS头。服务器需要在响应中添加适当的Access-Control-Allow-头来允许跨域请求。1.1NGINX配置在NGINX配置中，你可以通过add_header指令来设置CORS头。配置示例：server{  listen80;  server_nameapi.example.com;  location/{    proxy_pass
  • Nginx Hard模式 西木风落 中间组件NginxNginx配置详解Nginx配置优化Nginx面试hard
    一、Nginx简介1.Nginx概述Nginx是一个免费、开源、高性能、轻量级的HTTP和反向代理服务器，也是一个电子邮件（IMAP/POP3）代理服务器。其特点是能支持高并发请求处理，并且占用较少的内存资源，提供稳定的、丰富的模块库，有很高的配置灵活性。目前，几乎所有的web项目，都配有Nginx。Nginx由内核和一系列模块组成，内核提供Web服务的基本功能，启用网路协议、提供运行环境、创建连
  • nginx部署前端项目的一些配置【刚入门】 weixin_30847271 运维前端ViewUI
    前期准备：在linux上安装nginx，我用的是腾讯云centos7服务器，具体的安装过程可以到腾讯云的开发者实验室里体验，自己先试试水。修改nginx.conf配置文件，我用到的修改只是以下的部分。1.端口号2.项目的存放位置server{listen8088default_server;#访问的端口号。listen[::]:8088default_server;server_name_;#ro
  • 定制优化Nextcloud镜像 攻城狮_正
    Nextcloud是一款开源免费的私有云存储网盘项目，可以让你快速便捷地搭建一套属于自己或团队的云同步网盘，从而实现跨平台跨设备文件同步、共享、版本控制、团队协作等功能。它的客户端覆盖了Windows、Mac、Android、iOS、Linux等各种平台，也提供了网页端以及WebDAV接口，所以你几乎可以在各种设备上方便地访问你的云盘。Nextcloud基于PHP语言开发，可以使用Nginx+PH
  • 微服务之服务注册与发现：Etcd、Zookeeper、Consul 与 Nacos 比较 陌北v1 微服务etcdzookeeperConsulNacos
    在微服务架构中，服务注册与发现是实现服务动态管理和负载均衡的关键。本文将对四款主流的服务注册与发现工具——Etcd、Zookeeper、Consul、Nacos进行深入对比，从功能、性能、一致性、生态集成、应用场景等多个维度展开分析，帮助您选择最适合的工具。核心概念服务注册：服务实例启动时将自身信息（IP地址、端口、健康状态等）注册到注册中心。服务发现：服务消费者通过注册中心查询所需服务的地址列表
  • ASM系列六 利用TreeApi 添加和移除类成员 lijingyao8206 jvm动态代理ASM字节码技术TreeAPI
        同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。   package asm.core; /** * Created by yunshen.ljy on 2015/6/
  • Springmvc-权限设计 bee1314 springWebjsp
    万丈高楼平地起。 权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。 目标： 1.实现权限的管理（CRUD） 2.实现部门管理 （CRUD) 3.实现人员的管理 （CRUD） 4.实现部门和权限
  • 算法竞赛入门经典（第二版）第2章习题 CrazyMizzz c算法
    2.4.1 输出技巧 #include <stdio.h> int main() { int i, n; scanf("%d", &n); for (i = 1; i <= n; i++) printf("%d\n", i); return 0; } 习题2-2 水仙花数(daffodil
  • struts2中jsp自动跳转到Action 麦田的设计者 jspwebxmlstruts2自动跳转
    1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士）   2、＜jsp:forward page="xxx.action" /＞ ，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
  • php 操作webservice实例 IT独行者 PHPwebservice
    首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; OK 现在我们来体验webservice //server端 serve
  • Windows下使用Vagrant安装linux系统 _wy_ windowsvagrant
    准备工作： 下载安装 VirtualBox ：https://www.virtualbox.org/ 下载安装 Vagrant ：http://www.vagrantup.com/ 下载需要使用的 box ： 官方提供的范例：http://files.vagrantup.com/precise32.box 还可以在 http://www.vagrantbox.es/ 
  • 更改linux的文件拥有者及用户组(chown和chgrp) 无量 clinuxchgrpchown
    本文（转） http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/ http://ydlmlh.iteye.com/blog/1435157 一、基本使用： 使用chown命令可以修改文件或目录所属的用户：        命令
  • linux下抓包工具 矮蛋蛋 linux
    原文地址： http://blog.chinaunix.net/uid-23670869-id-2610683.html tcpdump -nn -vv -X udp port 8888 上面命令是抓取udp包、端口为8888 netstat -tln 命令是用来查看linux的端口使用情况 13 . 列出所有的网络连接 lsof -i 14. 列出所有tcp 网络连接信息 l
  • 我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起” alafqq mybatis
    最近看了  每一个用mybatis的男纸，你伤不起 原文地址 ：http://www.iteye.com/topic/1073938 发表一下个人看法。欢迎大神拍砖； 个人一直使用的是Ibatis框架，公司对其进行过小小的改良； 最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究； 发现多了一个mapper层；个人感觉就是个dao；
  • 解决java数据交换之谜 百合不是茶 数据交换
    交换两个数字的方法有以下三种 ，其中第一种最常用   /* 输出最小的一个数 */ public class jiaohuan1 { public static void main(String[] args) { int a =4; int b = 3; if(a<b){ // 第一种交换方式 int tmep =
  • 渐变显示 bijian1013 JavaScript
    <style type="text/css"> #wxf { FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98); height: 25px; } </style>
  • 探索JUnit4扩展：断言语法assertThat bijian1013 java单元测试assertThat
    一.概述         JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
  • 【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}} bit1129 gson
      如何把如下简单的JSON字符串反序列化为Java的POJO对象? {"data":{"IM":["MSN","QQ","Gtalk"]}}   下面的POJO类Model无法完成正确的解析：   import com.google.gson.Gson;
  • 【Kafka九】Kafka High Level API vs. Low Level API bit1129 kafka
    1. Kafka提供了两种Consumer API High Level Consumer API Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题  
  • 在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua
    Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
  • java-归并排序 bylijinnan java
    import java.util.Arrays; public class MergeSort { public static void main(String[] args) { int[] a={20,1,3,8,5,9,4,25}; mergeSort(a,0,a.length-1); System.out.println(Arrays.to
  • Netty源码学习-CompositeChannelBuffer bylijinnan javanetty
    CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 查看API（ http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description） 可以看到，所谓“Transparent Zero Copy”是通
  • Android中给Activity添加返回键 hotsunshine Activity
    // this need android:minSdkVersion="11" getActionBar().setDisplayHomeAsUpEnabled(true); @Override public boolean onOptionsItemSelected(MenuItem item) {
  • 静态页面传参 ctrain 静态
    $(document).ready(function () { var request = { QueryString : function (val) { var uri = window.location.search; var re = new RegExp("" + val + "=([^&?]*)", &
  • Windows中查找某个目录下的所有文件中包含某个字符串的命令 daizj windows查找某个目录下的所有文件包含某个字符串
    findstr可以完成这个工作。   [html]  view plain copy   >findstr /s /i "string" *.*   上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
  • 改善程序代码质量的一些技巧 dcj3sjt126com 编程PHP重构
    有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：    尽量保持方法简短    尽管很多人都遵
  • SharedPreferences对数据的存储 dcj3sjt126com
    SharedPreferences简介：                                                   &nbs
  • linux复习笔记之bash shell (2) bash基础 eksliang bashbash shell
    转载请出自出处： http://eksliang.iteye.com/blog/2104329 1.影响显示结果的语系变量（locale）  1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： [root@localhost shell]# locale LANG=en_US.UTF-8 LC_CTYPE="en_US.UTF-8"
  • Android零碎知识总结 gqdy365 android
    1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。 所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
  • HoverTree.Model.ArticleSelect类的作用 hvt Web.netC#hovertreeasp.net
    ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
  • PHP 判断是否使用代理 PHP Proxy Detector 天梯梦 proxy
    1. php 类 I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to
  • apache的math库中的回归——regression（翻译） lvdccyb Mathapache
    这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。 多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。   数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。   基本覆盖了：线代，统计，矩阵， 最优化理论 曲线拟合 常微分方程 遗传算法（GA）， 还有3维的运算。。。
  • 基础数据结构和算法十三：Undirected Graphs (2) sunwinner Algorithm
      Design pattern for graph processing. Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
  • 云计算平台最重要的五项技术 sumapp 云计算云平台智城云
    云计算平台最重要的五项技术 1、云服务器 云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。 特性 机型丰富 通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作； 仅需要几分钟，根据CP
  • 《京东技术解密》有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。  12月试读活动回顾： http://webmaster.iteye.com/blog/2164754 本次技术图书试读活动获奖名单及相应作品如下： 一等奖（两名） Microhardest：http://microhardest.ite
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他