搭建高可用的WEB群集

web高可用，其中服务包括（Nginx,PHP,MySQL,Memcached,zabbix,keepalived以及Xcahce插件等;

其中包含：       

       Nginx (Nginx的安装及Nginx反向代理配置，对Nginx进行优化)

       PHP（对PHP进行安装，及使用Xcache来加速php服务）

       MySQL（对Mysql进行安装，Mysql调优，Mysql主主同步，使用memcached+mysql实现高性能使用）

       使用keepalived对Nginx缓存服务进行高可用，防止单点故障等;

       在安装LNMP环境时掌握分离部署的搭建；对LNMP编写一键安装脚本等等....

其实我为什么想写这篇文章，也就是我目前博客大部分的知识也都概括了，有web服务，mysql数据库，负载均衡，缓存，高可用，以及监控等等。。所以我想结合在一起做成一个小架构~ 

经过我的整理，大致的拓扑图如下：

这里目前一共是有13台机器，大致的IP地址分类如下：

客户端-windows10x86_64

Linux环境-Centos7.2x86_64

Nginx-keepavlied-masterIP地址：192.168.1.10（1.12.2）

Nginx-keepavlied-slaveIP地址：192.168.1.20（1.12.2）

Nginx-web服务1-IP地址：192.168.1.30（1.12.2）

Nginx-web服务1-IP地址：192.168.1.40（1.12.2）

PHP+Xcache1-IP地址：192.168.1.50（php5.6）

PHP+Xcache2-IP地址：192.168.1.60（php5.6）

MySQL_master-keepalived-1-IP地址：192.168.1.70（Mysql5.7）

MySQL_slave-keepalived-1-IP地址：192.168.1.80（Mysql5.7）

MySQL_Master-keepalived-2-IP地址：192.168.1.90（Mysql5.7）

MySQL_slave-keepalived-2IP地址：192.168.1.100（Mysql5.7）

memcached1-IP地址：192.168.1.110

memcached2-IP地址：192.168.1.120

zabbix监控：192.168.1.130   邮箱：Email-163.com

一、什么是Nginx？

Nginx是俄罗斯人编写的十分轻量级的HTTP服务器,Nginx，它的发音为“engineX”，是一个高性能的HTTP和反向代理服务器，同时也是一个IMAP/POP3/SMTP代理服务器．Nginx是由俄罗斯人 Igor Sysoev为俄罗斯访问量第二的 Rambler.ru站点开发.

Nginx以事件驱动（epoll）的方式编写，所以有非常好的性能，同时也是一个非常高效的反向代理、负载平衡。由于Nginx本身的一些优点，轻量，开源，易用，越来越多的公司使用nginx作为自己公司的web应用服务器

如何选择Nginx版本？

nginx的英文官方网站是：http://www.nginx.org/在这里我们可以直接查看Nginx的各个版本号。Nginx的软件有三种版本：稳定版，开发板，和历史稳定版。开发板更新的较快，包含最近的功能和BUG修复，但同时也可能会遇到新的BUG，开发板的更新一旦稳定下来就会被纳入稳定版中。稳定版更新的较慢，但是软件的BUG会很少，可以作为企业的首选，因此通常建议使用稳定版。当然在实际工作中，选择稳定版时，尽量避免使用最新的版本，选择比已出来的最近版晚6-10个月的版本比较好。在本次我们选择用nginx1.12.2版本

二、代理的优点

1、反向代理（Reverse Proxy）方式是指以代理服务器来接受客户端的连接请求，然后将请求转发给网络上的web服务器（可能是apache、nginx、tomcat、iis等），并将从web服务器上得到的结果返回给请求连接的客户端，此时代理服务器对外就表现为一个服务器。

2、反向代理的作用

1）保护网站安全：任何来自Internet的请求都必须先经过代理服务器；

2）通过配置缓存功能加速Web请求：可以缓存真实Web服务器上的某些静态资源，减轻真实Web服务器的负载压力

3）实现负载均衡：充当负载均衡服务器均衡地分发请求，平衡集群中各个服务器的负载压力；

3、安装Nginx反向代理服务器（nginx-cache-master1.10）

1）安装Nginx基础依赖包 pcre zlib openssl

[root@nginx-cache-master10 ~]# yum install –y gcc gcc-c++ pcre-devel zlib-devel openssl-devel

2）下载软件包，进入http://nginx.org/download/复制对应版本的下载链接地址。

1. [root@nginx-cache-master10 src]# cd / usr/ local/ src/
2. [root@nginx-cache-master10 src]# wget http:// nginx .org/ download/ nginx-1 .12 .2 .tar .gz

3）创建Nginx运行用户

[root@nginx-cache-master10 src]# useradd -M -s /sbin/nologin nginx

4）解压Nginx源码包并进入解压目录，进行配置；在我们编译安装前我们可以隐藏Nginx软件名称以及版本号如下：

[root@nginx-cache-master10 nginx-1.12.2]# vim src/core/nginx.h

修改HTTP头信息中的connection字段，防止回显具体版本号

[root@nginx-cache-master10 nginx-1.12.2]# vim src/http/ngx_http_header_filter_module.c

有时候我们页面程序出现错误，Nginx会代我们返回相应的错误代码，回显的时候，会带上nginx和版本号，我们把他隐藏起来

修改完以上配置我们进行编译安装

[[email protected]]# ./configure--prefix=/usr/local/nginx --with-http_dav_module--with-http_stub_status_module --with-http_addition_module --with-http_sub_module  --with-http_flv_module --with-http_mp4_module--with-pcre --with-http_ssl_module --with-http_gzip_static_module  --user=nginx --group=nginx 

看到上图那么安装还是挺顺利的 接着make && make install即可

安装完成后 我们做一条软链接，方便我们启动Nginx程序

[root@nginx-cache-master10 nginx-1.12.2]# ln -s /usr/local/nginx/sbin/nginx /usr/local/sbin/

启动Nginx

接下来访问测试：

测试版本号！以及返回错误页面

错误信息

到这里我们的第一台Nginx安装完毕也就是主机：（nginx-cache-master1.10）

在（nginx-cache-slave1.20）主机上安装Nginx操作和master1是一样的这里我已经安装好了

三、配置Nginx反向代理

1）nginx-sticky-module模块：

这个模块的作用是通过cookie黏贴的方式将来自同一个客户端（浏览器）的请求发送到同一个后端服务器上处理，这样一定程度上可以解决多个backend servers的session同步的问题 —— 因为不再需要同步，而RR轮询模式必须要运维人员自己考虑session同步的实现。

另外内置的 ip_hash也可以实现根据客户端IP来分发请求，但它很容易造成负载不均衡的情况，而如果nginx前面有CDN网络或者来自同一局域网的访问，它接收的客户端IP是一样的，容易造成负载不均衡现象。nginx-sticky-module的cookie过期时间，默认浏览器关闭就过期。

这个模块并不合适不支持Cookie或手动禁用了cookie的浏览器，此时默认sticky就会切换成RR。它不能与ip_hash同时使用。

1. upstream backend {
2. server 192.168.146.120:80 weight=1;
3. server 192.168.146.130:80 weight=1;
4. sticky;
5. }

2）负载均衡与健康检查：

严格来说，nginx自带是没有针对负载均衡后端节点的健康检查的，但是可以通过默认自带的 ngx_http_proxy_module 模块和ngx_http_upstream_module 模块中的相关指令来完成当后端节点出现故障时，自动切换到下一个节点来提供访问。

1. upstream backend {
2. sticky;
3. server 192.168.1.30:80 weight=1 max_fails=2 fail_timeout=10s;
4. server 192.168.1.40:80 weight=1 max_fails=2 fail_timeout=10s;
5. }
6. server {
7. ……
8. location / {
9. proxy_pass http://backend;
10. }
11. ……
12. }

weight： 轮询权值也是可以用在ip_hash的，默认值为1
max_fails ： 允许请求失败的次数，默认为1。当超过最大次数时，返回proxy_next_upstream 模块定义的错误。
fail_timeout ： 有两层含义，一是在10s时间内最多容许2 次失败；二是在经历了 2 次失败以后，10s时间内不分配请求到这台服务器

3）nginx的proxy缓存使用：
缓存也就是将js、css、image等静态文件从后端服务器缓存到nginx指定的缓存目录下，既可以减轻后端服务器负担，也可以加快访问速度，但这样缓存及时清理成为了一个问题，所以需要 ngx_cache_purge 这个模块来在过期时间未到之前，手动清理缓存。
proxy模块中常用的指令时proxy_pass和proxy_cache.
nginx的web缓存功能的主要是由proxy_cache、fastcgi_cache指令集和相关指令集完成，proxy_cache指令负责反向代理缓存后端服务器的静态内容，fastcgi_cache主要用来处理FastCGI动态进程缓存。

1. http {
2. #$upstream_cache_status记录缓存命中率
3. log_format main '$remote_addr - $remote_user [$time_local]"$request" '
4. '$status $body_bytes_sent "$http_referer" '
5. '"$http_user_agent" "$http_x_forwarded_for"'
6. '"$upstream_cache_status"';
7. access_log logs/access.log main;
8. proxy_buffering on; #代理的时候，开启或关闭缓冲后端服务器的响应
9. proxy_temp_path /usr/local/nginx1.10/proxy_temp;
10. proxy_cache_path /usr/local/nginx1.10/proxy_cache levels=1:2keys_zone= my-cache: 100m inactive= 600m max_size= 2g;
11. server {
12. listen 80;
13. server_name localhost;
14. root html;
15. index index.php index.html index.htm;
16. #ngx_cache_purge实现缓存清除
17. location ~/purge(/.*) {
18. allow 127.0.0.1;
19. allow 192.168.146.0/24;
20. deny all;
21. proxy_cache_purge my-cache$host$1$is_args$args;
22. }
23. location ~.*\.( gif| jpg| png| html| htm| css| js| ico| swf| pdf)(.*) {
24. proxy_pass http://backend;
25. proxy_redirect off;
26. proxy_set_header Host $host;
27. proxy_set_header X-Real-IP$remote_addr;
28. proxy_set_header X-Forwarded-For$proxy_add_x_forwarded_for;
29. proxy_ignore_headers Set-Cookie;
30. proxy_hide_header Set-Cookie;
31. proxy_next_upstream error timeoutinvalid_header http_500 http_502 http_503 http_504;
32. proxy_cache my-cache;
33. add_header Nginx-Cache$upstream_cache_status;
34. proxy_cache_valid 200 304 301 3028h;
35. proxy_cache_valid 404 1m;
36. proxy_cache_valid any 1d;
37. proxy_cache_key$host$uri$is_args$args;
38. expires 30d;
39. }

相关选项说明：

proxy_bufferingon;代理的时候，开启或关闭缓冲后端服务器的响应。

当开启缓冲时，nginx尽可能快地从被代理的服务器接收响应，再将它存入缓冲区中。

proxy_temp_path：缓存临时目录。后端的响应并不直接返回客户端，而是先写到一个临时文件中，然后被rename一下当做缓存放在 proxy_cache_path 。0.8.9版本以后允许temp和cache个目录在不同文件系统上（分区），然而为了减少性能损失还是建议把它们设成一个文件系统上。

proxy_cache_path： 设置缓存目录，目录里的文件名是cache_key的MD5值。

levels=1:2keys_zone=my-cache:100m表示采用2级目录结构，第一层目录只有一个字符，是由levels=1:2设置，总共二层目录，子目录名字由二个字符组成。Web缓存区名称为my-cache，内存缓存空间大小为100MB，这个缓冲zone可以被多次使用。文件系统上看到的缓存文件名类似于/usr/local/nginx/proxy_cache/c/29/b7f54b2df7773722d382f4809d65029c 。

inactive=600max_size=2g表示600分钟没有被访问的内容自动清除，硬盘最大缓存空间为2GB，超过这个大学将清除最近最少使用的数据。

需要在默认情况，nginx不缓存从后端响应的http头中带有Set-Cookie的对象。如果客户端发送的请求带有Cookie header，varnish将忽略缓存，直接将请求传递到后端。nginx中通过proxy_ignore_headers设置忽略它们，设置方法如下：

解决办法：  

proxy_ignore_headersSet-Cookie;

proxy_hide_headerSet-Cookie;

proxy_cache：引用前面定义的缓存区 my-cache

proxy_cache_key：定义如何生成缓存的键，设置web缓存的key值，nginx根据key值md5哈希存储缓存

proxy_cache_valid：为不同的响应状态码设置不同的缓存时间，比如200、302等正常结果可以缓存的时间长点，而404、500等缓存时间设置短一些，这个时间到了文件就会过期，而不论是否刚被访问过。

add_header指令来设置response header, 语法: add_header name value;

$upstream_cache_status这个变量来显示缓存的状态，我们可以在配置中添加一个http头来显示这一状态，

$upstream_cache_status包含以下几种状态： 

•MISS未命中，请求被传送到后端 

•HIT缓存命中 

•EXPIRED缓存已经过期请求被传送到后端 

•UPDATING正在更新缓存，将使用旧的应答 

•STALE后端将得到过期的应答

expires：在响应头里设置Expires:或Cache-Control:max-age，返回给客户端的浏览器缓存失

下面的nginx.conf实现nginx在前端做反向代理服务器的完整配置文件的例子

1. user nginx nginx;
2. worker_processes 1;
3. error_log logs/ error .log;
4. #error_log logs/ error .log notice;
5. #error_log logs/ error .log info;
6. worker_rlimit_nofile 10240;
7. pid logs/ nginx .pid;
8. events {
9. use epoll;
10. worker_connections 4096;
11. }
12. http {
13. include mime.types;
14. default_type application/octet-stream;
15. log_format main '$remote_addr - $remote_user [$time_local] "$request" '
16. '$status $body_bytes_sent "$http_referer" '
17. '"$http_user_agent" "$http_x_forwarded_for"'
18. '"$upstream_cache_status"';
19. access_log logs/access.log main;
20. server_tokens off;
21. sendfile on;
22. #tcp_nopush on;
23. #keepalive_timeout 0;
24. keepalive_timeout 65;
25. #Compression Settings
26. gzip on;
27. gzip_comp_level 6;
28. gzip_http_version 1.1;
29. gzip_proxied any;
30. gzip_min_length 1k;
31. gzip_buffers 16 8k;
32. gzip_types text/plain text/css text/javascript application/json application/javascript application/x-javascript application/xml;
33. gzip_vary on;
34. #end gzip
35. # http_proxy Settings
36. client_max_body_size 10m;
37. client_body_buffer_size 128k;
38. proxy_connect_timeout 75;
39. proxy_send_timeout 75;
40. proxy_read_timeout 75;
41. proxy_buffer_size 4k;
42. proxy_buffers 4 32k;
43. proxy_busy_buffers_size 64k;
44. proxy_temp_file_write_size 64k;
45. proxy_buffering on;
46. proxy_temp_path /usr/local/nginx/proxy_temp;
47. proxy_cache_path /usr/local/nginx/proxy_cache levels=1:2 keys_zone= my-cache: 100m max_size= 1000m inactive= 600m max_size= 2g;
48. #load balance Settings
49. upstream backend {
50. sticky;
51. server 192.168.1.30:80 weight=1 max_fails=2 fail_timeout=10s;
52. server 192.168.1.40:80 weight=1 max_fails=2 fail_timeout=10s;
53. }
54. #virtual host Settings
55. server {
56. listen 80;
57. server_name localhost;
58. charset utf-8;
59. location ~/purge(/.*) {
60. allow 127.0.0.1;
61. allow 192.168.1.0/24;
62. deny all;
63. proxy_cache_purge my-cache $host$1$is_args$args;
64. }
65. location / {
66. index index.php index.html index.htm;
67. proxy_pass http://backend;
68. proxy_redirect off;
69. proxy_set_header Host $host;
70. proxy_set_header X-Real-IP $remote_addr;
71. proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
72. proxy_ignore_headers Set-Cookie;
73. proxy_hide_header Set-Cookie;
74. proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;
75. }
76. location ~ .*\.( gif| jpg| png| html| htm| css| js| ico| swf| pdf)(.*) {
77. proxy_pass http://backend;
78. proxy_redirect off;
79. proxy_set_header Host $host;
80. proxy_set_header X-Real-IP $remote_addr;
81. proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
82. proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;
83. proxy_cache my-cache;
84. add_header Nginx-Cache $upstream_cache_status;
85. proxy_cache_valid 200 304 301 302 8h;
86. proxy_cache_valid 404 1m;
87. proxy_cache_valid any 1d;
88. proxy_cache_key $host$uri$is_args$args;
89. expires 30d;
90. }
91. location / nginx_status {
92. stub_status on;
93. access_log off;
94. allow 192.168.1.0/24;
95. deny all;
96. }
97. }
98. }

以上配置文件加入到Nginx主配置中，两台Nginx主配都要一致！

配置完成后保存退出 重新加载Nginx即可

四、配置keepalived+Nginx实现高可用

keepalived这里不在做详细的介绍，简单一句话，keepalived高可用解决单点故障，如果一台主机宕机，那么从服务器就会接管主服务器

keepalived工作流程图如下：

Nginx-cache-master主机操作（安装keepalived）

1. [root@nginx-cache-master10 src]# tar zxfkeepalived-1 .2 .12 .tar .gz
3. [root@nginx-cache-master10 src]# cdkeepalived-1 .2 .12/
5. [[email protected]]# ./ configure --prefix=/ && make && make install

2、设置开机自启动

1. [root@nginx-cache-master10 keepalived-1.2.12]# chkconfig--add keepalived
3. [root@nginx-cache-master10 keepalived-1.2.12]# chkconfigkeepalived on

3、Nginx-cache-slave主机操作（安装keepalived）

1. [root@nginx-cache-slave20 keepalived-1.2.12]# tar zxfkeepalived-1 .2 .12 .tar .gz
2. [root@nginx-cache-slave20 keepalived-1.2.12]# cd keepalived-1 .2 .12/

[root@nginx-cache-slave20 keepalived-1.2.12]# . /configure--prefix=/ && make && make instal l

4、keepalived配置（以下是Nginx-cache-master主配置）路径：/etc/keepalived/keepalived.conf

1. ! Configuration File for keepalived
4. global_defs {
5. router_id 192.168.1.10
6. }
7. vrrp_script chk_http_port {
8. script "/opt/chk_nginx.sh"
9. interval 2 #每2秒检测一次nginx的运行状态
10. weight -5 #失败一次，将自己的优先级-5
11. }
14. vrrp_instance VI_1 {
15. state MASTER # 状态，主节点为MASTER，备份节点为BACKUP
16. interface eno16777728 # 绑定VIP的网络接口，通过ifconfig查看自己的网络接口
17. virtual_router_id 51 # 虚拟路由的ID号,两个节点设置必须一样
18. priority 100 # 节点优先级，值范围0～254，MASTER要比BACKUP高
19. advert_int 1 # 组播信息发送时间间隔，两个节点必须设置一样，默认为1秒
20. authentication { # 设置验证信息，两个节点必须一致
21. auth_type PASS
22. auth_pass 1111
23. }
24. # 虚拟 IP，两个节点设置必须一样。可以设置多个，一行写一个
25. virtual_ipaddress {
26. 192.168.1.150/24
27. }
30. track_script {
31. chk_http_port # nginx存活状态检测脚本
32. }
33. }

nginx-cache-slave主配置如下

1. ! Configuration File for keepalived
3. global_defs {
4. router_id 192.168.1.20
5. }
7. vrrp_script chk_http_port {
8. script "/opt/chk_nginx.sh"
9. interval 2
10. weight -5
11. }
13. vrrp_instance VI_1 {
14. state slave
15. interface eno16777728
16. virtual_router_id 51
17. priority 50 这里的节点优先级要小于master主机
18. advert_int 1
19. authentication {
20. auth_type PASS
21. auth_pass 1111
22. }
23. virtual_ipaddress {
24. 192.168.1.150/24
25. }
27. track_script {

配置完成后我们启动keepalived （master+slave同时操作）
systemctl restart keepalived（重启完成后查看vip地址）
master主机：

slave主机：

在keepalived主配置中我们定义了检检测Nginx脚本，我们需要在/opt/下创建chk_nginx.sh脚本

1. vrrp_script chk_http_port {
2. script "/opt/chk_nginx.sh"
3. interval 2
4. weight -5
5. }

脚本内容如下：（创建脚本后需要给脚本执行权限）

1. #!/ bin/ bash
3. A=` ps -Cnginx --no-header | wc -l`
5. if [ $A -eq0 ]; then
7. killall -9 keepalived
9. fi

剖析：如果Nginx服务停止运行，那么执行killall -9 keepalived同时也停止keepalived，这时候从就收不到主的广播，从而接管主的任务，验证如下：

这时候我们再次查看从的状态

到这里我们的keepalived+nginx高可用已经搭建完毕，按照正常情况下我们就可以访问我们的vip地址来获取数据了，我们现在来尝试的访问一下。http://192.168.1.150:80

但是它提示我们502，502错误指的是网关错误，我们先看下目前我们在整个架构中走到了哪里

到这里我们只是配置了前端的nginx反向代理以及keepalived高可用性，我们前端的代理指定了后端的web集群，所以它才会报502的错误，那么接下来我们配置后端的web集群！

五、搭建后端的web集群

1、安装Nginx1（1.30操作）

1）安装Nginx相关的依赖包（pcre zlib openssl）

[root@nginxweb1 ~]# yum installgcc gcc-c++ pcre-devel zlib-devel openssl-devel –y

2）创建Nginx用户指定id（因为后端的lnmp环境是分离部署的所以需要指定id）

1. [root@nginxweb1~]# groupadd -g 1001 nginx
2. [root@nginxweb1~]# useradd -u 900 nginx -g nginx -s / sbin/ nologin

3）下载Nginx源码包并隐藏版本号等等，上面已经有了这里不做演示了。

1. [root@nginxweb1src] #wget http:// nginx .org/ download/ nginx-1 .12 .2 .tar .gz
2. [root@nginxweb1src]# tar zxf nginx-1 .12 .2 .tar .gz
3. [root@nginxweb1src]# cd nginx-1 .12 .2/

[[email protected]]# ./configure --prefix=/usr/local/nginx --with-http_dav_module--with-http_stub_status_module --with-http_addition_module --with-http_sub_module  --with-http_flv_module --with-http_mp4_module--with-pcre --with-http_ssl_module --with-http_gzip_static_module  --user=nginx --group=nginx && make && make install

4）编译安装完成后我们优化执行路径

[[email protected]]# ln -s /usr/local/nginx/sbin/nginx  /usr/local/sbin/

5）启动Nginx并访问测试

验证错误页面返回信息

Nginx优化

1）设置Nginx最大打开的文件数

worker_rlimit_nofile65535;

这个指令是指当一个nginx进程打开的最多文件描述符数目，理论值应该是最多打开文件数（ulimit -n）与nginx进程数相除，但是nginx分配请求并不是 那么均匀，所以最好与ulimit -n的值保持一致。

文件资源限制的配置可以在/etc/security/limits.conf设置，针对root/user等各个用户或者*代表所有用户来设置。
*    soft   nofile   65535 
*    hard  nofile    65535
用户重新登录生效（ulimit -n）
[root@yankerp conf]# vim /etc/security/limits.conf

配置Nginx主配（vim /usr/local/nginx/conf/nginx.conf）

2）Nginx事件处理模型

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

nginx采用epoll事件模型，处理效率高
work_connections是单个worker进程允许客户端最大连接数，这个数值一般根据服务器性能和内存来制定，实际最大值就是worker进程数乘以work_connections
实际我们填入一个65535，足够了，这些都算并发值，一个网站的并发达到这么大的数量，也算一个大站了！
multi_accept 告诉nginx收到一个新连接通知后接受尽可能多的连接

3）Nginx连接超时时间
1、主要目的是保护服务器的资源，CPU，内存，控制的连接数，因为在建立连接也需要消耗资源的具体参数如下：

1. keepalive_timeout 60;
2. tcp_nodelay on;
3. client_header_buffer_size 4 k;
4. open_file_cache max=102400 inactive=20 s;
5. open_file_cache_valid 30 s;
6. open_file_cache_min_uses 1;
7. client_header_timeout 15;
8. client_body_timeout 15;
9. reset_timedout_connection on;
10. send_timeout 15;
11. server_tokens off;
12. client_max_body_size 10 m;

keepalived_timeout 客户端连接保持会话超时时间，超过这个时间，服务器断开这个链接

tcp_nodelay 也是防止网络阻塞，不过要包涵在keepalived参数才有效

client_header_buffer_size4k;
客户端请求头部的缓冲区大小，这个可以根据你的系统分页大小来设置，一般一个请求头的大小不会超过 1k，不过由于一般系统分页都要大于1k，所以这里设置为分页大小。分页大小可以用命令getconf PAGESIZE取得
open_file_cache max=102400 inactive=20s;
这个将为打开文件指定缓存，默认是没有启用的，max指定缓存数量，建议和打开文件数一致，inactive 是指经过多长时间文件没被请求后删除缓存。

open_file_cache_valid30s 这个是指多长时间检查一次缓存的有效信息

open_file_cache_min_uses1;
open_file_cache指令中的inactive 参数时间内文件的最少使用次数，如果超过这个数字，文件描述符一直是在缓存中打开的，如上例，如果有一个文件在inactive 时间内一次没被使用，它将被移除。

client_header_timeout 设置请求头的超时时间。我们也可以把这个设置低些，如果超过这个时间没有发送任何数据，nginx将返回request time out的错误

client_body_timeout 设置请求体的超时时间。我们也可以把这个设置低些，超过这个时间没有发送任何数据，和上面一样的错误提示

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

send_timeout 响应客户端超时时间，这个超时时间仅限于两个活动之间的时间，如果超过这个时间，客户端没有任何活动，nginx关闭连接

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

client_max_body_size  上传文件大小限制 

4fastcgi调优

1. fastcgi_connect_timeout 600;
2. fastcgi_send_timeout 600;
3. fastcgi_read_timeout 600;
4. fastcgi_buffer_size 64 k;
5. fastcgi_buffers 4 64 k;
6. fastcgi_busy_buffers_size 128 k;
7. fastcgi_temp_file_write_size 128 k;
8. fastcgi_temp_path / usr/ local/ nginx/ nginx_tmp;
9. fastcgi_intercept_errors on;
10. fastcgi_cache_path / usr/ local/ nginx/ fastcgi_cache levels=1 :2 keys_zone= cache_fastcgi :128m inactive=1 d max_size=10 g;

fastcgi_send_timeout600; #向FastCGI传送请求的超时时间
fastcgi_read_timeout 600; #指定接收FastCGI应答的超时时间。
fastcgi_buffer_size 64k;  #指定读取FastCGI应答第一部分需要用多大的缓冲区，默认的缓冲区大小为fastcgi_buffers指令中的每块大小，可以将这个值设置更小。
fastcgi_buffers 4 64k; #指定本地需要用多少和多大的缓冲区来缓冲FastCGI的应答请求，如果一个php脚本所产生的页面大小为256KB，那么会分配4个64KB的缓冲区来缓存，如果页面大小大于256KB，那么大于256KB的部分会缓存到fastcgi_temp_path指定的路径中，但是这并不是好方法，因为内存中的数据处理速度要快于磁盘。一般这个值应该为站点中php脚本所产生的页面大小的中间值，如果站点大部分脚本所产生的页面大小为256KB，那么可以把这个值设置为“8 32K”、“4 64k”等。
fastcgi_busy_buffers_size 128k; #建议设置为fastcgi_buffers的两倍，繁忙时候的buffer
fastcgi_temp_file_write_size 128k;   #在写入fastcgi_temp_path时将用多大的数据块，默认值是fastcgi_buffers的两倍，该数值设置小时若负载上来时可能报502 BadGateway
fastcgi_temp_path #缓存临时目录
fastcgi_intercept_errors on;# 这个指令指定是否传递4xx和5xx错误信息到客户端，或者允许nginx使用error_page处理错误信息。
注：静态文件不存在会返回404页面，但是php页面则返回空白页！！
fastcgi_cache_path /usr/local/nginx1.10/fastcgi_cache levels=1:2keys_zone=cache_fastcgi:128minactive=1d max_size=10g;# fastcgi_cache缓存目录，可以设置目录层级，比如1:2会生成16*256个子目录，cache_fastcgi是这个缓存空间的名字，cache是用多少内存（这样热门的内容nginx直接放内存，提高访问速度），inactive表示默认失效时间，如果缓存数据在失效时间内没有被访问,将被删除，max_size表示最多用多少硬盘空间。

fastcgi_cache cache_fastcgi;  #表示开启FastCGI缓存并为其指定一个名称。开启缓存非常有用，可以有效降低CPU的负载，并且防止502的错误放生。cache_fastcgi 为proxy_cache_path指令创建的缓存区名称
fastcgi_cache_valid 200 302 1h;  #用来指定应答代码的缓存时间，实例中的值表示将200和302应答缓存一小时，要和fastcgi_cache配合使用
fastcgi_cache_valid 301 1d;      #将301应答缓存一天
fastcgi_cache_valid any 1m;      #将其他应答缓存为1分钟
fastcgi_cache_min_uses 1;        #该指令用于设置经过多少次请求的相同URL将被缓存。
fastcgi_cache_key http://$host$request_uri; #该指令用来设置web缓存的Key值,nginx根据Key值md5哈希存储.一般根据$host(域名)、$request_uri(请求的路径)等变量组合成proxy_cache_key 。fastcgi_pass #指定FastCGI服务器监听端口与地址，可以是本机或者其它

nginx的缓存功能有：proxy_cache /fastcgi_cache
proxy_cache的作用是缓存后端服务器的内容，可能是任何内容，包括静态的和动态。
fastcgi_cache的作用是缓存fastcgi生成的内容，很多情况是php生成的动态的内容。
proxy_cache缓存减少了nginx与后端通信的次数，节省了传输时间和后端宽带。
fastcgi_cache缓存减少了nginx与php的通信的次数，更减轻了php和数据库(mysql)的压力。

5）GZIP调优

使用gzip压缩功能，可能为我们节约带宽，加快传输速度，有更好的体验，也为我们节约成本，所以说这是一个重点。
Nginx启用压缩功能需要你来ngx_http_gzip_module模块，apache使用的是mod_deflate
一般我们需要压缩的内容有：文本，js，html，css，对于图片，视频，flash什么的不压缩，同时也要注意，我们使用gzip的功能是需要消耗CPU的！具体参数如下：

1. gzip on;
2. gzip_min_length 2 k;
3. gzip_buffers 4 32 k;
4. gzip_http_version 1 .1;
5. gzip_comp_level 6;
6. gzip_types text/ plain text/ css text/ javascript application/ json application/ javascript application/ x-javascript application/ xml;
7. gzip_vary on;
8. gzip_proxied any;

gzip on;     #开启压缩功能

gzip_min_length1k; #设置允许压缩的页面最小字节数，页面字节数从header头的Content-Length中获取，默认值是0，不管页面多大都进行压缩，建议设置成大于1K，如果小与1K可能会越压越大。

gzip_buffers4 32k; #压缩缓冲区大小，表示申请4个单位为32K的内存作为压缩结果流缓存，默认值是申请与原始数据大小相同的内存空间来存储gzip压缩结果。

gzip_http_version1.1; #压缩版本，用于设置识别HTTP协议版本，默认是1.1，目前大部分浏览器已经支持GZIP解压，使用默认即可

gzip_comp_level6; #压缩比例，用来指定GZIP压缩比，1压缩比最小，处理速度最快，9压缩比最大，传输速度快，但是处理慢，也比较消耗CPU资源。

gzip_types text/csstext/xmlapplication/javascript; #用来指定压缩的类型，‘text/html’类型总是会被压缩。默认值: gzip_types text/html (默认不对js/css文件进行压缩)

6）expires缓存调优

缓存，主要针对于图片，css，js等元素更改机会比较少的情况下使用，特别是图片，占用带宽大，我们完全可以设置图片在浏览器本地缓存365d，css，js，html可以缓存个10来天，这样用户第一次打开加载慢一点，第二次，就非常快了！缓存的时候，我们需要将需要缓存的拓展名列出来， Expires缓存配置在server字段里面。

1. location ~* \.( ico| jpe? g| gif| png| bmp| swf| flv)$ {
2. expires 30d;
3. #log_not_found off;
4. access_log off;
5. }
7. location ~* \.( js| css)$ {
8. expires 7d;
9. log_not_found off;
10. access_log off;
11. }

在这里Nginx大致的调优就OK了这里我没有设置cpu核数，因为我这边就一核。资源不够用，配置完成后加载Nginx

1. [root@nginxweb1~]# nginx -t
3. nginx: theconfiguration file / usr/ local/ nginx/ conf/ nginx .conf syntax is ok
5. nginx :configuration file / usr/ local/ nginx/ conf/ nginx .conf test is successful
7. [root@nginxweb1~]# nginx -s reload

在这里我们的Nginx-web1已经配置完毕了，在nginx-web2（1.40主机上的配置和1是一样的 这里不在做演示了）

接下来我们导入不同的页面来测试Nginx反向代理是否能够代理后端的web服务器

1. Nginx1操作： [root@nginxweb1 ~]# echo "192 .168 .1 .30-nginx-web1" >/ usr/ local/ nginx/ html/ index .html
3. Nginx2:操作： [root@nginxweb1 ~]# echo "192 .168 .1 .40-nginx-web2" >/ usr/ local/ nginx/ html/ index .html

接下来访问VIP地址不断刷新测试是否能够代理后端web

出现以上页面证明，前端的nginx代理服务器能够成功的转发到后端的web服务器上，在这里我们在看看在整个架构中走到了哪里如下：

在竖行左边我们已经做完了，并且测试完成！前端已经成功的代理了后端的服务器，接下来配置后端的PHP、MySQL。让nginx能够解析到PHP服务，从而展示出动态页面！

六、安装部署PHP（PHP+Xcache）1.50操作

1、安装相关的依赖包

[root@php-xcache1 ~]# yum install gcc gcc-c++ libxml2-devel libcurl-devel openssl-devel bzip2-devel –y

2）安装Libmcrypt

1. [root@php-xcache1 src]# wget ftp:// mcrypt .hellug .gr/ pub/ crypto/ mcrypt/ libmcrypt/ libmcrypt-2 .5 .7 .tar .gz
2. [root@php-xcache1 src]# tar zxf libmcrypt-2 .5 .7 .tar .gz
3. [root@php-xcache1 src]# cd libmcrypt-2 .5 .7/
4. [root@php-xcache1 libmcrypt-2.5.7]# ./ configure --prefix=/ usr/ local/ libmcrypt && make && make install

3）正式安装php（在编译的过程稍微有点慢~~）
下载php安装包—>解压—>编译安装

1. [root@php-xcache1 src]# wget http:// cn2 .php .net/ distributions/ php-5 .6 .27 .tar .gz
2. [root@php-xcache1 src]# tar zxf php-5 .6 .27 .tar .gz
3. [root@php-xcache1 src]# cd php-5 .6 .27/
5. [root@php-xcache1 php-5.6.27]# ./ configure --prefix=/ usr/ local/ php5 .6 --with-mysql= mysqlnd --with-pdo-mysql= mysqlnd --with-mysqli= mysqlnd --with-openssl --enable-fpm --enable-sockets --enable-sysvshm --enable-mbstring --with-freetype-dir --with-jpeg-dir --with-png-dir --with-zlib --with-libxml-dir=/ usr --enable-xml --with-mhash --with-mcrypt=/ usr/ local/ libmcrypt --with-config-file-path=/ etc --with-config-file-scan-dir=/ etc/ php .d --with-bz2 --enable-maintainer-zts && make && make install

4）编译安装完成后我们创建Nginx用户（UID要和Nginx服务器一致！）

1. [root@php-xcache1 php-5.6.27]# groupadd -g 1001 nginx
2. [root@php-xcache1 php-5.6.27]# useradd -u 900 nginx -g nginx -s / sbin/ nologin

5）提供php文件及启动脚本

1. [root@php-xcache1 php-5.6.27]# cp php .ini-production / etc/ php .ini
2. [root@php-xcache1 php-5.6.27]# cp sapi/ fpm/ init .d .php-fpm / etc/ init .d/ php-fpm
3. [root@php-xcache1 php-5.6.27]# chmod + x / etc/ init .d/ php-fpm
4. [root@php-xcache1 php-5.6.27]# chkconfig --add php-fpm
5. [root@php-xcache1 php-5.6.27]# chkconfig php-fpm on

6）修改php主配置编辑如下：

1. [root@php-xcache1 php-5.6.27]# cp / usr/ local/ php5 .6/ etc/ php-fpm .conf .default / usr/ local/ php5 .6/ etc/ php-fpm .conf
2. [root@php-xcache1 php-5.6.27]# vim / usr/ local/ php5 .6/ etc/ php-fpm .conf

修改内容如下：

1. pid = run/ php-fpm .pid
2. user = nginx
3. group = nginx
4. listen = 192 .168 .1 .20 :9000 // PHP主机的 IP地址
5. pm .max_children = 50
6. pm .start_servers = 5
7. pm .min_spare_servers = 5
8. pm .max_spare_servers = 35

修改完成后启动php服务并查看状态

到这里我们的php服务搭建完成，接下来我们配置nginx支持php环境（1.30Nginx-cache-mater主机操作）

1. location / {
2. root /www; 修改网页目录
3. index index.php index.html index.htm; 添加index.php
4. }
5. location ~ \ .php$ {
6. root /www; 更改网页目录
7. fastcgi_pass 192.168.1.50:9000; 指定php1服务端的IP地址
8. fastcgi_index index.php;
9. fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;
10. include fastcgi_params;
11. }

[root@nginxweb1 ~]# vim /usr/local/nginx/conf/fastcgi_params添加如下：

fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;

添加完成后创建/www目录并创建测试页如下：（1.30Nginx-cache-mater主机操作）

1. [root@nginxweb1 ~] # mkdir /www
2. [root@nginxweb1 ~] # chown nginx:nginx /www/
3. [root@nginxweb1 ~] # cd /www/
4. [root@nginxweb1 www] # vim index.php
5. [root@nginxweb1 www] # cat index.php
7. phpinfo();
8. ?>

到这里我们先别重启Nginx接下来在PHP主机操作（1.50）

1. [root@php-xcache1 ~] # mkdir /www
2. [root@php-xcache1 ~] # chown -R nginx:nginx /www/
3. [root@php-xcache1 ~] # cd /www/
4. [root@php-xcache1 www] # vim index.php
6. phpinfo();
7. ?>

建完成后接下来我们重启nginx以及php，访问测试页（1.30&1.50操作）

1. [root@php-xcache1 ~]# systemctl restart php-fpm
2. [root@nginxweb1 www]# nginx -s reload

完事后我们访问测试页面：http://192.168.1.30

如果出现了上图证明nginx已经能够解析php了，那么我们来访问VIP地址1.150来测试下

我们访问发现一个是原先的测试页，一个是php测试页，这是因为我们只配置了一台Nginx+php还有一台没有配置也就是 1.40和1.60没有解析

2、安装部署PHP（PHP+Xcache）1.60操作 在这里的话我就不演示了。安装php过程和上面是一样的，我这边已经启动了

配置nginx支持php环境（1.40Nginx-cache-slave主机操作）

1. location / {
3. root /www; 修改网页目录
5. index index.php index.htmlindex.htm; 添加index.php
7. }
9. location ~\ .php$ {
11. root /www; 更改网页目录
13. fastcgi_pass 192.168.1.60:9000; 指定php2服务端的IP地址
15. fastcgi_index index.php;
17. fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;
19. include fastcgi_params;
21. }

剩下的操作就和上面的一摸一样了，配置完成后同样重新启动服务，访问如下：

此时，Nginx完全解析PHP-前端的Nginx反向代理也正常运行，这时候我们再看看在整个架构中走到了哪里

在左边部分我们成功的搭建了Nginx反向代理后端的web集群，同时在Nginx-web上做了优化提高了访问速度，到目前为止做到了Nginx能够解析PHP语言。接下来就是后半部分了，构建MySQL服务器。

七、搭建MySQL数据库（MySQL-Master：192.168.1.70操作）
本次采用MySQL二进制安装如下：

1）下载MySQL二进制安装包

[root@mysqlmaster src]# wget http://mirrors.sohu.com/mysql/MySQL-5.7/mysql-5.7.18-linux-glibc2.5-x86_64.tar.gz

2）在Centos7中默认自带了mariadb，所以需要卸载

1. [root@mysqlmaster src]# rpm -qa | grep mariadb
2. mariadb-libs-5.5.44-2.el7.centos.x86_64
3. [root@mysqlmaster src]# rpm -e mariadb-libs-5.5.44-2.el7.centos.x86_64 –nodeps

3）解压MySQL二进制包，并复制到/usr/local/mysql目录下

1. [root@mysqlmaster src]# tar zxf mysql-5.7.18-linux-glibc2.5-x86_64.tar.gz
2. [root@mysqlmaster src]# mv mysql-5.7.18-linux-glibc2.5-x86_64 /usr/local/mysql
3. [root@mysqlmaster src]# cd /usr/local/mysql/
4. [root@mysqlmaster mysql]# ll

4）优化执行路径

1. [root@mysqlmaster mysql]# echo "export PATH=$PATH:/usr/local/mysql/bin" >> /etc/profile
2. [root@mysqlmaster mysql]# source /etc/profile

5）创建data以及log目录

1. [root@mysqlmaster ~]# cd /usr/local/mysql/
2. [root@mysqlmaster mysql]# mkdir data
3. [root@mysqlmaster mysql]# mkdir log

6）建立mysql主配置文件

1. [root@mysqlmaster mysql]# vim /etc/my.cnf
2. [client]
3. socket=/usr/local/mysql/mysql.sock
4. [mysqld]
5. basedir=/usr/local/mysql
6. datadir=/usr/local/mysql/data
7. pid-file=/usr/local/mysql/data/mysqld.pid
8. socket=/usr/local/mysql/mysql.sock
9. log_error=/usr/local/mysql/log/mysql.err

7）建立mysql用户和组

[root@mysqlmaster mysql]# groupadd mysql && useradd -r -g mysql -s /bin/false mysql

8）设置相应的权限并初始化mysql数据库

[root@mysqlmaster mysql]# chmod 750 data/ && chown -R mysql . && chgrp -R mysql . && bin/mysqld --initialize --user=mysql

9）复制启动脚本并启动mysql数据库

1. [root@mysqlmaster mysql]# cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysqld && service mysqld start
2. Starting MySQL. SUCCESS!

查看mysql是否启动成功（Mysql密码存放在：/usr/local/mysql/log/mysql.err文件中）

到这里MySQL正式安装完毕！ （master已经安装好了，从的Mysql和主的都一样这里不在做演示！）

七、优化MySQL数据库
首先先插入两万行数据测试，之后会用的到，脚本如下：

1. #!/bin/bash
2. HOSTNAME="localhost"
3. PORT="3306"
4. USERNAME="root"
5. PASSWORD="pwd123"
6. DBNAME="test1"
7. TABLENAME="tb1"
8. #ceate database
9. mysql -h ${HOSTNAME} -P${PORT} -u${USERNAME} -p${PASSWORD} -e " drop database if exists ${DBNAME} "
10. create_db_sql=" create database if not exists ${DBNAME} "
11. mysql -h ${HOSTNAME} -P${PORT} -u${USERNAME} -p${PASSWORD} -e"${create_db_sql} "
12. #create table
13. create_table_sql=" create table if not exists ${TABLENAME}(stuid int not null primary key,stuname varchar( 20) not null,stusex char( 1)
14. not null,cardid varchar( 20) not null,birthday datetime,entertime datetime,address varchar( 100) default null) "
15. mysql -h ${HOSTNAME} -P${PORT} -u${USERNAME} -p${PASSWORD} ${DBNAME} -e"${create_table_sql} "
16. #insert data to table
17. i=" 1 "
18. while [ $i -le 20000 ]
19. do
20. insert_sql=" insert into ${TABLENAME} values($i, 'zhangsan', '1', '21276387261874682', '1999-10-10', '2017-10-24', 'beijingchangpingqu') "
21. mysql -h ${HOSTNAME} -P${PORT} -u${USERNAME} -p${PASSWORD} ${DBNAME} -e"${insert_sql} "
22. let i++
23. done
24. #select data
25. select_sql=" select count(*) from${TABLENAME} "
26. mysql -h ${HOSTNAME} -P${PORT} -u${USERNAME} -p${PASSWORD} ${DBNAME} -e"${select_sql} "

运行结果如下：

在没有优化之前我们使用mysqlslap来进行压力测试

1. [root@mysqlmaster~]# mysqlslap --defaults-file=/etc/my.cnf \
2. > --concurrency=100 --iterations=1 --create-schema='test1' \
3. > --query='select * from test1.tb1' engine=innodb \
4. > --number-of-queries=2000 -uroot -ppwd123 –verbose

我们可以清楚的看到在没有优化之前他使用的时间是34秒
下面列出了对性能优化影响较大的主要变量，主要分为连接请求的变量和缓冲区的变量

1)   连接请求的变量
Max_connections
Mysql的最大连接数，如果服务器的并发请求量比较大，可以调高这个值，当然这是要建立在机器能够支撑的情况下，因为如果连接数越来越多，mysql会为每个连接提供缓冲区，就会开销的越多的内存，所以需要适当的调整该值，不能随便去提高设值。
如下图：MySQL默认的最大连接数为151

修改/etc/my.cnf在[mysqld]下添加以下内容，设置最大连接数为1024，重启mysql服务验证

vim/etc/my.cnf

max_connections=1024添加

2）back_log
mysql能暂存的连接数量，当主要mysql线程在一个很短时间内得到非常多的连接请求时候它就会起作用，如果mysql的连接数据达到max_connections时候，新来的请求将会被存在堆栈中，等待某一连接释放资源，该推栈的数量及back_log,如果等待连接的数量超过back_log，将不被授予连接资源
back_log值指出在mysql暂时停止回答新请求之前的短时间内有多少个请求可以被存在推栈中，只有如果期望在一个短时间内有很多连接的时候需要增加它
可以通过以下命令查看back_log的设置默认是254

我们可以通过MySQL主配置修改它的大小，设置最大连接数为：1024随后重启MySQL服务再次查看
vim /etc/my.cnf 添加：back_log=1024

3）wait_timeout和interactive_timeout
wait_timeout：指的是mysql在关闭一个非交互的连接之前所要等待的秒数
interactive_timeoutz：指的是mysql在关闭一个交互的连接之前所需要等待的秒数，比如我们在终端上进行mysql管理，使用的即使交互的连接，这时候，如果没有操作的时间超过了interactive_time设置的时间就会自动的断开，默认的是28800，可调优为7200。wait_timeout:如果设置太小，那么连接关闭的就很快，从而使一些持久的连接不起作用
如果设置太大，容易造成连接打开时间过长，在show processlist时候，能看到很多的连接 一般希望wait_timeout尽可能低
查看wait_timeout和interactive_timeout的设置

修改/etc/my.cnf，添加以下内容
wait_timeout=100
interactive_timeout=100

4）query_cache_size（查询缓存简称QC）
使用查询缓冲，mysql将查询结果存放在缓冲区中，今后对于同样的select语句（区分大小写）,将直接从缓冲区中读取结果。
一个sql查询如果以select开头，那么mysql服务器将尝试对其使用查询缓存。
注：两个sql语句，只要想差哪怕是一个字符（列如大小写不一样；多一个空格等）,那么这两个sql将使用不同的一个cache。
上述状态值可以使用show status like 'Qcache%获得'

Qcache_free_blocks：缓存中相邻内存块的个数。如果该值显示较大，则说明Query Cache 中的内存碎片较多了，FLUSH QUERY CACHE会对缓存中的碎片进行整理，从而得到一个空闲块。 
注：当一个表被更新之后，和它相关的cache blocks将被free。但是这个block依然可能存在队列中，除非是在队列的尾部。可以用FLUSH QUERY CACHE语句来清空free blocks
Qcache_free_memory：Query Cache中目前剩余的内存大小。通过这个参数我们可以较为准确的观察出当前系统中的Query Cache内存大小是否足够，是需要增加还是过多了。
Qcache_hits：表示有多少次命中缓存。我们主要可以通过该值来验证我们的查询缓存的效果。数字越大，缓存效果越理想。
Qcache_inserts：表示多少次未命中然后插入，意思是新来的SQL请求在缓存中未找到，不得不执行查询处理，执行查询处理后把结果insert到查询缓存中。这样的情况的次数越多，表示查询缓存应用到的比较少，效果也就不理想。当然系统刚启动后，查询缓存是空的，这很正常。
Qcache_lowmem_prunes：多少条Query因为内存不足而被清除出Query Cache。通过“Qcache_lowmem_prunes”和“Qcache_free_memory”相互结合，能够更清楚的了解到我们系统中Query Cache 的内存大小是否真的足够，是否非常频繁的出现因为内存不足而有Query被换出。这个数字最好长时间来看；如果这个数字在不断增长，就表示可能碎片非常严重，或者内存很少。（上面的free_blocks和free_memory可以告诉您属于哪种情况） 
Qcache_not_cached：不适合进行缓存的查询的数量，通常是由于这些查询不是 SELECT语句或者用了now()之类的函数。 
Qcache_queries_in_cache：当前Query Cache中cache的Query数量； 
Qcache_total_blocks：当前Query Cache中的block数量；。 
我们再查询一下服务器关于query_cache的配置：

上图可以看出query_cache_type为off表示不缓存任何查询
修改/etc/my.cnf,配置完后的部分文件如下：
query_cache_size=256M
query_cache_type=1

6）max_connect_errors是一个mysql中与安全有关的计数器值，它负责阻止过多尝试失败的客户端以防止暴力破解密码等情况，当超过指定次数，mysql服务器将禁止host的连接请求，直到mysql服务器重启或通过flush hosts命令清空此host的相关信息 max_connect_errors的值与性能并无太大关系。
修改/etc/my.cnf文件，在[mysqld]下面添加如下内容
max_connect_errors=20
修改完后重启mysql服务


7）sort_buffer_size
每个需要进行排序的线程分配该大小的一个缓冲区。增加这值加速ORDER BY 或GROUP BY操作，Sort_Buffer_Size并不是越大越好，由于是connection级的参数，过大的设置+高并发可能会耗尽系统内存资源。列如：500个连接将会消耗500*sort_buffer_size（2M）=1G内存
修改/etc/my.cnf文件，在[mysqld]下面添加如下：
sort_buffer_size=2M


8）max_allowed_packet=32M
mysql根据配置文件会限制，server接受的数据包大小。有时候大的插入和更新会受max_allowed_packet参数限制，导致写入或者更新失败，更大值是1GB，必须设置1024的倍数
9）join_buffer_size=2M
用于表间关联缓存的大小，和sort_buffer_size一样，该参数对应的分配内存也是每个连接独享。


10）thread_cache_size = 300   
服务器线程缓存，这个值表示可以重新利用保存在缓存中线程的数量,当断开连接时,那么客户端的线程将被放到缓存中以响应下一个客户而不是销毁(前提是缓存数未达上限),如果线程重新被请求，那么请求将从缓存中读取,如果缓存中是空的或者是新的请求，那么这个线程将被重新创建,如果有很多新的线程，增加这个值可以改善系统性能.通过比较 Connections 和 Threads_created 状态的变量，可以看到这个变量的作用。设置规则如下：1GB 内存配置为8，2GB配置为16，3GB配置为32，4GB或更高内存，可配置更大。服务器处理此客户的线程将会缓存起来以响应下一个客户而不是销毁(前提是缓存数未达上限)
11.innodb_buffer_pool_size
对于InnoDB表来说，innodb_buffer_pool_size的作用就相当于key_buffer_size对于MyISAM表的作用一样。InnoDB使用该参数指定大小的内存来缓冲数据和索引。对于单独的MySQL数据库服务器，最大可以把该值设置成物理内存的80%。

mysql> show variables like'innodb_buffer_pool_size'; 

设置innodb_buffer_pool_size
修改/etc/my.cnf文件，在[mysqld]下面添加如下内容

innodb_buffer_pool_size= 2048M  

重启MySQL Server进入后，查看设置已经生效。
12. innodb_flush_log_at_trx_commit
主要控制了innodb将log buffer中的数据写入日志文件并flush磁盘的时间点，取值分别为0、1、2三个。0，表示当事务提交时，不做日志写入操作，而是每秒钟将log buffer中的数据写入日志文件并flush磁盘一次；1，则在每秒钟或是每次事物的提交都会引起日志文件写入、flush磁盘的操作，确保了事务的ACID；设置为2，每次事务提交引起写入日志文件的动作，但每秒钟完成一次flush磁盘操作。
实际测试发现，该值对插入数据的速度影响非常大，设置为2时插入10000条记录只需要2秒，设置为0时只需要1秒，而设置为1时则需要229秒。因此，MySQL手册也建议尽量将插入操作合并成一个事务，这样可以大幅提高速度。
根据MySQL手册，在允许丢失最近部分事务的危险的前提下，可以把该值设为0或2。


13.innodb_thread_concurrency = 0   
此参数用来设置innodb线程的并发数量，默认值为0表示不限制，若要设置则与服务器的CPU核数相同或是cpu的核数的2倍，建议用默认设置，一般为8.


14.innodb_log_buffer_size
此参数确定些日志文件所用的内存大小，以M为单位。缓冲区更大能提高性能，对于较大的事务，可以增大缓存大小。
innodb_log_buffer_size=32M


15. innodb_log_file_size = 50M  
此参数确定数据日志文件的大小，以M为单位，更大的设置可以提高性能.


16. innodb_log_files_in_group = 3  
为提高性能，MySQL可以以循环方式将日志文件写到多个文件。推荐设置为3


17.read_buffer_size = 1M  
MySql 读入缓冲区大小。对表进行顺序扫描的请求将分配一个读入缓冲区，MySql会为它分配一段内存缓冲区。如果对表的顺序扫描请求非常频繁，并且你认为频繁扫描进行得太慢，可以通过增加该变量值以及内存缓冲区大小提高其性能。和 sort_buffer_size一样，该参数对应的分配内存也是每个连接独享


18.read_rnd_buffer_size = 16M   
MySql 的随机读（查询操作）缓冲区大小。当按任意顺序读取行时(例如，按照排序顺序)，将分配一个随机读缓存区。进行排序查询时，MySql会首先扫描一遍该缓冲，以避免磁盘搜索，提高查询速度，如果需要排序大量数据，可适当调高该值。但MySql会为每个客户连接发放该缓冲空间，所以应尽量适当设置该值，以避免内存开销过大。
注：顺序读是指根据索引的叶节点数据就能顺序地读取所需要的行数据。随机读是指一般需要根据辅助索引叶节点中的主键寻找实际行数据，而辅助索引和主键所在的数据段不同，因此访问方式是随机的。


19.bulk_insert_buffer_size = 64M   
批量插入数据缓存大小，可以有效提高插入效率，默认为8M


20.binary log
log-bin=/usr/local/mysql/data/mysql-bin
binlog_cache_size = 2M  //为每个session 分配的内存，在事务过程中用来存储二进制日志的缓存, 提高记录bin-log的效率。没有什么大事务，dml也不是很频繁的情况下可以设置小一点，如果事务大而且多，dml操作也频繁，则可以适当的调大一点。前者建议是--1M，后者建议是：即 2--4M
max_binlog_cache_size = 8M //表示的是binlog 能够使用的最大cache 内存大小
max_binlog_size= 512M  //指定binlog日志文件的大小，如果当前的日志大小达到max_binlog_size，还会自动创建新的二进制日志。你不能将该变量设置为大于1GB或小于4096字节。默认值是1GB。在导入大容量的sql文件时，建议关闭sql_log_bin，否则硬盘扛不住，而且建议定期做删除。
expire_logs_days = 7  //定义了mysql清除过期日志的时间。
二进制日志自动删除的天数。默认值为0,表示“没有自动删除”。
mysqladmin flush-logs 也可以重新开始新的binarylog 

以下是相关优化总结：

1. slow_query_log=1
2. slow_query_log_file = /usr/local/mysql/data/slow_query_log
3. long_query_time=1
4. log-queries-not-using-indexes
5. max_connections=1024
6. back_log=128
7. wait_timeout=60
8. interactive_timeout=7200
9. key_buffer_size=256M
10. query_cache_size=256M
11. query_cache_type=1
12. query_cache_limit=50M
13. max_connect_errors=20
14. sort_buffer_size=2M
15. max_allowed_packet=32M
16. join_buffer_size=2M
17. thread_cache_size=200
18. innodb_buffer_pool_size=2048M
19. innodb_flush_log_at_trx_commit=1
20. innodb_log_buffer_size=32M
21. innodb_log_file_size=128M
22. innodb_log_files_in_group=3
23. log-bin=mysql-bin
24. binlog_cache_size=2M
25. max_binlog_cache_size=8M
26. max_binlog_size=512M
27. expire_logs_days=7
28. read_buffer_size=1M
29. read_rnd_buffer_size=16M
30. bulk_insert_buffer_size=64M
31. server-id=1

将以上的参数添加到mysql主配置中然后重启服务优化结束后，再次进行压力测试，查看效果

到这里我们的MySQL正式安装完毕！在192.168.1.80 slave主机上安装MySQL和上面一样 这里不再做演示，在这里我slave主机已经安装好了

八、配置MySQL主主同步之高可用

1）master操作 开启二进制日志及ID如下：

1. vim /etc/my.cnf
2. log-bin=mysql-bin
3. server-id=1

重启Mysql服务
2）登录mysql服务器给从服务器授权

1. mysql> grant replication slave on *.* to myslave@ '192.168.1.80' identified by '123456';
2. mysql> flush privileges;
3. 查看xcache缓存命中mysql> -c请求 –n并发数 show master status;

其中file列显示日志名，position列显示偏移量，这两个值在后面的从服务器的时候需要用到。

3）配置从服务器

1. vim/etc/my.cnf
2. log-bin=mysql-bin
3. server-id=2此id不能和master一致

配置完成后重启mysql服务

4）登录mysql服务，配置同步

1. mysql> change master to
2. -> master_host= '192.168.1.70',
3. -> master_user= 'myslave',
4. -> master_password= '123456',
5. -> master_port= 3306,
6. -> master_log_file= 'mysql-bin.000003',
7. -> master_log_pos= 603;
8. Query OK, 0rows affected, 2 warnings (0.01 sec)

如果出现两个yes证明已经成功
5）配置1.80成为1.70的主服务器（主主同步）从服务器操作
mysql> grant replication slave on *.* to myslave@'192.168.1.70' identified by '123456';
mysql> flush privileges;

6）1.70去连接1.80数据库

到这里我们的主主同步已经完成了，接下来测试，在主上创建yankai的库，查看从是否同步

从服务器验证

在从上面创建CSDN库在主上验证

到这里我们的主主同步就已经成功搭建了，我们看下架构图走到了哪里

九、部署Xcache为PHP加速（php-xcache1操作：1.50主机）

1、下载Xcache

1. [root@php-xcache1 src] # wget http://xcache.lighttpd.net/pub/Releases/3.2.0/xcache-3.2.0.tar.gz
2. [root@php-xcache1 src] # cd xcache-3.2.0/
3. [root@php-xcache1 xcache -3.2 .0] # /usr/local/php5.6/bin/phpize 使用phpize生成./configure文件
4. [root@php-xcache1 xcache -3.2 .0] # ./configure --enable-xcache --enable-xcache-coverager --enable-xcache-optimizer --with-php-config=/usr/local/php5.6/bin/php-config && make && make install

安装完成之后，出现下面的界面，记住以下路径，后面会用到

2）创建 xcache 缓存文件

1. [root@php-xcache1 ~] # touch /tmp/xcache
2. [root@php-xcache1 ~] # chmod +777 /tmp/xcache

3）拷贝 xcache 后台管理程序到网站根目录

1. [root@php-xcache1 xcache -3.2 .0] # cd /usr/local/src/xcache-3.2.0/
2. [root@php-xcache1 xcache -3.2 .0] # cp -r htdocs/ /www/xcache

4）配置 php 支持 xcache  
vi / etc/php.ini #编辑配置文件，在最后一行添加以下内容

1. [xcache-common]
2. extension = /usr/local/php5 .6/lib/php/extensions/no-debug-zts -20131226/
3. [xcache.admin]
4. xcache.admin.enable_auth = Off
5. [xcache]
6. xcache.shm_scheme = "mmap"
7. xcache.size= 60M
8. xcache.count = 1
9. xcache.slots = 8K
10. xcache.ttl= 0
11. xcache.gc_interval = 0
12. xcache.var_size= 64M
13. xcache.var_count = 1
14. xcache.var_slots = 8K
15. xcache.var_ttl= 0
16. xcache.var_maxttl= 0
17. xcache.var_gc_interval = 300
18. xcache.test =Off
19. xcache.readonly_protection = Off
20. xcache.mmap_path = "/tmp/xcache"
21. xcache.coredump_directory = ""
22. xcache.cacher =On
23. xcache.stat=On
24. xcache.optimizer =Off
25. [xcache.coverager]
26. xcache.coverager =On
27. xcache.coveragedump_directory = ""

将 xcache 目录拷贝到 Nginx主机的网页文档目录下（192.168.1.30）

重启PHP测试：浏览器中输入http://192.168.1.30/xcache

出现以上界面证明安装成功，接下来我们使用ab工具来进行压力测试
ab -c 500 -n 10000 http://192.168.1.30/index.php   

进行第二次压力测试

-c请求 –n并发数

查看xcache缓存命中

以上是php1的xcache，在php2部署xcache的方式和上面一模一样，这里不在做演示。

十、搭建个人站点wordpress

在搭建个人站点之前我们会用到数据库，所以我们接下来在数据库中操作（1.70master）

数据库操作完成后我们在Nginx1主机上安装wordpress如下：

1. [root@nginxweb1 ~]# tar zxf wordpress-4 .9 .1-zh_CN .tar .gz
2. [root@nginxweb1 ~]# mv wordpress /* /www/
3. [root@nginxweb1 ~]# cd /www/
4. [root@nginxweb1 www]# ls

在Nginx1主机上给php1主机传送/www目录的所有文件如下：

传输完成后我们访问站点，http://192.168.1.30/

最后输入用户名密码登录即可！

第二个站点和第一个安装过程都是一样的，这里不在做演示了

web2搭建wordpress需要注意的地方：

访问测试：

http://192.168.1.30 && http://192.168.1.40

测试访问VIP地址是否正常

从上图可以看出VIP地址可以访问到我们的个人站点，但是我们怎么测试它是否代理到后端了呢？在访问页面中怎么才知道它是由后端的哪台web提供的页面呢？这时候我们可以通过访问日志来查看。如下：

Nginx-web1：操作

1. [root@nginxweb1 ~]# cd / usr/ local/ nginx/ logs/
2. [root@nginxweb1 logs]# > access .log

首先清空Nginx-web1主机上的访问日志，以及Nginx-web2的访问日志。

清空完成后我们再次通过VIP访问-随后查看web服务器的日志信息

查看日志

2、查看web2日志

再次刷新页面，查看web2日志

1.10就是我们的Nginx-cache-master主机，也就是前端的代理服务，说明一切都正常运行。

接下来我们看看我们在整个架构中走到了哪里

前端的我们已经结束了，接下来就是后端的Mysql以及缓存监控了如下：

后端的MySQL主从复制这里不在做演示了，我这边已经配置好了，主从复制的话可以参考中主主同步，都是一样的。

十一、配置Memcached+Mysql实现缓存

Memcached工作流程图如下：

1）首先需要安装memcached依赖库libevent

1. [root@memcached src]# tar zxf libevent-2 .0 .22-stable .tar .gz
2. [root@memcached src]# cd libevent-2 .0 .22-stable/
3. [root@memcached libevent-2.0.22-stable]# ./ configure && make && make install

2）安装Memcached

1. [root@memcached src]# tar zxf memcached-1 .4 .33 .tar .gz
2. [root@memcached src]# cd memcached-1 .4 .33/
3. [root@memcached memcached-1.4.33]# ./ configure --prefix=/ usr/ local/ memcached --with-libevent=/ usr/ local && make && make install

3）检测是否成功安装

4）配置环境变量

[root@memcached memcached-1.4.33]#vim ~/.bash_profile 

MEMCACHED_HOME=/usr/local/memcached
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MEMCACHED_HOME/lib

5）刷新用户环境变量并启动memcached

-d 选项是启动一个守护进程。
-m 分配给Memcache使用的内存数量，单位是MB，默认64MB。
-l 监听的IP地址。（默认：INADDR_ANY，所有地址）
-p 设置Memcache的TCP监听的端口，最好是1024以上的端口。
-u 运行Memcache的用户，如果当前为root的话，需要使用此参数指定用户。
-c 选项是最大运行的并发连接数，默认是1024。
-P 设置保存Memcache的pid文件。

6）编写memcached服务启动脚本

vim /etc/init.d/memcached

1. #!/ bin/ sh
2. #
3. # pidfile: / usr/ local/ memcached/ memcached .pid
4. # memcached_home: / usr/ local/ memcached
5. # chkconfig: 35 21 79
6. # description: Start and stop memcached Service
7. # Source function library
8. . / etc/ rc .d/ init .d/ functions
9. RETVAL=0
10. prog=" memcached"
11. basedir=/ usr/ local/ memcached
12. cmd=${basedir}/ bin/ memcached
13. pidfile="$ basedir/${prog} .pid"
14. #interface to listen on ( default: INADDR_ANY, all addresses)
15. ipaddr="192 .168 .1 .70"
16. #listen port
17. port=11211
18. #username for memcached
19. username=" root"
20. #max memory for memcached, default is 64 M
21. max_memory=2048
22. #max connections for memcached
23. max_simul_conn=10240
24. start() {
25. echo -n $"Starting service: $prog "
26. $cmd -d -m $max_memory -u $username -l $ipaddr -p $port -c $max_simul_conn -P $pidfile
27. RETVAL=$?
28. echo
29. [ $RETVAL -eq 0 ] && touch /var/lock/subsys/$prog
30. }
31. stop() {
32. echo -n $"Stopping service: $prog "
33. run_user=$(whoami)
34. pidlist=$(ps -ef | grep $run_user | grep memcached | grep -v grep | awk '{print($2)}')
35. for pid in $pidlist
36. do
37. kill -9 $pid
38. if [ $? -ne 0 ]; then
39. return 1
40. fi
41. done
42. RETVAL=$?
43. echo
44. [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/$prog
45. }
46. # See how we were called.
47. case "$ 1 " in
48. start)
49. start
50. ;;
51. stop)
52. stop
53. ;;
54. restart)
55. stop
56. start
57. ;;
58. *)
59. echo "Usage: $ 0 {start|stop|restart|status}"
60. exit 1
61. esac
62. exit $ RETVAL

给予权限

1. [root@memcached ~]# chmod + x / etc/ init .d/ memcached
2. [root@memcached ~]# chkconfig --add memcached
3. [root@memcached ~]# chkconfig memcached on

7）安装memcache客户端（在php主机操作）1.50

[root@php-xcache1 memcache-3.0.8]# ./configure --enable-memcache --with-php-config=/usr/local/php5.6/bin/php-config && make && make install

安装完后会出下面提示一定要把下面框内的记住后面会用的到  

打开php.ini添加如下：(如果不知道添加到哪，可以添加到最后一行)

检查php扩展是否正确的安装

打开浏览器测试：

测试代码：（Nginx&php操作）
vim /www/cs/test.php

2. $memcache = new Memcache;
3. $memcache->connect( '192.168.1.110', 11211) or die ( "Could not connect");
4. $version = $memcache->getVersion();
5. echo "Server's version: ".$version. "
   ";
6. $tmp_object = new stdClass;
7. $tmp_object->str_attr = 'test';
8. $tmp_object->int_attr = 123;
9. $memcache->set( 'key', $tmp_object, false, 10) or die ( "Failed to save data at the server");
10. echo "Store data in the cache (data will expire in 10 seconds)
    ";
11. $get_result = $memcache->get( 'key');
12. echo "Data from the cache:
    ";
13. var_dump($get_result);
14. ?>

以上的1.110IP地址是memcached服务端的IP地址，访问测试：192.168.1.30/cs/test.php

去连接memcached服务端端口号为11211 如果成功那么打印出版本号以及test&123（大概意思）如下:

使用memcached实现session共享

配置php.ini中的Session为memcached方式
session.save_handler = memcache
session.save_path = "tcp://192.168.1.110:11211?persistent=1&weight=1&timeout=1&retry_interval=15"

测试memcached可用性(Nginx&&PHP操作)
vim /www/cs/memcached.php

2. session_start();
3. if (! isset($_SESSION[ 'session_time']))
4. {
5. $_SESSION[ 'session_time'] = time();
6. }
7. echo "session_time:".$_SESSION[ 'session_time']. "
   ";
8. echo "now_time:".time(). "
   ";
9. echo "session_id:".session_id(). "
   " ";
10. ?>

以上代码中大概意思获取session-id，访问如下：

访问网址：http://192.168.1.30/cs/memcache.php
可以查看session_time是否为memcache中的session，同时可以在不同的服务器上修改不同的标识查看是否为不同的服务器上的。

可以直接使用sessionid去memcached中查询如下：（memcached主机操作）

提示：如果get不到，那么请重启php以及重新加载nginx，清除浏览器再次访问

测试memcache缓存数据库数据（MySQL服务器操作）

1. mysql> grant select on testdb1.* to user@ '%' identified by '123456';
2. Query OK, 0 rows affected, 1 warning (0.01 sec)

在web服务器上创建php脚本（192.168.1.30&&1.50操作）

vim /www/cs/yankerp.php

2. $memcachehost = '192.168.1.110';
3. $memcacheport = 11211;
4. $memcachelife = 60;
5. $memcache = new Memcache;
6. $memcache->connect($memcachehost,$memcacheport) or die ( "Could not connect");
7. $query= "select * from test1 limit 10";
8. $key=md5($query);
9. if(!$memcache->get($key))
10. {
11. $conn=mysql_connect( "192.168.1.70", "user", "123456");
12. mysql_select_db(testdb1);
13. $result=mysql_query($query);
14. while ($row=mysql_fetch_assoc($result))
15. {
16. $arr[]=$row;
17. }
18. $f = 'mysql';
19. $memcache->add($key,serialize($arr), 0, 30);
20. $data = $arr ;
21. }
22. else{
23. $f = 'memcache';
24. $data_mem=$memcache->get($key);
25. $data = unserialize($data_mem);
26. }
27. echo $f;
28. echo "
    ";
29. echo "$key";
30. echo "
    ";
31. //print_r($data);
32. foreach($data as $a)
33. {
34. echo "number is $a[id]";
35. echo "
    ";
36. echo "name is $a[name]";
37. echo "
    ";
38. }
39. ?>

写入脚本后访问测试：192.168.1.30/cs/yankerp.php

第二次访问memcached已经做了缓存，那么就不会调用数据库 f5刷新即可

出现了上图那么证明我们的memcached成功缓存MySQL了，在memcached2搭建和以上是一样的。memcached1缓存MySQLmaster，memcached2缓存MySQL-slave主机，这时候我们看看我们在整个架构中走到了哪里

前面我们已经做了Nginx+keepalived反向代理，LNMP分离部署的搭建，包括使用Xcache加速PHP服务，Mysql主主同步+主从复制，以上做了Memcached缓存Mysql数据库，那么就剩下zabbix监控了

十二、部署Zabbix监控系统

1）部署zabbix监控需要LNMP/LAMP的支持，所以我就不演示怎么搭建LNMP环境了。这边我已经安装好zabbix大家可以参考我的这篇文章：http://blog.csdn.net/qq_39591494/article/details/78983861

2、zabbix客户端安装（192.168.1.10&20&30&40操作）也就是全部的Nginx主机

既然我们要监控我们就要添加监控的主机，在添加监控主机之前我们需要在被监控主机上安装agent，安装agent很简单，我们也是按照安装zabbix-server的流程安装，不过在安装的过程中只指定agent就可以了。

1）安装zabbix-配置zabbix-agent

1. [root@nginx-cache-master10 ~]# tar zxf zabbix-3 .2 .1 .tar .gz
2. [root@nginx-cache-master10 ~]# cd zabbix-3 .2 .1/
3. [root@nginx-cache-master10 zabbix-3.2.1]# ./ configure --prefix=/ usr/ local/ zabbix --enable-agent && make; make install
4. [root@nginx-cache-master10 zabbix-3.2.1]# cp misc/ init .d/ fedora/ core/ zabbix_agentd / etc/ init .d/
5. [root@nginx-cache-master10 zabbix-3.2.1]# mkdir -p / usr/ local/ zabbix/ logs
6. [root@nginx-cache-master10 zabbix-3.2.1]# groupadd zabbix
7. [root@nginx-cache-master10 zabbix-3.2.1]# useradd -g zabbix zabbix
8. [root@nginx-cache-master10 zabbix-3.2.1]# chown -R zabbix :zabbix / usr/ local/ zabbix/

2）配置开机自启动

1. [root@nginx-cache-master10 zabbix-3.2.1]# chkconfig --add zabbix_agentd
2. [root@nginx-cache-master10 zabbix-3.2.1]# chkconfig zabbix_agentd on

3）修改zabbix开机启动脚本的安装目录

[root@nginx-cache-master10 zabbix-3.2.1]#vim /etc/rc.d/init.d/zabbix_agentd

[root@nginx-cache-master10 zabbix-3.2.1]# systemctl daemon-reload

4）编辑zabbix_agentd.conf修改如下：

[root@nginx-cache-master10 zabbix-3.2.1]#vim /usr/local/zabbix/etc/zabbix_agentd.conf

PidFile=/usr/local/zabbix/logs/zabbix_agentd.pid
LogFile=/usr/local/zabbix/logs/zabbix_agentd.log
Server=192.168.1.101
ListenPort=10050
ServerActive=192.168.1.101
Hostname=192.168.1.10
Timeout=15
Include=/usr/local/zabbix/etc/zabbix_agentd.conf.d/

注：
其中Server和ServerActive都指定zabbixserver的IP地址，不同的是，前者是被动后者是主动。也就是说Server这个配置是用来允许192.168.1.10这个ip来我这取数据。而serverActive的192.168.1.10的意思是，客户端主动提交数据给他。
Hostname=XXX,这个定义的名字必须和web页面里面host的名字一样。

启动zabbix-agent（测试中-关闭防火墙）

以上是Nginx-cache1-master配置 其他三台Nginx安装都一样，只是配置的hostname不同

到这里zabbix客户端已经安装完毕！接下来配置zabbix-server端来监控zabbix客户端

3、配置zabbix-server

先在“配置”-“主机”里添加主机监控，监控os资源：内存，cpu，io，负载，带宽等.

添加完成后选择模版如下：

到这里zabbix监控linux主机设置完成，以上是一台，我这边监控了4台****

检测Linux主机的cpu情况如下：包含（Nginx-master1&Nginx-slave2&Nginx-web1&Nginx-web2）

我们查看nginx-slave2主机的情况

配置zabbix-server监控web主机

1）添加应用集

不断刷新页面，效果如下：

2）触发器配置

到这里我们的触发器就配置好了，当访问192.168.1.150VIP地址时，访问的结果不等于200OK那么就会触发刚刚配置的参数！ 以上只是Nginx-master的主机，slave配置和master一样，web1web2写自己的IP地址不能写VIP地址

三、设置zabbix邮箱报警

abbix监控服务端、客户端都已经部署完成，被监控主机已经添加，Zabiix监控运行正常。在Zabbix服务端设置邮件报警，当被监控主机宕机或者达到触发器预设值时，会自动发送报警邮件到指定邮箱。

1）安装依赖包

[root@localhost ~]# yum install perl-Net-SSLeay perl-IO-Socket-SSL -y

2）解压软件，然后将sendemail复制到/usr/local/bin/目录下，并加上可执行权限，然后修改用户和群组

1. [root@localhost ~]# tar zxf sendEmail-v1 .56 .tar .gz
2. [root@localhost ~]# cd sendEmail-v1 .56/
3. [root@localhost sendEmail-v1.56]# cp sendEmail / usr/ local/ bin/ sendEmail
4. [root@localhost sendEmail-v1.56]# chown zabbix :zabbix / usr/ local/ bin/

/usr/local/bin/sendEmail -f [email protected] -t [email protected] -s smtp.163.com -u "Zabbix报警测试" -o message-content-type=html -o message-charset=utf8 -xu yankerpcs -xp **** -m "邮件告警正在测试中"

/usr/local/bin/sendEmail                     #命令主程序
-f  [email protected]                       #发件人邮箱
-t [email protected]                              #收件人邮箱
-s smtp.163.com                           #发件人邮箱的smtp服务器
-u "我是邮件主题"                               #邮件的标题
-o message-content-type=html          #邮件内容的格式,html表示它是html格式
-o message-charset=utf8                   #邮件内容编码
-xu yankerpcs                       #发件人邮箱的用户名
-xp **********                             #发件人邮箱密码  注意：此密码是授权码如果是163的话
-m "我是邮件内容"                             #邮件的具体内容

以上图中表示我们可以正常的接受邮件，接下来配置zabbix邮件告警！

在以下目录下创建报警脚本sendmail.sh

/usr/local/zabbix/share/zabbix/alertscripts

给mail脚本执行权限并执行测试！

接受到邮件说明我们脚本还是没问题的

上面的邮件脚本配置好后，就要在web端添加报警媒介，在web页面的管理，报警媒介类型页面，点击右边的创建媒体类型

进入创建页面，然后输入名称“邮件报警脚本”，类型选择脚本，名称选择mail.sh，点击添加按钮，添加三个脚本参数，分别是{ALERT.SENDTO},{ALERT.SUBJECT},{ALERT.MESAGE}，分别对于mail.sh中的to、subject和body。添加完成后点下面的添加按钮，我们的报警媒介就创建完成了

创建好报警媒介后，就需要将报警媒介关联到我们的用户。点击管理，用户，然后选择我们的用户admin也可新建一个用户，点击用户名就进入到用户配置界面。点击报警媒介，然后点添加，选择我们上一步创建的邮件报警脚本，输入收件人，选择报警时间和类型，然后点击添加，就将创建好的报警媒介关联到我们的用户上面了。

现在需要做的是，创建一个触发动作，即系统出现故障时，触发这个动作，然后给我们的邮箱发送报警邮件。点击配置，选择动作，然后点击右边的创建动作。在动作这一页名称中写入我们定义的动作名以及触发条件

步骤是1-3,也即是从1开始到3结束。一旦故障发生，就是执行Email.sh脚本发生报警邮件给zabbix用户。 
假如故障持续了1个小时，它也只发送3次，第1-3次（即前3次）邮箱发送给zabbix用户，时间间隔为0秒。

设置恢复操作

测试：关闭掉所有的NGinx主机

是不是感觉好像缺了点什么。MySQL呢？ 其实我是想使用shell脚本的方式来监控Mysql服务如下：

1. #!/ bin/ bash
2. MMM=` netstat -lnt | grep 3306 | wc -l`
3. if [ "$MMM" -eq 0 ]
4. then
5. echo " MySQL宕机，正在重启" && systemctl start mysqld
6. else
7. echo " Mysql正在运行！"
8. fi

随后将他加入到定时任务每五分钟执行一次即可。可以在脚本中添加sendemail来进行报警通知

*/5 * * * * /bin/bash /home/sh/M.sh > /dev/null 2>&1