1.配置阿里yum源：
1.备份默认的yum仓库: (linux的yum仓库地址：/etc/yum.repos.d/xx.repo)
在这个目录的第一层文件夹下，名字以*.repo结尾的都会别识别为yum仓库
cd /etc/yum.repos.d
mkdir backrepo
mv * ./backrepo
2.在线下载yum仓库源:
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
-O 就是 改名，且指定位置
3.下载第二个源，epel源
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
2.安装python3 (将python3的环境变量配置在最前面)
1.1 解决python3安装所需的依赖关系
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 -y
1.2 下载python3的源代码
wget https://www.python.org/ftp/python/3.6.7/Python-3.6.7.tar.xz
1.3 最终搞得到一个压缩包Python-3.6.7.tar.xz
tar -zxvf Python-3.6.7.tar.xz
1.4 进入python3的源码目录
cd Python-3.6.7
1.5 开始编译安装三部曲
1.释放makefile，编译文件，并且指定安装路径
./configure --prefix=/opt/python36/
2.开始编译，调用gcc编译器
make | make install 一般表示进行安装; make uninstall 是卸载; 不加参数就是默认的进行源代码编译。
3.开始安装，到/opt/python36目录下
make install
1.6 安装完毕之后，python3的解释器就出现在了/opt/python36/bin目录下
1.7 配置PATH环境变量，写入如下变量到/etc/profile
vim /etc/profile
PATH="/opt/python36/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin"
1.8 读取/etc/profile
source /etc/profile #读取配置文件，让PATH生效
3.安装virtualenv——python的虚拟环境
1.安装virtualenv
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenv
2.创建虚拟环境
virtualenv --no-site-packages --python=python3 venv
--no-site-packages # 这个参数用于构建，干净的环境，没有任何的第三方包
--python=python3 # 指定虚拟环境的本体，是python的哪一个版本
venv # 相等于 ./venv , 就是一个虚拟环境的文件夹，是虚拟python解释器
3.激活虚拟环境
进入 ： venv/bin
source activate
4.验证虚拟环境是否正确
which pip3 # 是否来自于自定义的 venv 路径
5.虚拟环境安装完毕。
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple 第三方库==版本号
6.退出虚拟环境
deactivate
4.安装virtualenvwrapper。 (统一管理虚拟环境)
1.安装 pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple virtualenvwrapper
2.配置环境变量，每次开机都加载virtualenvwrapper这个工具，注意配置的是个人环境变量配置文件
vim ~/.bash_profile #打开文件
# 写入如下环境变量 export也是一个读取指令，让变量生效的
export WORKON_HOME=~/Envs(虚拟环境目录存放地址) #设置virtualenv的统一管理目录
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS='--no-site-packages' #添加virtualenvwrapper的参数，生成干净隔绝的环境
export VIRTUALENVWRAPPER_PYTHON=/opt/python362/bin/python3 #指定python解释器，虚拟环境以谁去分身
source /opt/python362/bin/virtualenvwrapper.sh #执行virtualenvwrapper安装脚本
3.此时退出linux终端回话，重新登录，让virtualenvwrapper工具生效
4.学习virtualenvwrapper他的命令，管理虚拟环境
mkvirtualenv 虚拟环境的名字 #创建虚拟环境，存放目录是统一管理的
workon 虚拟环境的名字 #可以在任意目录直接激活虚拟环境
rmvirtualenv 虚拟环境的名字 #删除虚拟环境
lsvirtualenv #列出所有的虚拟环境
cdvirtualenv #进入虚拟环境的目录
cdsitepackages #进入虚拟环境的第三方包
5.保证本地开发环境和线上一致性：
1.导出本地python环境的所有模块
pip3 freeze > requirements.txt
2.将这个依赖文件，发送给服务器linux requirements.txt
3.服务器linux上，构建虚拟环境，安装这个文件，即可
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
6.安装nginx(tengine)：
1.解除依赖
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
2.下载淘宝nginx的源代码包
wget http://tengine.taobao.org/download/tengine-2.3.0.tar.gz
3.解压缩源码包
tar -zxvf tengine-2.3.0.tar.gz
4.进入源码目录开始编译安装
cd tengine-2.3.0
./configure --prefix=/opt/tngx230/
make && make install
5.配置淘宝nginx的环境变量，写入/etc/profile
PATH="/opt/python362/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/tngx230/sbin"
source /etc/profile
6.启动nginx
nginx 直接输入nginx 指令，默认代表启动，不得再执行第二次
nginx -s reload #平滑重启nginx，不重启nginx，仅仅是重新读取nginx配置文件
nginx -s stop #停止nginx进程
nginx -t #检测nginx.conf的语法
7.nginx 的负载均衡
1.环境准备，准备三台机器
192.168.16.37 资源服务器
192.168.16.140 资源服务器
192.168.16.241 充当代理服务器作用，以及负载均衡的作用
分别配置三台机器
192.168.16.37 资源服务器 提供dnf的页面
192.168.16.140 资源服务器 ,提供小猫咪的页面 (讲道理，应该是和192.168.16.37一样的代码配置，一样的页面)
192.168.16.241 负载均衡的配置
# 192.168.16.241 的 nginx.conf修改为如下的配置
1.添加负载均衡池，写入web服务器的地址
upstream mydjango(可以自定义) {
#负载均衡的方式，默认是轮训，1s一次
server 192.168.16.37 ;
server 192.168.16.140 ;
}
负载均衡的规则
轮询 按时间顺序逐一分配到不同的后端服务器(默认) (不做配置，默认轮询)
weight 加权轮询,weight值越大,分配到的访问几率越高，最常用的方式， 权重(优先级)
ip_hash 每个请求按访问IP的hash结果分配,这样来自同一IP的固定访问一个后端服务器 (根据客户端ip哈希分配，不能和weight一起用)
url_hash 按照访问URL的hash结果来分配请求,是每个URL定向到同一个后端服务器
least_conn 最少链接数,那个机器链接数少就分发
2.负载均衡的配置方式第二步骤
# 192.168.16.241 的 nginx.conf 文件：
location / {
proxy_pass http://mydjango; # 负载均衡器，接收到请求后，转发给负载均衡的地址池
}
8.nginx 的动静分离的配置
1.配置动态请求的服务器
192.168.16.140 充当静态服务器，返回小猫咪的页面，以及一些图片资源
安装nginx即可
192.168.16.140 的 nginx.conf 配置文件如下：
# 当所有请求来自于 192.168.16.140/ 时，就进入如下路径匹配，返回 小猫咪 页面
location / {
root html;
index index.html index.htm;
}
# 当请求是192.168.16.140/**.jpg 就进入如下location匹配，返回/opt/images/目录下的内容
location ~* .*\.(png|jpg|gif)$ {
root /opt/images/;
}
2.配置静态请求的服务器
192.168.16.37 运行django页面
安装nginx，以及django动态页面
1.先后台运行django页面
python3 nginx_django/manage.py runserver 0.0.0.0:8000
2.修改 192.168.16.37 的 nginx的配置，可以转发，动静的请求
upstream mydjango {
server 192.168.16.37:8000;
}
upstream mystatic {
server 192.168.16.140:80;
}
server {
listen 80;
server_name 192.168.16.37; #当外部请求，是192.168.16.37:80时候，就进入如下location，返回django页面，反向代理
location / {
proxy_pass http://mydjango;
}
location ~ .*\.(png|jpg|gif)$ {
proxy_pass http://mystatic; #当外部请求时，192.168.16.37:80/**.jpg，就转发给那台静态资源服务器，去处理
}
}
3.在负载均衡器上，配置请求转发
192.168.16.241 配置负载均衡，动静分离
1.定义一个upstrem地址池，进行请求分发定义
upstream myserver {
server 192.168.16.37;
server 192.168.16.140;
}
2.通过location进行请求分发的操作
location / {
proxy_pass http://myserver;
}
9.linux配置多台虚拟机
配置方式如下
1.服务器准备好了，安装好 nginx
2.在windows中写入hosts假的域名
找到如下文件，编辑写入域名对应关系
C:\Windows\System32\drivers\etc\hosts
192.168.16.37 www.dnf.com
192.168.16.37 www.cf.com
3.修改nginx.conf的配置，实现多虚拟主机，多个server{}标签是同级的关系
#第一个虚拟主机，dnf网址
server {
listen 80;
server_name www.dnf.com;
location / {
root /opt/dnf/;
index index.html index.htm;
}
}
#第二个虚拟主机，日剧的页面
server {
listen 80;
server_name www.cf.com;
location / {
root /opt/cf/;
index index.html;
}
}
4.准备2个网站的文件夹，以及页面文件
/opt/dnf/index.html
/opt/cf/index.html
5.重启nginx
nginx -s reload
6.访问2个虚拟主机的页面，在windows浏览器中访问
www.s19dnf.com
www.s19riju.com
10.linux 配置反向代理
配置nginx实现反向代理的步骤：
环境准备2台机器
192.168.16.37 充当资源服务器，提供一个页面
1.提供了一个dnf的页面
192.168.16.140 充当代理服务器的角色 (也是安装nginx，转发请求，反向代理的功能也是nginx提供的)
1.安装好nginx
2.修改如下配置 nginx.conf
#当你的请求来自于192.168.16.140/ 这样的url时，就进入如下location路径匹配
server {
listen 80;
server_name 192.168.16.140;
location / {
proxy_pass 192.168.16.37:80; #当请求进来这个路径匹配，这个nginx代理角色，直接转发给资源服务器
}
}
3.测试访问反向代理的页面
访问 192.168.16.140即可看到192.168.16.37的页面了
11.配置部署 Django 项目
nginx + uwsgi + 虚拟环境 + mysql + supervisor 环境准备，准备一台linux 192.168.16.37 ，
第一步：先准备后端代码
修改django的settings.py
ALLOWED_HOSTS = ["*"] # 允许所有主机访问
注意：如果这个项目用的部是sqlite，所以需要配置数据库了
第二步：安装python3解释器，以及虚拟环境工具virtualenvwrapper
第三步：修改 nginx 的配置
收集django的所有静态文件，统一管理，丢给nginx去解析
1.修改django的settings.py，写入如下参数
STATIC_ROOT='/opt/static'
STATIC_URL = '/static/'
STATICFILES_DIRS = [
os.path.join(BASE_DIR, 'static')
]
2.执行命令，收集静态文件
python3 manage.py collectstatic
3.nginx配置:
1). nginx的反向代理功能
2). nginx解析静态文件的功能
location /{
uwsgi_pass 127.0.0.1:8000;
include uwsgi_params;
}
location /static{
alias /opt/s19static; #别名
}
第四步：通过uwsgi启动 Django项目
1.激活虚拟环境在虚拟环境下，安装所需的模块 安装如下内容即可
(django-demo) [root@nginx1 django-demo]# cat requirements.txt
Django==1.11.20 django-multiselectfield==0.1.8 PyMySQL==0.9.3 pytz==2019.1
2.安装这个文件
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
3.安装uwsgi命令
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple uwsgi
4.1 通过uwsgi直接启动 Django项目
uwsgi --http :8088 --module xxx.wsgi --py-autoreload=1
--http 指定用http协议
:8088 指定ob_crm启动的端口
--module 指定django的wsgi.py的文件地址---django项目第二层的目录名，下面的wsgi.py
--py-autoreload=1 开启uwsgi的热加载功能
4.2 通过 uwsgi.ini 配置文件启动 Django项目
由于uwsgi的启动参数过多，我们可以选择配置文件的方式：
1.创建uwsgi.ini文件，写入如下参数
touch uwsgi.ini
写入如下内容，根据你自己的项目目录路径来更改
[uwsgi]
chdir = /opt/teaching_plan/ob_crm/ # 填写你项目的绝对路径，第一层
module = ob_crm.wsgi # 找到django的那个wsgi.py文件，根据上面一条参数，的相对路径来写
home = /root/Envs/ob_crm # 虚拟环境的绝对路径
master = true
processes = 4 # 根据cpu核数来定义这个参数，启动多少个进程
#指定你的django启动在什么地址上，并且是什么协议
socket = 0.0.0.0:8000 # 如果你用了nginx，进行反向代理，请用socket参数
#http = 0.0.0.0:8000 # 如果你没用nginx反向代理，想要直接访问django用这个参数
vacuum = true
py-autoreload = 1
~
2.通过配置文件启动项目
uwsgi --ini uwsgi.ini # uwsgi.ini 这里是 相对位置
第四步(2)：配置进程管理工具supervisor的使用 (supervisor其实就是在帮咱们去执行命令)
退出虚拟环境，在物理环境下安装
1.安装supervisor,通过pip直接安装
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple supervisor
2.生成supervisor的配置文件
echo_supervisord_conf > /etc/supervisor.conf
3.修改配置，写入你管理ob_crm的命令参数
vim /etc/supervisor.conf #直接进入最底行，写任务
[program:s19_ob_crm]
command=/root/Envs/ob_crm/bin/uwsgi --ini /opt/teaching_plan/ob_crm/uwsgi.ini
stopasgroup=true
killasgroup=true
4.通过命令，启动supervisor，同时启动 (django-demo) [root@nginx1 conf]#
#启动服务端的命令
supervisord -c /etc/supervisor.conf
#通过客户端命令，管理
(django-demo) [root@nginx1 conf]# supervisorctl -c /etc/supervisor.conf
<s19_ob_crm RUNNING pid 10483, uptime 0:00:36 >
# 此时会进入一个 supervisor 的输入状态
supervisor> stop s19_ob_crm #停止任务
s19_ob_crm: stopped
supervisor> status s19_ob_crm #查看任务状态
s19_ob_crm STOPPED May 08 12:23 PM
supervisor> stop all s19_ob_crm #停止所有的任务
s19_ob_crm STOPPED May 08 12:23 PM
supervisor> start all s19_ob_crm #启动所有任务
s19_ob_crm RUNNING May 08 12:23 PM
12.部署一个前后端分离 Vue + Django的 项目
vue(js框架)(nginx返回vue的页面) + django rest freamwork(提供api数据接口的框架)（后端）+ 虚拟环境 + sqlite + redis（key-value型的数据库）
后端部署过程：
同 上面的 Django 项目的部署
前端部署过程：
因为使用的是 vue ,所有需要安装 nodejs
1.安装 nodejs 的环境
1.下载nodejs的解释器用于编译vue代码
wget https://nodejs.org/download/release/v8.6.0/node-v8.6.0-linux-x64.tar.gz
2.解压缩node的源代码包
tar -zxvf node-v8.6.0-linux-x64.tar.gz
[root@nginx1 bin]# pwd
/opt/s19luffy/node-v8.6.0-linux-x64/bin
[root@nginx1 bin]# ls
node npm npx
node如同python3.6是一个解释器
npm 如同pip是一个包管理工具
3.配置node的环境变量PATH
PATH="/opt/python362/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/tngx230/sbin:/opt/s19luffy/node-v8.6.0-linux-x64/bin"
2.安装 vue 的环境
1.下载前端代码
wget https://files.cnblogs.com/files/pyyu/07-luffy_project_01.zip
2.解压缩代码包
unzip 07-luffy_project_01.zip
未更改过的vue代码，长这样
[root@nginx1 07-luffy_project_01]# ls
build config index.html package.json(vue包信息的) package-lock.json README.md src static
3.修改 vue 向后台发送数据的接口地址，修改为 django 项目所在 服务器IP , 端口也要对应与 django 启动的端口 ..
批量修改接口地址
sed -i "s/127.0.0.1:8000/192.168.16.37:8500/g" api.js # /opt/django/07-luffy_project_01/src/restful/api.js
4.安装vue的模块
npm install
5.模块安装完毕后，进行编译打包，生成dist，静态文件夹
npm run build
6.编译打包vue完成之后，会生成一个dist静态文件夹，里面存放了路飞学成首页所有的内容，交给nginx即可
/opt/django/07-luffy_project_01/dist
3：nginx配置方式如下：
1.支持vue的页面虚拟主机
location / {
root /opt/django/07-luffy_project_01/dist;
index index.html;
try_files $uri $uri/ /index.html; #保证路飞首页，刷新不出现404
}
2.反向代理的虚拟主机
server {
listen 8500;
server_name 192.168.16.37;
location / {
uwsgi_pass 192.168.16.37:9000; # 这里必须与 django 的 项目启动端口对应
include uwsgi_params;
}
}
13.redis的 conf 文件
redis.conf 其中配置文件内容如下：
bind 192.168.16.37 #redis绑定的地址
protected-mode yes #redis安全模式
port 6380 #redis的端口
daemonize yes #后台运行redis
requirepass password #redis的密码
14.配置redis的数据持久化
1.RDB
1.基于内存快照的数据持久化
持久化数据文件是一个压缩的二进制文件
通过save指令可以手动触发 持久化,也可以配置时间触发持久化
2.配置方式如下
vim redis-rdb.conf
写入:
bind 192.168.16.37
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379 #redis的数据存放目录
dbfilename dbmp.rdb #这里是配置redis 持久化rdb方式的核心文件，开启了rdb功能
save 900 1 #以下这三个是持久化的时间间隔机制 自动执行save持久化
save 300 10
save 60 10000
创建数据文件夹
mkdir -p /data/6379
3.指定支持持久化的redis配置文件启动
redis-server redis-rdb.conf
4.redis指定端口和主机登录
redis-cli -p 6379 -h 192.168.16.37
5.测试写入redis数据
>> set name test
>> save -->触发持久化 (要不通过 save ,要不就是等待 30秒) 此时就会生成一个 dump.rdb 数据文件在 /data/6379 目录
注意：rdb有缺点，可能会造成数据丢失，但是持久化速度最快
2.AOF持久化模式
1.在配置文件中，定义功能参数，即可使用aof
vim redis-aof.conf
写入：
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
appendonly yes
appendfsync everysec
2.指定aof配置文件启动
redis-server redis-aof.conf
3.启动redis服务端，查看aof日志变动，并且aof数据持久化
3.特殊：redis不重启从rdb切换到aof数据持久化
1.实现准备，准备一个rdb的redis数据库，写入数据
2.在登录了 rdb的数据库当中，进行切换aof，命令如下
3.配置aof的方式如下，通过config set命令，设置aof的功能
127.0.0.1:6379> CONFIG set appendonly yes
OK
127.0.0.1:6379> CONFIG SET save ""
OK
4.还得修改配置文件，以后永远都是aof
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename dbmp.rdb
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec
15.redis的主从复制的配置
1. 主从库的 redis.conf 的配置
redis-6379.conf 主库
port 6379
daemonize yes
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
dbfilename dump.rdb
dir /data/6379
protected-mode no
redis-6380.conf 从库1
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no
slaveof 127.0.0.1 6379 # 这句话是关键，表示是从库，绑定主库的 ip 和 端口
2.创建数据库文件夹
mkdir -p /data/{6379,6380,6381}
3.分别启动三个redis数据库实例，默认已经是主从关系了
redis-server redis-6379.conf
redis-server redis-6380.conf
4.检查redis的主从关系
info指令用于查看redis的数据库详细信息
redis-cli -p 6379 info replication
redis-cli -p 6380 info replication
16.redis的主从复制故障修复
注意：现在是 三个 redis 服务
6379是主， 6380是从，6381是从
1.手动杀死主库，来模拟 主库意外死亡
kill 主库pid
2.选择一个从库为新的主库，假设 6380 变成主，6381 变成 6381的从
登录 6380数据库，输入
127.0.0.1:6380> slaveof no one
OK
去登录6381从库
127.0.0.1:6381> slaveof no one
OK
127.0.0.1:6381> slaveof 127.0.0.1 6380
3.此时就是6380是主库，6381是从库
17.redis配置高可用的哨兵功能
1.配置redis-sentinel
三个redis实例，准备一主两从的架构
redis-6379.conf
port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/opt/data/6379"
redis-6380.conf
redis-6381.conf
配置文件定义如下
sed "s/6379/6380/g" redis-6379.conf > redis-6380.conf
sed "s/6379/6381/g" redis-6379.conf > redis-6381.conf
echo "slaveof 127.0.0.1 6379" >> redis-6380.conf
echo "slaveof 127.0.0.1 6379" >> redis-6381.conf
创建三个数据文件夹
mkdir -p /opt/data/{6379,6380,6381}
2.分别启动三个redis数据库
1030 redis-server redis-6379.conf
1031 redis-server redis-6380.conf
1032 redis-server redis-6381.conf
检查三个数据库redis的身份信息
redis-cli -p 6379 info replication
redis-cli -p 6380 info replication
redis-cli -p 6381 info replication
3.编辑三个redis-sentinel配置文件，运行三个哨兵进程
redis-sentinel-26379.conf
配置如下，其他节点，仅仅是端口的不同
port 26379
dir /opt/data/26379
logfile "26379.log"
sentinel monitor myredis(自定义名) 127.0.0.1 6379 1
sentinel down-after-milliseconds myredis 30000
sentinel parallel-syncs myredis 1
sentinel failover-timeout myredis 180000
daemonize yes
其他两个配置文件，创建如下
sed "s/26379/26380/g" redis-sentinel-26379.conf > redis-sentinel-26380.conf
sed "s/26379/26381/g" redis-sentinel-26379.conf > redis-sentinel-26381.conf
创建三个文件夹
mkdir -p /opt/data/{26379,26380,26381}
分别启动三个哨兵
redis-sentinel redis-sentinel-26379.conf
redis-sentinel redis-sentinel-26380.conf
redis-sentinel redis-sentinel-26381.conf
此时验证redis-sentinel是否成功
redis-cli -p 26379 info sentinel #查看哨兵是否成功
如果信息如下，则正确，找到了2个slave从，3个哨兵同伴
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=s19msredis,status=ok,address=127.0.0.1:6379, slaves=2,sentinels=3
4. 杀死redis主库，查看是否会自动的主从故障切换
18.redis-cluster集群搭建
1.环境准备6个redis节点配置文件
redis-7000.conf
port 7000
daemonize yes
dir "/opt/redis/data"
logfile "7000.log"
dbfilename "dump-7000.rdb"
cluster-enabled yes
cluster-config-file nodes-7000.conf
cluster-require-full-coverage no
redis-7001.conf
redis-7002.conf
redis-7003.conf
redis-7004.conf
redis-7005.conf
其他redis数据库节点，仅仅是端口的不同即可
替换生成配置文件如下
sed "s/7000/7001/g" redis-7000.conf > redis-7001.conf
sed "s/7000/7002/g" redis-7000.conf > redis-7002.conf
sed "s/7000/7003/g" redis-7000.conf > redis-7003.conf
sed "s/7000/7004/g" redis-7000.conf > redis-7004.conf
sed "s/7000/7005/g" redis-7000.conf > redis-7005.conf
生成数据文件夹
mkdir -p /opt/redis/data
分别启动6个节点
redis-server redis-7000.conf
redis-server redis-7001.conf
redis-server redis-7002.conf
redis-server redis-7003.conf
redis-server redis-7004.conf
redis-server redis-7005.conf
2.此时redis的集群还未分配 槽位(slots)，需要下载ruby的脚本，创建这个16384个槽位分配
1.下载ruby的源码包
wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
2.解压缩
tar -zxvf ruby-2.3.1.tar.gz
3.进入ruby源码包目录
./configure --prefix=/opt/ruby-2-3-1/
make
make install
4.配置ruby的环境变量
PATH=".../opt/ruby-2-3-1/bin"
5.读取PATH环境变量
source /etc/profile
6.下载安装ruby操作redis的包
wget http://rubygems.org/downloads/redis-3.3.0.gem
#ruby安装操作redis的包模块
gem install -l redis-3.3.0.gem
7.分配redis集群的槽位
redis-trib.rb 命令，默认不会添加环境变量，直接用绝对路径去创建.
find /opt/ -name redis-trib.rb #查看这个脚本的绝对路径
/opt/redis-4.0.10/src/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
(--replicas 1这个意思是每一个主库，只有一个从库)
确定 yes
8.此时槽位已经分配好了，可以写入集群数据了
登录某一个节点，写入数据查看结果
redis-cli -p 7000 -c #-c 以集群方式运行
集群数据会经过重定向，计算出槽位，放入某一个节点
注意：当将某个一个槽位 范围的 主库以及它的从库都杀死了，如果配置文件 cluster-require-full-coverage 为 no,
则整个 集群并不会停止服务，只是 槽值 位于这个区间的 键全部都不可用
264
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
