Linux 的配置操作

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 
                
            # 此时会进入一个 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, 
            则整个 集群并不会停止服务，只是 槽值 位于这个区间的 键全部都不可用