[TOC]

架构环境规划

wanip lanip hostname

192.168.203.134 192.168.202.5 lb01
192.168.203.6 192.168.202.6 lb02
192.168.203.129 192.168.202.7 web01
192.168.203.190 192.168.202.8 web02
192.168.203.9 192.168.202.9 web03
192.168.203.150 192.168.202.130 nfs
192.168.203.128 192.168.202.129 backup
192.168.203.192 192.168.202.51 db01
192.168.203.61 192.168.202.61 m01
192.168.203.71 192.168.202.71 zabbix

集群架构系统基础环境准备

1.安装全新Centos7系统，配置网卡为eth0及eth1命名模式

1.第一块网卡为NAT模式[公网环境]，配置的网段为192.168.203.0网段
2.第二块网卡为LAN模式[私网环境]，配置的网段为192.168.202.0网段
3.优化安装好的Centos7虚拟机，安装常用软件、关闭防火墙等等

2.优化步骤

1.配置yum仓库

rm -f /etc/yum.repos.d/*
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo`sed -i -e '/mirrors.cloud.aliyuncs.com/d' -e '/mirrors.aliyuncs.com/d' /etc/yum.repos.d/base.repo
yum makecache

2.安装基础软件包

yum install net-tools vim tree htop iftop \
iotop lrzsz sl wget unzip telnet nmap nc psmisc \
dos2unix bash-completion bash-completion-extra sysstat \
rsync nfs-utils httpd-tools -y

#3.关闭防火墙firewalld
systemctl disable firewalld
systemctl stop firewalld

#4. 关闭selinux
sed -i '/^SELINUX=/c SELINUX=disabled' /etc/selinux/config
#4.1 修改ssh连接
sed -ri '$aGSSAPIAuthentication no\nUseDNS no' /etc/ssh/sshd_config

#5.调整单个进程最大能打开文件的数量
echo '* - nofile 65535' >> /etc/security/limits.conf

3.基于优化后的虚拟机进行克隆
1.连接克隆（需要依赖于母体）
2.完整克隆（完完全全的复制一份，占用磁盘空间）

4.对新克隆后的主机进行如下操作:
1.修改主机名 hostnamectl set-hostname backup
2.修改IP地址sed -i 's#200#41#g' /etc/sysconfig/network-scripts/ifcfg-eth[01]
3.重启服务器
5.创建xshell标签->测试连接服务器是否成功

rsync

发送端和接收端都需要安装

rsync -avz /etc/passwd root@192.168.203.150:/tmp

4.用什么工具做备份？
scp 网络之间的拷贝，全量拷贝的方式 （ssh协议）
rsync 远程同步（增量）

备份的方式
完全备份，每次都进行全部备份 (效率低下, 占用空间)
增量备份，仅备份客户端与服务端差异的部分 (提高备份效率,节省空间, 适合异地备份 )
rsync数据的同步模式
推送： 本地将数据上传至备份服务器上 （上传）
拉取： 备份服务器获取本地服务器的数据 （下载）
rsync的数据传输方式
本地传输（类似于使用cp命令）
远程传输（通过网络传输 a—>b）
守护进程（运行一个服务一直在后台）

命令    选项      源文件   目标文件
Local:  rsync [OPTION...] SRC...   [DEST]
rsync -avz ./anaconda-ks.cfg /opt/    

Access via remote shell:（走的ssh协议）
拉取 Pull: rsync [OPTION...] [USER@]HOST:SRC... [DEST]
推送 Push: rsync [OPTION...] SRC... [USER@]HOST:DEST

推送方式：
##nfs----->推送方
##backup-->接收方

[root@nfs ~]# rsync -avz /etc/passwd root@172.16.1.41:/tmp
将本地的/etc/passwd文件，推送到172.16.1.41服务器的tmp目录下，使用的是41的root用户身份

拉取方式：
##nfs----->拉取方
##backup-->备份源
[root@nfs ~]# rsync -avz root@172.16.1.41:/etc/services ./
本地nfs服务器下载172.16.1.41服务器/etc/services这个文件，至本地当前目录下，使用的是41的系统用户root身份

Rsync借助SSH协议同步数据存在的缺陷（临时发送数据）
1.使用系统用户（不安全）
2.使用普通用户（会导致权限不足情况）


Access via rsync daemon:
下载 Pull: rsync [OPTION...] [USER@]HOST::SRC... [DEST]
    上传 Push: rsync [OPTION...] SRC... [USER@]HOST::DEST

主机角色 外网IP(NAT) 内网IP(LAN) 主机名称
Rsync服务端 192.168.203.41 192.168.202.129 backup
Rsync客户端 192.168.203.31 192.168.202.130 nfs

1.安装
yum install rsync -y
2.配置
[root@backup ~]# rpm -qc rsync
/etc/rsyncd.conf # 主配置文件<br />/etc/sysconfig/rsyncd # 选项

[root@backup ~]# cat /etc/rsyncd.conf 

uid = rsync
gid = rsync
port = 873
fake super = yes
use chroot = no
max connections = 200
timeout = 600
ignore errors
read only = false
list = false
auth users = rsync_backup
secrets file = /etc/rsync.passwd
log file = /var/log/rsyncd.log
#####################################
[backup]
comment = welcome to oldboyedu backup!
path = /backup

—- 配置详解
[root@backup ~]# vim /etc/rsyncd.conf
uid = rsync # 运行进程的用户
gid = rsync # 运行进程的用户组
port = 873 # 监听端口
fake super = yes # 无需让rsync以root身份运行，允许接收文件的完整属性
use chroot = no # 禁锢推送的数据至某个目录, 不允许跳出该目录
max connections = 200 # 最大连接数
timeout = 600 # 超时时间
ignore errors # 忽略错误信息
read only = false # 对备份数据可读写
list = false # 不允许查看模块信息
auth users = rsync_backup # 定义虚拟用户，作为连接认证用户
secrets file = /etc/rsync.passwd # 定义rsync服务用户连接认证密码文件路径

[backup] # 定义模块信息
comment = commit # 模块注释信息
path = /backup # 定义接收备份数据目录

创建rsync进程启动时需要使用的用户
[root[@backup ](/backup ) ~]# useradd rsync -M -s /sbin/nologin <br />[root@backup ~]# id rsync
uid=1000(rsync) gid=1000(rsync) groups=1000(rsync)

创建密码文件，在密码文件中写入对应的虚拟用户以及虚拟用户的密码
/etc/rsync.passwd—-》rsync虚拟用户以及rsync虚拟用户的密码
[root[@backup ](/backup ) ~]# echo "rsync_backup:123456" > /etc/rsync.passwd <br />[root[@backup ](/backup ) ~]# chmod 600 /etc/rsync.passwd
创建存储备份数据的目录，并进行授权
[root[@backup ](/backup ) ~]# mkdir /backup <br />[root[@backup ](/backup ) ~]# chown -R rsync.rsync /backup/
启动rsync服务并加入开机自启动
[root[@backup ](/backup ) ~]# systemctl start rsyncd.service && systemctl enable rsyncd
检查rsync的873端口是否存在
[root[@backup ](/backup ) ~]# netstat -lntp <br />Active Internet connections (only servers)<br />Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name<br />tcp 0 0 0.0.0.0:873 0.0.0.0:* LISTEN 11129/rsync
客户端测试
Access via rsync daemon:<br />下载 Pull: rsync [OPTION...] [USER@]HOST::SRC... [DEST]<br />上传 Push: rsync [OPTION...] SRC... [USER@]HOST::DEST

客户端nfs推送（注意加/ 和不加/的区别）
[root@nfs ~]# rsync -avz /etc/ rsync_backup@172.16.1.41::backup    #推送/etc/下面的内容
[root@nfs ~]# rsync -avz /etc rsync_backup@172.16.1.41::backup    #推送/etc这个目录

客户端拉取
[root@nfs ~]# rsync -avz rsync_backup@172.16.1.41::backup /opt
拉取服务端172.16.1.41的backup目录下面的所有内容至本地的 /opt目录

注意事项：
rsync_backup：客户端通过该虚拟用户连接rsync服务
是一个虚拟用户，由服务端的配置文件中定义【auth users】
通常存放在指定的一个文件中，该文件也是有服务端配置文件定义【secrets file】

rsync：【模块对应的目录，必须授权为配置文件中定义的uid和gid的用户】
    用于运行rsync服务时需要使用到的系统用户
    用于将接收到的数据以自己的身份写入到对应的目录中

实现客户端与服务端无差异同步：—delete
#推送方式实现无差异，以客户端为准，客户端有什么服务端就有什么
[root[@nfs ](/nfs ) ~]# rsync -avz --delete /root [rsync_backup@192.168.202.129](mailto:rsync_backup@172.16.1.41)::backup
#拉取方式实现无差异，以服务端为准，服务端有什么客户端就有什么
[root[@nfs ](/nfs ) ~]# rsync -avz --delete [rsync_backup@192.168.202.129](mailto:rsync_backup@172.16.1.41)::backup /opt/
对传输时候进行限速：
[root[@nfs ](/nfs ) ~]# dd if=/dev/zero of=./size.disk bs=1M count=500 生成大文件
限制传输的速率为1MB
[root[@nfs ](/nfs ) ~]# rsync -avzP --bwlimit=1 ./size.disk [rsync_backup@192.168.202.129](mailto:rsync_backup@172.16.1.41)::backup<br />``Password:<br />sending incremental file list<br />size.disk<br />118,358,016 22% 1.01MB/s 0:06:33

取消每次传输时需要输入密码【客户端才会配置】
方式一：
[root@nfs ~]# echo “123456” > /etc/rsync.pass
[root@nfs ~]# chmod 600 /etc/rsync.pass 上该文件找123456
[root@nfs ~]# rsync -avzP —bwlimit=1 ./size.disk rsync_backup@192.168.202.129::backup —password-file=/etc/rsync.pass
方式二：写Shell脚本
[root@nfs ~]# export RSYNC_PASSWORD=123456
[root@nfs ~]# rsync -avzP ./size.disk rsync_backup@192.168.202.129::backup

rsync参数：-avz
-a #归档模式传输, 等于-tropgDl
-v #详细模式输出, 打印速率, 文件数量等
-z #传输时进行压缩以提高效率
-r #递归传输目录及子目录，即目录下得所有目录都同样传输。
-t #保持文件时间信息
-o #保持文件属主信息
-p #保持文件权限
-g #保持文件属组信息
-l #保留软连接
-P #显示同步的过程及传输时的进度等信息
-D #保持设备文件信息
-L #保留软连接指向的目标文件
-e #使用的信道协议,指定替代rsh的shell程序 ssh
--exclude=PATTERN #指定排除不需要传输的文件模式
--exclude-from=file #文件名所在的目录文件
--bwlimit=100 #限速传输
--partial #断点续传
--delete #让目标目录和源目录数据保持一致

1.我要备份什么？
/etc/fstab /var/spool/cron/USERNAME /server/scripts
2.我要怎么备份？
/backup/主机名ip地址时间 命名的目录中

3.我要备份到哪？
rsync备份服务器 192.168.202.129
—————————————————————————————————————————————————

客户端

批量修改时间。并执行脚本，产生数据文件
[root@nfs ~]# for i in {1..30};do date -s 2018/12/$i;sh /server/scripts/client_push_data.sh ;done
[root@nfs ~]# cat /server/scripts/client_push_data.sh

#!/bin/bash
#1.定义变量
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
SRC=/backup
HOST=$(hostname)
ADDR=$(ifconfig eth1|awk 'NR==2 {print $2}')
DATE=$(date +%F)
DEST=${HOST}_${ADDR}_${DATE}
#2.创建目录
[ -d $SRC/$DEST ] || mkdir -p $SRC/$DEST

#3.备份文件
cd / && \
[ -f $SRC/$DEST/sys.tar.gz ] || tar czf $SRC/$DEST/sys.tar.gz etc/fstab etc/passwd && \
[ -f $SRC/$DEST/other.tar.gz ] || tar czf $SRC/$DEST/other.tar.gz var/spool/cron/ server/scripts && \

#4.使用md5打标记
[ -f $SRC/$DEST/flag_$DATE ] || md5sum $SRC/$DEST/*.tar.gz  > $SRC/$DEST/flag_$DATE 

#4.本地推送到备份服务器
export RSYNC_PASSWORD=123456
rsync -avz $SRC/$DEST rsync_backup@172.16.1.41::backup

#5.保留本地最近7天的数据
find $SRC/ -type d -mtime +7|xargs rm -rf

服务端

1.配置邮件
[root@backup ~]# yum install mailx -y
[root@backup ~]# vim /etc/mail.rc
set from=123@qq.com
set smtp=smtps://smtp.qq.com:465
set smtp-auth-user=123@qq.com
set smtp-auth-password=xxxxxx
set smtp-auth=login
set ssl-verify=ignore
set nss-config-dir=/etc/pki/nssdb/

2.验证能否成功的发送邮件
[root@backup ~]# mkdir /server/scripts -p
[root@backup ~]# cat /server/scripts/check_client_data.sh

#!/bin/bash
#1.定义变量
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
SRC=/backup
DATE=$(date +%F)

#1.使用md5进行校验，并保存校验的结果
md5sum -c $SRC/*_$DATE/flag_$DATE > $SRC/result_$DATE

#2.将保存的结果文件发送给管理员
mail -s "Rsync Backup $DATE" 572891887@qq.com <$SRC/result_$DATE

#3.保留最近180天的数据
find $SRC/ -type d -mtime +180|xargs rm -rf

最后进行整体测试：
1.删除客户端的整个目录
2.删除服务端/backup下面的所有内容
3.编写定时任务测试【在修改客户端每天凌晨1点，服务端每天凌晨5点】

如何扩展备份多台服务器：
[root@web01 ~]# rsync -avz root@192.168.202.130:/server /
[root@web01 ~]# sh /server/scripts/client_push_data.sh

NFS

服务端安装

    [root@nfs ~]# yum install nfs-utils -y

配置

    [root@nfs ~]# cat /etc/exports<br />        /data 192.168.202.0/24(rw,sync,all_squash)

授权

    [root@nfs ~]# mkdir /data<br />        [root@nfs ~]# chown -R nfsnobody.nfsnobody /data/

启动

[root@nfs ~]# systemctl start nfs-server &&  systemctl enable nfs-server

检查

[root@nfs ~]# cat /var/lib/nfs/etab
/data 192.168.202.0/24(rw,sync,wdelay,hide,nocrossmnt,secure,root_squash,all_squash,no_subtree_check,secure_locks,acl,no_pnfs,anonuid=65534,anongid=65534,sec=sys,rw,secure,root_squash,all_squash)

客户端操作

安装

[root@nfs ~]# yum install nfs-utils -y #rpc软件包、showmount命令

启动

systemctl start rpcbind

检查nfs是否有共享的内容

[root@backup ~]# showmount -e 192.168.202.130
Export list for 192.168.202.130:
/data 192.168.202.0/24

挂载

[root@web01 ~]# mount -t nfs 192.168.202.130:/data /opt<br />    [root@web01 ~]# df -h<br />    Filesystem         Size  Used Avail Use% Mounted on<br />    /dev/sda3           99G  1.2G   98G   2% /<br />    devtmpfs           477M     0  477M   0% /dev<br />    tmpfs              488M     0  488M   0% /dev/shm<br />    tmpfs              488M  7.7M  480M   2% /run<br />    tmpfs              488M     0  488M   0% /sys/fs/cgroup<br />    /dev/sda1          197M  102M   96M  52% /boot<br />    tmpfs               98M     0   98M   0% /run/user/0<br />    192.168.202.130:/data   99G  1.8G   98G   2% /opt

尝试写入数据测试<br />    [root@web01 opt]# pwd<br />    /opt<br />    [root@web01 opt]# touch file <br />    [root@web01 opt]# mkdir test<br />    [root@web01 opt]# ll<br />    total 0<br />    -rw-r--r-- 1 nfsnobody nfsnobody 0 Jan  7 10:37 file<br />    drwxr-xr-x 2 nfsnobody nfsnobody 6 Jan  7 10:37 test

在客户端将nfs挂载信息写入/etc/fstab文件中

[root@web01 ~]#vim /etc/fstab <br />    192.168.202.130:/data                        /opt                   nfs     defaults 0 0<br />    mount -a   #验证fstab开机启动是否填写错误。<br />    nfs挂载：客户端当前的目录仅仅只是nfs服务端共享目录的一个入口文件<br />

nfs共享参数

ro 只读权限
root_squash 当NFS客户端以root管理员访问时，映射为NFS服务器的匿名用户(不常用)
no_root_squash 当NFS客户端以root管理员访问时，映射为NFS服务器的root管理员(不常用)
no_all_squash 无论NFS客户端使用什么账户访问，都不进行压缩
async 优先将数据保存到内存，然后再写入硬盘；这样效率更高，但可能会丢失数据
rw* 读写权限
sync* 同时将数据写入到内存与硬盘中，保证不丢失数据
all_squash 无论NFS客户端使用什么账户访问，均映射为NFS服务器的匿名用户(常用)
anonuid* 配置all_squash使用,指定NFS的用户UID,必须存在系统
anongid* 配置all_squash使用,指定NFS的用户UID,必须存在系统

验证ro权限
[root@nfs ~]# cat /etc/exports
/data 192.168.202.0/24(ro,sync,all_squash)
[root@nfs ~]# systemctl restart nfs-server
[root@web01 ~]# touch /opt/ttt
touch: cannot touch ‘/opt/ttt’: Read-only file system #通常这样的错误都是设定的ro权限导致

2.验证all_squash、anonuid、anongid权限
[root@nfs ~]# cat /etc/exports
/data 192.168.202.0/24(rw,sync,all_squash,anonuid=666,anongid=666)
创建用户
[root@nfs ~]# groupadd -g 666 www
[root@nfs ~]# useradd -u666 -g666 www
[root@nfs ~]# id www
uid=666(www) gid=666(www) groups=666(www)
授权
[root@nfs ~]# chown -R www.www /data/
重启
[root@nfs ~]# systemctl restart nfs-server

客户端重新挂载验证
[root@web01 opt]# touch file
[root@web01 opt]# touch test
[root@web01 opt]# ll
total 4
-rw-r—r— 1 666 666 0 Jan 7 11:29 file
-rw-r—r— 1 666 666 0 Jan 7 11:29 test

客户端如果觉得666不好看，建议在客户端上创建同名的用户以及uid
[root@web01 ~]# groupadd -g 666 www
[root@web01 ~]# useradd -u 666 -g 666 www
[root@web01 ~]# id www
uid=666(www) gid=666(www) groups=666(www)
[root@web01 ~]# ll /opt/
total 4
-rw-r—r— 1 www www 0 Jan 7 11:29 file
-rw-r—r— 1 www www 0 Jan 7 11:29 test

1.NFS存储优点
1.NFS文件系统简单易用、方便部署、数据可靠、服务稳定、满足中小企业需求。
2.NFS文件系统内存放的数据都在文件系统之上，所有数据都是能看得见。

2.NFS存储局限
1.存在单点故障, 如果构建高可用维护麻烦web->nfs(sersync)->backup
2.NFS数据明文, 并不对数据做任何校验。
3.客户端挂载NFS服务没有密码验证, 安全性一般(内网使用)

3.NFS应用建议
1.生产场景应将静态数据尽可能往前端推, 减少后端存储压力
2.必须将存储里的静态资源通过CDN缓存jpg\png\mp4\avi\css\js
3.如果没有缓存或架构本身历史遗留问题太大, 在多存储也无用

sample /etc/exports file
共享的目录 共享给谁(共享的参数)
/ master(rw) trusty(rw,no_root_squash)
/projects proj.local.domain(rw)
/usr .local.domain(ro) @trusted(rw)
/home/joe pc001(rw,all_squash,anonuid=150,anongid=100)
/pub *(ro,insecure,all_squash)
/srv/www -sync,rw server @trusted @external(ro)
/foo 2001:db8:9:e54::/64(rw) 192.0.2.0/24(rw)
/build buildhost[0-9].local.domain(rw)

sersync

案例: 实现web上传视频文件，实则是写入NFS至存储，当NFS存在新的数据则会实时的复制到备份服务器
角色 外网IP(NAT) 内网IP(LAN) 安装工具
web01 eth0:192.168.203.129 eth1:192.168.202.132 httpd php
nfs-server eth0:192.168.203.150 eth1:192.168.202.130 nfsServer、rsync+inotify+sersync
backup eth0:192.168.203.128 eth1:192.168.202.129 rsync-server

1.web上传视频至nfs存储

nfs存储服务 192.168.202.130

1.安装

    [root@nfs ~]# yum install nfs-utils -y

2.配置

    [root@nfs ~]# cat /etc/exports<br />        /data 192.168.202.0/24(rw,sync,all_squash,anonuid=666,anongid=666)<br />        [root@nfs ~]# groupadd -g666 www<br />        [root@nfs ~]# useradd -u666 -g666 www<br />        [root@nfs ~]# mkdir /data<br />        [root@nfs ~]# chown -R www.www /data

3.启动

    [root@nfs ~]# systemctl restart nfs-server && sysytemctl enable nfs-server

web服务器操作：192.168.202.132

1.安装

    [root@web01 ~]# yum install httpd php -y

2.配置

    进程运行的身份（最好是和nfs的匿名用户保持一致）<br />            [root@web01 html]# sed -i '/^User/c User www' /etc/httpd/conf/httpd.conf     <br />            [root@web01 html]# sed -i '/^Group/c Group www' /etc/httpd/conf/httpd.conf<br />        挂载<br />            [root@web01 ~]# mount -t nfs 192.168.202.130:/data /var/www/html        #核心<br />        上传代码<br />            [root@web01 ~]# cd /var/www/html/<br />            [root@web01 html]# rz kaoshi.zip<br />            [root@web01 html]# unzip kaoshi.zip

3.启动

    [root@web01 ~]# systemctl start httpd

4.修改上传大小

    [root@web01 ~]# vim /etc/php.ini中设置：<br />        upload_max_filesize = 200M;<br />        post_max_size = 200M;<br />

5.注意: 修改完配置记得重启服务

[root@web01 ~]#  systemctl restart httpd

2.web和nfs的数据都备份在备份服务器的/backup

备份服务器操作如下：192.168.202.129

1.安装

    [root@backup ~]# yum install rsync -y

2.配置

  • 修改配置文件的用户，组，备份目录

      [root@backup ~]# cat /etc/rsyncd.conf

          uid = www
      gid = www
      port = 873
      fake super = yes
      use chroot = no
      max connections = 200
      timeout = 600
      ignore errors
      read only = false
      list = true
      auth users = rsync_backup
      secrets file = /etc/rsync.passwd
      log file = /var/log/rsyncd.log
      #####################################
      [backup]
      path = /backup

      [data]
      path = /data

      <br />        创建用户<br />            [root@backup ~]# groupadd -g666 www<br />            [root@backup ~]# useradd -u666 -g666 www<br />        准备虚拟连接用户账号和密码<br />        [root@backup ~]# cat /etc/rsync.passwd <br />        rsync_backup:123456<br />        [root@backup ~]# chmod 600 /etc/rsync.passwd<br />        创建数据存放的目录<br />        [root@backup ~]# mkdir -p /data /backup<br />        [root@backup ~]# chown -R www.www /data/ /backup/

    3.启动

      [root@backup ~]# systemctl restart rsyncd

    4.客户端执行脚本

    测试rsync的备份是否ok （客户端的数据都写入到/backup目录中） 192.168.202.7 192.168.202.31
    [root@web01 ~]# sh /server/scripts/client_push_data.sh
    sending incremental file list
    web01_192.168.202.7_2019-01-08/
    web01_192.168.202.7_2019-01-08/flag_2019-01-08
    web01_192.168.202.7_2019-01-08/other.tar.gz
    web01_192.168.202.7_2019-01-08/sys.tar.gz

3.如何将nfs的数据实时的同步到备份服务器的/data目录
监控nfs服务器上面的/data目录，如果发生变化则触发动作，动作可以是执行一次同步。
1.安装
[root@nfs ~]# yum install inotify-tools 监控工具
[root@nfs ~]# rz -E sersync2.5.464bitbinarystablefinal.tar.gz
[root@nfs ~]# tar xf sersync2.5.464bitbinarystablefinal.tar.gz
[root@nfs ~]# mv GNU-Linux-x86/ /usr/local/sersync
2.配置
创建客户端密码文件
[root@nfs ~]# cat /etc/rsync.passwd
123456
[root@nfs ~]# chmod 600 /etc/rsync.passwd
3.启动
[root@nfs ~]# /usr/local/sersync/sersync2 -h
set the system param
execute：echo 50000000 > /proc/sys/fs/inotify/maxuserwatches
execute：echo 327679 > /proc/sys/fs/inotify/maxqueuedevents
parse the command param
_
参数-d:启用守护进程模式
参数-r:在监控前，将监控目录与远程主机用rsync命令推送一遍
参数-n: 指定开启守护线程的数量，默认为10个
参数-o:指定配置文件，默认使用confxml.xml文件
参数-m:单独启用其他模块，使用 -m refreshCDN 开启刷新CDN模块
参数-m:单独启用其他模块，使用 -m socket 开启socket模块
参数-m:单独启用其他模块，使用 -m http 开启http模块
不加-m参数，则默认执行同步程序

安装监控工具
yum -y install inotify-tools
启动
[root@nfs ~]# /usr/local/sersync/sersync2 -dro /usr/local/sersync/confxml.xml
#启动sersync后一定要提取同步的命令，手动运行一次，检查是否存在错误

cd /data && rsync -az -R --delete ./  --timeout=100 rsync_backup@192.168.202.129::data --password-file=/etc/rsync.passwd >/dev/null 2>&1

停止<br />    [root@nfs data]# pkill sersync<br />

4.如何平滑的迁移nfs数据到backup服务器。并且让后续的上传都是上传至backup （不能出现业务中断）
1.backup服务器上需要运行和nfs服务器上一样的业务环境
创建用户
[root@backup ~]# groupadd -g 666 www
[root@backup ~]# useradd -u666 -g666 www
配置
[root@backup ~]# yum install -y nfs-utils -y
[root@backup ~]# cat /etc/exports
/data 192.168.202.0/24(rw,sync,all_squash,anonuid=666,anongid=666)
启动
[root@backup ~]# systemctl restart nfs-server

2.先实现实时的同步 √

3.在web上实现切换，卸载nfs的/data目录，重新挂载backup服务的/data目录<br />        [root@web01 ~]# umount -lf /var/www/html/ && mount -t nfs 192.168.202.129:/data /var/www/html/<br />

项目需求： 最近涉及到数百万张图片从本地存储迁移到云存储，为了使完成图片迁移，并保证图片无缺失，业务不中断，决定采用实时同步，同步完后再做流量切换。在实时同步方案中进行了几种尝试。
实施步骤
项目总结
sersync对数百万张图片数据做到了实时同步，新增的数据能够立马同步到另一台，最后上百G的图片数据实现了在线迁移。

实时同步：
1.为什么要使用实时同步？
1.解决nfs单点
2.大量的静态资源迁移（本地迁移云端）
2.实时同步能解决什么问题？
1.平滑的迁移
2.备份：减少人为的干预
3.实时同步工具选择？
rsync+inotify 少量文件同步，麻烦。同步大文件太慢，遍历扫描，非常影响效率。
sersync 配置简单，多线程同步，同步块。适合大量的小文件或者图片。
lsryncd

4.demo：用户上传文件—>web—>写入—>nfs存储—>inotify—>action—>rsync—->backup

用户上传文件—>web—>写入—>nfs存储（本地）—->实时的同步到—>存储（云端）
web—>卸载存储（本地）—->重新挂载存储(云端)
——————————————————————————————————————————————————————
备份客户端的脚本如下
[root@web01 ~]#vi /server/scripts/client_push_data.sh

#!/bin/bash
#1.定义变量
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
SRC=/backup
HOST=$(hostname)
ADDR=$(ifconfig eth1|awk 'NR==2 {print $2}')
DATE=$(date +%F)
DEST=${HOST}_${ADDR}_${DATE}

#2.创建目录
[ -d $SRC/$DEST ] || mkdir -p $SRC/$DEST

#3.备份文件
cd / && \
[ -f $SRC/$DEST/sys.tar.gz ] || tar czf $SRC/$DEST/sys.tar.gz etc/fstab etc/passwd && \
[ -f $SRC/$DEST/other.tar.gz ] || tar czf $SRC/$DEST/other.tar.gz var/spool/cron/ server/scripts && \

#4.使用md5打标记
[ -f $SRC/$DEST/flag_$DATE ] || md5sum $SRC/$DEST/*.tar.gz  > $SRC/$DEST/flag_$DATE 

#4.本地推送到备份服务器
export RSYNC_PASSWORD=123456
rsync -avz $SRC/$DEST rsync_backup@192.168.202.129::backup

#5.保留本地最近7天的数据
find $SRC/ -type d -mtime +7|xargs rm -rf

ssh

密钥：
1.生成密钥对 公钥 私钥
[root@m01 ~]# ssh-keygen -C lzc@qq.com
2.将公钥推送到你需要连接的主机，第一次需要输入对端主机的密码
[root@m01 ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@172.16.1.31
root@172.16.1.31’s password:
3.通过ssh命令测试连接是否需要密码
[root@m01 ~]# ssh 172.16.1.31
Last login: Wed Jan 9 10:39:16 2019 from 172.16.1.61

SSH作为远程连接服务，通常我们需要考虑到该服务的安全，所以需要对该服务进行安全方面的配置。
1.更改远程连接登陆的端口 6666
2.禁止ROOT管理员直接登录
3.密码认证方式改为密钥认证
4.重要服务不使用公网IP地址
5.使用防火墙限制来源IP地址
Port 6666 # 变更SSH服务远程连接端口√
PermitRootLogin no # 禁止root用户直接远程登录√
PasswordAuthentication no # 禁止使用密码直接远程登录√
UseDNS no # 禁止ssh进行dns反向解析，影响ssh连接效率参数√
GSSAPIAuthentication no # 禁止GSS认证，减少连接时产生的延迟√

ssh服务
telnet和ssh协议之间区别
ssh客户端
ssh 远程连接
scp 远程拷贝
sftp 远程传输

ssh登录方式
用户密码
密钥方式
ssh-keygen 生成密钥对命令
ssh-copy-id 推送公钥的脚本

用户—公网—>跳板机的ssh服务—内网—>连接后端服务器
Windows生成密钥
Linux生成密钥
MAC
ssh安全
防止别人攻击，或者暴力破解
修改服务器连接端口
禁止root直接远程登录
禁止直接使用密码认证
—————————————重要的服务部使用公网IP

fail2ban 工具
fail2ban可以监控系统日志，并且根据一定规则匹配异常IP后使用Firewalld将其屏蔽，尤其是针对一些爆破/扫描等非常有效。
1.开启Firewalld防火墙
[root@bgx ~]# systemctl start firewalld
[root@bgx ~]# systemctl enable firewalld
[root@bgx ~]# firewall-cmd —state
running

2.修改firewalld规则，启用Firewalld后会禁止一些服务的传输，但默认会放行常用的22端口, 如果想添加更多，以下是放行SSH端口（22）示例，供参考：
#放行SSHD服务端口
[root@bgx ~]# firewall-cmd —permanent —add-service=ssh —add-service=http
#重载配置
[root@bgx ~]# firewall-cmd —reload
#查看已放行端口
[root@bgx ~]# firewall-cmd —list-service

3.安装fail2ban,需要有epel
[root@bgx ~]# yum install fail2ban fail2ban-firewalld mailx -y

4.配置fail2ban规则.local会覆盖.conf文件
[root@bgx fail2ban]# cat /etc/fail2ban/jail.local

[DEFAULT]
ignoreip = 127.0.0.1/8
bantime  = 86400
findtime = 600
maxretry = 5
banaction = firewallcmd-ipset
action = %(action_mwl)s

[sshd]
enabled = true
filter  = sshd
port    = 22
action = %(action_mwl)s
logpath = /var/log/secure

5.启动服务，并检查状态
[root@bgx ~]# systemctl start fail2ban.service
[root@bgx ~]# fail2ban-client status sshd

6.清除被封掉的IP地址
[root@bgx ~]# fail2ban-client set sshd unbanip 10.0.0.1

LNMP

1.使用官方仓库安装Nginx

[root@nginx ~]# cat /etc/yum.repos.d/nginx.repo
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=0
enabled=1

安装Nginx
[root@nginx ~]# yum install nginx -y

2.安装php7.1

[root@nginx ~]# yum remove php-mysql-5.4 php php-fpm php-common
[root@nginx ~]# cat /etc/yum.repos.d/php.repo
[php]
name = php Repository
baseurl = http://us-east.repo.webtatic.com/yum/el7/x86_64/
gpgcheck = 0

[root@nginx ~]# yum -y install php71w php71w-cli php71w-common php71w-devel php71w-embedded php71w-gd php71w-mcrypt php71w-mbstring php71w-pdo php71w-xml php71w-fpm php71w-mysqlnd php71w-opcache php71w-pecl-memcached php71w-pecl-redis php71w-pecl-mongodb

3.安装Mariadb数据库

[root@nginx ~]# yum install mariadb-server mariadb -y

4.配置nginx与php集成

[root@web01 conf.d]# vim php.conf
server {
listen 80;
server_name php.oldboy.com;
root /code;

location / {<br />        index index.php index.html;<br />    }

location ~ \.php$ {<br />        fastcgi_pass 127.0.0.1:9000;<br />        #php路径 $document_root$fastcgi_script_name<br />        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;<br />        include fastcgi_params;<br />    }<br />}

5.重载Nginx

[root@web01 conf.d]# nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
[root@web01 conf.d]# nginx -s reload

6.启动php-fpm

[root@web01 conf.d]# systemctl start php-fpm && systemctl enable php-fpm

7.测试nginx与php是否集成成功

[root@web01 conf.d]#vi /code/page.php

<?php
    phpinfo();
?>

8.启动数据库

[root@web01 conf.d]# systemctl start mariadb && systemctl enable mariadb
[root@web01 conf.d]# mysqladmin password ‘Bgx123.com’ #配置密码（默认mysql是空密码）
[root@web01 conf.d]# mysql -uroot -pBgx123.com #使用账号和密码登录mysql

9.测试能否正常连接数据库

vi test.php

<?php
    $servername = "localhost";
    $username = "root";
    $password = "Bgx123.com";

    // 创建连接
    $conn = mysqli_connect($servername, $username, $password);

    // 检测连接
    if (!$conn) {
        die("Connection failed: " . mysqli_connect_error());
    }
    echo "php连接MySQL数据库成功";
?>

10.部署wordpress

[root@web01 conf.d]# cat blog.oldboy.com.conf 

server {
    listen 80;
    server_name blog.oldboy.com;
    root /code/wordpress;

    location / {
        index index.php index.html;
    }

    location ~ \.php$ {
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

11.根据nginx中定义的内容，创建站点目录并且进行授权

[root@web01 conf.d]# mkdir /code
[root@web01 conf.d]# cd /code
[root@web01 code]# wget https://cn.wordpress.org/wordpress-5.0.3-zh_CN.tar.gz
[root@web01 code]# tar xf wordpress-5.0.3-zh_CN.tar.gz

12.修改nginx与php-fpm的运行用户为www，并授权代码属主和属组都为www

注意：如果没有该用户，启动一定会报错
[root@web01 code]# groupadd -g 666 www
[root@web01 code]# useradd -u666 -g666 www

修改nginx与php-fpm管理进程，的运行身份为www
[root@web01 code]# sed -i ‘/^user /c user www;’ /etc/nginx/nginx.conf
[root@web01 code]# sed -i ‘/^user/c user = www’ /etc/php-fpm.d/www.conf
[root@web01 code]# sed -i ‘/^group/c group = www’ /etc/php-fpm.d/www.conf

一定要重启才生效
[root@web01 code]# nginx -s reload
[root@web01 code]# systemctl restart php-fpm

最后授权代码为www
[root@web01 code]# chown -R www.www /code/wordpress

13.创建数据库

MariaDB [(none)]> create database wordpress; #创建一个库，名称叫wordpress
Query OK, 1 row affected (0.00 sec)

MariaDB [(none)]> show databases; #查询该台数据库服务有多少个库
+——————————+
| Database |
+——————————+
| information_schema |
| mysql |
| performance_schema |
| test |
| wordpress |
+——————————+
5 rows in set (0.00 sec)

14.解决nginx上传文件大小限制

 client_max_body_size 100m;            #默认nginx仅支持上传1m大小的文件<br />    [root@web01 code]# systemctl restart nginx

wecenter知乎
[root@web01 conf.d]# cat zh.oldboy.com.conf
server {
listen 80;
server_name zh.oldboy.com;
root /code/zh;
client_max_body_size 100m;

location / {<br />        index index.php index.html;<br />    }

location ~ \.php$ {<br />        fastcgi_pass 127.0.0.1:9000;<br />        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;<br />        include fastcgi_params;<br />    }<br />}<br />[root@web01 code]# systemctl restart nginx

2.下载软件
[root@web01 code]# rz -E WeCenter_3-2-1.zip
[root@web01 code]# unzip WeCenter_3-2-1.zip
[root@web01 code]# mv WeCenter_3-2-1 zh
[root@web01 code]# chown -R www.www zh/

3.配置数据库
[root@web01 code]# mysql -uroot -pBgx123.com
MariaDB [(none)]> create database zh;
MariaDB [(none)]> show databases;
+——————————+
| Database |
+——————————+
| information_schema |
| mysql |
| performance_schema |
| test |
| wordpress |
| zh |
+——————————+
6 rows in set (0.00 sec)

———————————————————————————————————————————————————
edusoho
1.配置nginx
[root@web01 code]# cat /etc/nginx/conf.d/edu.oldboy.com.conf
server {
listen 80;
server_name edu.oldboy.com;
root /code/edusoho/web;
client_max_body_size 200m;

location / {<br />        index app.php;<br />        try_files $uri @rewriteapp;<br />    }<br />    location @rewriteapp {<br />        rewrite ^(.*)$ /app.php/$1 last;<br />    }

location ~ ^/udisk {<br />        internal;<br />        root /code/edusoho/app/data/;<br />    }

location ~ ^/(app|app_dev)\.php(/|$) {<br />        fastcgi_pass   127.0.0.1:9000;<br />        fastcgi_split_path_info ^(.+\.php)(/.*)$;<br />        include fastcgi_params;<br />        fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;<br />        fastcgi_param  HTTPS              off;<br />        fastcgi_param HTTP_X-Sendfile-Type X-Accel-Redirect;<br />        fastcgi_param HTTP_X-Accel-Mapping /udisk=/code/edusoho/app/data/udisk;<br />        fastcgi_buffer_size 128k;<br />        fastcgi_buffers 8 128k;<br />    }

# 配置设置图片格式文件<br />    location ~* \.(jpg|jpeg|gif|png|ico|swf)$ {<br />        # 过期时间为3年<br />        expires 3y;<br />        # 关闭日志记录<br />        access_log off;<br />        # 关闭gzip压缩，减少CPU消耗，因为图片的压缩率不高。<br />        gzip off;<br />    }<br />    # 配置css/js文件<br />    location ~* \.(css|js)$ {<br />        access_log off;<br />        expires 3y;<br />    }<br />    # 禁止用户上传目录下所有.php文件的访问，提高安全性<br />    location ~ ^/files/.*\.(php|php5)$ {<br />        deny all;<br />    }

# 以下配置允许运行.php的程序，方便于其他第三方系统的集成。<br />    location ~ \.php$ {<br />        fastcgi_pass   127.0.0.1:9000;<br />        fastcgi_split_path_info ^(.+\.php)(/.*)$;<br />        include fastcgi_params;<br />        fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;<br />        fastcgi_param  HTTPS              off;<br />    }<br />}

2.下载软件，并且授权
wget http://download.edusoho.com/edusoho-8.2.17.tar.gz
tar xf edusoho-8.2.17.tar.gz
chown -R www.www edusoho

3.调整php的上传大小
[root@web01 ~]# vim /etc/php.ini
post_max_size = 200M
upload_max_filesize = 200M
[root@web01 code]# systemctl restart php-fpm

lnmp拆分

1.lnmp架构，实现原理？
blog.oldboy.com/test.png
blog.oldboy.com/page.php

nginx —> fastcgi —> php-fpm
fastcgi_pass address:port;
10.0.0.8:9000;
unix:/tmp/php.socket

2.如果关闭后端的php则会出现502错误？

3.nginx+php与apache+php的区别是什么？
nginx 是以fastcgi协议调用的php
apache是以模块的方式加载的php
4.数据库拆分环境规划
主机名称 应用环境 外网地址 内网地址
web01 nginx+php 192.168.202.132 192.168.203.129
db01 mysql 192.168.203.192

1.备份192.168.202.132服务器上mysql的数据

[root@web01 ~]# mysqldump -uroot -p'Bgx123.com' --all-databases --single-transaction > mysql-all.sql

2.传输192.168.202.132的备份数据至192.168.203.192的服务器上

[root@web01 ~]# scp mysql-all.sql root@192.168.203.192:/root

3.需要先在192.168.203.192服务器上安装mysql服务，然后使用mysql命令进行还原。

[root@db01 ~]# yum install mariadb-server mariadb -y
[root@db01 ~]# systemctl enable mariadb && systemctl start mariadb
[root@db01 ~]# mysql </root/mysql-all.sql
[root@db01 ~]# systemctl restart mariadb
[root@db01 ~]# mysql -uroot -pBgx123.com
MariaDB [(none)]> show databases;
+——————————+
| Database |
+——————————+
| information_schema |
| edusoho |
| mysql |
| performance_schema |
| test |
| wordpress |
| zh |
+——————————+
7 rows in set (0.00 sec)

4.将web程序连接的本地数据库修改到远程数据库上。

1）先在本地192.168.202.132服务器上停止本地的数据库<br />    [root@web01 ~]# systemctl disable mariadb<br />    [root@web01 ~]# systemctl stop mariadb<br />    <br />    2）在192.168.203.192的服务器上授权远程主机能够能连接mysql数据库<br />    [root@db01 ~]# mysql -uroot -pBgx123.com<br />    MariaDB [(none)]> grant all privileges on *.* to oldboy@'%' identified by 'Bgx123.com';<br />    <br />    3）在192.168.202.132服务器上测试远程账户能否连接192.168.203.192的数据库<br />    [root@web01 wordpress]# yum install mariadb -y<br />    [root@web01 wordpress]# mysql -h 192.168.203.192 -uoldboy -pBgx123.com<br />    MariaDB [(none)]> 

4）在192.168.202.132服务器上修改web程序连接数据库的配置文件<br />    [root@web01 wordpress]# vim /code/wordpress/wp-config.php<br />    // ** MySQL 设置 - 具体信息来自您正在使用的主机 ** //<br />    /** WordPress数据库的名称 */<br />    define('DB_NAME', 'wordpress');

/** MySQL数据库用户名 */<br />**    define('DB_USER', 'oldboy');**

/** MySQL数据库密码 */<br />    define('DB_PASSWORD', 'Bgx123.com');

/** MySQL主机 */<br />**    define('DB_HOST', '192.168.203.192');**

5.拆分192.168.202.132wecenter连接远程192.168.203.192数据库信息

[root@web01 zh]# vim /code/zh/system/config/database.php <br />        $config['driver'] = 'MySQLi';^M<br />        $config['master'] = array (<br />          'charset' => 'utf8',<br />**          'host' => '192.168.203.192',**<br />**          'username' => 'oldboy',**<br />          'password' => 'Bgx123.com',<br />          'dbname' => 'zh',<br />        );^M

6.拆分192.168.202.132 edusoho连接远程192.168.203.192数据库信息
[root@web01 edusoho]# vim /code/edusoho/app/config/parameters.yml
database_driver: pdo_mysql
database_host: 192.168.203.192
database_port: 3306
database_name: edusoho
database_user: oldboy
database_password: ‘Bgx123.com’

必须清理缓存<br />    [root@web01 edusoho]# rm -rf /code/edusoho/app/cache/*<br />

扩展多台web

关闭防火墙和selinux

1.统一环境

    0）准备对应的www用户<br />            [root@web02 ~]# groupadd -g666 www<br />            [root@web02 ~]# useradd -u666 -g666 www

    1）拷贝web01上面的yum仓库<br />            [root@web02 ~]# scp root@192.168.202.132:/etc/yum.repos.d/*.repo /etc/yum.repos.d/<br />            <br />        2）安装nginx和php<br />            [root@web02 ~]# yum -y install nginx php71w php71w-cli php71w-common php71w-devel php71w-embedded php71w-gd php71w-mcrypt php71w-mbstring php71w-pdo php71w-xml php71w-fpm php71w-mysqlnd php71w-opcache php71w-pecl-memcached php71w-pecl-redis php71w-pecl-mongodb

2.统一配置（同步web01上面的配置到web02）

    1）同步nginx<br />        [root@web02 ~]# rsync  -avz --delete root@192.168.202.132:/etc/nginx/ /etc/nginx/<br />        [root@web02 ~]# nginx -t<br />        [root@web02 ~]# systemctl enable nginx && systemctl start nginx

    2）同步php（/etc/php-fpm.conf /etc/php-fpm.d  /etc/php.ini）<br />        [root@web02 ~]# rsync  -avz --delete root@192.168.202.132:/etc/php* /etc/<br />        [root@web02 ~]# systemctl enable php-fpm && systemctl start php-fpm

3.统一代码

    [root@web01 ~]# tar czf code.tar.gz /code                #在web01上打包站点<br />        [root@web01 ~]# scp code.tar.gz root@192.168.203.190:/tmp    #在web01上将打包好的代码发送给web02<br />        [root@web02 ~]# tar xf /tmp/code.tar.gz -C /            #在web02上进行解压，并解压到/目录下

4.配置host解析，进行访问

共享多台web的静态资源

1.准备192.168.202.130共享存储服务器，规划目录，配置好权限

    0）创建用户<br />            [root@nfs ~]# groupadd -g666 www<br />            [root@nfs ~]# useradd -u666 -g666 www    <br />        <br />        1）安装<br />            [root@nfs ~]# yum install nfs-utils -y<br />            <br />        2）配置<br />            [root@nfs ~]# cat /etc/exports<br />            /data/blog 192.168.202.0/24(rw,sync,all_squash,anonuid=666,anongid=666)<br />            /data/zh 192.168.202.0/24(rw,sync,all_squash,anonuid=666,anongid=666)<br />            /data/edu 192.168.202.0/24(rw,sync,all_squash,anonuid=666,anongid=666)

    3）根据配置，创建目录，准备用户，授权等等<br />            [root@nfs ~]# rm -rf /data/<br />            [root@nfs ~]# mkdir /data/{blog,zh,edu} -p<br />            [root@nfs ~]# chown -R www.www /data/<br />        <br />        4）启动<br />            [root@nfs ~]# systemctl enable nfs-utils && systemctl restart nfs-utils<br />

2.将图片较多的web02服务器，推送到nfs共享存储上

    [root@web02 ~]# cd /code/wordpress/wp-content<br />        [root@web02 wp-content]# scp -r uploads/* root@192.168.203.150:/data/blog/<br />        注意：需要上nfs服务器上进行重新的递归授权，否则会出现无法上传文件的错误<br />        [root@nfs ~]# chown -R www.www /data/

3.web01和web02分别都进行挂载，此时图片进行实现了共享

    mount -t nfs 192.168.202.130:/data/blog  /code/wordpress/wp-content/uploads/

nginx代理与负载

正向与反向代理的区别

区别在于形式上服务的"对象"不一样<br />    正向代理代理的对象是客户端，为客户端服务   PC电脑<br />    反向代理代理的对象是服务端，为服务端服务    服务器

反向代理模式 Nginx配置模块
http、websocket、https ngx_http_proxy_module
fastcgi ngx_http_fastcgi_module
uwsgi ngx_http_uwsgi_module
grpc ngx_http_v2_module

1.配置后端的web

[root@web01 conf.d]# cat web.oldboy.com.conf 

server {
    listen 80;
    server_name web.oldboy.com;
    root /web;

    location / {
        index index.php index.html;
    }
}

[root@web01 conf.d]# mkdir /web
[root@web01 conf.d]# echo "Web01....." > /web/index.html
[root@web01 conf.d]# nginx -t
[root@web01 conf.d]# systemctl restart nginx

2.nginx代理配置

[root@lb01 conf.d]# vi proxy_web.conf

server {
    listen 80;
    server_name web.oldboy.com;
    location / {
        proxy_pass http://192.168.203.129:80;
        proxy_set_header Host $http_host;
    }
}

t[root@web01 conf.d]# systemctl restart nginx

3.抓包分析

4.代理相关的参数

proxy_pass http://192.168.203.129:80;;
proxy_http_version 1.1;                                            #代理使用http1.1协议
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

[root@lb01 conf.d]# cat /etc/nginx/proxy_params

proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_connect_timeout 30;
proxy_send_timeout 60;
proxy_read_timeout 60;

proxy_buffering on;
proxy_buffer_size 32k;
proxy_buffers 4 128k;

7.代理配置location时调用, 方便后续多个Location重复使用
location / {
proxy_pass http://127.0.0.1:8080;
include proxy_params;
}

nginx代理局限性
1.一个location仅能代理后端一台主机

3.四层负载均衡与七层负载均衡区别
四层负载均衡数据包在底层就进行了分发，而七层负载均衡数据包则是在最顶层进行分发、由此可以看出，七层负载均衡效率没有四负载均衡高。
七层负载均衡更贴近于服务，如:http协议就是七层协议，我们可以用Nginx可以作会话保持，URL路径规则匹配、head头改写等等，这些是四层负载均衡无法实现的。

配置实例
1.Web01服务器上配置nginx, 并创建对应html文件
[root@web01 ~]# cd /etc/nginx/conf.d/
[root@web01 conf.d]# cat node.conf 

server {
    listen 80;
    server_name node.oldboy.com;
    location / {
        root /node;
        index index.html;
    }
}

[root@web01 conf.d]# mkdir /node
[root@web01 conf.d]# echo “Web01…” > /node/index.html
[root@web01 conf.d]# systemctl restart nginx

2.Web02服务器上配置nginx, 并创建对应html文件
[root@web02 ~]# cd /etc/nginx/conf.d/
[root@web02 conf.d]# cat node.conf 

server {
    listen 80;
    server_name node.oldboy.com;
    location / {
        root /node;
        index index.html;
    }
}

[root@web02 conf.d]# mkdir /node
[root@web02 conf.d]# echo “Web02…” > /node/index.html
[root@web02 conf.d]# systemctl restart nginx

3.配置Nginx负载均衡
[root@lb01 ~]# cd /etc/nginx/conf.d/
[root@lb01 conf.d]# cat node_proxy.conf 

upstream node {
    server 192.168.203.129:80;
    server 192.168.203.190:80;
}
server {
    listen 80;
    server_name node.oldboy.com;

    location / {
        proxy_pass http://node;
        include proxy_params;
    }
}

[root@lb01 conf.d]# systemctl restart nginx
4.准备Nginx负载均衡调度使用的proxy_params
[root@Nginx ~]# vim /etc/nginx/proxy_params

proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_connect_timeout 30;
proxy_send_timeout 60;
proxy_read_timeout 60;

proxy_buffering on;
proxy_buffer_size 32k;
proxy_buffers 4 128k;

负载均衡配置：
[root@lb01 conf.d]# vim proxy_oldboy.com.conf

upstream node {
        server 192.168.203.129:80;
        server 192.168.203.190:80;
}
server {
        listen 80;
        server_name blog.oldboy.com;
        location / {
                proxy_pass http://node;
                include proxy_params;
        }
}

server {
        listen 80;
        server_name zh.oldboy.com;
        location / {
                proxy_pass http://node;
                include proxy_params;
        }
}

nginx代理

  • 正向代理
  • 反向代理

反向代理场景
proxy_pass
proxy_set_header #携带头部信息 

proxy_http_version 1.1;                                    #代理向后请求使用的版本<br />    proxy_set_header Host $http_host;                        #代理向后端主机请求时携带的host域名<br />    proxy_set_header X-Real-IP $remote_addr;<br />    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;    #获取客户端真实IP以及全链路IP

proxy_connect_timeout 30;            #代理连接后端超时时间<br />    proxy_send_timeout 60;                #后端传递数据至代理超时时间<br />    proxy_read_timeout 60;                #后端响应代理的超时时间

proxy_buffering on;<br />    proxy_buffer_size 32k;<br />    proxy_buffers 4 128k;

负载均衡

稳定，高效，容灾<br />    负载均衡代理的是一组虚拟资源池。<br />    负载均衡能对物理主机进行逻辑上的捆绑。（主要是让后端的主机组成集群。）<br />    调度--》服务节点<br />    负载均衡场景<br />        lb    --> web01  web02

域名调度-t一个负载分域名访问
cat proxy_oldboy.com.conf

同一目录下upstream名称不能冲突

upstream www {
  server 192.168.203.129:80;
  server 192.168.203.190:80;
}

server {
    listen 80;
    server_name blog.oldboy.com;
    location / {
        proxy_pass http://www;
                include proxy_params;
    }
}
server {
        listen 80;
        server_name zhihu.oldboy.com;
        location / {
                proxy_pass http://www;
                include proxy_params;
        }
}

    <br />问题:<br />使用nginx负载均衡时，如何将后端请求超时的服务器流量平滑的切换到另一台上。<br />         Nginx是本身是有机制的，如果出现一个节点down掉的时候，Nginx会更据你具体负载均衡的设置，将请求转移到其他的节点上，但是，如果后台服务连接没有down掉，但是返回错误异常码了如:504、502、500

nginx 负载均衡与会话

nginx作为代理服务
正向代理 ——-> 上网
反向代理 ——-> 为后端节点没有公网IP的主机进行代理

http_proxy_module
proxy_pass address 将请求转发至对应的地址 http://IP:PORT
proxy_set_header 设置代理头部信息 Host X-Forward-For X-Real-IP
proxy_http_version 1.1; 让代理与后端通信时使用http1.1协议

include proxy_params; 方便调用

<br />    location  ~^/user {<br />        proxy_pass http://10.0.0.7;<br />    }<br />    location  ~^/pass {<br />        proxy_pass http://10.0.0.8;<br />    }<br />    location  ~^/login {<br />        proxy_pass http://10.0.0.9;<br />    }

nginx负载均衡

代理仅能代理一台主机，负载均衡能代理一组资源池

使用nginx负载均衡时，如何将后端请求超时的服务器流量平滑的切换到另一台上。
Nginx是本身是有机制的，如果出现一个节点down掉的时候，Nginx会更据你具体负载均衡的设置，将请求转移到其他的节点上，但是，如果后台服务连接没有down掉，但是返回错误异常码了如:504、502、500

server {
listen 80;
server_name xuliangwei.com;

location / {<br />        proxy_pass http://node;<br />        proxy_next_upstream error timeout http_500 http_502 http_503 http_504;<br />    }<br />}

后端的状态

  • 调度模式
  • 健康检查（编译）
  • 会话登录

状态 概述
down 当前的server暂时不参与负载均衡
backup 预留的备份服务器
max_fails 允许请求失败的次数
fail_timeout 经过max_fails失败后, 服务暂停时间
max_conns 限制最大的接收连接数

down一般用于停机维护时使用
upstream web {
server 172.16.1.7:80 down;
server 172.16.1.8:80;
}

backup当所有的server不可用时，才会启用
upstream web {
server 172.16.1.7:80 backup;
server 172.16.1.8:80;
}

健康检查，但无法查看到具体的指标，不够形象
upstream web {
server 172.16.1.7:80 max_fails=2 fail_timeout=10s;
server 172.16.1.8:80 max_fails=2 fail_timeout=10s;
}

调度算法

概述
轮询 按时间顺序逐一分配到不同的后端服务器(默认)
weight 加权轮询,weight值越大,分配到的访问几率越高
ip_hash 每个请求按访问IP的hash结果分配,这样来自同一IP的固定访问一个后端服务器
url_hash 按照访问URL的hash结果来分配请求,是每个URL定向到同一个后端服务器
least_conn 最少链接数,那个机器链接数少就分发

轮询

upstream web {
server 10.0.0.7:80;
server 10.0.0.8:80;
}

加权轮询

upstream web {
server 172.16.1.7:80 weight=5;
server 172.16.1.8:80 weight=1;
}

ip_hash

ip_hash 能解决会话登录，会造成负载不均衡，基于hash值来确定会话，不会调度，不能加权轮询一起使用
upstream web {
ip_hash;
server 172.16.1.7:80;
server 172.16.1.8:80;
}

nginx第三方健康检查模块

1.安装依赖包
[root@lb02 ~]# yum install -y gcc glibc gcc-c++ pcre-devel openssl-devel patch

2.下载nginx源码包以及nginx_upstream_check模块第三方模块
[root@lb02 ~]# wget http://nginx.org/download/nginx-1.22.0.tar.gz
[root@lb02 ~]# wget https://github.com/yaoweibin/nginx_upstream_check_module

3.解压nginx源码包以及第三方模块
[root@lb02 ~]# tar xf nginx-1.22.0.tar.gz
[root@lb02 ~]# unzip master.zip

4.进入nginx目录，打补丁(nginx的版本是1.22补丁就选择1.20+的,p1代表在nginx目录，p0是不在nginx目录)
[root@lb02 ~]# cd nginx-1.22.0/
[root@lb01 nginx-1.22.0]# patch -p1 <../nginx_upstream_check_module-master/check_1.20.1+.patch
patching file src/http/modules/ngx_http_upstream_hash_module.c
patching file src/http/modules/ngx_http_upstream_ip_hash_module.c
patching file src/http/modules/ngx_http_upstream_least_conn_module.c
patching file src/http/ngx_http_upstream_round_robin.c
patching file src/http/ngx_http_upstream_round_robin.h
nginx -V #查看原有的编译参数

./configure --prefix=/usr/share/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib64/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --http-client-body-temp-path=/var/lib/nginx/tmp/client_body --http-proxy-temp-path=/var/lib/nginx/tmp/proxy --http-fastcgi-temp-path=/var/lib/nginx/tmp/fastcgi --http-uwsgi-temp-path=/var/lib/nginx/tmp/uwsgi --http-scgi-temp-path=/var/lib/nginx/tmp/scgi --pid-path=/run/nginx.pid --lock-path=/run/lock/subsys/nginx --user=nginx --group=nginx --with-compat --with-debug --with-file-aio --with-google_perftools_module --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_degradation_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_image_filter_module=dynamic --with-http_mp4_module --with-http_perl_module=dynamic --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-http_xslt_module=dynamic --with-mail=dynamic --with-mail_ssl_module --with-pcre --with-pcre-jit --add-module=/root/nginx_upstream_check_module-master --with-stream=dynamic --with-stream_ssl_module --with-stream_ssl_preread_module --with-threads --with-cc-opt='-O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic ' --with-ld-opt='-Wl,-z,relro  -Wl,-E'

[root@lb02 nginx-1.22.0]# make && make install

5.在已有的负载均衡上增加健康检查的功能
[root@lb01 conf.d]# cat proxy_web.conf

upstream web {
   #监控
    server 172.16.1.7:80 max_fails=2 fail_timeout=10s;
    server 172.16.1.8:80 max_fails=2 fail_timeout=10s;
    check interval=3000 rise=2 fall=3 timeout=1000 type=tcp;
}

server {
    listen 80;
    server_name web.oldboy.com;
    location / {
        proxy_pass http://web;
        include proxy_params;
    }

    location /upstream_check {
        check_status;
    }
}

重启lb web01/02的nginx
image.png

会话保持问题

  • ip_hash
  • session复制

  • session共享

         本地文件--->nfs共享<br />           通过程序-》写入redis数据库<br />          通过程序-》写入mysql数据库

    通过session共享会话

    1.配置Nginx

    [root@web01 conf.d]# cat php.conf
    server {
    listen 80;
    server_name php.oldboy.com;
    root /code/phpMyAdmin-4.8.4-all-languages;

    location / {
    index index.php index.html;
    }

    location ~ .php$ {
    fastcgi_pass 127.0.0.1:9000;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
    }
    }
    [root@web01 conf.d]# systemctl restart nginx

2.安装phpmyadmin

（web01和web02上都装）

[root@web01 conf.d]# cd /code
[root@web01 code]# wget https://files.phpmyadmin.net/phpMyAdmin/4.8.4/phpMyAdmin-4.8.4-all-languages.zip
[root@web01 code]# unzip phpMyAdmin-4.8.4-all-languages.zip

3.配置phpmyadmin连接远程的数据库

[root@web01 code]# cd phpMyAdmin-4.8.4-all-languages/
[root@web01 phpMyAdmin-4.8.4-all-languages]# cp config.sample.inc.php config.inc.php
[root@web01 phpMyAdmin-4.8.4-all-languages]# vim config.inc.php
/ Server parameters db/
$cfg[‘Servers’][$i][‘host’] = ‘192.168.203.192’;

4.配置授权

[root@web01 conf.d]# chown -R www.www /var/lib/php/

5.将web01上配置好的phpmyadmin以及nginx的配置文件推送到web02主机上

[root@web01 code]# scp -rp phpMyAdmin-4.8.4-all-languages root@192.168.203.190:/code/
[root@web01 code]# scp /etc/nginx/conf.d/php.conf root@192.168.203.190:/etc/nginx/conf.d/

6.在web02上重载Nginx服务

[root@web02 code]# systemctl restart nginx

7.授权

[root@web02 code]# chown -R www.www /var/lib/php/

如果没有session文件夹需要手动创建

8.接入负载均衡

[root@lb01 conf.d]# vim proxy_php.com.conf 

upstream php {
        server 192.168.203.190:80;
        server 192.168.203.129:80;
}
server {
        listen 80;
        server_name php.oldboy.com;
        location / {
                proxy_pass http://php;
                include proxy_params;
        }
}

[root@lb01 conf.d]# nginx -t
[root@lb01 conf.d]# systemctl restart nginx
查看session文件下的session文件

通过redis解决会话登录问题

reids来保存会话数据

1.安装redis

[root@db01 ~]# yum install redis -y

2.配置redis监听在192.168.203.0网段上

[root@db ~]# sed -i '/^bind/c bind 127.0.0.1 192.168.203.192' /etc/redis.conf

3.启动redis

[root@db01 ~]# systemctl start redis && systemctl enable redis

4.php配置session连接redis

需要phpredis模块 yum -y install php71w-pecl-redis.x86_64

1.修改/etc/php.ini文件

[root@web01 ~]# vim /etc/php.ini
session.save_handler = redis
session.save_path = “tcp://192.168.203.192:6379”
#session.save_path = “tcp://192.168.203.192:6379?auth=123” #如果redis存在密码，则使用该方式
session.auto_start = 1

#2.注释php-fpm.d/www.conf 里面的两条内容，否则session内容会一直写入/var/lib/php/session目录中

;php_value[session.save_handler] = files

;php_value[session.save_path] = /var/lib/php/session

3.重启php-fpm

[root@web01 code]# systemctl restart php-fpm

5.将web01上配置好的文件推送到web02

[root@web01 code]# scp /etc/php.ini root@192.168.203.190/etc/php.ini
[root@web01 code]# scp /etc/php-fpm.d/www.conf root@192.168.203.190:/etc/php-fpm.d/www.conf

6.上web02上重启php-fpm

[root@web02 code]# systemctl restart php-fpm

7.redis查看数据

127.0.0.1:6379> keys *
1) “PHPREDIS_SESSION:41fecea871a78cf060df76c737a1eaf8”
2) “PHPREDIS_SESSION:88da7f0c3d51b01a4b8a42896a3fea44”
127.0.0.1:6379>

nginx四层代理

七层负载均衡作用：（OSI 应用层）
流量分发
后端服务高可用
调度策略
轮询
加权轮询
ip_hash (会话登录) redis将session_id进行共享
url_hash
健康检查（官方）
backup 备机
down 注释
max_fails 失败的次数
fail_timeout 多长时间内失败max_fails次，则视为down
健康检查 check_upstream 第三方

四层负载均衡：（OSI传输层 ip:port）

nginx1.9 版本<br />硬件：F5<br />软件：LVS、Haproxy、Nginx

1.四层+七层来作负载均衡，4层可以保证7层的负载均衡的高可用性。如:nginx就无法保证自己的服务高可用，需要依赖lvs或者keepalive来作。

2.如:tcp协议的负载均衡，有些请求是TCP协议的(mysql、ssh)，或者说这些请求只需要使用4层进行端口的转发就可以了，所以使用4层负载均衡。
比如做：mysql读的负载均衡（轮询）
比如做：端口映射、端口转发 tcp/udp

四层负载均衡总结

1.四层负载均衡仅能转发TCP/IP协议、UDP协议，通常用来转发端口，如: tcp/3306，tcp/22，udp/53。
2.四层负载均衡可以用来解决七层负载均衡的端口限制问题。（七层负载均衡最大使用65535个端口号）
3.可以用来解决七层负载均衡的高可用问题。（多台后端七层负载均衡能同时的使用）
4.四层的转发效率比七层的高的多，但仅支持tcp/ip协议，不支持http或者https协议

环境

lb-1  192.168.203.134
lb-2      192.168.203.135
lb-3      192.168.203.137
nfs
mysql
redis

1.在lb02上面安装Nginx
[root@lb02 ~]# cat /etc/yum.repos.d/nginx.repo
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=0
enabled=1
[root@lb02 ~]# yum install nginx -y

2.在lb02上面拷贝lb02的所有nginx相关配置即可。
[root@lb02 ~]# scp -rp root@192.168.203.134:/etc/nginx /etc/

3.启动nginx
[root@lb02 conf.d]# nginx -t
[root@lb02 conf.d]# systemctl start nginx && systemctl enable nginx

zhihu打不开关闭php-ini里面的auto-start

4.配置nginx四层负载均衡
stream —with-stream tcp

[root@lb02 ~]# cat /etc/yum.repos.d/nginx.repo
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=0
enabled=1
[root@lb02 ~]# yum install nginx -y
[root@lb02 ~]# vim /etc/nginx/nginx.conf
events {
….
}

include /etc/nginx/conf.c/*.conf;

http {
…..
}

3.创建存放四层负载均衡配置的目录
[root@lb4-01 conf.c]# rm -f /etc/nginx/conf.d/default.conf #删除http的80端口
[root@lb4-01 ~]# mkdir /etc/nginx/conf.c
[root@lb4-01 ~]# cd /etc/nginx/conf.c
[root@lb4-01 conf.c]# cat lb_domain.conf
stream {
upstream lb {
server 192.168.203.135:80 weight=5 max_fails=3 fail_timeout=30s;
server 192.168.203.137:80 weight=5 max_fails=3 fail_timeout=30s;
}

server {<br />        listen 80;<br />        proxy_connect_timeout 3s;<br />        proxy_timeout 3s;<br />        proxy_pass lb;<br />    }<br />}<br />4.重载服务<br />[root@lb4-01 conf.c]# nginx -t<br />nginx: the configuration file /etc/nginx/nginx.conf syntax is ok<br />nginx: configuration file /etc/nginx/nginx.conf test is successful<br />[root@lb4-01 conf.c]# systemctl restart nginx  && systemctl enable nginx

使用nginx四层负载均衡实现tcp的转发
请求负载均衡 5555 —-> 192.168.203.134:22;
请求负载均衡 6666 —-> 192.168.203.134:3306;

定义转发ssh的22端口
upstream ssh_7 {
server 10.0.0.7:22;
}
#定义转发mysql的3306端口
upstream mysql_51 {
server 10.0.0.51:3306;
}
server {
listen 5555;
proxy_connect_timeout 3s;
proxy_timeout 300s;
proxy_pass ssh_7;
}

server {<br />        listen 6666;<br />        proxy_connect_timeout 3s;<br />        proxy_timeout 3s;<br />        proxy_pass mysql_51;<br />    }<br />}

nginx四层负载均衡记录日志

stream {
log_format proxy ‘$remote_addr $remote_port - [$time_local] $status $protocol ‘
‘“$upstream_addr” “$upstream_bytes_sent” “$upstream_connect_time”‘ ;

        access_log /var/log/nginx/proxy.log proxy;<br />}<br />日志展示效果<br />[root@lb01 conf.c]# tailf /var/log/nginx/proxy.log<br />192.168.203.1 11238 - [22/Jun/2022:09:57:52 +0800] 200 TCP "192.168.203.137:80" "0" "0.000"<br />192.168.203.1 11237 - [22/Jun/2022:09:57:53 +0800] 200 TCP "192.168.203.135:80" "760" "0.000"

四层负载均衡：
转发TCP/ip协议，端口转发
解决七层负载均衡高可用，解决网站并发或者链接的瓶颈。
场景：
4+7 大规模集群使用场景
通过四层负载均衡的2222端口，转发到后端的某一台主机的22端口

四层负载均衡
硬件：F5
软件：LVS、Haproxy、Nginx(1.90)诞生 stream(tcp) 不能配置在http层

四层负载均衡场景演示：

动静分离

四层负载均衡
四层 内核空间 转发 传输层（tcp、udp 转发 ）
七层 用户空间 代理 应用层（域名匹配，路径规则控制、安全、限速、等）

静态

[root@web01 images]# cat /etc/nginx/conf.d/ds.conf
server{
listen 80;
server_name ds.oldboy.com;
root /soft/code;
index index.html;
location ~ ^..(png|jpg|mp4|)$ {
root /soft/code/images;
}
}

动态

location ~ \.php$ {<br />        fastcgi_pass 127.0.0.1:9000;<br />        .....<br />    }<br />        <br />实际线上的配置<br />server {<br />        listen 80;<br />        server_name   www.oldboy.com;<br />        if ($http_user_agent ~* "Android|Iphone") {<br />                rewrite ^/$ [https://sj.oldboy.com](https://sj.oldboy.com) redirect;<br />        }       <br />}

flag

last 本条规则匹配完成后，停止匹配，不在匹配后面的规则
break 本条规则匹配完成后，停止匹配，不在匹配后面的规则

redirect 返回302临时重定向, 地址栏会显示跳转后的地址
permanent 返回301永久重定向, 地址栏会显示跳转后的地址

server {
listen 80;
server_name rewrite.oldboy.com;
root /code;

location ~ ^/break {<br />        rewrite ^/break /test/ break;<br />    }<br />    location ~ ^/last {<br />        rewrite ^/last /test/ last;<br />    }<br />    location /test/ {<br />            default_type application/json;<br />            return 200 "ok";<br />    }

}

break

1.请求rewrite.oldboy.com/break<br />        首先：会去查找本地的/code/test/index.html;<br />            如果找到了<br />              有location匹配，则返回匹配的内容；<br />              没有location则返回/code/test/index.html的内容<br />            如果没找到该目录则报错404，如果找到该目录没找到对应的index文件则403

last

1.请求rewrite.oldboy.com/last<br />        首先：会对当前server重新的发起一次请求，rewrite.oldbo.com/test/<br />            如果有location匹配上，则直接返回该location的内容。<br />            如果没有location匹配，/code/test/index.html;<br />[root@web01 code]# cat /etc/nginx/conf.d/ds.conf<br />server{<br />   listen 80;<br />   server_name ds.oldboy.com;<br />   root /soft/code;<br />   index index.html;<br />   location / {<br />        rewrite ^/$  /images/6.jpg last;<br />    }<br />   location /test {<br />        rewrite ^(.*)$   [https://www.baidu.com](https://www.baidu.com) redirect;<br />    }<br />}

redirect和permanent都是一个跳转，那redirect和permanent区别在哪呢 （实现https）

redirect: 每次请求都会询问服务器，如果当服务器不可用时，则会跳转失败。<br />    permanent: 第一次请求会询问，浏览器会记录跳转的地址，第二次则不再询问服务器，直接通过浏览器缓存的地址跳转。<br />[root@web01 conf.d]# vim rewrite.conf<br />server {<br />    listen 80;<br />    server_name rewrite.oldboy.com;<br />    root /code;

location /oldboy {
#rewrite ^(.)$ https://www.xuliangwei.com redirect;
rewrite ^(.)$ https://www.xuliangwei.com permanent;
}

http://www.bgx.com/abc/1.html ==> http://www.bgx.com/ccc/bbb/2.html

1.准备真实的访问路径
[root@web03 ~]# mkdir /code/ccc/bbb -p
[root@web03 ~]# echo “ccc_bbb_2” > /code/ccc/bbb/2.html

2.Nginx跳转配置
[root@web03 conf.d]# cat ccbb.conf
server {
listen 80;

location / {
root /code;
index index.html;
}
location /abc {
rewrite (.*) /ccc/bbb/2.html redirect;
#return 302 /ccc/bbb/2.html;
}
}

#http://www.bgx.com/2018/ccc/bbb/2.html ==> http://www.bgx.com/2014/ccc/bbb/2.html

例4:用户访问course-11-22-33.html实际上真实访问是/course/11/22/33/course33.html
#http://www.bgx.com/course-11-22-33.html ==> http://www.bgx.com/course/11/22/33/course_33.html
#http://www.bgx.com/course-44-55-66.html ==> http://www.bgx.com/course/44/55/66/course_66.html

location ~ ^/course {
rewrite (.)-(.)-(.)-(.).(.*) /$1/$2/$3/$4/$1$4.$5 break;
}
1.Rewrite优先级
1.先执行server块的rewrite指令
2.其次执行location匹配规则
3.最后执行location中的rewrite


server {
listen 80;
server_name www.nginx.org nginx.org;
if ($http_host = nginx.org){
rewrite (.*) http://www.nginx.org$1;
}
}

——————
例5:将http请求，跳转至https

server {
listen 80;
server_name bgx.com;
rewrite ^(.*) https://$server_name$1 redirect;
#return 302 https://$server_name$request_uri;
}
server {
listen 443;
server_name bgx.com;
ssl on;
}
—————
#推荐的书写格式
server {
listen 80;
server_name oldboy.com;
rewrite ^ http://www.oldboy.com$request_uri;
}

server {
listen 80;
server_name www.oldboy.com;
}

https

<br />$http_user_agent<br />手机<br />    iphone<br />    andriod<br />电脑

Nginx Rewrite
rewrite url替换 rewrite 正则 真实的文件 flag
return http->https return 状态码 跳转后的地址(可以使用变量)
301 permanent
302 redirect
rewrite ^(.*)$ https://$server_name$1 redirect;
return 302 https://$server_name$request_uri;
break：
last：

sub_filter ‘’ ‘’;
<img src=”https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1548388386797&di=b7ba40a1f0f42f35be5a6be629dda7bb&imgtype=0&src=http%3A%2F%2Fpic125.nipic.com%2Ffile%2F20170324%2F10616187_132808685036_2.jpg” alt=””>

Https证书的类型
DV
OV
EV

HTTPS证书购买选择
保护1个域名 www
保护5个域名 www images cdn test m
通配符域名 *.oldboy.com

HTTPS注意事项
Https不支持续费,证书到期需重新申请新并进行替换.
Https不支持三级域名解析, 如test.m.oldboy.com

Https显示绿色, 说明整个网站的url都是https的。
Https显示黄色, 因为网站代码中包含http的不安全连接。
Https显示红色, 要么证书是假的，要么证书过期。

nginx必须有ssl模块
[root@Nginx ~]# nginx -V
—with-http_ssl_module

自签证书

创建存放ssl证书的路径

[root@Nginx ~]# mkdir -p /etc/nginx/ssl_key
[root@Nginx ~]# cd /etc/nginx/ssl_key

生成证书

openssl genrsa -idea -out server.key 2048
openssl req -days 36500 -x509 -sha256 -nodes -newkey rsa:2048 -keyout server.key -out server.crt

配置nginx使用证书

[root@Nginx ~]# cat /etc/nginx/conf.d/ssl.conf

server {
    listen 443;
    server_name s.oldboy.com;
    ssl on;
    ssl_certificate   ssl_key/server.crt;
    ssl_certificate_key  ssl_key/server.key;
    location / {
        root /code;
        index index.html;
    }
}

准备对应的站点目录, 并重启Nginx服务
[root@Nginx ~]# mkdir -p /code
[root@Nginx ~]# echo “Https” > /code/index.html
[root@Nginx ~]# systemctl restart nginx

如果希望http的流量全部导入到https上

[root@web01 conf.d]# vim s.oldboy.conf 

server {
        listen 443;
        server_name s.oldboy.com;
        root /code;
        ssl on;
        ssl_certificate ssl_key/server.crt;
        ssl_certificate_key ssl_key/server.key;
        location / {
                index index.html;
        }
}
server {
        listen 80;
        server_name s.oldboy.com;
        #把80的流量转发到https
        return 302 https://$server_name$request_uri;
}

1.配置2台web服务器都监听在80端口
2.配置负载均衡，也监听在80端口，进行访问网站测试。
3.在负载均衡器上管理我们的ssl证书。
fastcgi_params HTTPS on; 参数是添加在后端的web上。

负载均衡器的配置

[root@lb01 conf.d]# cat proxy_oldboy.com.conf 

upstream node {
    server 192.168.203.135:80;
    server 192.168.203.137:80;
}

server {
    listen 80;
    server_name blog.oldboy.com;
    return 302 https://$server_name$request_uri;
}

server {
    listen 443;
    server_name blog.oldboy.com;
    ssl on;
    ssl_certificate ssl_key/server.crt;
        ssl_certificate_key ssl_key/server.key;
    location / {
        proxy_pass http://node;
        include proxy_params;
    }
}

server {
    listen 80;
    server_name zhihu.oldboy.com;
    return 302 https://$server_name$request_uri;
}
server {
    listen 443;
    server_name zhihu.oldboy.com;
    ssl on;
    ssl_certificate ssl_key/server.crt;
        ssl_certificate_key ssl_key/server.key;
    location / {
        proxy_pass http://node;
        include proxy_params;
    }
}

后端web的配置支持https

必须启用fastcgi_param HTTPS on;
[root@web01 conf.d]# cat blog.oldboy.com.conf 

server {
    listen 80;
    server_name blog.oldboy.com;
    root /code/wordpress;
    client_max_body_size 100m;

    location / {
        index index.php index.html;
    }
    location ~ \.php$ {
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param HTTPS on;
        include fastcgi_params;
    }
}

php.conf
server {
    listen 80;
    server_name php.oldboy.com;
    root /code/phpMyAdmin-4.9.10-all-languages;

    location / {
        index index.php index.html;
        client_max_body_size 100m;
    }

    location ~ \.php$ {
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
        fastcgi_param HTTPS on;
    }
}

重新加载php-fpm nginx

systemctl restart php-fpm
systemctl restart nginx

ssl_session_cache shared:SSL:10m; #在建立完ssl握手后如果断开连接，在session_timeout时间内再次连接，是不需要在次建立握手，可以复用之前的连接 ssl_session_timeout 1440m; #ssl连接断开后的超时时间 ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #使用的TLS版本协议 ssl_prefer_server_ciphers on; #Nginx决定使用哪些协议与浏览器进行通讯 ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4; #加密套件

公网单台服务器配置https

server {
        listen 443;
        server_name blog.lingxiao998.com;
        root /code/wordpress;
        client_max_body_size 100m;
        ssl on;
        ssl_certificate ssl_key/1775624_blog.lingxiao998.com.pem;
        ssl_certificate_key ssl_key/1775624_blog.lingxiao998.com.key;
        ssl_session_cache shared:SSL:1m;
        ssl_session_timeout 1440m;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
}

server {
    listen 80;
    server_name blog.lingxiao998.com;
    return 302 https://$server_name$request_uri;
}

负载高可用

四层负载均衡
动静分离
rewrite rewrite 正则 替换的字符串 flag标记 跳转
https 单台https 多台 SLB
1.什么是高可用。
通常情况下，都是启动2台相同的业务系统，一台故障，另外一台自动接管。

2.高可用实现的工具。
服务高可用，keepalived软件实现 （硬件。）

3.keepalived如何实现高可用?
keepalived基于VRRP协议，虚拟路由冗余协议。

4.VRRP解决什么问题。

1.实践环境，配置实现虚IP转移
状态 IP 角色
节点1 192.168.202.136 Master
节点2 192.168.202.137 Backup
VIP 192.168.202.138

安装keepalived
yum install keepalived -y

配置Master的Keepalived

global_defs {                     #全局配置
    router_id lb01                #表示身份->名称
}

vrrp_instance VI_1 {
    state MASTER                #标识角色状态
    interface eth0                #网卡绑定接口
    virtual_router_id 50        #虚拟路由id
    priority 150                #优先级
    advert_int 1                #监测间隔时间
    authentication {            #认证
        auth_type PASS            #明文认证
        auth_pass 1111            #明文密码
}
    virtual_ipaddress {            
        192.168.202.138                #虚拟的VIP地址
    }
}

配置Backup的Keepalived

global_defs {
    router_id lb02
}

vrrp_instance VI_1 {
    state BACKUP        
    interface eth0
    virtual_router_id 50
    priority 100
    advert_int 1
    authentication {    
        auth_type PASS
        auth_pass 1111
}
    virtual_ipaddress {
        192.168.202.138    
    }
}

对比keepalived的master与backup配置的区别
Keepalived配置区别 Master配置 Backup节配置
route_id(唯一标识) lb01 lb02
state(角色状态) Master Backup
priority(竞选优先级) 150 100

启动keepalived
[root@lb01 ~]# systemctl enable keepalived && systemctl start keepalived

5.配置非抢占式
1、两个节点的state都必须配置为BACKUP
2、两个节点都必须加上配置 nopreempt
3、其中一个节点的优先级必须要高于另外一个节点的优先级。
两台服务器都角色状态启用nopreempt后，必须修改角色状态统一为BACKUP，唯一的区分就是优先级。

引用官方文档对nopreempt字段的说明：
“nopreempt” allows the lower priority machine to maintain the master role, even when a higher priority machine comes back online.
NOTE: For this to work, the initial state of this entry must be BACKUP.
根据上述描述，第一点提到的state必须配置为BACKUP就明白了。

Master
vrrp_instance VI_1 {
state MASTER
priority 150
nopreempt
}

通过windows的arp去验证，是否会切换MAC地址、
arp -a

keepalived虚拟地址漂移与Nginx服务进行关联
1.Nginx默认监听在所有的IP地址上。
2.用户将域名解析到VIP上面即可。

由于某些原因，导致两台keepalived高可用服务器在指定时间内，无法检测到对方的心跳消息，各自取得资源及服务的所有权，而此时的两台高可用服务器又都还活着。

服务器网线松动等网络故障
服务器硬件故障发生损坏现象而崩溃
主备都开启firewalld防火墙

如果发生闹裂，则随机kill掉一台即可。

1.在备上编写检测脚本, 测试如果能ping通主并且备节点还有VIP的话则认为产生了列脑
[root@lb02 ~]# cat check_split_brain.sh

#!/bin/sh
lb01_vip=192.168.202.138
lb01_ip=192.168.202.136
while true;do
    ping -c 2 -W 3 $lb01_ip &>/dev/null
    if [ $? -eq 0 -a `ip add|grep "$lb01_vip"|wc -l` -eq 1 ];then
        echo "ha is split brain.warning."
    else
        echo "ha is ok"
    fi
sleep 5
done

Nginx服务死掉等
1.会导致用户无法正常的访问到网站。
2.该服务器的VIp也不会进行漂移(因为keepalived与nginx是两个不同的软件)

解决手段：
1.写个监控脚本，如果nginx停止运行，则尝试启动，如果尝试失败，则停止keepalived

<br />编写脚本<br />    [root@lb01 ~]# mkdir /server/scripts<br />    [root@lb01 ~]# vim /server/scripts/check_web.sh<br />    #!/bin/sh<br />    nginxpid=$(ps -C nginx --no-header|wc -l)

#1.判断Nginx是否存活,如果不存活则尝试启动Nginx

    if [ $nginxpid -eq 0 ];then
        systemctl start nginx
        sleep 3
        #2.等待3秒后再次获取一次Nginx状态
        nginxpid=$(ps -C nginx --no-header|wc -l) 
        #3.再次进行判断, 如Nginx还不存活则停止Keepalived,让地址进行漂移,并退出脚本  
        if [ $nginxpid -eq 0 ];then
            systemctl stop keepalived
       fi
    fi

#给脚本增加执行权限<br />    [root@lb01 ~]# chmod +x /server/scripts/check_web.sh<br />在Master的keepalived中调用脚本，抢占式，仅需在master配置即可。（注意，如果配置为非抢占式，那么需要两台服务器都使用该脚本）<br />[root@lb01 ~]# cat /etc/keepalived/keepalived.conf

global_defs {
         router_id LVS_01
}

#1.每5秒执行一次脚本, 脚本执行内容不能超过5秒,否则会被中断再次重新运行脚本
vrrp_script check_web {
   script "/server/scripts/check_web.sh"
   interval 5
}

vrrp_instance VI_1 {
    nopreempt
    state MASTER
    interface eth0
    virtual_router_id 50
    priority 150
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.202.138
    }

    #2.调用并运行该脚本
    track_script {
        check_web
    }
}

nginx优化

1.系统结构和瓶颈
2.分析，压力测试工具ab、stub_status
3.了解业务模式
4.了解系统层次化的结构
5.性能与安全

OSI[flag]
硬件 代理(CPU) 静态(磁盘IO) 动态(cpu、内存)
网络
系统 文件描述符(文件句柄)
应用 服务于服务保持长连接 http1.1
服务 静态资源服务优化

压力测试工具ab

[root@lb02 ~]# yum -y install httpd-tools
[root@web01 conf.d]# ab
ab: wrong number of arguments
Usage: ab [options] [http[s]://]hostname[:port]/path

[root@web01 conf.d]# cat jsp.conf
server {
servername ;
listen 80;
location / {
root /code;
try_files $uri @java_page;
}
location @java_page{
proxy_pass http://127.0.0.1:8080;
}
}

分别给Nginx准备静态网站
[root@web01 ~]# cat /code/tt.html
Nginx Ab Load

[root@web01 ~]# systemctl restart nginx
[root@web01 conf.d]# ab -n100000 -c200 http://127.0.0.1/tt.html
[root@web01 conf.d]# ab -k -n100000 -c200 http://127.0.0.1/tt.html
[root@web01 conf.d]# ab -n100000 -c200 http://127.0.0.1/tt.html

系统层面优化

打开文件数

1.系统全局性修改。<br />    # *代表所有用户<br />    * soft nofile 25535<br />    * hard nofile 25535

2.用户局部性修改。<br />    root soft nofile 65535<br />    root hard nofile 65535

3.进程局部性修改<br />    worker_rlimit_nofile 65535;    #针对Nginx进程(核心模块)

调整内核参数

：让time_wait状态重用(端口重用)[flag]
[root@web01 ROOT]# vim /etc/sysctl.conf
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_timestamps = 1
[root@web01 ROOT]# sysctl -p

代理服务优化

upstream http_backend {
    server 127.0.0.1:8080;
    keepalive 16;   #长连接
}

server {
    ...
    location /http/ {
        proxy_pass http://http_backend;
        proxy_http_version 1.1;         #对于http协议应该指定为1.1
        proxy_set_header Connection ""; #清除“connection”头字段
        proxy_next_upstream error timeout http_500 http_502 http_503 http_504;  #平滑过渡
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwared-For $proxy_add_x_forwarded_for;
        proxy_connect_timeout 30s;        # 代理连接web超时时间
        proxy_read_timeout 60s;            # 代理等待web响应超时时间
        proxy_send_timeout 60s;            # web回传数据至代理超时时间
        proxy_buffering on;                # 开启代理缓冲区,web回传数据至缓冲区,代理边收边传返回给客户端
        proxy_buffer_size 32k;            # 代理接收web响应的头信息的缓冲区大小
        proxy_buffers 4 128k;            # 缓冲代理接收单个长连接内包含的web响应的数量和大小
        ...
    }
}

3.对于fastcgi服务器，需要设置fastcgi_keep_conn以便保持长连接[flag]

upstream fastcgi_backend {
    server 127.0.0.1:9000;
    keepalive 8;
}

server {
    ...
    location /fastcgi/ {
        fastcgi_pass fastcgi_backend;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        fastcgi_keep_conn on;

        fastcgi_connect_timeout 60s;
        include        fastcgi_params;
        ...
    }
}

注意:
1.scgi和uwsgi协议没有保持连接的概念。
2.但无论是proxy、fastcgi、uwsgi协议都有cache缓存的功能，开启后可加速网站访问的效率。（取决硬件）

缓存

1.现在设置缓存10s中的时间。10s到了 缓存是不是应该过期。
浏览器If-None-Match “9-1550193224000” 询问 web服务器 etag “9-1550193224000”
浏览器认为只是缓存过期，内容并没有修改，所以协商后还是304

  浏览器If-Modified-Since  Tue, 29 Jan 2019 02:29:51 GMT<br />        询问   <br />      web服务器  Last-Modified:        Tue, 29 Jan 2019 02:29:51 GMT<br />    浏览器认为只是缓存过期，内容并没有修改，所以协商后还是304

ETag: “5c4fba9f-6” ETag: “5c662c2a-a”
If-None-Match: “5c4fba9f-6” If-None-Match: “5c4fba9f-6”

开启浏览器缓存

server {
    listen 80;
    server_name static.bgx.com;

    location ~ .*\.(jpg|gif|png)$ {
        expires      7d;
    }
    location ~ .*\.(js|css)$ {
        expires      30d;
    }
}

  • 如果不希望缓存

      location ~ \.*(png|jpg|gif|jpeg)$ {<br />        #       expires 30d;<br />                add_header Cache-Control no-store;<br />                add_header Pragma no-cache;<br />        }<br />}

静态资源压缩

[root@Nginx conf.d]# cat static_server.conf 

server {
    listen 80;
    server_name static.oldboy.com;

    location ~*  .*\.(jpg|gif|png)$ {
        root /code/images;
        gzip on;
        gzip_http_version 1.1;
        gzip_comp_level 2;
        gzip_types  image/jpeg image/gif image/png;
        }
}

针对txt

[root@Nginx conf.d]# cat static_server.conf 

server {
    listen 80;
    server_name static.oldboy.com;
    sendfile on;
    location ~ .*\.(txt|xml|html|json|js|css)$ {
        gzip on;
        gzip_http_version 1.1;
        gzip_comp_level 1;
        gzip_types text/plain application/json application/x-javascript application/css application/xml text/javascript;
    }
}

防盗链

10.0.0.8 static.oldboy.com
#1.配置Nginx
[root@web02 conf.d]# cat static.conf
server {
listen 80;
server_name static.oldboy.com;
root /code;

location / {<br />        index index.html;<br />    }<br />}

2.上传2张图片
一张是可以被盗链的图片
一张是广告位的图片

3.重启服务器
[root@web02 code]# systemctl restart nginx
10.0.0.7 dl.oldboy.com ###盗链服务器

1.配置Nginx
[root@web01 conf.d]# cat try.conf
server {
server_name dl.oldboy.com;
listen 80;
root /code;
location / {
index index.html;
}
}

2.配置盗链的页面
[root@web01 code]# cat /code/tt.html






综合架构 - 图2](http://static.oldboy.com/smg.jpg"/>) #根据情况修改你的服务器地址


3.在10.0.0.8 添加防盗链操作
location ~ .(gif|jpg|png|bmp)$ {
valid_referers none blocked .xuliangwei.com;
if ($invalid_referer) {
return 403; #可以选择直接返回403
rewrite ^(.*)$ /ggw.png break; #也可以选择返回一张水印的图片，给公司做广告
}

跨站访问

1.准备a网站
[root@Nginx ~]# cat /code/http_origin.html




](http://libs.baidu.com/jquery/2.1.4/jquery.min.js">)



测试跨域访问





2.准备b网站
3.通过浏览器测试跨域访问

4.在b网站上允许a网站跨域访问
[root@Nginx conf.d]# cat fj.xuliangwei.com.conf
location ~ ..(html|htm)$ {
add_header Access-Control-Allow-Origin ;
add_header Access-Control-Allow-Methods GET,POST,PUT,DELETE,OPTIONS;
}

cpu亲和

1.查看当前CPU物理状态
[root@nginx ~]# lscpu |grep “CPU(s)”
CPU(s): 24 #总的核心数
On-line CPU(s) list: 0-23

每个物理cpu使用的是那些核心（代表2颗物理CPU，）
NUMA node0 CPU(s): 0,2,4,6,8,10,12,14,16,18,20,22
NUMA node1 CPU(s): 1,3,5,7,9,11,13,15,17,19,21,23

本次演示服务器为 两颗物理cpu，每颗物理CPU12个核心, 总共有24个核心

#修改nginx启动的work进程为自动。
worker_processes auto;
worker_cpu_affinity auto;

[root@web01 ~]# ps -eo pid,args,psr|grep [n]ginx
1242 nginx: master process /usr/ 2
1243 nginx: worker process 0
1244 nginx: worker process 1
1245 nginx: worker process 2
1246 nginx: worker process 3

不推荐调整的方式
# 第一种绑定组合方式
worker_processes 24;
worker_cpu_affinity 000000000001 000000000010 000000000100 000000001000 000000010000 000000100000 000001000000 000010000000 000100000000 001000000000 010000000000 10000000000;

# 第二种方式(使用较少)<br />    worker_processes 2;<br />    worker_cpu_affinity 101010101010 010101010101;<br />

Nginx通用配置

Nginx代理相关配置 Nginx Fastcgi

[root@nginx ~]# cat nginx.conf

user www;                   # nginx进程启动用户
worker_processes auto;      #与cpu核心一致即可
worker_cpu_affinity auto;   # cpu亲和

error_log /var/log/nginx/error.log warn;    # 错误日志
pid /run/nginx.pid;
worker_rlimit_nofile 35535;     #每个work能打开的文件描述符，调整至1w以上,负荷较高建议2-3w

events {
    use epoll;                  # 使用epoll高效网络模型
    worker_connections 10240;   # 限制每个进程能处理多少个连接，10240x[cpu核心]
}

http {
    include             mime.types;
    default_type        application/octet-stream;
    charset utf-8;      # 统一使用utf-8字符集

    # 定义日志格式
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;    # 访问日志

    server_tokens off;  # 禁止浏览器显示nginx版本号
    client_max_body_size 200m;  # 文件上传大小限制调整

    # 文件高效传输，静态资源服务器建议打开
    sendfile            on;
    tcp_nopush          on;
    # 文件实时传输，动态资源服务建议打开,需要打开keepalive
    tcp_nodelay         on;
    keepalive_timeout   65;

    # Gzip 压缩
    gzip on;
    gzip_disable "MSIE [1-6]\.";
    gzip_http_version 1.1;
    gzip_comp_level 2;
    gzip_buffers 16 8k;
    gzip_min_length 1024;
    gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml applicati
on/xml+rss text/javascript image/jpeg;

    # 虚拟主机
    include /etc/nginx/conf.d/*.conf;
}

Nginx安全与优化总结

1.cpu亲和、worker进程数、调整每个worker进程打开的文件数
2.使用epool网络模型、调整每个worker进程的最大连接数
3.文件的高效读取sendfile、nopush、
4.文件的传输实时性、nodealy
5.开启tcp长链接、以及长链接超时时间keepalived
6.开启文件传输压缩gzip
7.开启静态文件expires缓存
8.隐藏Nginx的版本号
9.禁止通过IP地址访问,禁止恶意域名解析,只允许域名访问
10.配置放盗链、以及跨域访问
11.防DDOS、cc攻击, 限制单IP并发连接，以及http请求
12.优雅限制nginx错误页面
13.nginx加密传输https优化
14.nginx proxy_cache、fastcgi_cache、uwsgi_cache缓存

php

1.php程序配置管理文件/etc/php.ini，主要调整日志、文件上传、禁止危险函数、关闭版本号显示、等
#;;;;;;;;;;;;;;;;;
# Error logging ; #错误日志设置
#;;;;;;;;;;;;;;;;;
expose_php = Off # 关闭php版本信息
display_error = Off # 屏幕不显示错误日志
error_reporting = E_ALL # 记录PHP的每个错误
log_errors = On # 开启错误日志
error_log = /var/log/php_error.log # 错误日志写入的位置
date.timezone = Asia/Shanghai # 调整时区,默认PRC

;;;;;;;;;;;;;;;
# File Uploads ; #文件上传设置
#;;;;;;;;;;;;;;;
file_uploads = On # 允许文件上传
upload_max_filesize = 300M # 允许上传文件的最大大小
post_max_size = 300M # 允许客户端单个POST请求发送的最大数据
max_file_uploads = 20 # 允许同时上传的文件的最大数量
memory_limit = 128M # 每个脚本执行最大内存

[Session] #会话共享
session.save_handler = redis
session.save_path = “tcp://172.16.1.51:6379”

https://blog.csdn.net/unixtech/article/details/53761832
#php禁止危险函数执行（取决于实际情况，需要和开发沟通）
disable_functions = chown,chmod,pfsockopen,phpinfo

2.php-fpm进程管理配置文件/etc/php-fpm.conf
#第一部分，fpm配置
;include=etc/fpm.d/*.conf

第二部分，全局配置
[global]
;pid = /var/log/php-fpm/php-fpm.pid #pid文件存放的位置
;error_log = /var/log/php-fpm/php-fpm.log #错误日志存放的位置
;log_level = error #日志级别, alert, error, warning, notice, debug
rlimit_files = 65535 #php-fpm进程能打开的文件数
;events.mechanism = epoll #使用epoll事件模型处理请求

第三部分，进程池定义
[www] #池名称
user = www #进程运行的用户
group = www #进程运行的组
;listen = /dev/shm/php-fpm.sock #监听在本地socket文件
listen = 127.0.0.1:9000 #监听在本地tcp的9000端口
;listen.allowed_clients = 127.0.0.1 #允许访问FastCGI进程的IP，any不限制

pm = dynamic #动态调节php-fpm的进程数
pm.max_children = 512 #最大启动的php-fpm进程数
pm.start_servers = 32 #初始启动的php-fpm进程数
pm.min_spare_servers = 32 #最少的空闲php-fpm进程数
pm.max_spare_servers = 64 #最大的空闲php-fpm进程数
pm.max_requests = 1500 #每一个进程能响应的请求数
pm.process_idle_timeout = 15s;
pm.status_path = /phpfpm_status #开启php的状态页面

#第四部分，日志相关

php_flag[display_errors] = off
php_admin_value[error_log] = /var/log/phpfpm_error.log
php_admin_flag[log_errors] = on

#慢日志

request_slowlog_timeout = 5s #php脚本执行超过5s的文件
slowlog = /var/log/php_slow.log #记录至该文件中

慢日志示例

[21-Nov-2013 14:30:38] [pool www] pid 11877
script_filename = /usr/local/lnmp/nginx/html/www.quancha.cn/www/fyzb.php
[0xb70fb88c] file_get_contents() /usr/local/lnmp/nginx/html/www.quancha.cn/www/fyzb.php:2

php 状态页面

pm.status_path = /phpfpm_status #开启php的状态页面
[root@nginx ~]# curl http://127.0.0.1/phpfpm_status
pool: www #fpm池名称,大多数为www
process manager: dynamic #动态管理phpfpm进程
start time: 05/Jul/2016 #启动时间，如果重启会发生变化
start since: 409 #php-fpm运行时间
accepted conn: 22 #当前池接受的连接数
listen queue: 0 #请求等待队列,如果这个值不为0,那么需要增加FPM的进程数量
max listen queue: 0 #请求等待队列最高的数量
listen queue len: 128 #请求等待队列的长度
idle processes: 4 #php-fpm空闲的进程数量
active processes: 1 #php-fpm活跃的进程数量
total processes: 5 #php-fpm总的进程数量
max active processes: 2 #php-fpm最大活跃的进程数量(FPM启动开始计算)
max children reached: 0 #进程最大数量限制的次数，如果数量不为0，则说明phpfpm最大进程数量过小,可以适当调整。

5.PHP-FPM

配置文件 4核16G、4核32G
[root@nginx ~]# cat /etc/php-fpm.d/www.conf
[global]
pid = /var/run/php-fpm.pid

error_log = /var/log/php-fpm.log
log_level = warning
rlimit_files = 655350
events.mechanism = epoll

[www]
user = nginx
group = nginx
listen = 127.0.0.1:9000
listen.allowed_clients = 127.0.0.1

pm = dynamic
pm.max_children = 512
pm.start_servers = 32
pm.min_spare_servers = 32
pm.max_spare_servers = 64
pm.process_idle_timeout = 15s;
pm.max_requests = 2048
pm.status_path = /phpfpm_status

php-www模块错误日志
php_flag[display_errors] = off
php_admin_value[error_log] = /var/log/php/php-www.log
php_admin_flag[log_errors] = on

php慢查询日志
request_slowlog_timeout = 5s
slowlog = /var/log/php-slow.log

nginx
硬件层面 代理比较的消耗CPU、内存、 静态比较消耗磁盘IO、
网络层面 网络带宽大小、传输速率、是否有丢包、
系统层面 调整文件描述。 timewait重用
应用层面 nginx作为代理 keepalive 长连接
服务层面 nginx作为静态 浏览器缓存、文件传输、压缩、防盗链、跨域访问、CPU亲和
nginx作为缓存 proxy_cache fastcgi_cache uwsgi_cache
nginx作为安全 nginx+lua实现waf防火墙

php
php.ini 错误日志记录、文件大小的调整、session会话共享的配置、禁止不必要的函数(与开发协商)
php-fpm 监听地址、进程的动态调节、日志开启。
php状态 php自身监控的状态信息
php慢查询 什么时间、什么进程、运行什么文件、哪个函数、第几行达到了超时时间

zabbix

ansible

elk

<br />    <br />    <br />    <br />    <br />    <br />    <br />    <br />    








































<br />