运维部落

香港vps促销1G99元 点击购买 美国vps促销512M59元 点击购买 日本vps促销1G100元 点击购买

打开Windows PowerShell（一个像是命令提示符的东西[蓝底白字]，但不是命令提示符）， 在Windows PowerShell内输入cmd回车，当返回如下信息： Microsoft Windows [版本 6.2.9200] (c) 2012 Microsoft Corporation。保留所有权利。 则表示已成功进入命令行环境，然后再输入： rundll32.exe shell32.dll,Control_RunDLL desk.cpl,,0 回车后，勾选所需要的桌面图标的名称，确定即可。

以上是网络上广为流传的方式 ，不过我在win2012r2下并没有成功。提示出错。按以上的命令行办法其实只能在运行用跑。具体办法：

光标移到右下角出现设置之类的直接搜出 “运行” 然后打开运行后。再行输入运行rundll32.exe shell32.dll,Control_RunDLL desk.cpl,,0

这样才可以把个性化调出来。

美国服务器虽然与中国相隔比较远，但是美国服务器通常都是通过海底光缆与中国电信和中国网通直接相连，具有很高的稳定性，通常访问ping值在180ms到220ms之间，并且丢包率维持在5%以下，如美国服务器出现丢包率比较高时，可能是受到外界干扰因素而造成的，下面我们就详细分析一下美国服务器丢包率比较高是什么原因。

美国服务器丢包率比较高是什么原因
　　一.人为因素的干扰
　　由于美国服务器是与电信或者网通直接相连，因而在宽带国际出口处可能会受到人为性的干扰而导致美国服务器丢包率非常高，如果是这种情况，几乎所有美国服务器都会出现高丢包率的现象。

　　如何检测是否受人为因素干扰
　　1.通过咨询其他美国服务器租用商或许寻找相关的新闻，了解一下是否其他服务商的美国服务器是a否也出现高丢包率的现象。

　　2.美国服务器出现高丢包率时，可能也会出现ping值不正常的情况，你可以到一些例如17ce等常用测速网站，用全球的服务器来对你的美国服务器IP进行测速，如果除开中国节点外，其他地区的ping值都正常，就说明宽带国际出口受到干扰。

　　二.服务器受到攻击
　　如果服务器被高流量型的DDoS攻击时，服务器资源了，带宽资源都会被占用而出现高频率丢包现象。通产高防服务器不会出现这种情况，因为高防服务器机房具有充足的带宽资源，并且能够对攻击流量进行有效识别，如果流量的攻击超过机房的保护范围时，美国服务器服务商通知用户并做出高防处理。

　　三.共享带宽可能会出现这种情况
　　如果用户选择的是共享代理的美国服务器，在网络带宽出现峰值时，就可能会出现高丢包率的现象，因而在租用美国服务器时尽量选择独享带宽，而共享带宽就必须要根据用户对网络业务的带宽需求来定。

　　以上就是美国服务器丢包率比较高是什么原因的相关介绍，这几点是美国服务器出现高丢包率的最常见因素，当然监测出现高丢包率还与本地电脑是否中毒，监测时是否在下载东西等有关因而我们需要从多个方面进行考虑，然后在找服务商协助解决。

最近帮朋友接了个小项目，客户在他们的美国机房租了几台服务器，然后想在上面做上网用的代理服务器，供客户在国内使用。具体需求如下：

1、客户的这台服务器具有多个出口ip地址

2、客户希望使用认证的方式使用代理服务器上网

3、客户希望通过不同的认证用户实现从不同的出口ip访问网络

4、隐藏代理信息，隐藏真实上网ip

此客户需求相当明确，根据上面罗列，条理也很清晰。本文的目的就是向大家介绍笔者实现这个需求的思路和步骤。

作者简介：刘晗昭，网名蚊子（博客），某通信业国企系统工程师，熟悉各种主流开源软件的使用，部署和组合应用，以及主流网站架构。目前关注系统架构和系统优化。

笔者使用了Squid来实现这一需求。Squid是一种在Linux系统下使用的优秀的代理服务器软件，还可以用在AIX、Digital Unix、FreeBSD、HP-UX、Irix、NetBSD、Nextstep、SCO和Solaris等系统上。更多关于squid的介绍就不在这里多讲了，有需要的去官方网站上看吧，51CTO也有这方面的专题。

这里先看下我设计的逻辑图：

根据图中所示，红色的用户1会通过红色的出口ip1访问internet，绿色的用户2会通过绿色的出口ip2访问internet，用户3和用户4同样对应相应颜色的出口访问internet。

接下来根据上面的需求进行逐一的分解。

一、需求分析

1、服务器具有多个出口ip地址

这个没什么可说的，客户的出口ip为：

10.100.10.1
10.100.10.2
10.100.10.3
2、使用认证的方式使用代理服务器上网

这里要用到squid的认证功能。squid的认证功能大类包括basic_auth，digest_auth，external_acl，negotiate_auth，ntlm_auth这5种（注：squid-2.7.STABLE9版本），每个大类下面还有具体的认证方式，如NCSA，LDAP，DB等等，具体支持哪些可以去这些目录下面看。

笔者在这里主要介绍的是NCSA的方式，此种认证方式类似apache的auth认证方式，通过用户名密码来验证，密码文件也是通过htpasswd程序来创建。后面会给出具体配置。

3、通过不同的认证用户实现从不同的出口ip访问网络

先说实现不同出口ip访问网络，这个主要是依靠squid的tcp_outgoing_address配置实现的，此参数可以根据source ip或者用户名的不同，分配不同的出口ip出去。

如此一来，搭配第二个需求中的用户验证，正好就可以实现第三个需求了。后面会给出具体的配置。

4、隐藏代理信息，隐藏真实上网ip

这个需求很多人应该都想到使用什么配置文件了，对，就是squid的header_access这个参数。主要就是隐藏掉HTTP_VIA，VIA和X-forwarded-for。后面会给出具体配置。

二、安装配置

首先要做的就是下载一个squid安装包（下载地址）。笔者这里使用的是2.7 STABLE9，操作的当前目录是/tmp，下面所有涉及到目录的都是基于此目录。squid源文件路径是/tmp/squid-2.7.STABLE9.tar.gz

安装步骤如下：

tar zxvf squid-2.7.STABLE9.tar.gz
cd squid-2.7.STABLE9
./configure –prefix=/usr/local/squid –enable-async-io=320 –enable-icmp –enable-delay-pools –enable-kill-parent-hack –enable-snmp –enable-arp-acl –enable-htcp –enable-cache-digests –enable-removal-policies=heap,lru –enable-default-err-language=Simplify_Chinese –enable-x-accelerator-vary –enable-follow-x-forwarded-for –with-aufs-threads=320 –with-pthreads –with-dl –with-maxfd=65536 –enable-basic-auth-helpers=DB,NCSA –enable-digest-auth-helpers=password –enable-large-cache-files –with-large-files
make
make install
如果以上步骤中无报错，squid就被正确安装完毕了。

接下来执行：

cd /usr/local/squid/
#（之后的所有操作均在此目录下完成）
grep -v “^#” etc/squid.conf.default|uniq > etc/squid.conf
将创建一份未注释的配置文件。

接下来编辑此文件

vi etc/squid.conf
修改编辑的内容如下：

在

20 acl CONNECT method CONNECT
21
22 http_access allow manager localhost
这两行中间加入：include “/usr/local/squid/etc/auth.conf”。auth.conf文件的内容后面会有详细介绍。

在

32 icp_access deny all
33
34 http_port 3128
这两行中间加入：always_direct allow all，意思是对所有ip过来的请求都允许转发。

将49 broken_vary_encoding allow apache行后面的所有内容删除，加上如下内容

forwarded_for off
#隐藏x-forwarded-for头
header_access HTTP_VIA deny all
#隐藏HTTP_VIA头
header_access VIA deny all
#隐藏VIA头
cache_effective_group daemon
#设置squid执行的用户组，这里使用了系统自带的daemon用户组
cache_effective_user daemon
#设置squid执行的用户，这里使用了系统自带的daemon用户

visible_hostname test
#设置错误页面中出现的服务器名称，可自行更改
cache_dir aufs /usr/local/squid/cache 100 16 256
#设置squid的缓存，可自行调整
cache_store_log none
#关闭store.log
都修改添加完毕后，保存退出。

紧接着我们来创建auth.conf。

vi /usr/local/squid/etc/auth.conf
输入如下内容

# 设置验证相关的配置内容，指定密码文件
1 auth_param basic program /usr/local/squid/libexec/ncsa_auth /usr/local/squid/etc/passwd
2 auth_param basic children 10 #设置验证子进程数
3 auth_param basic credentialsttl 2 hours #设置验证有效期
4 auth_param basic casesensitive off #设置是否区分大小写
5
# 后面这三行分别定义了三个用户组。每个用户组指定了一个用户文件。
6 acl usergroup1 proxy_auth “/usr/local/squid/etc/ip1user”
7 acl usergroup2 proxy_auth “/usr/local/squid/etc/ip2user”
8 acl usergroup3 proxy_auth “/usr/local/squid/etc/ip3user”
9
# 后面三条允许这三个组的用户可以访问网络
10 http_access allow usergroup1
11 http_access allow usergroup2
12 http_access allow usergroup3
13
# 这三条用来分配哪个组的用户走哪个出口ip
14 tcp_outgoing_address10.100.10.1 usergroup1
15 tcp_outgoing_address10.100.10.2 usergroup2
16 tcp_outgoing_address 10.100.10.3 usergroup3
编辑完成后保存退出。

接下来是创建用户文件，vi /usr/local/squid/etc/ip1user，填入如下内容

user1
user2
保存退出。这里用户数量不限，每个用户名占用一行。

如果一开始没有那么多用户，建议使用touch命令将文件创建好，不然启动squid的时候会出错。

接下来创建用户的密码文件，第一次创建密码文件请使用下面的命令

htpasswd -cb /usr/local/squid/etc/passwd user1 111111
倒数第二个字段是用户名，最后一个字段是用户对应的密码

如果之前创建过了密码文件，使用下面的命令就可以了

htpasswd -b /usr/local/squid/etc/passwd user2 111111
命令解释同上。

到此为止，配置文件等相关工作就基本完成了。下面来说说squid的初始化工作。

首先，mkdir cache，创建cache目录

然后执行，chown -R daemon.daemon，变更当前目录及所有子目录的的属主与属组。笔者这里使用系统自有的daemon用户和组。

这些工作都做好之后呢，就来执行 sbin/squid -z对squid进行初始化，如果没有报错信息呢，初始化工作就算是做完了，下面启动squid服务即可了，启动命令为

sbin/squid -ND &
然后通过下面的命令查看一下3128端口是否启动

netstat -ln|grep 3128
如果出现下面的内容，说明squid服务已经正常运行了

tcp 0 0 0.0.0.0:3128 0.0.0.0:* LISTEN
到此为止，一个支持用户身份验证的多出口代理服务器就完全配置完毕了，赶快打开浏览器，配置好代理服务器，测试一下吧。看看浏览网页是否会弹出验证的提示。

另外还可以登录proxy checker工具网站查看使用不同的用户组的用户，是否上网ip不一样，同时这个页面还能查看当前上网方式是否使用了代理。

如何用BIND, GeoIP, Nginx, Varnish来创建你自己的高效的CDN网络？
CDN，意思是Content Distrubtion Network，意思是内容分发网络，简单的说，就是全地域范围内的负载均衡，全地域的概念可以是全国，也可以是全世界。由统一的DNS服务器进行地址转发，选择离用户最近的地区服务器进行负载均衡。本质上是从一个机房内的负载均衡扩展到了全世界范围内的负载均衡。同时可以将本地化的内容，由当地的服务器实现。做浏览器的地区自动选择。
比如在中国，被人为划分成两大区域，北方是网通，南方是电信。这两个网络之间互访是比较慢的。作为大型网站，一种解决办法是将全部服务器架设在双线或三线ISP处，由ISP来提供路由上的选择。这样做，线路的成本会比较高。另一种办法就是将服务器架设在两边，南方一台，北方一台，然后由服务器自己选择，如果IP在电信，就转发请求到南方的服务器，如果是网通就转发到北方的服务器。
再扩大范围，可以将美国来的请求交由美国服务器处理，这样也缩短了用户在路由上的等待时间。这就是内容分发网络。
而作为这个网络上的所有节点，都可以当成虚拟服务器来看待。至于在各地的服务器如何做负载均衡，可以由各节点之间完成。
准备工作如下：你需要下载如下软件以实现上述功能
Nginx，BIND，GeoIP，Varnish
接下来是编译和安装bind9和geoip
# tar -xzvf bind-9.2.4.tar.gz
# tar -xzvf GeoIP-1.4.6.tar.gz
# cd GeoIP-1.4.6
# ./configure –prefix=/usr/local/geoip
# make
# make install
# cd ..
# patch -p0 < bind-9.2.4-geodns-patch/patch.diff //给bind9打补丁，让bind9直接支持geoip库
# cd bind-9.2.4
# CFLAGS=”-I/usr/local/geoip/include” LDFLAGS=”-L/usr/local/geoip/lib -lGeoIP” ./configure –prefix=/usr/local/bind
# make
# make install
装好bind后我们来制作named.conf
view “us” {
// 匹配北美的客户端 US & Canada
match-clients { country_US; country_CA; };
// Provide recursive service to internal clients only.
recursion no;
zone “cdn.xianglei.com” {
type master;
file “pri/xianglei-us.db”;
};
zone “.” IN {
type hint;
file “named.ca”;
};
};
view “latin” {
// 匹配到南美国家
match-clients { country_AR; country_CL; country_BR; };
recursion no;
zone “cdn.xianglei.com” {
type master;
file “pri/xianglei-latin.db”;
};
zone “.” IN {
type hint;
file “named.ca”;
};
};
照此办理，你也可以匹配到欧洲，非洲等等，然后来开始制作nginx和varnish
注意，以上内容是你要在主节点服务器上做的，主节点服务器只负责对DNS请求进行转发。
约定一下，我们将Bind服务器叫做动态节点服务器，Nginx+Varnish叫做边界服务器。
以下内容是副节点服务器需要做的，也就是实际在某个地区放置的服务器
# ./configure –prefix=/usr/local/nginx –with-http_realip_module
# make
# make install
并配置Nginx
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
upstream dynamic_node {
server 1.1.1.1:80; # 1.1.1.1 是主DNS节点的IP地址
}
server {
listen 8080;
server_name cdn.xianglei.net;
location ~* \.(gif|jpg|jpeg|png|wmv|avi|mpg|mpeg|mp4|htm|html|js|css|mp3|swf|ico|flv)$ {
proxy_set_header X-Real-IP $remote_addr;
proxy_pass http://dynamic_node;
proxy_store /var/www/cache$uri;
proxy_store_access user:rw group:rw all:r;
}
以上我们用nginx只对静态文件进行缓存，将静态文件缓存在/var/www/cache文件夹下，如果你没有的话，需要创建这个文件夹。并且nginx监听的是8080端口，这是因为，我们需要用varnish来监听80端口进行动态文件的转发。这里实际上是用nginx做了一个静态文件的反向代理和缓存的服务器，而真正让用户能够看到网页和动态文件的反向代理是varnish，而静态和动态文件的分开存放，能将效率提升不少。
最后我们来配置varnish服务。
# tar -xzvf varnish-2.1.2.tar.gz
# ./configure –prefix=/usr/local/varnish
# make
# make install
然后是varnish的选项
backend default {
.host = “127.0.0.1″;
.port = “8080″;
}
sub vcl_recv {
if (req.url ~ “\.(js|css|jpg|jpeg|png|gif|gz|tgz|bz2|tbz|mp3|ogg|swf)$”) {
return (lookup);
}
}
sub vcl_fetch {
if (req.url ~ “\.(js|css|jpg|jpeg|png|gif|gz|tgz|bz2|tbz|mp3|ogg|swf)$”) {
unset obj.http.set-cookie;
}
}
其他的配置内容可参看varnish的配置文章。
总结：
这样做的好处在于：
1.从根源上解决了DNS在轮询上的不确定性，能够做到在DNS上的快速响应。也避免了过去用Nginx+GeoIP时的负载高的问题。毕竟DNS的计算要比Nginx小多了。
2.降低大网站的服务器负载压力和运营成本，毕竟F5BigIP和双线路的价格和服务费都太高了。
3.易扩展性强，如某地区负载压力大，只需在该地区增加边界服务器组的web server即可完成，无需考虑跳转问题。

架构简介

前几天网友来信说帮忙实现这样一个架构：只有两台机器，需要实现其中一台死机之后另一台能接管这台机器的服务，并且在两台机器正常服务时，两台机器都能用上。于是设计了如下的架构。

此架构主要是由keepalived实现双机高可用，维护了一个外网VIP,一个内网VIP。正常情况时，外网VIP和内网VIP都绑定在server1服务器，web请求发送到server1的nginx，nginx对于静态资源请求就直接在本机检索并返回，对于php的动态请求，则负载均衡到server1和server2。对于SQL请求，会将此类请求发送到Atlas MySQL中间件，Atlas接收到请求之后，把涉及写操作的请求发送到内网VIP，读请求操作发送到mysql从，这样就实现了读写分离。

当主服务器server1宕机时，keepalived检测到后，立即把外网VIP和内网VIP绑定到server2，并把server2的mysql切换成主库。此时由于外网VIP已经转移到了server2，web请求将发送给server2的nginx。nginx检测到server1宕机，不再把请求转发到server1的php-fpm。之后的sql请求照常发送给本地的atlas，atlas把写操作发送给内网VIP，读操作发送给mysql从，由于内网VIP已经绑定到server2了，server2的mysql同时接受写操作和读操作。

当主服务器server1恢复后，server1的mysql自动设置为从，与server2的mysql主同步。keepalived不抢占server2的VIP，继续正常服务。

架构要求

要实现此架构，需要三个条件：
1、服务器可以设置内网IP，并且设置的内网IP互通;
2、服务器可以随意绑定IDC分配给我们使用的外网IP，即外网IP没有绑定MAC地址;
3、MySQL服务器支持GTID，即MySQL-5.6.5以上版本。

环境说明

server1
eth0: 10.96.153.110(对外IP)
eth1: 192.168.1.100(对内IP)
server2
eth0: 10.96.153.114(对外IP)
eth1: 192.168.1.101(对内IP)
系统都是CentOS-6。

对外VIP: 10.96.153.239
对内VIP: 192.168.1.150

hosts设置

/etc/hosts:
192.168.1.100 server1
192.168.1.101 server2

Nginx PHP MySQL Memcached安装

这几个软件的安装推荐使用EZHTTP来完成。

解决session共享问题

php默认的session存储是在/tmp目录下，现在我们是用两台服务器作php请求的负载，这样会造成session分布在两台服务器的/tmp目录下，导致依赖于session的功能不正常。我们可以使用memcached来解决此问题。
上一步我们已经安装好了memcached，现在只需要配置php.ini来使用memcached，配置如下，打开php.ini配置文件，修改为如下两行的值：
session.save_handler = memcache
session.save_path = “tcp://192.168.1.100:11211,tcp://192.168.1.101:11211″
之后重启php-fpm生效。

Nginx配置

Server1配置
http {
[...]
upstream php-server {
server 192.168.1.101:9000;
server 127.0.0.1:9000;
keepalive 100;
}
[...]
server {
[...]
location ~ \.php$ {
fastcgi_pass php-server;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
[...]
}
[...]
}

Server2配置
http {
[...]
upstream php-server {
server 192.168.1.100:9000;
server 127.0.0.1:9000;
keepalive 100;
}
[...]
server {
[...]
location ~ \.php$ {
fastcgi_pass php-server;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
[...]
}
[...]
}
这两个配置主要的作用是设置php请求的负载均衡。

MySQL配置

mysql util安装
我们需要安装mysql util里的主从配置工具来实现主从切换。
cd /tmp
wget http://dev.mysql.com/get/Downloads/MySQLGUITools/mysql-utilities-1.5.3.tar.gz
tar xzf mysql-utilities-1.5.3.tar.gz
cd mysql-utilities-1.5.3
python setup.py build
python setup.py install

mysql my.cnf配置
server1:
[mysql]
[...]
protocol=tcp
[...]
[...]
[mysqld]
[...]
# BINARY LOGGING #
log-bin = /usr/local/mysql/data/mysql-bin
expire-logs-days = 14
binlog-format= row
log-slave-updates=true
gtid-mode=on
enforce-gtid-consistency =true
master-info-repository=TABLE
relay-log-info-repository=TABLE
server-id=1
report-host=server1
report-port=3306
[...]
server2:
[mysql]
[...]
protocol=tcp
[...]
[mysqld]
[...]
# BINARY LOGGING #
log-bin = /usr/local/mysql/data/mysql-bin
expire-logs-days = 14
binlog-format= row
log-slave-updates=true
gtid-mode=on
enforce-gtid-consistency =true
master-info-repository=TABLE
relay-log-info-repository=TABLE
server-id=2
report-host=server2
report-port=3306
[...]
这两个配置主要是设置了binlog和启用gtid-mode，并且需要设置不同的server-id和report-host。

开放root帐号远程权限
我们需要在两台mysql服务器设置root帐号远程访问权限。
mysql> grant all on *.* to ‘root’@’192.168.1.%’ identified by ‘Xp29at5F37′ with grant option;
mysql> grant all on *.* to ‘root’@'server1′ identified by ‘Xp29at5F37′ with grant option;
mysql> grant all on *.* to ‘root’@'server2′ identified by ‘Xp29at5F37′ with grant option;
mysql> flush privileges;

设置mysql主从
在任意一台执行如下命令：
mysqlreplicate –master=root:Xp29at5F37@server1:3306 –slave=root:Xp29at5F37@server2:3306 –rpl-user=rpl:o67DhtaW
# master on server1: … connected.
# slave on server2: … connected.
# Checking for binary logging on master…
# Setting up replication…
# …done.

显示主从关系
mysqlrplshow –master=root:Xp29at5F37@server1 –discover-slaves-login=root:Xp29at5F37
# master on server1: … connected.
# Finding slaves for master: server1:3306
# Replication Topology Graph
server1:3306 (MASTER)
|
+— server2:3306 – (SLAVE)

检查主从状态
mysqlrplcheck –master=root:Xp29at5F37@server1 –slave=root:Xp29at5F37@server2
# master on server1: … connected.
# slave on server2: … connected.
Test Description Status
—————————————————————————
Checking for binary logging on master [pass]
Are there binlog exceptions? [pass]
Replication user exists? [pass]
Checking server_id values [pass]
Checking server_uuid values [pass]
Is slave connected to master? [pass]
Check master information file [pass]
Checking InnoDB compatibility [pass]
Checking storage engines compatibility [pass]
Checking lower_case_table_names settings [pass]
Checking slave delay (seconds behind master) [pass]
# …done.

Keepalived配置

keepalived安装(两台都装)
yum -y install keepalived
chkconfig keepalived on

keepalived配置(server1)
vi /etc/keepalived/keepalived.conf
vrrp_sync_group VG_1 {
group {
inside_network
outside_network
}
}

vrrp_instance inside_network {
state BACKUP
interface eth1
virtual_router_id 51
priority 101
advert_int 1
authentication {
auth_type PASS
auth_pass 3489
}
virtual_ipaddress {
192.168.1.150/24
}
nopreempt
notify /data/sh/mysqlfailover-server1.sh
}

vrrp_instance outside_network {
state BACKUP
interface eth0
virtual_router_id 50
priority 101
advert_int 1
authentication {
auth_type PASS
auth_pass 3489
}
virtual_ipaddress {
10.96.153.239/24
}
nopreempt
}

keepalived配置(server2)
vrrp_sync_group VG_1 {
group {
inside_network
outside_network
}
}

vrrp_instance inside_network {
state BACKUP
interface eth1
virtual_router_id 51
priority 100
advert_int 1
authentication {
auth_type PASS
auth_pass 3489
}
virtual_ipaddress {
192.168.1.150
}
notify /data/sh/mysqlfailover-server2.sh
}

vrrp_instance outside_network {
state BACKUP
interface eth0
virtual_router_id 50
priority 100
advert_int 1
authentication {
auth_type PASS
auth_pass 3489
}
virtual_ipaddress {
10.96.153.239/24
}
}
此keepalived配置需要注意的是：
1、两台server的state都设置为backup，server1增加nopreempt配置，并且server1 priority比server2高，这样用来实现当server1从宕机恢复时，不抢占VIP;
2、server1设置notify /data/sh/mysqlfailover-server1.sh,server2设置notify /data/sh/mysqlfailover-server2.sh,作用是自动切换主从
/data/sh/mysqlfailover-server1.sh脚本内容：
#!/bin/bash

sleep 10
state=$3
result=`mysql -h127.0.0.1 -P3308 -uroot -pXp29at5F37 -e ‘show slave status;’`
[[ "$result" == "" ]] && mysqlState=”master” || mysqlState=”slave”

if [[ "$state" == "MASTER" ]];then
if [[ "$mysqlState" == "slave" ]];then
mysqlrpladmin –slave=root:Xp29at5F37@server1:3308 failover
fi

elif [[ "$state" == "BACKUP" ]];then
if [[ "$mysqlState" == "master" ]];then
mysqlreplicate –master=root:Xp29at5F37@server2:3308 –slave=root:Xp29at5F37@server1:3308 –rpl-user=rpl:o67DhtaW
fi
fi

sed -i ‘s/proxy-read-only-backend-addresses.*/proxy-read-only-backend-addresses = 192.168.1.150:3308/’ /usr/local/mysql-proxy/conf/my.cnf
mysql -h127.0.0.1 -P2345 -uuser -ppwd -e “REMOVE BACKEND 2;”
/data/sh/mysqlfailover-server2.sh脚本内容：
#!/bin/bash

sleep 10
state=$3
result=`mysql -h127.0.0.1 -P3308 -uroot -pXp29at5F37 -e ‘show slave status;’`
[[ "$result" == "" ]] && mysqlState=”master” || mysqlState=”slave”

if [[ "$state" == "MASTER" ]];then
if [[ "$mysqlState" == "slave" ]];then
mysqlrpladmin –slave=root:Xp29at5F37@server2:3308 failover
fi

elif [[ "$state" == "BACKUP" ]];then
if [[ "$mysqlState" == "master" ]];then
mysqlreplicate –master=root:Xp29at5F37@server1:3308 –slave=root:Xp29at5F37@server2:3308 –rpl-user=rpl:o67DhtaW
fi
fi

sed -i ‘s/proxy-read-only-backend-addresses.*/proxy-read-only-backend-addresses = 192.168.1.150:3308/’ /usr/local/mysql-proxy/conf/my.cnf
mysql -h127.0.0.1 -P2345 -uuser -ppwd -e “REMOVE BACKEND 2;”

Atlas设置

atlas安装
到这里下载最新版本，https://github.com/Qihoo360/Atlas/releases
cd /tmp
wget https://github.com/Qihoo360/Atlas/releases/download/2.2.1/Atlas-2.2.1.el6.x86_64.rpm
rpm -i Atlas-2.2.1.el6.x86_64.rpm

atlas配置
cd /usr/local/mysql-proxy/conf
cp test.cnf my.cnf
vi my.cnf
调整如下参数，
proxy-backend-addresses = 192.168.1.150:3306
proxy-read-only-backend-addresses = 192.168.1.101:3306
pwds = root:qtyU1btXOo074Itvx0UR9Q==
event-threads = 8
注意：
proxy-backend-addresse设置为内网VIP
proxy-read-only-backend-addresses设置为server2的IP
root:qtyU1btXOo074Itvx0UR9Q==设置数据库的用户和密码，密码是通过/usr/local/mysql-proxy/bin/encrypt Xp29at5F37生成。
更详细参数解释请查看，Atlas配置详解。

启动atlas
/usr/local/mysql-proxy/bin/mysql-proxy –defaults-file=/usr/local/mysql-proxy/conf/my.cnf
之后程序里配置mysql就配置127.0.0.1:1234就好。

部署atlas自动维护脚本
在两台机器都部署此脚本，并添加定时任务（如每2分钟运行一次）我们把脚本放在/data/sh/auto_maintain_atlas.sh,脚本内容为：
#!/bin/bash

count=`mysql -N -h127.0.0.1 -P2345 -uuser -ppwd -e “select * from backends;” | wc -l`

if [[ "$count" == "1" ]];then
result=`mysql -hserver1 -P3308 -uroot -pXp29at5F37 -e ‘show slave status\G’`
if echo “$result” | grep Slave_IO_State;then
slaveIP=192.168.1.100
else
result=`mysql -hserver2 -P3308 -uroot -pXp29at5F37 -e ‘show slave status\G’`
slaveIP=192.168.1.101
fi

slaveIORunning=`echo “$result” | awk -F’:’ ‘/Slave_IO_Running:/{print $2}’`
slaveSQLRunning=`echo “$result” | awk -F’:’ ‘/Slave_SQL_Running:/{print $2}’`
SlaveSQLRunning_State=`echo “$result” | awk -F’:’ ‘/Slave_SQL_Running_State:/{print $2}’`
if [[ "$slaveIORunning" =~ "Yes" && "$slaveSQLRunning" =~ "Yes" && "$SlaveSQLRunning_State" =~ "Slave has read all relay log" ]];then
mysql -h127.0.0.1 -P2345 -uuser -ppwd -e “add slave ${slaveIP}:3308;”
fi
fi
为什么需要这个脚本呢？假设目前mysql主服务器在s1,s1宕机后，s2接管VIP，接着删除atlas中设置的slave backend，其mysql提升为主。过一段时间后，s1从宕机中恢复，这时候s1的mysql自动切换为从，接着删除atlas中设置的slave backend，开始连接s2的mysql主同步数据。到这个时候我们发现，已经不存在读写分离了，所有的sql都发送给了s2的mysql。auto_maintain_atlas.sh脚本就派上用场了，此脚本会定时的检查主从是否已经同步完成，如果完成就自动增加slave backend，这样读写分离又恢复了，完全不需要人工干预。

server1主宕机测试

测试keepalived是否工作正常
我们来模拟server1宕机。
在server1上执行shutdown关机命令。
此时我们登录server2，执行ip addr命令，输出如下：
1: lo: mtu 16436 qdisc noqueue state UNKNOWN
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 00:0c:29:81:9d:42 brd ff:ff:ff:ff:ff:ff
inet 10.96.153.114/24 brd 10.96.153.255 scope global eth0
inet 10.96.153.239/24 scope global secondary eth0
inet6 fe80::20c:29ff:fe81:9d42/64 scope link
valid_lft forever preferred_lft forever
3: eth1: mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 00:0c:29:81:9d:4c brd ff:ff:ff:ff:ff:ff
inet 192.168.1.101/24 brd 192.168.1.255 scope global eth1
inet 192.168.1.150/32 scope global eth1
inet6 fe80::20c:29ff:fe81:9d4c/64 scope link
valid_lft forever preferred_lft forever
我们看到对外VIP 10.96.153.239和对内IP 192.168.1.150已经转移到server2了，证明keepalived运行正常。

测试是否自动切换了主从
登录server2的mysql服务器，执行show slave status;命令，如下：
mysql> show slave status\G
Empty set (0.00 sec)
我们发现从状态已经为空，证明已经切换为主了。

测试server1是否抢占VIP
为什么要测试这个呢？如果server1恢复之后抢占了VIP，而我们的Atlas里后端设置的是VIP，这样server1启动之后，sql的写操作就会向server1的mysql发送，而server1的mysql数据是旧于server2的，所以这样会造成数据不一致，这个是非常重要的测试。
我们先来启动server1，之后执行ip addr，输出如下：
1: lo: mtu 16436 qdisc noqueue state UNKNOWN
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 00:0c:29:f1:4f:4e brd ff:ff:ff:ff:ff:ff
inet 10.96.153.110/24 brd 10.96.153.255 scope global eth0
inet6 fe80::20c:29ff:fef1:4f4e/64 scope link
valid_lft forever preferred_lft forever
3: eth1: mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 00:0c:29:f1:4f:58 brd ff:ff:ff:ff:ff:ff
inet 192.168.1.100/24 brd 192.168.1.255 scope global eth1
inet6 fe80::20c:29ff:fef1:4f58/64 scope link
valid_lft forever preferred_lft forever
我们看到，server1并没有抢占VIP，测试正常。不过另人郁闷的是，在虚拟机的环境并没有测试成功，不知道为什么。

测试server2的atlas是否已经删除slave backend
我们测试这个是为了保证atlas已经没有slave backend，也就是没有从库的设置了，否则当server1恢复时，有可能会把读请求发送给server1的mysql，造成读取了旧数据的问题。

[root@server1 ~]# mysql -h127.0.0.1 -P2345 -uuser -ppwd
mysql> select * from backends;
+————-+——————–+——-+——+
| backend_ndx | address | state | type |
+————-+——————–+——-+——+
| 1 | 192.168.1.150:3308 | up | rw |
+————-+——————–+——-+——+
1 rows in set (0.00 sec)
如果看到只有一个后端，证明运作正常。

测试server1 mysql是否设置为从
serve1恢复后，登录server1的mysql服务器，执行show slave status;命令，如下：

mysql> show slave status\G
*************************** 1. row ***************************
Slave_IO_State: Opening tables
Master_Host: server1
Master_User: rpl
Master_Port: 3308
Connect_Retry: 60
Master_Log_File: mysql-bin.000015
Read_Master_Log_Pos: 48405991
Relay_Log_File: mysql-relay-bin.000002
Relay_Log_Pos: 361
Relay_Master_Log_File: mysql-bin.000015
Slave_IO_Running: Yes
Slave_SQL_Running: yes

测试是否自动恢复读写分离
server1恢复后一段时间，我们可以看是读写分离是否已经恢复。

[root@server1 ~]# mysql -h127.0.0.1 -P2345 -uuser -ppwd
Warning: Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 1
Server version: 5.0.99-agent-admin
Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the current input statement.
mysql> select * from backends;
+————-+——————–+——-+——+
| backend_ndx | address | state | type |
+————-+——————–+——-+——+
| 1 | 192.168.1.150:3308 | up | rw |
| 2 | 192.168.1.100:3308 | up | ro |
+————-+——————–+——-+——+
2 rows in set (0.00 sec)

我们看到server1已经被添加为slave backend了。这表示已经成功恢复读写分离。

eaccelerator.shm_size=”32″
eAccelerator 可以使用的共享内存的数量 (以兆为单位) . “0″ 是指操作系统的默认值. 默认值是 “0″.可根据服务器的实际情况来调整，16，32，64，128都是可以的。
eaccelerator.cache_dir=”/home/php/tmp”
这个目录是给磁盘缓存使用. eAccelerator 在这里储存预先编译好的代码, 进程数据, 内容以及用户的自定义内容. 同样的数据也能被储存在共享内存中 (这样可以提高访问速度). 默认的设置是 “/tmp/eaccelerator”.
eaccelerator.enable=”1″
开启或关闭 eAccelerator。”1″ 为开启，”0″ 为关闭。默认值为 “1″。
eaccelerator.optimizer=”1″
启或关闭内部优化器，可以提升代码执行速度。”1″ 为开启，”0″ 为关闭。默认值为 “1″。
eaccelerator.check_mtime=”1″
打开或者关闭 PHP 的文件修改检查. “1″ 是指打开, “0″ 是指关闭. 如果您在修改以后重新编译 PHP 的文件,那么您应当设置为 “1″. 默认值是 “1″.
eaccelerator.debug=”0″
开启或关闭调试日志记录。”1″ 为开启，”0″ 为关闭。默认值为 “0″。会将缓存命中得记录写入日志。
eaccelerator.filter=”"
判断哪些 PHP 文件必须缓存。您可以指定缓存和不缓存的文件类型（如 “*.php *.phtml”等）
如果参数以 “!” 开头，则匹配这些参数的文件被忽略缓存。默认值为 “”，即，所有 PHP 文件
都将被缓存。
eaccelerator.shm_max=”0″
当使用 ” eaccelerator_put() ” 函数时禁止其向共享内存中存储过大的文件。该参数指定允许
存储的最大值，单位：字节 (10240, 10K, 1M)。”0″ 为不限制。默认值为 “0″。
eaccelerator.shm_ttl=”0″
当 eAccelerator 获取新脚本的共享内存大小失败时，它将从共享内存中删除所有在
最后 “shm_ttl” 秒内没有存取的脚本缓存。默认值为 “0″，即：不从共享内春中删除
任何缓存文件。
eaccelerator.shm_prune_period=”0″
当 eAccelerator 获取新脚本的共享内存大小失败时，他将试图从共享内存中删除早于
“shm_prune_period” 秒的缓存脚本。默认值为 “0″，即：不从共享内春中删除
任何缓存文件。
eaccelerator.shm_only=”0″
允许或禁止将已编译脚本缓存在磁盘上。该选项对 session 数据和内容缓存无效。默认
值为 “0″，即：使用磁盘和共享内存进行缓存。
eaccelerator.compress=”1″
允许或禁止压缩内容缓存。默认值为 “1″，即：允许压缩。
eaccelerator.compress_level=”9″
指定内容缓存的压缩等级。默认值为 “9″，为最高等级。

注意：
nginx 1.1.8 之后的版本的语法改为limit_conn_zone $binary_remote_addr zone=NAME:10m;
NAME 就是 zone 的名字详情请看这里 http://nginx.org/en/docs/http/ngx_http_limit_conn_module.html

限制连接数:
要限制连接，必须先有一个容器对连接进行计数，在http段加入如下代码：
“zone=” 给它一个名字，可以随便叫，这个名字要跟下面的 limit_conn 一致
$binary_remote_addr = 用二进制来储存客户端的地址，1m 可以储存 32000 个并发会话

… 省掉 N 字
http
{
limit_conn_zone $binary_remote_addr zone=addr:10m;

接下来需要对server不同的位置（location段）进行限速，比如限制每个IP并发连接数为1，则
server
{
listen 80;
server_name 192.168.11.128;
index index.html index.htm index.php;
limit_conn addr 1; #是限制每个IP只能发起1个连接 （addr 要跟 limit_conn_zone 的变量对应）
limit_rate 100k; #限速为 100KB/秒
root html;

注意事项：
limit_rate 100k; //是对每个连接限速100k。这里是对连接限速，而不是对IP限速！如果一个IP允许两个并发连接，那么这个IP就是限速limit_rate * 2

配置方法如下：

1、在nginx.conf里的http{}里加上如下代码：
#ip limit
limit_conn_zone $binary_remote_addr zone=perip:10m;
limit_conn_zone $server_name zone=perserver:10m;

2、在需要限制并发数和下载带宽的网站配置server{}里加上如下代码：
limit_conn perip 2;
limit_conn perserver 20;
limit_rate 100k;

补充说明下参数：
$binary_remote_addr是限制同一客户端ip地址；
$server_name是限制同一server最大并发数；
limit_conn为限制并发连接数；
limit_rate为限制下载速度；

转另一篇文章：nginx 限速
注意：
nginx 1.1.8 之后的版本的语法改为limit_conn_zone $binary_remote_addr zone=NAME:10m;
NAME 就是 zone 的名字详情请看这里 http://nginx.org/en/docs/http/ngx_http_limit_conn_module.html

限制连接数:
要限制连接，必须先有一个容器对连接进行计数，在http段加入如下代码：
“zone=” 给它一个名字，可以随便叫，这个名字要跟下面的 limit_conn 一致
$binary_remote_addr = 用二进制来储存客户端的地址，1m 可以储存 32000 个并发会话

… 省掉 N 字
http
{
limit_conn_zone $binary_remote_addr zone=addr:10m;

接下来需要对server不同的位置（location段）进行限速，比如限制每个IP并发连接数为1，则
server
{
listen 80;
server_name 192.168.11.128;
index index.html index.htm index.php;
limit_conn addr 1; #是限制每个IP只能发起1个连接 （addr 要跟 limit_conn_zone 的变量对应）
limit_rate 100k; #限速为 100KB/秒
root html;

注意事项：
limit_rate 100k; //是对每个连接限速100k。这里是对连接限速，而不是对IP限速！如果一个IP允许两个并发连接，那么这个IP就是限速limit_rate * 2

如何设置能限制某个IP某一时间段的访问次数是一个让人头疼的问题，特别面对恶意的ddos攻击的时候。其中CC攻击（Challenge Collapsar）是DDOS（分布式拒绝服务）的一种，也是一种常见的网站攻击方法，攻击者通过代理服务器或者肉鸡向向受害主机不停地发大量数据包，造成对方服务器资源耗尽，一直到宕机崩溃。

cc攻击一般就是使用有限的ip数对服务器频繁发送数据来达到攻击的目的，nginx可以通过HttpLimitReqModul和HttpLimitZoneModule配置来限制ip在同一时间段的访问次数来防cc攻击。

HttpLimitReqModul用来限制连单位时间内连接数的模块，使用limit_req_zone和limit_req指令配合使用来达到限制。一旦并发连接超过指定数量，就会返回503错误。

HttpLimitConnModul用来限制单个ip的并发连接数，使用limit_zone和limit_conn指令

这两个模块的区别前一个是对一段时间内的连接数限制，后者是对同一时刻的连接数限制。

1 HttpLimitReqModul 限制某一段时间内同一ip访问数实例
2 HttpLimitZoneModule 限制并发连接数实例
3 nginx白名单设置

HttpLimitReqModul 限制某一段时间内同一ip访问数实例
http{
…

#定义一个名为allips的limit_req_zone用来存储session，大小是10M内存，
#以$binary_remote_addr 为key,限制平均每秒的请求为20个，
#1M能存储16000个状态，rete的值必须为整数，
#如果限制两秒钟一个请求，可以设置成30r/m

limit_req_zone $binary_remote_addr zone=allips:10m rate=20r/s;
…
server{
…
location {
…

#限制每ip每秒不超过20个请求，漏桶数burst为5
#brust的意思就是，如果第1秒、2,3,4秒请求为19个，
#第5秒的请求为25个是被允许的。
#但是如果你第1秒就25个请求，第2秒超过20的请求返回503错误。
#nodelay，如果不设置该选项，严格使用平均速率限制请求数，
#第1秒25个请求时，5个请求放到第2秒执行，
#设置nodelay，25个请求将在第1秒执行。

limit_req zone=allips burst=5 nodelay;
…
}
…
}
…
}

HttpLimitZoneModule 限制并发连接数实例
limit_zone只能定义在http作用域，limit_conn可以定义在http server location作用域

http{
…

#定义一个名为one的limit_zone,大小10M内存来存储session，
#以$binary_remote_addr 为key
#nginx 1.18以后用limit_conn_zone替换了limit_conn
#且只能放在http作用域
limit_conn_zone one $binary_remote_addr 10m;
…
server{
…
location {
…
limit_conn one 20; #连接数限制

#带宽限制,对单个连接限数，如果一个ip两个连接，就是500x2k
limit_rate 500k;

…
}
…
}
…
}

nginx白名单设置
以上配置会对所有的ip都进行限制，有些时候我们不希望对搜索引擎的蜘蛛或者自己测试ip进行限制，
对于特定的白名单ip我们可以借助geo指令实现。
1.

http{
geo $limited{
default 1;
#google
64.233.160.0/19 0;
65.52.0.0/14 0;
66.102.0.0/20 0;
66.249.64.0/19 0;
72.14.192.0/18 0;
74.125.0.0/16 0;
209.85.128.0/17 0;
216.239.32.0/19 0;
#M$
64.4.0.0/18 0;
157.60.0.0/16 0;
157.54.0.0/15 0;
157.56.0.0/14 0;
207.46.0.0/16 0;
207.68.192.0/20 0;
207.68.128.0/18 0;
#yahoo
8.12.144.0/24 0;
66.196.64.0/18 0;
66.228.160.0/19 0;
67.195.0.0/16 0;
74.6.0.0/16 0;
68.142.192.0/18 0;
72.30.0.0/16 0;
209.191.64.0/18 0;
#My IPs
127.0.0.1/32 0;
123.456.0.0/28 0; #example for your server CIDR
}
geo指令定义了一个白名单$limited变量，默认值为1，如果客户端ip在上面的范围内，$limited的值为0

2.使用map指令映射搜索引擎客户端的ip为空串，如果不是搜索引擎就显示本身真是的ip，这样搜索引擎ip就不能存到limit_req_zone内存session中，所以不会限制搜索引擎的ip访问

map $limited $limit {
1 $binary_remote_addr;
0 “”;
}

3.设置limit_req_zone和limit_req
limit_req_zone $limit zone=foo:1m rate=10r/m;

limit_req zone=foo burst=5;

最后我们使用ab压php-fpm的方式，对上面的方法效果实际测试下

例1：限制只允许一分钟内只允许一个ip访问60次配置，也就是平均每秒1次
首先我们准备一个php脚本放在根目录下$document_root
test.php

nginx配置增加limit_req_zone 和 limit_req

http{
…
limit_req_zone $binary_remote_addr zone=allips:10m rate=60r/m;
…
server{
…
location {
…
limit_req zone=allips;
…
}
…
}
…
}
ab -n 5 -c 1 http://www.weizhang.org/test.php

118.144.94.193 – - [22/Dec/2012:06:27:06 +0000] “GET /test.php HTTP/1.0″ 200 11000 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:06:27:06 +0000] “GET /test.php HTTP/1.0″ 503 537 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:06:27:07 +0000] “GET /test.php HTTP/1.0″ 503 537 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:06:27:07 +0000] “GET /test.php HTTP/1.0″ 503 537 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:06:27:07 +0000] “GET /test.php HTTP/1.0″ 503 537 “-” “ApacheBench/2.3″

未设置brust和nodelay可以看到该配置只允许每秒访问1次，超出的请求返回503错误

http{
…
limit_req_zone $binary_remote_addr zone=allips:10m rate=60r/m;
…
server{
…
location {
…
limit_req zone=allips burst=1 nodelay;
…
}
…
}
…
}
ab -n 5 -c 1 http://www.weizhang.org/test.php

118.144.94.193 – - [22/Dec/2012:07:01:00 +0000] “GET /test.php HTTP/1.0″ 200 11000 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:07:01:00 +0000] “GET /test.php HTTP/1.0″ 200 11000 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:07:01:01 +0000] “GET /test.php HTTP/1.0″ 503 537 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:07:01:01 +0000] “GET /test.php HTTP/1.0″ 503 537 “-” “ApacheBench/2.3″
118.144.94.193 – - [22/Dec/2012:07:01:01 +0000] “GET /test.php HTTP/1.0″ 503 537 “-” “ApacheBench/2.3″

设置brust=1和nodelay后允许第1秒处理两个请求。

大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必须更深入一些。在本指南中，我将解释Nginx的那些设置可以微调，以优化处理大量客户端时的性能。需要注意一点，这不是一个全面的微调指南。这是一个简单的预览——那些可以通过微调来提高性能设置的概述。你的情况可能不同。

基本的 (优化过的)配置

我们将修改的唯一文件是nginx.conf，其中包含Nginx不同模块的所有设置。你应该能够在服务器的/etc/nginx目录中找到nginx.conf。首先，我们将谈论一些全局设置，然后按文件中的模块挨个来，谈一下哪些设置能够让你在大量客户端访问时拥有良好的性能，为什么它们会提高性能。本文的结尾有一个完整的配置文件。

高层的配置

nginx.conf文件中，Nginx中有少数的几个高级配置在模块部分之上。

1. user www-data;
2. pid /var/run/nginx.pid;
3. worker_processes auto; 
4. worker_rlimit_nofile 100000; 

user和pid应该按默认设置 – 我们不会更改这些内容，因为更改与否没有什么不同。

worker_processes 定义了nginx对外提供web服务时的worker进程数。最优值取决于许多因素，包括（但不限于）CPU核的数量、存储数据的硬盘数量及负载模式。不能确定的时候，将其设置为可用的CPU内核数将是一个好的开始（设置为“auto”将尝试自动检测它）。

worker_rlimit_nofile 更改worker进程的最大打开文件数限制。如果没设置的话，这个值为操作系统的限制。设置后你的操作系统和Nginx可以处理比“ulimit -a”更多的文件，所以把这个值设高，这样nginx就不会有“too many open files”问题了。

Events模块

events模块中包含nginx中所有处理连接的设置。

1. events {
2. worker_connections 2048; 
3. multi_accept on;
4. use epoll; 
5. }

worker_connections 设置可由一个worker进程同时打开的最大连接数。如果设置了上面提到的worker_rlimit_nofile，我们可以将这个值设得很高。

记住，最大客户数也由系统的可用socket连接数限制（~ 64K），所以设置不切实际的高没什么好处。

multi_accept 告诉nginx收到一个新连接通知后接受尽可能多的连接。

use 设置用于复用客户端线程的轮询方法。如果你使用Linux 2.6+，你应该使用epoll。如果你使用*BSD，你应该使用kqueue。

（值得注意的是如果你不知道Nginx该使用哪种轮询方法的话，它会选择一个最适合你操作系统的）

HTTP 模块

HTTP模块控制着nginx http处理的所有核心特性。因为这里只有很少的配置，所以我们只节选配置的一小部分。所有这些设置都应该在http模块中，甚至你不会特别的注意到这段设置。

1. http {
2. server_tokens off;
3. sendfile on;
4. tcp_nopush on;
5. tcp_nodelay on;
6. …
7. }

server_tokens  并不会让nginx执行的速度更快，但它可以关闭在错误页面中的nginx版本数字，这样对于安全性是有好处的。

sendfile 可以让sendfile()发挥作用。sendfile()可以在磁盘和TCP socket之间互相拷贝数据(或任意两个文件描述符)。Pre-sendfile是传送数据之前在用户空间申请数据缓冲区。之后用read()将数据从文件拷贝到这个缓冲区，write()将缓冲区数据写入网络。sendfile()是立即将数据从磁盘读到OS缓存。因为这种拷贝是在内核完成的，sendfile()要比组合read()和write()以及打开关闭丢弃缓冲更加有效(更多有关于sendfile)。

tcp_nopush 告诉nginx在一个数据包里发送所有头文件，而不一个接一个的发送。

tcp_nodelay 告诉nginx不要缓存数据，而是一段一段的发送–当需要及时发送数据时，就应该给应用设置这个属性，这样发送一小块数据信息时就不能立即得到返回值。

1. access_log off;
2. error_log /var/log/nginx/error.log crit;

access_log 设置nginx是否将存储访问日志。关闭这个选项可以让读取磁盘IO操作更快(aka,YOLO)

error_log 告诉nginx只能记录严重的错误：

1. keepalive_timeout 10;
2. client_header_timeout 10;
3. client_body_timeout 10;
4. reset_timedout_connection on;
5. send_timeout 10;

keepalive_timeout  给客户端分配keep-alive链接超时时间。服务器将在这个超时时间过后关闭链接。我们将它设置低些可以让ngnix持续工作的时间更长。

client_header_timeout 和client_body_timeout 设置请求头和请求体(各自)的超时时间。我们也可以把这个设置低些。

reset_timeout_connection 告诉nginx关闭不响应的客户端连接。这将会释放那个客户端所占有的内存空间。

send_timeout 指定客户端的响应超时时间。这个设置不会用于整个转发器，而是在两次客户端读取操作之间。如果在这段时间内，客户端没有读取任何数据，nginx就会关闭连接。

1. limit_conn_zone $binary_remote_addr zone=addr:5m;
2. limit_conn addr 100;

limit_conn_zone 设置用于保存各种key（比如当前连接数）的共享内存的参数。5m就是5兆字节，这个值应该被设置的足够大以存储（32K*5）32byte状态或者（16K*5）64byte状态。

limit_conn 为给定的key设置最大连接数。这里key是addr，我们设置的值是100，也就是说我们允许每一个IP地址最多同时打开有100个连接。

1. include /etc/nginx/mime.types;
2. default_type text/html;
3. charset UTF-8;

include 只是一个在当前文件中包含另一个文件内容的指令。这里我们使用它来加载稍后会用到的一系列的MIME类型。

default_type 设置文件使用的默认的MIME-type。

charset 设置我们的头文件中的默认的字符集

1. gzip on;
2. gzip_disable ”msie6″;
3. # gzip_static on;
4. gzip_proxied any;
5. gzip_min_length 1000;
6. gzip_comp_level 4;
7. gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

gzip 是告诉nginx采用gzip压缩的形式发送数据。这将会减少我们发送的数据量。

gzip_disable 为指定的客户端禁用gzip功能。我们设置成IE6或者更低版本以使我们的方案能够广泛兼容。

gzip_static 告诉nginx在压缩资源之前，先查找是否有预先gzip处理过的资源。这要求你预先压缩你的文件（在这个例子中被注释掉了），从而允许你使用最高压缩比，这样nginx就不用再压缩这些文件了（想要更详尽的gzip_static的信息，请点击这里）。

gzip_proxied 允许或者禁止压缩基于请求和响应的响应流。我们设置为any，意味着将会压缩所有的请求。

gzip_min_length 设置对数据启用压缩的最少字节数。如果一个请求小于1000字节，我们最好不要压缩它，因为压缩这些小的数据会降低处理此请求的所有进程的速度。

gzip_comp_level 设置数据的压缩等级。这个等级可以是1-9之间的任意数值，9是最慢但是压缩比最大的。我们设置为4，这是一个比较折中的设置。

gzip_type 设置需要压缩的数据格式。上面例子中已经有一些了，你也可以再添加更多的格式。

1. # cache informations about file descriptors, frequently accessed files
2. # can boost performance, but you need to test those values
3. open_file_cache max=100000 inactive=20s;
4. open_file_cache_valid 30s;
5. open_file_cache_min_uses 2;
6. open_file_cache_errors on;
7. ##
8. # Virtual Host Configs
9. # aka our settings for specific servers
10. ##
11. include /etc/nginx/conf.d/*.conf;
12. include /etc/nginx/sites-enabled/*;

open_file_cache 打开缓存的同时也指定了缓存最大数目，以及缓存的时间。我们可以设置一个相对高的最大时间，这样我们可以在它们不活动超过20秒后清除掉。

open_file_cache_valid 在open_file_cache中指定检测正确信息的间隔时间。

open_file_cache_min_uses 定义了open_file_cache中指令参数不活动时间期间里最小的文件数。

open_file_cache_errors 指定了当搜索一个文件时是否缓存错误信息，也包括再次给配置中添加文件。我们也包括了服务器模块，这些是在不同文件中定义的。如果你的服务器模块不在这些位置，你就得修改这一行来指定正确的位置。

一个完整的配置

1. user www-data;
2. pid /var/run/nginx.pid;
3. worker_processes auto;
4. worker_rlimit_nofile 100000;
5. events {
6. worker_connections 2048;
7. multi_accept on;
8. use epoll;
9. }
10. http {
11. server_tokens off;
12. sendfile on;
13. tcp_nopush on;
14. tcp_nodelay on;
15. access_log off;
16. error_log /var/log/nginx/error.log crit;
17. keepalive_timeout 10;
18. client_header_timeout 10;
19. client_body_timeout 10;
20. reset_timedout_connection on;
21. send_timeout 10;
22. limit_conn_zone $binary_remote_addr zone=addr:5m;
23. limit_conn addr 100;
24. include /etc/nginx/mime.types;
25. default_type text/html;
26. charset UTF-8;
27. gzip on;
28. gzip_disable ”msie6″;
29. gzip_proxied any;
30. gzip_min_length 1000;
31. gzip_comp_level 6;
32. gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
33. open_file_cache max=100000 inactive=20s;
34. open_file_cache_valid 30s;
35. open_file_cache_min_uses 2;
36. open_file_cache_errors on;
37. include /etc/nginx/conf.d/*.conf;
38. include /etc/nginx/sites-enabled/*;
39. }

编辑完配置后，确认重启nginx使设置生效。

1. sudo service nginx restart