mariadb

MYSQL(mariadb)

Red Hat Enterprise Linux/CentOS 7.0 发行版已将默认的数据库从 MySQL 切换到 MariaDB

1. MariaDB数据库管理系统是MySQL的一个分支，主要由开源社区在维护，采用GPL授权许可。
2. 开发这个分支的原因之一是：甲骨文公司收购了MySQL后，有将MySQL闭源的潜在风险，因此社区采用分支的方式来避开这个风险。
3. MariaDB的目的是完全兼容MySQL，包括API和命令行，使之能轻松成为MySQL的代替品。

yum安装mariadb

添加yum源安装Mariadb

1. 1、首先在 RHEL/CentOS 和 Fedora 操作系统中添加 MariaDB 的 YUM 配置文件 MariaDB.repo 文件。
3. #编辑创建mariadb.repo仓库文件
4. vi /etc/yum.repos.d/MariaDB.repo

1. 2、添加repo仓库配置
2. [mariadb]
3. name = MariaDB
4. baseurl = http://yum.mariadb.org/10.1/centos7-amd64
5. gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
6. gpgcheck=1

yum一键安装mariadb

1. 当 MariaDB 仓库地址添加好后，你可以通过下面的一行命令轻松安装 MariaDB。
3. yum install MariaDB-server MariaDB-client -y

1. mariadb数据库的相关命令是：
3. systemctl start mariadb #启动MariaDB
5. systemctl stop mariadb #停止MariaDB
7. systemctl restart mariadb #重启MariaDB
9. systemctl enable mariadb #设置开机启动

初始化mysql

1. 在确认 MariaDB 数据库软件程序安装完毕并成功启动后请不要立即使用。为了确保数据 库的安全性和正常运转，需要先对数据库程序进行初始化操作。这个初始化操作涉及下面 5 个 步骤。
2. ➢ 设置 root 管理员在数据库中的密码值(注意，该密码并非 root 管理员在系统中的密 码，这里的密码值默认应该为空，可直接按回车键)。
3. ➢ 设置 root 管理员在数据库中的专有密码。
4. ➢ 随后删除匿名账户，并使用 root 管理员从远程登录数据库，以确保数据库上运行的业
5. 务的安全性。
6. ➢ 删除默认的测试数据库，取消测试数据库的一系列访问权限。
7. ➢ 刷新授权列表，让初始化的设定立即生效。

确保mariadb服务器启动后，执行命令初始化

1. mysql_secure_installation

创建mysql普通用户

生产环境里不会死磕root用户，为了数据库的安全以及和其他用户协同管理数据库，就需要创建其他数据库账户，然后分配权限，满足工作需求。

1. MariaDB [(none)]> create user username@'%' identified by 'password';
3. MariaDB [(none)]> use mysql;
5. MariaDB [mysql]> select host,user,password from user where user='username';

切换普通用户yuchao，查看数据库信息，发现无法看到完整的数据库列表

1. [root@master ~]# mysql -uusername -p -h 127.0.0.1
3. MariaDB [(none)]> show databases;

mysql授权sql

mysql使用grant命令对账户进行授权，grant命令常见格式如下

1. grant 权限 on 数据库.表名 to 账户@主机名 对特定数据库中的特定表授权
2. grant 权限 on 数据库.* to 账户@主机名 　　对特定数据库中的所有表给与授权
3. grant 权限1,权限2,权限3 on *.* to 账户@主机名 　　 对所有库中的所有表给与多个授权
4. grant all privileges on *.* to 账户@主机名 　　 对所有库和所有表授权所有权限

退出数据库，使用root登录，开始权限设置

1. [root@master ~]# mysql -uroot -p
3. MariaDB [(none)]> use mysql;
5. ##授予远程登录的权限
6. MariaDB [(none)]> grant all privileges on *.* to username@"%" identified by 'password';
8. MariaDB [mysql]> show grants for username@"%";

移除权限

1. MariaDB [(none)]> revoke all privileges on *.* from username@"%";

mysql备份与恢复

mysqldump命令用于备份数据库数据

1. [root@master ~]# mysqldump -u root -p --all-databases > /tmp/db.dump

进入mariadb数据库，删除一个db

1. [root@master ~]# mysql -uroot -p
3. MariaDB [(none)]> drop database s11;

进行数据恢复，吧刚才重定向备份的数据库文件导入到mysql中

1. [root@master ~]# mysql -uroot -p < /tmp/db.dump

7.1 mysql主从复制

MySQL数据库的主从复制方案，是其自带的功能，并且主从复制并不是复制磁盘上的数据库文件，而是通过binlog日志复制到需要同步的从服务器上。

MySQL数据库支持单向、双向、链式级联，等不同业务场景的复制。在复制的过程中，一台服务器充当主服务器（Master），接收来自用户的内容更新，而一个或多个其他的服务器充当从服务器（slave），接收来自Master上binlog文件的日志内容，解析出SQL，重新更新到Slave，使得主从服务器数据达到一致。

主从复制的逻辑有以下几种

一主一从，单向主从同步模式，只能在Master端写入数据

一主多从

应用场景

1. 利用复制功能当Master服务器出现问题时，我们可以人工的切换到从服务器继续提供服务，此时服务器的数据和宕机时的数据几乎完全一致。
2. 复制功能也可用作数据备份，但是如果人为的执行drop,delete等语句删除，那么从库的备份功能也就失效了.

主从复制原理图

1. (1) master将改变记录到二进制日志(binary log)中（这些记录叫做二进制日志事件，binary log events）；
2. (2) slave将master的binary log events拷贝到它的中继日志(relay log)；
3. (3) slave重做中继日志中的事件，将改变反映它自己的数据。

步骤1 配置master主库

1. #查看数据库状态
2. systemctl status mariadb
3. #停mariadb
4. systemctl stop mariadb
6. #修改配置文件
7. vim /etc/my.cnf
8. #修改内容
9. #解释：server-id服务的唯一标识（主从之间都必须不同）；log-bin启动二进制日志名称为mysql-bin
10. 　　[mysqld]
11. 　　server-id=1
12. 　　log-bin=mysql-bin
14. #重启mariadb
15. systemctl start mariadb

步骤2 在master主库添加进行同步的用户

1. 1.新建用于主从同步的用户username,允许登录的从库是'%'
2. create user 'username'@'%' identified by 'password';
4. 2.#题外话：如果提示密码太简单不复合策略加在前面加这句
5. mysql> set global validate_password_policy=0;
7. 3.给从库账号授权,说明给username从库复制的权限，在"%"机器上复制
8. grant replication slave on *.* to 'username'@'%';
9. #检查主库创建的复制账号
10. select user,host from mysql.user;
11. #检查授权账号的权限
12. show grants for username@'%';
14. 实现对主数据库锁表只读，防止数据写入，数据复制失败
15. flush table with read lock;
17. 4.检查主库的状态
18. MariaDB [(none)]> show master status
19. -> ;
20. +------------------+----------+--------------+------------------+
21. | File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
22. +------------------+----------+--------------+------------------+
23. | mysql-bin.000001 | 575 | | |
24. +------------------+----------+--------------+------------------+
25. 1 row in set (0.00 sec)
27. File是二进制日志文件名，Position 是日志开始的位置。后面从库会用到 后面从库会用到 后面从库会用到！！！！！！
31. 5.锁表后，一定要单独再打开一个SSH窗口，导出数据库的所有数据，
33. [root@oldboy_python ~ 19:32:45]#mysqldump -uroot -p --all-databases > /data/all.sql
35. 6.确保数据导出后，没有数据插入，完毕再查看主库状态
37. show master status;
39. 7.导出数据完毕后，解锁主库，恢复可写；
41. unlock tables;
43. 8.将备份导出的数据scp至Slave数据库
45. scp /data/all.sql root@ip:/data/

步骤3 配置salve从库机器

1. 1.设置server-id值并关闭binlog功能参数
2. 数据库的server-id在主从复制体系内是唯一的，Slave的server-id要与主库和其他从库不同，并且注释掉Slave的binlog参数。
4. 2.因此修改Slave的/etc/my.cnf，写入
5. [mysqld]
6. server-id=3
8. 3.重启数据库
9. systemctl restart mariadb
11. 4.检查Slava从数据库的各项参数
12. show variables like 'log_bin';
13. show variables like 'server_id';
15. 5.恢复主库Master的数据导入到Slave库
16. 导入数据（注意sql文件的路径）
17. mysql>source /data/all.sql;
18. 方法二：
19. #mysql -uroot -p < abc.sql
21. 6.配置复制的参数，Slave从库连接Master主库的配置
22. mysql > change master to master_host='x.x.x.x',
23. master_user='username',
24. master_password='password',
25. master_log_file='mysql-bin.000001',
26. master_log_pos=575;
28. 7.启动从库的同步开关，测试主从复制的情况
29. start slave;
30. 8.查看复制状态
31. show slave status\G;

步骤4 检测主从复制状态关键点

1. MariaDB [(none)]> show slave status\G
2. *************************** 1. row ***************************
3. Slave_IO_State: Waiting for master to send event
4. Master_Host: 192.168.119.10
5. Master_User: chaoge
6. Master_Port: 3306
7. Connect_Retry: 60
8. Master_Log_File: mysql-bin.000001
9. Read_Master_Log_Pos: 1039
10. Relay_Log_File: slave-relay-bin.000002
11. Relay_Log_Pos: 537
12. Relay_Master_Log_File: mysql-bin.000001
13. Slave_IO_Running: Yes
14. Slave_SQL_Running: Yes

Tip:

注意此处还未配置从库的只读模式，只需在slave服务器上配置/etc/my.cnf，加上以下配置，并且在slave上创建普通用户，使用普通用户主从同步即可达到只读的效果

如果用root用户，无法达到readonly，这是一个坑

1. [mysqld]
2. character-set-server=utf8
3. collation-server=utf8_general_ci
4. log-error=/var/log/mysqld.log
5. server-id=3
6. read-only=true
7. [client]
8. default-character-set=utf8
9. [mysql]
10. default-character-set=utf8

 

 

 

redis

1. Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件

安装redis

1. 安装方式：
2. 1. yum安装
3. 2.源码编译安装

大家用过yum，是相当省事好用吧，为什么还要学习源码安装？

有人说编译安装性能好？错

编译安装的优势是：

• 编译安装时可以指定扩展的module（模块），php、apache、nginx都是一样有很多第三方扩展模块，如mysql，编译安装时候，如果需要就定制存储引擎（innodb，还是MyIASM）
• 编译安装可以统一安装路径，linux软件约定安装目录在/opt/下面
• 软件仓库版本一般比较低，编译源码安装可以根据需求，安装最新的版本

编译安装redis步骤

1. 1.下载redis源码
2. wget http://download.redis.io/releases/redis-4.0.10.tar.gz
3. 2.解压缩
4. tar -zxf redis-4.0.10.tar.gz
5. 3.切换redis源码目录
6. cd redis-4.0.10.tar.gz
7. 4.编译源文件
8. make
9. 5.编译好后，src/目录下有编译好的redis指令
10. 6.make install 安装到指定目录，默认在/usr/local/bin

redis可执行文件

1. ./redis-benchmark //用于进行redis性能测试的工具
2. ./redis-check-dump //用于修复出问题的dump.rdb文件
3. ./redis-cli //redis的客户端
4. ./redis-server //redis的服务端
5. ./redis-check-aof //用于修复出问题的AOF文件
6. ./redis-sentinel //用于集群管理

启动redis服务端

1. 启动redis非常简单，直接./redis-server就可以启动服务端了，还可以用下面的方法指定要加载的配置文件：
2. redis-server redis.conf
3. 默认情况下，redis-server会以非daemon的方式来运行，且默认服务端口为6379。

使用redis客户端

1. #执行客户端命令即可进入
2. ./redis-cli
3. #测试是否连接上redis
4. 127.0.0.1:6379 > ping
5. 返回pong代表连接上了
7. //用set来设置key、value
8. 127.0.0.1:6379 > set name "chaoge"
9. OK
10. //get获取name的值
11. 127.0.0.1:6379 > get name
12. "chaoge"

8.1 redis发布订阅

redis提供了发布（publish）订阅（subbscribe）功能

发布订阅的命令

发布订阅的命令

1. PUBLISH channel msg
2. 将信息 message 发送到指定的频道 channel
4. SUBSCRIBE channel [channel ...]
5. 订阅频道，可以同时订阅多个频道
7. UNSUBSCRIBE [channel ...]
8. 取消订阅指定的频道, 如果不指定频道，则会取消订阅所有频道
9. PSUBSCRIBE pattern [pattern ...]
10. 订阅一个或多个符合给定模式的频道，每个模式以 * 作为匹配符，比如 it* 匹配所 有以 it 开头的频道( it.news 、 it.blog 、 it.tweets 等等)， news.* 匹配所有 以 news. 开头的频道( news.it 、 news.global.today 等等)，诸如此类
11. PUNSUBSCRIBE [pattern [pattern ...]]
12. 退订指定的规则, 如果没有参数则会退订所有规则
13. PUBSUB subcommand [argument [argument ...]]
14. 查看订阅与发布系统状态
15. 注意：使用发布订阅模式实现的消息队列，当有客户端订阅channel后只能收到后续发布到该频道的消息，之前发送的不会缓存，必须Provider和Consumer同时在线。

发布订阅

窗口1，启动两个redis-cli窗口，均订阅diantai 频道（channel）

窗口2，启动发布者向频道 diantai发送消息

1. [root@web02 ~]# redis-cli
2. 127.0.0.1:6379> PUBLISH diantai 'jinyewugenglaiwojia'
3. (integer) 2

窗口3，查看订阅者的消息状态

订阅一个或者多个符合模式的频道

窗口1，启动两个redis-cli窗口，均订阅 wang*频道（channel）

1. 127.0.0.1:6379> PSUBSCRIBE wang*
2. Reading messages... (press Ctrl-C to quit)
3. 1) "psubscribe"
4. 2) "wang*"
5. 3) (integer) 1
8. 1) "pmessage"
9. 2) "wang*"
10. 3) "wangbaoqiang"
11. 4) "jintian zhennanshou "

窗口2，启动redis-cli窗口，均订阅wang*频道

1. 127.0.0.1:6379> PSUBSCRIBE wang*
2. Reading messages... (press Ctrl-C to quit)
3. 1) "psubscribe"
4. 2) "wang*"
5. 3) (integer) 1
9. 1) "pmessage"
10. 2) "wang*"
11. 3) "wangbaoqiang"
12. 4) "jintian zhennanshou "

窗口3，发布者消息

1. [root@web02 ~]# redis-cli
2. 127.0.0.1:6379> PUBLISH wangbaoqiang "jintian zhennanshou "
3. (integer) 2

8.2 redis持久化rdb与aof

Redis是一种内存型数据库，一旦服务器进程退出，数据库的数据就会丢失，为了解决这个问题，Redis提供了两种持久化的方案，将内存中的数据保存到磁盘中，避免数据的丢失。

RDB持久化

redis提供了RDB持久化的功能，这个功能可以将redis在内存中的的状态保存到硬盘中，它可以手动执行。

也可以再redis.conf中配置，定期执行。

RDB持久化产生的RDB文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis可以通过这个文件还原数据库当时的状态。

1. RDB(持久化)
2. 内存数据保存到磁盘
3. 在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）
4. 优点：速度快，适合做备份，主从复制就是基于RDB持久化功能实现
5. rdb通过再redis中使用save命令触发 rdb
8. rdb配置参数：
10. dir /data/6379/
11. dbfilename dbmp.rdb
13. 每过900秒 有1个操作就进行持久化
15. save 900秒 1个修改类的操作
16. save 300秒 10个操作
17. save 60秒 10000个操作
19. save 900 1
20. save 300 10
21. save 60 10000

redis持久化之RDB实践

1.启动redis服务端,准备配置文件

1. daemonize yes
2. port 6379
3. logfile /data/6379/redis.log
4. dir /data/6379 #定义持久化文件存储位置
5. dbfilename dbmp.rdb #rdb持久化文件
6. bind 10.0.0.10 127.0.0.1 #redis绑定地址
7. requirepass redhat #redis登录密码
8. save 900 1 #rdb机制 每900秒 有1个修改记录
9. save 300 10 #每300秒 10个修改记录
10. save 60 10000 #每60秒内 10000修改记录

2.启动redis服务端

3.登录redis设置一个key

1. redis-cli -a redhat

4.此时检查目录，/data/6379底下没有dbmp.rdb文件

5.通过save触发持久化，将数据写入RDB文件

1. 127.0.0.1:6379> set age 18
2. OK
3. 127.0.0.1:6379> save
4. OK

redis持久化之AOF

AOF（append-only log file）
记录服务器执行的所有变更操作命令（例如set del等），并在服务器启动时，通过重新执行这些命令来还原数据集
AOF 文件中的命令全部以redis协议的格式保存，新命令追加到文件末尾。
优点：最大程序保证数据不丢
缺点：日志记录非常大

1. redis-client 写入数据 > redis-server 同步命令 > AOF文件

配置参数

1. AOF持久化配置，两条参数
3. appendonly yes
4. appendfsync always 总是修改类的操作
5. everysec 每秒做一次持久化
6. no 依赖于系统自带的缓存大小机制

1.准备aof配置文件 redis.conf

1. daemonize yes
2. port 6379
3. logfile /data/6379/redis.log
4. dir /data/6379
5. dbfilename dbmp.rdb
6. requirepass redhat
7. save 900 1
8. save 300 10
9. save 60 10000
10. appendonly yes
11. appendfsync everysec

2.启动redis服务

1. redis-server /etc/redis.conf

3.检查redis数据目录/data/6379/是否产生了aof文件

1. [root@web02 6379]# ls
2. appendonly.aof dbmp.rdb redis.log

4.登录redis-cli，写入数据，实时检查aof文件信息

1. [root@web02 6379]# tail -f appendonly.aof

5.设置新key，检查aof信息，然后关闭redis，检查数据是否持久化

1. redis-cli -a redhat shutdown
3. redis-server /etc/redis.conf
5. redis-cli -a redhat

redis 持久化方式有哪些？有什么区别？

rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于rdb持久化功能

aof：以追加的方式记录redis操作日志的文件。可以最大程度的保证redis数据安全，类似于mysql的binlog

RDB持久化切换AOF持久化

确保redis版本在2.2以上

1. [root@pyyuc /data 22:23:30]#redis-server -v
2. Redis server v=4.0.10 sha=00000000:0 malloc=jemalloc-4.0.3 bits=64 build=64cb6afcf41664c

本文在redis4.0中，通过config set命令，达到不重启redis服务，从RDB持久化切换为AOF

实验环境准备

redis.conf服务端配置文件

1. daemonize yes
2. port 6379
3. logfile /data/6379/redis.log
4. dir /data/6379
5. dbfilename dbmp.rdb
6. save 900 1 #rdb机制 每900秒 有1个修改记录
7. save 300 10 #每300秒 10个修改记录
8. save 60 10000 #每60秒内 10000修改记录

启动redis服务端

1. redis-server redis.conf

登录redis-cli插入数据，手动持久化

1. 127.0.0.1:6379> set name chaoge
2. OK
3. 127.0.0.1:6379> set age 18
4. OK
5. 127.0.0.1:6379> set addr shahe
6. OK
7. 127.0.0.1:6379> save
8. OK

检查RDB文件

1. [root@pyyuc /data 22:34:16]#ls 6379/
2. dbmp.rdb redis.log

备份这个rdb文件，保证数据安全

1. [root@pyyuc /data/6379 22:35:38]#cp dbmp.rdb /opt/

执行命令，开启AOF持久化

1. 127.0.0.1:6379> CONFIG set appendonly yes #开启AOF功能
2. OK
3. 127.0.0.1:6379> CONFIG SET save "" #关闭RDB功能
4. OK

确保数据库的key数量正确

1. 127.0.0.1:6379> keys *
2. 1) "addr"
3. 2) "age"
4. 3) "name"

确保插入新的key，AOF文件会记录

1. 127.0.0.1:6379> set title golang
2. OK

此时RDB已经正确切换AOF，注意还得修改redis.conf添加AOF设置，不然重启后，通过config set的配置将丢失

8.3 redis主从同步

原理：

1. 从服务器向主服务器发送 SYNC 命令。
2. 接到 SYNC 命令的主服务器会调用BGSAVE 命令，创建一个 RDB 文件，并使用缓冲区记录接下来执行的所有写命令。
3. 当主服务器执行完 BGSAVE 命令时，它会向从服务器发送 RDB 文件，而从服务器则会接收并载入这个文件。
4. 主服务器将缓冲区储存的所有写命令发送给从服务器执行。
   -——————
   1、在开启主从复制的时候，使用的是RDB方式的，同步主从数据的
   2、同步开始之后，通过主库命令传播的方式，主动的复制方式实现
   3、2.8以后实现PSYNC的机制，实现断线重连

redis主从同步配置

步骤一、准备一主两从的数据库实例

主节点：6380

从节点：6381、6382

6380.conf

1. 1、环境：
2. 准备两个或两个以上redis实例
4. mkdir /data/638{0..2} #创建6380 6381 6382文件夹
6. 配置文件示例：
7. vim /data/6380/redis.conf
8. port 6380
9. daemonize yes
10. pidfile /data/6380/redis.pid
11. loglevel notice
12. logfile "/data/6380/redis.log"
13. dbfilename dump.rdb
14. dir /data/6380
15. protected-mode no

6381.conf

1. vim /data/6381/redis.conf
2. port 6381
3. daemonize yes
4. pidfile /data/6381/redis.pid
5. loglevel notice
6. logfile "/data/6381/redis.log"
7. dbfilename dump.rdb
8. dir /data/6381
9. protected-mode no

6382.conf

1. port 6382
2. daemonize yes
3. pidfile /data/6382/redis.pid
4. loglevel notice
5. logfile "/data/6382/redis.log"
6. dbfilename dump.rdb
7. dir /data/6382
8. protected-mode no

启动三个redis实例

1. redis-server /data/6380/redis.conf
2. redis-server /data/6381/redis.conf
3. redis-server /data/6382/redis.conf

步骤二、配置主从同步

6381/6382命令行

redis-cli -p 6381
SLAVEOF 127.0.0.1 6380 #指明主的地址

redis-cli -p 6382
SLAVEOF 127.0.0.1 6380 #指明主的地址

检查主从状态

从库：

1. 127.0.0.1:6382> info replication
2. 127.0.0.1:6381> info replication

主库：

1. 127.0.0.1:6380> info replication

测试写入数据，主库写入数据，检查从库数据

1. 主
2. 127.0.0.1:6380> set name chaoge
5. 从
6. 127.0.0.1:6381>get name

手动进行主从复制故障切换

1. #关闭主库6380
2. redis-cli -p 6380
3. shutdown

检查从库主从信息，此时master_link_status:down

1. redis-cli -p 6381
2. info replication
3. redis-cli -p 6382
4. info replication

既然主库挂了，我想要在6381 6382之间选一个新的主库

1.关闭6381的从库身份

1. redis-cli -p 6381
2. info replication
3. slaveof no one

2.将6382设为6381的从库

1. 6382连接到6381：
2. [root@db03 ~]# redis-cli -p 6382
3. 127.0.0.1:6382> SLAVEOF no one
4. 127.0.0.1:6382> SLAVEOF 127.0.0.1 6381

3.检查6382，6381的主从信息

8.4 redis哨兵

redis-Sentinel

1. Redis-Sentinel是redis官方推荐的高可用性解决方案，
2. 当用redis作master-slave的高可用时，如果master本身宕机，redis本身或者客户端都没有实现主从切换的功能。
4. 而redis-sentinel就是一个独立运行的进程，用于监控多个master-slave集群，
5. 自动发现master宕机，进行自动切换slave > master。

sentinel主要功能如下：

• 不时的监控redis是否良好运行，如果节点不可达就会对节点进行下线标识
• 如果被标识的是主节点，sentinel就会和其他的sentinel节点“协商”，如果其他节点也人为主节点不可达，就会选举一个sentinel节点来完成自动故障转义
• 在master-slave进行切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换

Redis-sentinel工作机制

1. 每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令
4. 如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线。
6. 如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。
8. 当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线
10. 在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令
12. 当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次
14. 若没有足够数量的 Sentinel 同意 Master 已经下线， Master 的客观下线状态就会被移除。
16. 若 Master 重新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。
18. 主观下线和客观下线
20. 主观下线：Subjectively Down，简称 SDOWN，指的是当前 Sentinel 实例对某个redis服务器做出的下线判断。
21. 客观下线：Objectively Down， 简称 ODOWN，指的是多个 Sentinel 实例在对Master Server做出 SDOWN 判断，并且通过 SENTINEL is-master-down-by-addr 命令互相交流之后，得出的Master Server下线判断，然后开启failover.
23. SDOWN适合于Master和Slave，只要一个 Sentinel 发现Master进入了ODOWN， 这个 Sentinel 就可能会被其他 Sentinel 推选出， 并对下线的主服务器执行自动故障迁移操作。
25. ODOWN只适用于Master，对于Slave的 Redis 实例，Sentinel 在将它们判断为下线前不需要进行协商， 所以Slave的 Sentinel 永远不会达到ODOWN。

redis主从复制背景问题

Redis主从复制可将主节点数据同步给从节点，从节点此时有两个作用：

• 一旦主节点宕机，从节点作为主节点的备份可以随时顶上来。
• 扩展主节点的读能力，分担主节点读压力。

但是问题是：

• 一旦主节点宕机，从节点上位，那么需要人为修改所有应用方的主节点地址（改为新的master地址），还需要命令所有从节点复制新的主节点

那么这个问题，redis-sentinel就可以解决了

主从复制架构图

redis sentinel架构图

redis的一个进程，但是不存储数据，只是监控redis

安装配置redis哨兵

本实验是在测试环境下，考虑到学生机器较弱，因此只准备一台linux服务器用作环境！！

服务器环境，一台即可完成操作

主节点master的redis-6379.conf

1. port 6379
2. daemonize yes
3. logfile "6379.log"
4. dbfilename "dump-6379.rdb"
5. dir "/var/redis/data/"

从节点slave的redis-6380.conf

1. port 6380
2. daemonize yes
3. logfile "6380.log"
4. dbfilename "dump-6380.rdb"
5. dir "/var/redis/data/"
6. slaveof 127.0.0.1 6379 // 从属主节点

从节点slave的redis-6381.conf

1. port 6381
2. daemonize yes
3. logfile "6380.log"
4. dbfilename "dump-6380.rdb"
5. dir "/var/redis/data/"
6. slaveof 127.0.0.1 6379 // 从属主节点

启动redis主节点

1. redis-server /etc/redis-6379.conf

测试redis主节点是否通信

1. redis-cli ping

启动两slave节点

还记得上面超哥的截图吗？总体redis配置文件如下，6379为master，6380和6381为slave

1. -rw-r--r-- 1 root root 145 Nov 7 17:44 /etc/redis-6379.conf #这个为主，port是6379
2. -rw-r--r-- 1 root root 93 Nov 7 17:42 /etc/redis-6380.conf　　　 # 这个是从，port6380，并且得加上新的参数slaveof
3. -rw-r--r-- 1 root root 115 Nov 7 17:42 /etc/redis-6381.conf # 这个是从，port6381，并且得加上新的参数slaveof

1. redis-server /etc/redis-6380.conf
2. redis-server /etc/redis-6381.conf

验证从节点的redis服务

1. [root@master ~]$redis-cli -p 6380 ping
2. PONG
3. [root@master ~]$redis-cli -p 6381 ping
4. PONG

检测主从关系

在主节点上查看主从通信关系

1. [root@master ~]# redis-cli -p 6379 info replication
2. # Replication
3. role:master
4. connected_slaves:2
5. slave0:ip=192.168.119.10,port=6380,state=online,offset=407,lag=0
6. slave1:ip=192.168.119.10,port=6381,state=online,offset=407,lag=0
7. master_repl_offset:407
8. repl_backlog_active:1
9. repl_backlog_size:1048576
10. repl_backlog_first_byte_offset:2
11. repl_backlog_histlen:406

在从节点上查看主从关系（6380、6379）

1. [root@slave 192.168.119.11 ~]$redis-cli -p 6380 info replication
2. # Replication
3. role:slave
4. master_host:192.168.119.10
5. master_port:6379
6. master_link_status:up
7. master_last_io_seconds_ago:3
8. master_sync_in_progress:0
9. slave_repl_offset:505
10. slave_priority:100
11. slave_read_only:1
12. connected_slaves:0
13. master_repl_offset:0
14. repl_backlog_active:0
15. repl_backlog_size:1048576
16. repl_backlog_first_byte_offset:0
17. repl_backlog_histlen:0

此时可以在master上写入数据，在slave上查看数据，此时主从复制配置完

配置redis sentinel环境

实验的环境是单独一台linux

1. [root@master tmp]# ll /etc/redis-*
2. -rw-r--r-- 1 root root 145 Nov 7 17:44 /etc/redis-6379.conf
3. -rw-r--r-- 1 root root 93 Nov 7 17:42 /etc/redis-6380.conf
4. -rw-r--r-- 1 root root 115 Nov 7 17:42 /etc/redis-6381.conf
5. -rw-r--r-- 1 root root 556 Nov 7 17:42 /etc/redis-sentinel-26379.conf
6. -rw-r--r-- 1 root root 556 Nov 7 17:42 /etc/redis-sentinel-26380.conf
7. -rw-r--r-- 1 root root 556 Nov 7 17:42 /etc/redis-sentinel-26381.conf

redis-sentinel-26379.conf配置文件写入如下信息

1. // Sentinel节点的端口
2. port 26379
3. dir /var/redis/data/
4. logfile "26379.log"
6. // 当前Sentinel节点监控 192.168.119.10:6379 这个主节点
7. // 2代表判断主节点失败至少需要2个Sentinel节点节点同意
8. // mymaster是主节点的别名
9. sentinel monitor mymaster 192.168.119.10 6379 2
11. //每个Sentinel节点都要定期PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30000毫秒30s且没有回复，则判定不可达
12. sentinel down-after-milliseconds mymaster 30000
14. //当Sentinel节点集合对主节点故障判定达成一致时，Sentinel领导者节点会做故障转移操作，选出新的主节点，
15. 原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为1
16. sentinel parallel-syncs mymaster 1
18. //故障转移超时时间为180000毫秒
19. sentinel failover-timeout mymaster 180000

1. redis-sentinel-26380.conf
2. redis-sentinel-26381.conf的配置仅仅差异是port(端口)的不同。

然后启动三个sentinel哨兵

1. redis-sentinel /etc/redis-sentinel-26379.conf
2. redis-sentinel /etc/redis-sentinel-26380.conf
3. redis-sentinel /etc/redis-sentinel-26381.conf

此时查看哨兵是否成功通信

1. [root@master ~]# redis-cli -p 26379 info sentinel
2. # Sentinel
3. sentinel_masters:1
4. sentinel_tilt:0
5. sentinel_running_scripts:0
6. sentinel_scripts_queue_length:0
7. sentinel_simulate_failure_flags:0
8. master0:name=mymaster,status=ok,address=192.168.119.10:6379,slaves=2,sentinels=3
9. #看到最后一条信息正确即成功了哨兵，哨兵主节点名字叫做mymaster，状态ok，监控地址是192.168.119.10:6379，有两个从节点，3个哨兵

redis高可用故障实验

大致思路

• 杀掉主节点的redis进程6379端口，观察从节点是否会进行新的master选举，进行切换

• 重新恢复旧的“master”节点，查看此时的redis身份

  首先查看三个redis的进程状态

1. ps -ef|grep redis

检查三个节点的复制身份状态

第一个

1. [root@master tmp]# redis-cli -p 6381 info replication
2. # Replication
3. role:slave
4. master_host:127.0.0.1
5. master_port:6380

第二个

1. [root@master tmp]# redis-cli -p 6380 info replication
2. # Replication
3. role:master
4. connected_slaves:2
5. slave0:ip=127.0.0.1,port=6381,state=online,offset=54386,lag=0
6. slave1:ip=127.0.0.1,port=6379,state=online,offset=54253,lag=0

第三个

1. [root@master tmp]# redis-cli -p 6379 info replication
2. # Replication
3. role:slave
4. master_host:127.0.0.1
5. master_port:6380

此时，干掉master！！！然后等待其他两个节点是否能自动被哨兵sentienl，切换为master节点

1. ps -ef|grep 6380 #干掉master进程

此时查看两个slave的状态

精髓就是查看一个参数

1. master_link_down_since_seconds:13

稍等片刻之后，发现slave节点成为master节点！！

1. [root@master tmp]# redis-cli -p 6379 info replication
2. # Replication
3. role:master
4. connected_slaves:1
5. slave0:ip=127.0.0.1,port=6381,state=online,offset=41814,lag=1

大功告成！！

8.5 redis-cluster

为什么要用redis-cluster

并发问题

1. redis官方生成可以达到 10万/每秒,每秒执行10万条命令
2. 假如业务需要每秒100万的命令执行呢？

数据量太大

一台服务器内存正常是16~256G，假如你的业务需要500G内存，你怎么办？

新浪微博作为世界上最大的redis存储，就超过1TB的数据，去哪买这么大的内存条？

解决方案如下

1. 配置一个超级牛逼的计算机，超大内存，超强cpu，但是问题是。。。。
   

2.正确的应该是考虑分布式，加机器，把数据分到不同的位置，分摊集中式的压力，一堆机器做一件事

客户端分片

1. redis实例集群主要思想是将redis数据的key进行散列，通过hash函数特定的key会映射到指定的redis节点上

数据分布原理图

分布式数据库首要解决把整个数据集按照分区规则映射到多个节点的问题，即把数据集划分到多个节点上，每个节点负责整个数据的一个子集。

常见的分区规则有哈希分区和顺序分区。Redis Cluster采用哈希分区规则，因此接下来会讨论哈希分区规则。

• 节点取余分区
• 一致性哈希分区
• 虚拟槽分区(redis-cluster采用的方式)

顺序分区

哈希分区

例如按照节点取余的方式，分三个节点

1~100的数据对3取余，可以分为三类

• 余数为0
• 余数为1
• 余数为2

那么同样的分4个节点就是hash(key)%4

节点取余的优点是简单，客户端分片直接是哈希+取余

虚拟槽分区

Redis Cluster采用虚拟槽分区

虚拟槽分区巧妙地使用了哈希空间，使用分散度良好的哈希函数把所有的数据映射到一个固定范围内的整数集合，整数定义为槽（slot）。

Redis Cluster槽的范围是0 ～ 16383。

槽是集群内数据管理和迁移的基本单位。采用大范围的槽的主要目的是为了方便数据的拆分和集群的扩展，

每个节点负责一定数量的槽。

如何搭建redis-cluster

搭建集群分为几部

• 准备节点（几匹马儿）
• 节点通信（几匹马儿分配主从）
• 分配槽位给节点（slot分配给马儿）

redis-cluster集群架构

1. 多个服务端，负责读写，彼此通信，redis指定了16384个槽。
3. 多匹马儿，负责运输数据，马儿分配16384个槽位，管理数据。
5. ruby的脚本自动就把分配槽位这事做了

安装方式

官方提供通过ruby语言的脚本一键安装

步骤一、通过配置，redis.conf开启redis-cluster

1. port 7000
2. daemonize yes
3. dir "/opt/redis/data"
4. logfile "7000.log"
5. dbfilename "dump-7000.rdb"
6. cluster-enabled yes #开启集群模式
7. cluster-config-file nodes-7000.conf　　#集群内部的配置文件
8. cluster-require-full-coverage no　　#redis cluster需要16384个slot都正常的时候才能对外提供服务，换句话说，只要任何一个slot异常那么整个cluster不对外提供服务。 因此生产环境一般为no

redis支持多实例的功能，我们在单机演示集群搭建，需要6个实例，三个是主节点，三个是从节点，数量为6个节点才能保证高可用的集群。

每个节点仅仅是端口运行的不同！

1. [root@yugo /opt/redis/config 17:12:30]#ls
2. redis-7000.conf redis-7002.conf redis-7004.conf
3. redis-7001.conf redis-7003.conf redis-7005.conf
5. #确保每个配置文件中的端口修改！！

步骤二、运行redis实例

创建6个节点的redis实例

1. 1855 2018-10-24 15:46:01 redis-server redis-7000.conf
2. 1856 2018-10-24 15:46:13 redis-server redis-7001.conf
3. 1857 2018-10-24 15:46:16 redis-server redis-7002.conf
4. 1858 2018-10-24 15:46:18 redis-server redis-7003.conf
5. 1859 2018-10-24 15:46:20 redis-server redis-7004.conf
6. 1860 2018-10-24 15:46:23 redis-server redis-7005.conf

1. redis-server redis-7000.conf
2. redis-server redis-7001.conf
3. redis-server redis-7002.conf
4. redis-server redis-7003.conf
5. redis-server redis-7004.conf
6. redis-server redis-7005.conf

步骤3、开启redis-cluster

1. 下载、编译、安装Ruby
2. 安装rubygem redis
3. 安装redis-trib.rb命令

第一步、安装ruby

1. #下载ruby源码包
2. wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
3. #解压缩ruby源码包
4. tar -zxvf ruby-2.3.1.tar.gz
5. #编译且安装
6. ./configure --prefix=/opt/ruby/
7. make && make install

第二步、配置ruby环境变量

1. vim /etc/profile
2. 写入如下配置
3. PATH=$PATH:/opt/ruby/bin

第三步、安装ruby操作redis包

1. wget http://rubygems.org/downloads/redis-3.3.0.gem
2. gem install -l redis-3.3.0.gem

第四部、安装redis-trib.rb命令

1. [root@yugo /opt/redis/src 18:38:13]#cp /opt/redis/src/redis-trib.rb /usr/local/bin/

一键开启redis-cluster集群

1. #每个主节点，有一个从节点，代表--replicas 1
2. redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005
4. #集群自动分配主从关系 7000、7001、7002为 7003、7004、7005 主动关系

查看集群状态

1. redis-cli -p 7000 cluster info
3. redis-cli -p 7000 cluster nodes #等同于查看nodes-7000.conf文件节点信息
5. 集群主节点状态
6. redis-cli -p 7000 cluster nodes | grep master
7. 集群从节点状态
8. redis-cli -p 7000 cluster nodes | grep slave

写入redis-cluster集群数据

安装完毕后，检查集群状态

1. [root@yugo /opt/redis/src 18:42:14]#redis-cli -p 7000 cluster info
2. cluster_state:ok
3. cluster_slots_assigned:16384
4. cluster_slots_ok:16384
5. cluster_slots_pfail:0
6. cluster_slots_fail:0
7. cluster_known_nodes:6
8. cluster_size:3
9. cluster_current_epoch:6
10. cluster_my_epoch:1
11. cluster_stats_messages_ping_sent:10468
12. cluster_stats_messages_pong_sent:10558
13. cluster_stats_messages_sent:21026
14. cluster_stats_messages_ping_received:10553
15. cluster_stats_messages_pong_received:10468
16. cluster_stats_messages_meet_received:5
17. cluster_stats_messages_received:21026

测试写入集群数据，登录集群必须使用redis-cli -c -p 7000必须加上-c参数

1. 127.0.0.1:7000> set name chao
2. -> Redirected to slot [5798] located at 127.0.0.1:7001
3. OK
4. 127.0.0.1:7001> exit
5. [root@yugo /opt/redis/src 18:46:07]#redis-cli -c -p 7000
6. 127.0.0.1:7000> ping
7. PONG
8. 127.0.0.1:7000> keys *
9. (empty list or set)
10. 127.0.0.1:7000> get name
11. -> Redirected to slot [5798] located at 127.0.0.1:7001
12. "chao"

8.6 redis-python api

1. 1、对redis的单实例进行连接操作
3. python3
4. >>>import redis
5. >>>r = redis.StrictRedis(host='localhost', port=6379, db=0,password='root')
6. >>>r.set('lufei', 'guojialei')
7. True
8. >>>r.get('lufei')
9. 'bar'
12. --------------------
14. 2、sentinel集群连接并操作
17. [root@db01 ~]# redis-server /data/6380/redis.conf
18. [root@db01 ~]# redis-server /data/6381/redis.conf
19. [root@db01 ~]# redis-server /data/6382/redis.conf
20. [root@db01 ~]# redis-sentinel /data/26380/sentinel.conf &
24. --------------------------------
25. ## 导入redis sentinel包
26. >>> from redis.sentinel import Sentinel
27. ##指定sentinel的地址和端口号
28. >>> sentinel = Sentinel([('localhost', 26380)], socket_timeout=0.1)
29. ##测试，获取以下主库和从库的信息
30. >>> sentinel.discover_master('mymaster')
31. >>> sentinel.discover_slaves('mymaster')
32. ##配置读写分离
33. #写节点
34. >>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
35. #读节点
36. >>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
37. ###读写分离测试 key
38. >>> master.set('oldboy', '123')
39. >>> slave.get('oldboy')
40. '123'
43. ----------------------
44. redis cluster的连接并操作（python2.7.2以上版本才支持redis cluster，我们选择的是3.5）
45. https://github.com/Grokzen/redis-py-cluster
48. 3、python连接rediscluster集群测试
49. 使用
51. python3
52. >>> from rediscluster import StrictRedisCluster
53. >>> startup_nodes = [{"host": "127.0.0.1", "port": "7000"}]
54. ### Note: decode_responses must be set to True when used with python3
55. >>> rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)
56. >>> rc.set("foo", "bar")
57. True
58. >>>
59. 'bar'

 

 

想必我们大多数人都是通过访问网站而开始接触互联网的吧。我们平时访问的网站服务 就是 Web 网络服务，一般是指允许用户通过浏览器访问到互联网中各种资源的服务。

 

Web 网络服务是一种被动访问的服务程序，即只有接收到互联网中其他主机发出的 请求后才会响应，最终用于提供服务程序的 Web 服务器会通过 HTTP(超文本传输协议)或 HTTPS(安全超文本传输协议)把请求的内容传送给用户。

 

目前能够提供 Web 网络服务的程序有 IIS、Nginx 和 Apache 等。其中，IIS(Internet Information Services，互联网信息服务)是 Windows 系统中默认的 Web 服务程序

 

2004 年 10 月 4 日，为俄罗斯知名门户站点而开发的 Web 服务程序 Nginx 横空出世。 Nginx 程序作为一款轻量级的网站服务软件，因其稳定性和丰富的功能而快速占领服务器市 场，但 Nginx 最被认可的还当是系统资源消耗低且并发能力强，因此得到了国内诸如新浪、 网易、腾讯等门户站的青睐。

 

 

1. web服务器（nginx）：接收HTTP请求（例如www.pythonav.cn/xiaocang.jpg）并返回数据
3. web框架（django，flask）：开发web应用程序，处理接收到的数据

 

nginx介绍

 

1. nginx是一个开源的，支持高性能，高并发的www服务和代理服务软件。它是一个俄罗斯人lgor sysoev开发的，作者将源代码开源出来供全球使用。
2. nginx比它大哥apache性能改进许多，nginx占用的系统资源更少，支持更高的并发连接，有更高的访问效率。
3. nginx不但是一个优秀的web服务软件，还可以作为反向代理，负载均衡，以及缓存服务使用。
4. 安装更为简单，方便，灵活。
6. 支持高并发，能支持几万并发连接
7. 资源消耗少，在3万并发连接下开启10个nginx线程消耗的内存不到200M
8. 可以做http反向代理和负载均衡
9. 支持异步网络i/o事件模型epoll

 

Tengine

 

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

 

安装配置nginx

 

安装nginx前的依赖环境解决

 

1. #执行第一条语句即可
2. yum install gcc patch libffi-devel python-devel zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel openssl openssl-devel -y
4. #依赖简单介绍
5. 一. gcc 安装
6. 安装 nginx 需要先将官网下载的源码进行编译，编译依赖 gcc 环境，如果没有 gcc 环境，则需要安装：
8. yum install gcc-c++
9. 二. PCRE pcre-devel 安装
10. PCRE(Perl Compatible Regular Expressions) 是一个Perl库，包括 perl 兼容的正则表达式库。nginx 的 http 模块使用 pcre 来解析正则表达式，所以需要在 linux 上安装 pcre 库，pcre-devel 是使用 pcre 开发的一个二次开发库。nginx也需要此库。命令：
12. yum install -y pcre pcre-devel
13. 三. zlib 安装
14. zlib 库提供了很多种压缩和解压缩的方式， nginx 使用 zlib 对 http 包的内容进行 gzip ，所以需要在 Centos 上安装 zlib 库。
16. yum install -y zlib zlib-devel
17. 四. OpenSSL 安装
18. OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及 SSL 协议，并提供丰富的应用程序供测试或其它目的使用。
19. nginx 不仅支持 http 协议，还支持 https（即在ssl协议上传输http），所以需要在 Centos 安装 OpenSSL 库。

 

编译安装nginx

 

1. 1.下载源码包
2. wget -c https://nginx.org/download/nginx-1.12.0.tar.gz
3. 2.解压缩源码
4. tar -zxvf nginx-1.12.0.tar.gz
5. 3.配置，编译安装 开启nginx状态监测功能
6. ./configure --prefix=/opt/nginx112/
7. make && make install
8. 4.启动nginx，进入sbin目录,找到nginx启动命令
9. cd sbin
10. ./nginx #启动
11. ./nginx -s stop #关闭
12. ./nginx -s reload #重新加载
13. 5.修改PATH
14. PATH=$PATH:/opt/nginx112/

 

nginx软件目录

 

1. [root@oldboy_python /opt/nginx1-12 11:44:02]#ls
2. client_body_temp conf fastcgi_temp html logs proxy_temp sbin scgi_temp static uwsgi_temp

 

• conf 存放nginx所有配置文件的目录,主要nginx.conf
• html 存放nginx默认站点的目录，如index.html、error.html等
• logs 存放nginx默认日志的目录，如error.log access.log
• sbin 存放nginx主命令的目录,sbin/nginx

 

Nginx主配置文件/etc/nginx/nginx.conf是一个纯文本类型的文件，整个配置文件是以区块的形式组织的。一般，每个区块以一对大括号{}来表示开始与结束。

 

1. CoreModule核心模块
3. user www; #Nginx进程所使用的用户
4. worker_processes 1; #Nginx运行的work进程数量(建议与CPU数量一致或auto)
5. error_log /log/nginx/error.log #Nginx错误日志存放路径
6. pid /var/run/nginx.pid #Nginx服务运行后产生的pid进程号

 

1. events事件模块
3. events {
4. worker_connections //每个worker进程支持的最大连接数
5. use epool; //事件驱动模型, epoll默认
6. }

 

1. http内核模块
3. //公共的配置定义在http{}
4. http { //http层开始
5. ...
6. //使用Server配置网站, 每个Server{}代表一个网站(简称虚拟主机)
7. 'server' {
8. listen 80; //监听端口, 默认80
9. server_name localhost; //提供服务的域名或主机名
10. access_log host.access.log //访问日志
11. //控制网站访问路径
12. 'location' / {
13. root /usr/share/nginx/html; //存放网站代码路径
14. index index.html index.htm; //服务器返回的默认页面文件
15. }
16. //指定错误代码, 统一定义错误页面, 错误代码重定向到新的Locaiton
17. error_page 500 502 503 504 /50x.html;
18. }
19. ...
20. //第二个虚拟主机配置
21. 'server' {
22. ...
23. }
25. include /etc/nginx/conf.d/*.conf; //包含/etc/nginx/conf.d/目录下所有以.conf结尾的文件
27. } //http层结束

 

部署nginx站点

 

nginx默认站点是Nginx目录下的html文件夹，这里可以从nginx.conf中查到

 

1. location /{
2. root html; #这里是默认的站点html文件夹，也就是 /opt/nginx1-12/html/文件夹下的内容
3. index index.html index.htm; #站点首页文件名是index.html
4. }

 

如果要部署网站业务数据，只需要把开发好的程序全放到html目录下即可

 

1. [root@oldboy_python /tmp 11:34:52]#ls /opt/nginx1-12/html/
2. index.html jssts.jpeg lhy.mp4 man.jpg wget-log

 

因此只需要通过域名/资源，即可访问

 

1. http://www.pyyuc.cn/man.jpg

 

Nginx多个虚拟主机

 

如果每台linux服务器只运行了一个小网站，那么人气低，流量小的草根站长需要承担高额的服务器租赁费，也造成了硬件资源浪费。

 

虚拟主机就是将一台服务器分割成多个“虚拟服务器”，每个站点使用各自的硬盘空间，由于省资源，省钱，众多网站都使用虚拟主机来部署网站。

 

1. 虚拟主机的概念就是在web服务里的一个独立的网站站点，这个站点对应独立的域名（IP），具有独立的程序和资源目录，可以独立的对外提供服务。
2. 这个独立的站点配置是在nginx.conf中使用server{}代码块标签来表示一个虚拟主机。
3. Nginx支持多个server{}标签，即支持多个虚拟主机站点。

 

虚拟主机类型

 

1. 基于域名的虚拟主机
2. 通过不同的域名区分不同的虚拟主机，是企业应用最广的虚拟主机。
4. 基于端口的虚拟主机
5. 通过不同的端口来区分不同的虚拟主机，一般用作企业内部网站，不对外直接提供服务的后台，例如www.pythonav.cn:9000
7. 基于IP的虚拟主机
8. 通过不同的IP区分不同的虚拟主机，此类比较少见，一般业务需要多IP的常见都会在负载均衡中绑定VIP

 

 

nginx可以自动识别用户请求的域名，根据不同的域名请求服务器传输不同的内容，只需要保证服务器上有一个可用的ip地址，配置好dns解析服务。

 

/etc/hosts是linux系统中本地dns解析的配置文件，同样可以达到域名访问效果

 

修改nginx.conf

 

1. egrep -v '#|^$' /opt/nginx1-12/conf/nginx.conf
2. #配置文件内容如下
3. worker_processes 1;
4. events {
5. worker_connections 1024;
6. }
7. http {
8. include mime.types;
9. default_type application/octet-stream;
10. log_format main '$remote_addr - $remote_user [$time_local] "$request" '
11. '$status $body_bytes_sent "$http_referer" '
12. '"$http_user_agent" "$http_x_forwarded_for"';
13. access_log logs/access.log main;
14. sendfile on;
15. keepalive_timeout 65;
16. #虚拟主机1
17. server {
18. listen 80;
19. server_name www.pyyuc.cn;
20. location /{
21. root html/pyyuc;
22. index index.html index.htm;
23. }
24. }
25. #虚拟主机2
26. server {
27. listen 80;
28. server_name www.pythonav.cn;
29. location /{
30. root html/pythonav;
31. index index.html index.htm;
32. }
33. }
34. }

 

1. [root@oldboy_python /opt/nginx1-12 14:52:12]#curl www.pythonav.cn
2. <meta charset=utf8>我是pythonav，未成年禁止入内
3. [root@oldboy_python /opt/nginx1-12 14:52:40]#curl www.pyyuc.cn
4. <meta charset=utf8>我是pyyuc站点

 

Nginx访问日志功能

 

日志功能对每个用户访问网站的日志信息记录到指定的日志文件里，开发运维人员可以分析用户的浏览器行为，此功能由ngx_http_log_module模块负责，官网地址是：

 

http://nginx.org/en/docs/http/ngx_http_log_module.html

 

控制日志的参数

 

1. log_format 记录日志的格式，可定义多种格式
2. accsss_log 指定日志文件的路径以及格式

 

　　log_format main ‘$remote_addr - $remote_user [$time_local] “$request” ‘
　　‘$status $body_bytes_sent “$http_referer” ‘
　　‘“$http_user_agent” “$http_x_forwarded_for”‘;

 

对应参数解析

 

1. $remote_addr 记录客户端ip
2. $remote_user 远程用户，没有就是 “-”
3. $time_local 　　 对应[14/Aug/2018:18:46:52 +0800]
4. $request　　　 　对应请求信息"GET /favicon.ico HTTP/1.1"
5. $status　　　 　状态码
6. $body_bytes_sent　　571字节 请求体的大小
7. $http_referer　　对应“-”　　由于是直接输入浏览器就是 -
8. $http_user_agent　　客户端身份信息
9. $http_x_forwarded_for　　记录客户端的来源真实ip 97.64.34.118

 

日志效果如下

 

1. 66.102.6.6 - - [14/Aug/2018:18:46:52 +0800] "GET /favicon.ico HTTP/1.1" 404 571 "-"
3. "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36 Google Favicon" "97.64.34.118"

 

nginx.conf默认配置

 

1. log_format main '$remote_addr - $remote_user [$time_local] "$request" '
2. '$status $body_bytes_sent "$http_referer" '
3. '"$http_user_agent" "$http_x_forwarded_for"';
5. access_log logs/access.log main;

 

日志格式配置定义

 

1. log_format是日志关键字参数，不能变
2. main是日志格式指定的标签，记录日志时通过main标签选择指定的格式。

 

Nginx404页面优化

 

在网站运行过程中，可能因为页面不存在等原因，导致网站无法正常响应请求，此时web服务会返回系统的错误码，但是默认的错误页面很不友好。

 

 

 

因此我们可以将404，403等页面的错误信息重定向到网站首页或者其他指定的页面，提升用户访问体验。

 

1. server {
2. listen 80;
3. server_name www.pythonav.cn;
4. root html/pythonav;
5. location /{
6. index index.html index.htm;
7. }
8. 　　　　　　#在pythonav路径下的40x.html错误页面
9. error_page 400 403 404 405 /40x.html;
10. }

 

40x.html

 

1. <img style='width:100%;height:100%;' src=https://pic1.zhimg.com/80/v2-77a9281a2bebc7a2ea5e02577af266a8_hd.png>

 

此时访问www.pythonav.cn/asdasd错误页面已经优化了

 

 

Nginx反向代理功能

 

nginx实现负载均衡的组件

 

1. ngx_http_proxy_module proxy代理模块，用于把请求抛给服务器节点或者upstream服务器池

 

机器准备，两台服务器

 

1. master 192.168.11.63　　主负载
2. slave 192.168.11.64　　web1

 

反向代理配置文件nginx.conf

 

1. worker_processes 1;
2. error_log logs/error.log;
3. pid logs/nginx.pid;
4. events {
5. worker_connections 1024;
6. }
7. http {
8. include mime.types;
9. default_type application/octet-stream;
10. log_format main '$remote_addr - $remote_user [$time_local] "$request" '
11. '$status $body_bytes_sent "$http_referer" '
12. '"$http_user_agent" "$http_x_forwarded_for"';
13. access_log logs/access.log main;
14. sendfile on;
15. keepalive_timeout 65;
17. server {
18. listen 80;
19. server_name 192.168.11.63;
20. location / {
21. proxy_pass http://192.168.11.64;
22. root html;
23. index index.html index.htm;
24. }
25. error_page 500 502 503 504 /50x.html;
26. location = /50x.html {
27. root html;
28. }
29. }
30. }

 

此时访问master的服务器192.168.11.63:80地址，已经会将请求转发给slave的80端口

 

除了页面效果的展示以外，还可以通过log(access.log)查看代理效果

 

63端日志

 

 

64端日志

 

 

9.1 nginx负载均衡

 

集群概念

 

 

集群优点

 

 

 

 

 

 

 

负载均衡介绍

 

 

 

 

9.2 nginx实现负载均衡

 

1. Web服务器，直接面向用户，往往要承载大量并发请求，单台服务器难以负荷，我使用多台WEB服务器组成集群，前端使用Nginx负载均衡，将请求分散的打到我们的后端服务器集群中，
2. 实现负载的分发。那么会大大提升系统的吞吐率、请求性能、高容灾

 

 

Nginx要实现负载均衡需要用到proxy_pass代理模块配置

 

Nginx负载均衡与Nginx代理不同地方在于

 

Nginx代理仅代理一台服务器，而Nginx负载均衡则是将客户端请求代理转发至一组upstream虚拟服务池

 

Nginx可以配置代理多台服务器，当一台服务器宕机之后，仍能保持系统可用。

 

upstream配置

 

在nginx.conf > http 区域中

 

1. upstream django {
2. server 10.0.0.10:8000;
3. server 10.0.0.11:9000;
4. }

 

在nginx.conf > http 区域 > server区域 > location配置中

 

添加proxy_pass

 

1. location / {
2. root html;
3. index index.html index.htm;
4. proxy_pass http://django;
5. }

 

此时初步负载均衡已经完成，upstream默认按照轮训方式负载，每个请求按时间顺序逐一分配到后端节点。

 

upstream分配策略

 

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

 

1.轮询(不做配置，默认轮询)

 

2.weight权重(优先级)

 

3.ip_hash配置，根据客户端ip哈希分配，不能和weight一起用weight 权重

 

1. upstream django {
2. server 10.0.0.10:8000 weight=5;
3. server 10.0.0.11:9000 weight=10;#这个节点访问比率是大于8000的
4. }

 

ip_hash

 

1. 每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器
2. upstream django {
3. 　　　　ip_hash;
4. server 10.0.0.10:8000;
5. server 10.0.0.11:9000;
6. }

 

backup

 

在非backup机器繁忙或者宕机时，请求backup机器，因此机器默认压力最小

 

1. upstream django {
2. server 10.0.0.10:8000 weight=5;
3. server 10.0.0.11:9000;
4. server node.oldboy.com:8080 backup;
5. }

 

Nginx实验负载均衡

 

1. 角色 ip 主机名
2. lb01 192.168.119.10 lb01
3. web01 192.168.119.11 web01
4. web02 192.168.119.12 web02

 

关闭防火墙

 

1. iptables -F
2. sed -i 's/enforcing/disabled/' /etc/selinux/config
4. systemctl stop firewalld
5. systemctl disable firewalld

 

一、web01服务器配置nginx，创建index.html

 

1. server {
2. listen 80;
3. server_name 192.168.119.11;
4. location / {
5. root /node;
6. index index.html index.htm;
7. }
8. }
10. mkdir /node
11. echo 'i am web01' > /node/index.html
13. #启动NGINX
14. ./sbgin/nginx

 

二、web01服务器配置nginx,创建index.html

 

1. server {
2. listen 80;
3. server_name 192.168.119.12;
4. location / {
5. root /node;
6. index index.html index.htm;
7. }
10. mkdir /node
11. echo 'i am web02...' > /node/index.html
12. #启动nginx
13. ./sbing/nginx

 

三、配置lb01服务器的nginx负载均衡

 

1.检查lb01的 nginx.conf

 

1. http {
2. include mime.types;
3. default_type application/octet-stream;
4. sendfile on;
5. keepalive_timeout 65;
6. upstream node {
7. 　　server 192.168.119.11:80;
8. 　　server 192.168.119.12:80;
9. }
10. server {
11. listen 80;
12. server_name 192.168.119.10;
13. location / {
14. 　　proxy_pass http://node;
15. 　　include proxy_params; #需要手动创建
16. }
17. }
18. }

 

2.手动创建proxy_params文件，文件中存放代理的请求头相关参数

 

1. [root@lb01 conf]# cat /opt/nginx/conf/proxy_params
2. proxy_set_header Host $http_host;
3. proxy_set_header X-Real-IP $remote_addr;
4. proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
6. proxy_connect_timeout 30;
7. proxy_send_timeout 60;
8. proxy_read_timeout 60;
10. proxy_buffering on;
11. proxy_buffer_size 32k;
12. proxy_buffers 4 128k;

 

1. 启动lb01负载均衡nginx服务
3. ./sbin/nginx

 

四、访问lb01节点nginx，反复刷新

 

 

 

五、nginx动静分离

 

 

环境准备

 

1. 系统 服务 软件 ip地址
2. centos7(lb01) 负载均衡 nginx proxy 192.168.119.10
3. centos7(web01) 静态资源 nginx静态资源 192.168.119.11
4. centos7(web02) 动态资源 django 192.168.119.12

 

一、在web01机器上，配置静态资源，图片等

 

1. cat nginx.conf
4. server {
5. listen 80;
6. server_name 192.168.119.11;
7. #定义网页根目录
8. root /code;
9. #定义了静态资源
10. index index.html;
11. #域名匹配，所有的png、jpg、gif请求资源，都去/root/code/images底下找
12. location ~* .*\.(png|jpg|gif)$ {
13. root /code/images;
14. }
16. #重启nginx
17. ./sbin/nginx

 

1. #创建目录
2. mkdir -p /code/images
3. #准备首页文件
4. [root@web01 /code]$cat index.html
5. static files...
6. #准备静态文件，图片
7. [root@web01 /code/images]$wget http://pythonav.cn/av/girlone.jpg^C
8. [root@web01 /code/images]$ls
9. girlone.jpg

 

二、在web02配置动态请求，准备一个flask程序和静态资源转发

 

1. cat nginx.conf
3. #静态资源地址
4. upstream static {
5. server 192.168.119.11:80;
6. }
7. #flask动态请求
8. upstream flask {
9. server 192.168.119.12:8080;
10. }
12. server {
13. listen 80;
14. server_name 192.168.119.12;
15. 　　　　　　#当请求到达192.168.119.12:80/时，转发给flask的8080应用
16. location / {
17. proxy_pass http://flask;
18. include proxy_params;
19. }
20. 　　　　　　#当判断资源请求是 192.168.119.12/girl.jpg时候，转发请求给static地址池的服务器192.168.119.11/
21. location ~ .*\.(png|jpg|gif)$ {
22. 　　　　　　　　proxy_pass http://static;
23. include proxy_params;
24. }

 

准备flask应用,flask.py

 

1. from flask import Flask
2. app=Flask(__name__)
3. @app.route('/')
4. def hello():
5. return "i am flask....from nginx"
6. if __name__=="__main__":
7. app.run(host='0.0.0.0',port=8080)

 

后台运行flask程序

 

1. python flask-web.py &

 

三、在负载均衡服务器lb01上测试访问192.168.119.10