运维部落

宝塔等Nginx环境添加允许跨域Header头

我已宝塔面板为例:
点击站点修改
点击配置文件
在 39 行下面添加
add_header ‘Access-Control-Allow-Origin’ ‘*’;
add_header ‘Access-Control-Allow-Credentials’ ‘true’;
add_header ‘Access-Control-Allow-Methods’ ‘GET, POST, OPTIONS’;
然后重启 nginx.
下面是通用 nginx 添加允许跨域header头

使用ngx_http_headers_module中的add_header指令，在响应头中添加允许跨域。

Syntax: add_header name value [always];
Default: —
Context: http, server, location, if in location
一般地，我们把允许跨域的头加在动态接口后面，比如 php，就加在解析 php 后面

add_header Access-Control-Allow-Origin *;
add_header Access-Control-Allow-Headers X-Requested-With;
add_header Access-Control-Allow-Methods GET,POST;
注意，在实际中 Allow-Origin 不要指定为*，要设置为允许访问的域名，比如 http://abc.com

宝塔面板很好用。大家都知道不过有些默认的选择项目也给大家说一下。

宝塔面板ip地址默认访问页在此目录下(默认安装的是NMP环境就在如下路径中)
/www/server/nginx/html/

删除掉index.html或是改名不就可以不用出现访问ip地址时的尴尬了。因为别人一看就知道你是哪个面板了。

Nginx/LVS/HAProxy的基于Linux的开源免费的负载均衡软件。

LVS：使用集群技术和Linux操作系统实现一个高性能、高可用的服务器，它具有很好的可伸缩性、可靠性和可管理性，是一款强大实用的开源软件。

LVS的优点：

1：抗负载能力强、是工作在网络4层之上仅作分发之用，没有流量的产生，这个特点也决定了它在负载均衡软件里的性能最强的，也保证了均衡器I/O的性能不会受到大流量的影响。；
2：lvs是专门的负载均衡软件，对任何应用都可以做负载均衡；
3：工作稳定，因为其本身抗负载能力很强，自身有完整的双机热备方案，目前用的比较多的是lvs+keepalived，比较大型的用的多的是lvs+heartbeat。

nginx的优点：

1：Nginx的高并发，同时能承载上万个并发连接；
2：nginx有充足的第三方功能模块的支持，主要通过upstream模块进行负载均衡；
3：nginx对网络的依赖较小，理论上只要Ping得通，网页访问正常，nginx就能连得通；
4：工作在网络的7层之上，可以针对http应用做一些分流的策略，它的正则规则比haproxy更为强大和灵活，这也是它目前广泛流行的主要原因之一，nginx单凭这点可利用的场合就远多于lvs了。

nginx的缺点：

1：将Nginx当做反向代理时，负载均衡功能不是很好，对后端服务器的健康检查功能较弱；
2：nginx仅能支持http、https和email协议，这样就在适用范围上面小些，这个是它的缺点；
3：nginx只支持通过端口来检测，不支持通过url来检测。

haproxy的优点：

1：HAProxy的优点能够补充Nginx的一些缺点，比如支持Session的保持，Cookie的引导；同时支持通过获取指定的url来检测后端服务器的状态；
2：haproxy也是专门的负载均衡软件，Haproxy可以负载http，还可以负载均衡mysql；
3：HAProxy是支持虚拟主机的。

总结这么多，我觉得根据不同的需求，不同的功能，可以选择不同的软件类的负载均衡软件，当然也是可以选择硬件类的负载均衡器。
像对于大型的，需要进行高并发的网站或者对网络不太严格的时候，可以使用nginx；
对于大型的Web服务器的时候可以使用haproxy；
对性能有严格要求的时候可以使用lvs，就单纯从负载均衡的角度来说，lvs也许会成为主流，更适合现在大型的互联网公司。

准备一台linux服务器。nginx官网：http://nginx.org/ 。在网上搜到大致用的是 ngx_stream_core_module 这个模块，这里你也可以关注一下官方文档中的其他模块都是做什么的，那么这有相关的启用配置说明，与示例配置。

第一句便是：该ngx_stream_core_module模块是自1.9.0版本。此模块不是默认构建的，应使用配置参数启用 –with-stream 。

那好吧，我们就安装nginx，搞这个的，安装应该都会吧。

1
2

[root@localhost /]# cd /usr/local/src
[root@localhost src]# wget http://nginx.org/download/nginx-1.11.10.tar.gz

然后解压，解压完，根据文档提示需要使用这个参数–with-stream 来启用功能。

1

[root@localhost src]# ./configure  --prefix=/usr/local/nginx --with-stream

然后，make，make install。

完成之后就是nginx配置配置文件啦，这个文档中有示例，可知与events模块平级，按照这做就好啦。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

user  nobody;
worker_processes  auto;
error_log  logs/error.log  info;
 
pid        logs/nginx.pid;
 
events {
    worker_connections  1024;
}
stream {
    upstream dns_upstreams {
        server 120.79.11.11:53;
        server 177.1.22.1:53;
    }
    server {
        listen 53 udp;
        proxy_pass dns_upstreams;
        proxy_connect_timeout 1s;
        proxy_timeout 5s;
    }
}

toa模块是为了让后端的realserver能够看到真实的clientip而不是lvs的dip。
1、下载http://kb.linuxvirtualserver.org … 86_64.rs.src.tar.gz
2、解压
3、编辑.config，将CONFIG_IPV6=M改成CONFIG_IPV6=y
测试的时候发现如果不改会遇到报错，可以看下这个帖子：http://bbs.linuxtone.org/forum.p … 1631&pid=111599
4、编辑Makefile，可以在EXTRAVERSION =处加上自定义的一些说明，将会在uname -r中显示。比如-shanks.e11.x86_64
5、make -jn
6、make modules_install
7、make install
8、修改/boot/grub/grub.conf     用第一个内核启动
9、reboot
10、装个nginx，试试看能不能看见真实的clientip。
参考：http://kb.linuxvirtualserver.org/wiki/IPVS_FULLNAT_and_SYNPROXY

在给nginx 配置了一个超长的域名后，通过 /usr/local/nginx/sbin/ngnix -t 检查配置文件时出现一下错误：
. 代码如下:
could not build the server_names_hash, you should increase server_names_hash_bucket_size: 32

解决办法是在nginx的配置文件的http段中增加如下配置：
. 代码如下:
server_names_hash_bucket_size 64;

如果已经存在，需要加大后面的数值，注意：该数值是32的倍数为宜。
下面是nginx官方文档：
. 代码如下:
如果定义了大量名字，或者定义了非常长的名字，那可能需要在http配置块中使用server_names_hash_max_size和server_names_hash_bucket_size指令进行调整。server_names_hash_bucket_size的默认值可能是32，或者是64，或者是其他值，取决于CPU的缓存行的长度。如果这个值是32，那么定义“too.long.server.name.example.org”作为虚拟主机名就会失败，而nginx显示下面错误信息：
could not build the server_names_hash,
you should increase server_names_hash_bucket_size: 32
出现了这种情况，那就需要将指令的值扩大一倍：
http {
server_names_hash_bucket_size 64;
…
如果定义了大量名字，得到了另外一个错误：
could not build the server_names_hash,
you should increase either server_names_hash_max_size: 512
or server_names_hash_bucket_size: 32
那么应该先尝试设置server_names_hash_max_size的值差不多等于名字列表的名字总量。如果还不能解决问题，或者服务器启动非常缓慢，再尝试提高server_names_hash_bucket_size的值。

如何用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了。这表示已经成功恢复读写分离。

注意：
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