Docker的安装及使用

1 为什么会出现docker
一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。作为开发+运维之间的协助我们需要关心的问题很多，这也是很多互联网公司不得不面对的问题，
特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员都是考验。
Docker之所以发展如此迅速，也是运维它给出了一个标准化的解决方案-----系统平滑移植，容器虚拟化技术。
环境配置如此麻烦，换一台机器，就要重新来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装?也就是说，安装的时候，把原始环境一模一样的复制过来。开发人员利用Docker可以消除协作编码时“在我的机器上可正常工作”的问题。
之前在服务器配置一个应用的运行环境，要安装各种软件,比如redis,mysql等换一台服务器还得重新安装
Docker的出现使得Docker得以打破过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。

2 docker的理念
Docker是基于Go语言实现的云开源项目。Docker 是一个 C/S 模式的架构，后端是一个松耦合架构，众多模块各司其职。
Docker的主要目标是“Build，Ship and Run Any App,Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次镜像，处处运行”。

Linux容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。将应用打成镜像，通过镜像成为运行在Docker容器上面的实例，而 Docker容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作。
一句话概括：
解决了运行环境和配置问题的软件容器， 方便做持续集成并有助于整体发布的容器虚拟化技术。

3 容器和虚拟机的比较
虚拟机（virtual machine）就是带环境安装的一种解决方案。
它可以在一种操作系统里面运行另一种操作系统，比如在Windows10系统里面运行Linux系统CentOS7。
虚拟机的缺点：
1 资源占用多 2 冗余步骤多 3 启动慢
Linux容器(Linux Containers，缩写为 LXC)
Linux容器是与系统其他部分隔离开的一系列进程，从另一个镜像运行，并由该镜像提供支持进程所需的全部文件。容器提供的镜像包含了应用的所有依赖项，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。

Linux 容器不是模拟一个完整的操作系统而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

对比：

比较了 Docker 和传统虚拟化方式的不同之处：

*传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；

*容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。

• 每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。

4 能干嘛
· 开发/运维（DevOps）新一代开发工程师
· 一次构建、随处运行
· 更快速的应用交付和部署
· 更便捷的升级和扩缩容
· 更简单的系统运维
· 更高效的计算资源利用（Docker是内核级虚拟化）
应用场景：

5 去哪里下
· 官网
· docker官网：http://www.docker.com
· 仓库
· Docker Hub官网: https://hub.docker.com/

6 docker安装
6.1 前提条件
docker并非是一个通用的容器工具，它依赖于已存在并运行的linux内核环境
docker实际上是在已经运行的linux下制造了一个隔离的文件环境，因此他的执行效率等同于所部署的linux主机
因此docker必须部署在linux内核的系统上。

目前，CentOS 仅发行版本中的内核支持 Docker。Docker 运行在CentOS 7 (64-bit)上，
要求系统为64位、Linux系统内核版本为 3.8以上，这里选用Centos7.x

查看centos版本：

cat /etc/redhat-relaese

uname命令用于打印当前系统相关信息（内核版本号、硬件架构、主机名称和操作系统类型等）

6.2 docker的 基本组成

· 镜像(image)
Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。
它也相当于是一个root文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的 root 文件系统。
相当于容器的“源代码”，docker镜像文件类似于Java的类模板，而docker容器实例类似于java中new出来的实例对象。

· 容器(container)
1 从面向对象角度
Docker 利用容器（Container）独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台

2 从镜像容器角度
可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

· 仓库(repository)
仓库（Repository）是集中存放镜像文件的场所。
类似于
Maven仓库，存放各种jar包的地方；
github仓库，存放各种git项目的地方；
Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。
最大的公开仓库是 Docker Hub(https://hub.docker.com/)，
存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云 、网易云等
· 小总结
需要正确的理解仓库/镜像/容器这几个概念:
Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。

image文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

镜像文件

• image 文件生成的容器实例，本身也是一个文件，称为镜像文件。
  容器实例
• 一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器
  仓库
• 就是放一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候再从仓库中拉下来就可以了。

6.3 安装步骤
· CentOS7安装Docker
· https://docs.docker.com/engine/install/centos/
· 安装步骤
· 确定你是CentOS7及以上版本
· cat /etc/redhat-release
· 卸载旧版本
https://docs.docker.com/engine/install/centos/

· yum安装gcc相关 --要求CentOS7能上外网
· yum -y install gcc
· yum -y install gcc-c++
· 安装需要的软件包
· yum install -y yum-utils
· 设置stable镜像仓库
因为docker官网上的仓库地址是经常国外使用的，所有用阿里云的
· yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
· 安装DOCKER CE
· yum -y install docker-ce docker-ce-cli containerd.io
· 启动docker
· systemctl start docker
· 测试
· docker version
· 卸载docker engine
· systemctl stop docker
· yum remove docker-ce docker-ce-cli containerd.io
· rm -rf /var/lib/docker
· rm -rf /var/lib/containerd

6.4 阿里云镜像加速器（在阿里云平台创建镜像加速器，从docker hub 方便快速的下载镜像）

6.5 docker 常用命令
· 启动docker： systemctl start docker
· 停止docker： systemctl stop docker
· 重启docker： systemctl restart docker
· 查看docker状态： systemctl status docker
· 开机启动： systemctl enable docker
· 查看docker概要信息： docker info
· 查看docker总体帮助文档： docker --help
· 查看docker命令帮助文档： docker 具体命令 --help
· 列出本地主机上的镜像：docker images
· 搜索镜像：docker search 某个XXX镜像名字
· 下载镜像：docker pull 某个XXX镜像名字
· docker system df 查看镜像/容器/数据卷所占的空间
· 删除镜像：单个-docker rmi 某个XXX镜像名字ID，多个-· docker rmi -f 镜像名1:TAG 镜像名2:TAG，全部-· docker rmi -f $(docker images -qa)
· 启动容器：· docker run -it redis:6.0.8 —·----run进去容器，exit退出，容器停止 —· run进去容器，ctrl+p+q退出，容器不停止
· 重新进入已经启动的容器： docker exec -it 容器ID bash 用exit退出，容器不会停止。docker attach 容器ID 用exit退出，容器停止
· 从容器内拷贝文件到主机上-----· docker cp 容器ID:容器内路径 目的主机路径
· 导出容器： docker export 容器ID > 文件名.tar
· 导入容器：cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号

6.6 docker 悬浮镜像是啥？
仓库名、标签都是的镜像，俗称虚悬镜像dangling image

7 docker 镜像

7.1是什么？
是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是image镜像文件。
只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。

7.2 镜像是分层
以我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载

7.3 镜像加载原理
docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS(UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加)—简略介绍，具体的可以看官网说明

7.4 镜像为啥采用分层
镜像分层最大的一个好处就是共享资源，方便复制迁移，就是为了复用。

7.5 重点–· Docker镜像层都是只读的，容器层是可写的

7.6 提交镜像
· docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

8 本地镜像发布到阿里云
8.1 在阿里云平台创建镜像仓库–· https://promotion.aliyun.com/ntms/act/kubernetes.html

8.2 镜像仓库创建好后，在管理界面有响应的脚本，直接使用就可以了。

9 本地镜像发布到私有库
9.1 ·下载镜像Docker Registry

9.2 运行私有库Registry，相当于本地有个私有Docker hub
docker run -d -p 5000:5000 -v /zzyyuse/myregistry/:/tmp/registry --privileged=true registry
默认情况，仓库被创建在容器的/var/lib/registry目录下，建议自行用容器卷映射，方便于宿主机联调

9.3 验证是否有镜像：url -XGET http://192.168.111.162:5000/v2/_catalog，如果访问不了，因为docker默认不允许http方式推送镜像，通过配置选项来取消这个限制。====> 修改完后如果不生效，建议重启docker

9.4 修改镜像名符合私服规范： docker tag 镜像:Tag Host:Port/Repository:Tag
docker tag zzyyubuntu:1.2 192.168.111.162:5000/zzyyubuntu:1.2

9.5 发布镜像：docker push 192.168.111.162:5000/zzyyubuntu:1.2

10 docker容器卷

1. 是什么
   卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性：
   卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷-----· 将docker容器内的数据保存进宿主机的磁盘中
2. 挂载使用

–privileged=true

3. 查看数据卷是否挂载成功

docker inspect 容器ID

4. 能干嘛
   1：数据卷可在容器之间共享或重用数据
   2：卷中的更改可以直接实时生效，爽
   3：数据卷中的更改不会包含在镜像的更新中
   4：数据卷的生命周期一直持续到没有容器使用它为止
   案例：
   1 docker修改，主机同步获得
   2 主机修改，docker同步获得
   3 docker容器stop，主机修改，docker容器重启数据同步。

5. 限制读写规则
   docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:rw 镜像名 —备注，默认读写
   docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名

6. 继承（两个容器的继承）
   docker run -it --privileged=true --volumes-from 父类 --name u2 ubuntu

11 docker上安装mysql
注意点：
1，docker 默认字符集编码修改
查看命令为： SHOW VARIABLES LIKE ‘character%’
2，要做mysql数据备份，防止容易不小心删除时数据还在

安装步骤：
1，搜索镜像：docker search mysql
2，拉取镜像：docker pull mysql:5.7
3，新建容器实例：zzyy/mysql 是指本机的地址

docker run -d -p 3306:3306 --privileged=true
-v /zzyyuse/mysql/log:/var/log/mysql
-v /zzyyuse/mysql/data:/var/lib/mysql
-v /zzyyuse/mysql/conf:/etc/mysql/conf.d
-e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:5.7

4，在本机zzyy/mysql /下新建my.cnf

[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8

5，重启mysql：docker restart mysql
6，进入mysql容器内：docker exec -it mysql bash
7，查看编码： SHOW VARIABLES LIKE ‘character%’ 如果是utf-8 就可以新建数据库-表-插数据

12 docker 上安装主从复制mysql
1，新建主服务器容器实例3307

docker run -p 3307:3306 --name mysql-master
-v /mydata/mysql-master/log:/var/log/mysql
-v /mydata/mysql-master/data:/var/lib/mysql
-v /mydata/mysql-master/conf:/etc/mysql
-e MYSQL_ROOT_PASSWORD=root
-d mysql:5.7

2.进入/mydata/mysql-master/conf目录下新建my.cnf

[mysqld]
##设置server-id,同一局域网中需要唯一
server_id-101
##指定不需要同步的数据库名称
binlog-ignore-db=mysql
#开启二进制日志功能
log-bin=mall-mysql-bin
##设置二进制日志使用内存大小(事务)
binlog_cache_size=1M
##设置使用的二进制日志格式(mixed, statement, row)
binlog_format=mixed
##二进制日志过期清理时间,默认值为0:表示不自动清理。
expire_logs_days=7
##跳过主从复制中遇到的所有错误或指定类型的错误,避免slave端复制中断。
##如: 1062错误是指一些主键重复, 1032错误是因为主从数据库数据不一致
slave_skip_errors=1062

3.修改完配置后重启master实例
docker restart mysql-master

4.进入mysql-master容器
docker exec -it mysql-master bash
mysql -uroot -proot

5.master容器实例内创建数据同步用户
CREATE USER ‘slave’@’%’ IDENTIFIED BY '123456;
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON . To ‘slave’@%;
6.新建从服务器容器实例3308

docker run -p 3308:3306 --name mysql-slave
-v /mydata/mysql-slave/log:/var/log/mysql
-v /mydata/mysql-slave/data:/var/lib/mysql
-v /mydata/mysql-slave/conf:/etc/mysql
-e MYSQL_ROOT_PASSWORD=root
-d mysql:5.7

7.进入/mydata/mysql-slave/conf目录下新建my.cnf

[mysqld]
##设置server-id,同一局域网中需要唯一
server_id=102
##指定不需要同步的数据库名称
binlog-ignore-db=mysql
#开启二进制日志功能,以备salve作为其他数据库实例的master时使用
log-bin=mall-mysql-slave-bin
##设置二进制日志使用内存大小(事务)
binlog_cache_size=1M
##设置使用的二进制日志格式(mixed, statement, row)
binlog_format=mixed
##二进制日志过期清理时间,默认值为0:表示不自动清理。
expire_logs_days=7
##跳过主从复制中遇到的所有错误或指定类型的错误,避免slave端复制中断。
##如: 1062错误是指一些主键重复, 1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
##relay-log配置中继日志
relay_log=mall-mysql-relay-bin
##log-slave-updates表示slave将复制事件写进自己的二进制日志
log_slave_updates-1
##slave设置为只读(具有super权限的用户除外)
read_only=1

8.修改完配置后重启slave实例
docker restart mysql-slave

9.在主数据库mysql-master中查看主从同步状态
show master status

10.进入mysql-slave容器
docker exec -it mysql-slave bash
mysql -uroot -proot

11.在从数据库中配置主从复制

change master to master_host=‘宿主机ip’, master_user=‘slave’, master_password=‘123456’, master_port=3307, master_log_file=‘mall-mysql-bin.000001’, master_log_pos=617, master_connect_retry=30;

master_host：主数据库的IP地址；
master_port：主数据库的运行端口；
master_user：在主数据库创建的用于同步数据的用户账号；
master_password：在主数据库创建的用于同步数据的用户密码；
master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；
master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；
master_connect_retry：连接失败重试的时间间隔，单位为秒。

12.在从数据库中查看主从同步状态
show slave status \G
主要看
Slave IO Running: No
Slave SOL Running: No

13.在从数据库中开启主从同步
start slave

14.查看从数据库状态发现已经同步
show slave status \G
Slave IO Running: YES
Slave SOL Running: YES

15.主从复制测试
主数据库创建数据库-数据表-插入数据
从数据库查看数据

13 docker 上安装单击版redis

安装步骤：
1，拉取镜像：docker pull redis:6.0.8
2，本机新建目录：mkdir -p /app/redis
3，拷贝原始的redis.conf到 /app/redis目录下
4，修改redis.conf :
开启redis验证 可选 requirepass 123。
允许redis外地连接 必须注释掉 # bind 127.0.0.1。
daemonize no 将daemonize yes注释起来或者 daemonize no设置，因为该配置和docker run中-d参数冲突，会导致容器一直启动失败。
开启redis数据持久化 appendonly yes 可选。
5，创建容器（也叫运行镜像）

docker run -p 6379:6379 --name myr3 --privileged=true
-v /app/redis/redis.conf:/etc/redis/redis.conf
-v /app/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf

6，进入redis：docker exec -it myr3 bash
7，连接redis：redis-cli 可执行redis命令

14 docker上安装redis集群–分布式存储案例
对于redis面试时经常会问一下问题：
· 1~2亿条数据需要缓存，请问如何设计这个存储案例
答：
· 单机单台100%不可能，肯定是分布式存储，用redis如何落地？
解决方案：
· 哈希取余分区
· 一致性哈希算法分区
· 哈希槽分区

14.1 哈希取余分区

14.2 一致性哈希算法分区
是什么？
一致性Hash算法背景
一致性哈希算法在1997年由麻省理工学院中提出的，设计目标是为了解决
分布式缓存数据变动和映射问题，某个机器宕机了，分母数量改变了，自然取余数不OK了
能干嘛？
提出一致性Hash解决方案。 目的是当服务器个数发生变动时， 尽量减少影响客户端到服务器的映射关系
三大步骤：
第一步：· 算法构建一致性哈希环
一致性哈希环
一致性哈希算法必然有个hash函数并按照算法产生hash值，这个算法的所有可能哈希值会构成一个全量集，这个集合可以成为一个hash空间[0,2^32-1]，这个是一个线性空间，但是在算法中，我们通过适当的逻辑控制将它首尾相连(0 = 2^32),这样让它逻辑上形成了一个环形空间。

它也是按照使用取模的方法，前面笔记介绍的节点取模法是对节点（服务器）的数量进行取模。而一致性Hash算法是对2^32取模，简单来说，一致性Hash算法将整个哈希值空间组织成一个虚拟的圆环，如假设某哈希函数H的值空间为0-2^32-1（即哈希值是一个32位无符号整形），整个哈希环如下图：整个空间按顺时针方向组织，圆环的正上方的点代表0，0点右侧的第一个点代表1，以此类推，2、3、4、……直到2^{32-1，也就是说0点左侧的第一个点代表2}32-1， 0和2^{32-1在零点中方向重合，我们把这个由2}32个点组成的圆环称为Hash环。

第二步：· 服务器IP节点映射
节点映射

将集群中各个IP节点映射到环上的某一个位置。

将各个服务器使用Hash进行一个哈希，具体可以选择服务器的IP或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置。假如4个节点NodeA、B、C、D，经过IP地址的哈希函数计算(hash(ip))，使用IP地址哈希后在环空间的位置如下：

第三步：· key落到服务器的落键规则

当我们需要存储一个kv键值对时，首先计算key的hash值，hash(key)，将这个key使用相同的函数Hash计算出哈希值并确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该定位到的服务器，并将该键值对存储在该节点上。

如我们有Object A、Object B、Object C、Object D四个数据对象，经过哈希计算后，在环空间上的位置如下：根据一致性Hash算法，数据A会被定为到Node A上，B被定为到Node B上，C被定为到Node C上，D被定为到Node D上。

优点1：容错性
--------假设Node C宕机，可以看到此时对象A、B、D不会受到影响，只有C对象被重定位到Node D。一般的，在一致性Hash算法中，如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响。简单说，就是C挂了，受到影响的只是B、C之间的数据，并且这些数据会转移到D进行存储。
优点2：扩展性

------------数据量增加了，需要增加一台节点NodeX，X的位置在A和B之间，那收到影响的也就是A到X之间的数据，重新把A到X的数据录入到X上即可，
不会导致hash取余全部数据重新洗牌。

缺点：
Hash环的数据倾斜问题

一致性Hash算法在服务节点太少时，容易因为节点分布不均匀而造成数据倾斜（被缓存的对象大部分集中缓存在某一台服务器上）问题，
例如系统中只有两台服务器：

总结：
为了在节点数目发生改变时尽可能少的迁移数据
将所有的存储节点排列在收尾相接的Hash环上，每个key在计算Hash后会顺时针找到临近的存储节点存放。
而当有节点加入或退出时仅影响该节点在Hash环上顺时针相邻的后续节点。
优点
加入和删除节点只影响哈希环中顺时针方向的相邻的节点，对其他节点无影响。
缺点
数据的分布和节点的位置有关，因为这些节点不是均匀的分布在哈希环上的，所以数据在进行存储时达不到均匀分布的效果。

14.2 哈希槽分区
1 是什么？
哈希槽实质就是一个数组，数组[0,2^14 -1]形成hash slot空间。

2 为什么出现
解决一致性哈希算法的数据倾斜问题

3 能干什么
解决均匀分配的问题，在数据和节点之间又加入了一层，把这层称为哈希槽（slot），用于管理数据和节点之间的关系，现在就相当于节点上放的是槽，槽里放的是数据。

槽解决的是粒度问题，相当于把粒度变大了，这样便于数据移动。
哈希解决的是映射问题，使用key的哈希值来计算所在的槽，便于数据分配。

4 多少个hash槽
一个集群只能有16384个槽，编号0-16383（0-2^14-1）。这些槽会分配给集群中的所有主节点，分配策略没有要求。可以指定哪些编号的槽分配给哪个主节点。集群会记录节点和槽的对应关系。解决了节点和槽的关系后，接下来就需要对key求哈希值，然后对16384取余，余数是几key就落入对应的槽里。slot = CRC16(key) % 16384。以槽为单位移动数据，因为槽的数目是固定的，处理起来比较容易，这样数据移动问题就解决了。

5 哈希槽计算
Redis 集群中内置了 16384 个哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点。当需要在 Redis 集群中放置一个 key-value时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，也就是映射到某个节点上。如下代码，key之A 、B在Node2， key之C落在Node3上


15 docker上安装三主三从的redis集群
1 · 关闭防火墙+启动docker后台服务
systemctl stop firewalld
systemctl start docker
2 · 新建6个docker容器redis实例

docker run -d --name redis-node-1 --net host --privileged=true -v /data/redis/share/redis-node-1:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381
docker run -d --name redis-node-2 --net host --privileged=true -v /data/redis/share/redis-node-2:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6382
docker run -d --name redis-node-3 --net host --privileged=true -v /data/redis/share/redis-node-3:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6383
docker run -d --name redis-node-4 --net host --privileged=true -v /data/redis/share/redis-node-4:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6384
docker run -d --name redis-node-5 --net host --privileged=true -v /data/redis/share/redis-node-5:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6385
docker run -d --name redis-node-6 --net host --privileged=true -v /data/redis/share/redis-node-6:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6386

· --net host
· 使用宿主机的IP和端口，默认
· --privileged=true
· 获取宿主机root用户权限
· --cluster-enabled yes
· 开启redis集群
· --appendonly yes
· 开启持久化
3 · 进入容器· docker exec -it redis-node-1 /bin/bash · 构建主从关系
//注意，进入docker容器后才能执行以下命令，且注意自己的真实IP地址

redis-cli --cluster create 192.168.111.147:6381 192.168.111.147:6382 192.168.111.147:6383 192.168.111.147:6384 192.168.111.147:6385 192.168.111.147:6386 --cluster-replicas 1

–cluster-replicas 1 表示为每个master创建一个slave节点
· 一切OK的话，3主3从搞定
· 链接进入6381作为切入点，查看集群状态 命令 ： cluster info
· 链接进入6381作为切入点，查看节点状态 命令：cluster nodes

4 · 主从容错切换迁移案例
查看集群信息命令：redis-cli --cluster check 192.168.111.147:6381
数据读写存储：
进入6381后，指定连接6381 ：redis-cli -p 6381 -c
然后读写时可以看到主动redis都有响应数据
容错切换迁移：
把主6381 停止后，查看集群信息，可以发现6381下的6385成了新的master
如果还原成原先的主从，先启动6381，再停了6385，再启动6385

5 · 主从扩容案例
新建6387、6388两个节点+新建后启动+查看是否8节点
· 进入6387容器实例内部
· docker exec -it redis-node-7 bash
· 将新增的6387节点(空槽号)作为master节点加入原集群
redis-cli --cluster add-node 自己实际IP地址:6387 自己实际IP地址:6381
6387 就是将要作为master新增节点
6381 就是原来集群节点里面的领路人，相当于6387拜拜6381的码头从而找到组织加入集群
这是查看6387：edis-cli --cluster check 真实ip地址:6381 是没有槽号的
· 重新分派槽号
命令:redis-cli --cluster reshard IP地址:端口号
redis-cli --cluster reshard 192.168.111.147:6381 6381 只是个领路人

· 槽号分派说明
为什么6387是3个新的区间，以前的还是连续？
重新分配成本太高，所以前3家各自匀出来一部分，从6381/6382/6383三个旧节点分别匀出1364个坑位给新节点6387

· 为主节点6387分配从节点6388
命令：redis-cli --cluster add-node ip:新slave端口 ip:新master端口 --cluster-slave --cluster-master-id 新主机节点ID

redis-cli --cluster add-node 192.168.111.147:6388 192.168.111.147:6387 --cluster-slave --cluster-master-id e4781f644d4a4e4d4b4d107157b9ba8144631451-------这个是6387的编号，按照自己实际情况

6 · 主从缩容案例
6387和6388下线
先删除从节点6388
命令：redis-cli --cluster del-node ip:从机端口 从机6388节点ID
redis-cli --cluster del-node 192.168.111.147:6388 5d149074b7e57b802287d1797a874ed7a1a284a8
· 将6387的槽号清空，重新分配，本例将清出来的槽号都给6381
redis-cli --cluster reshard 192.168.111.147:6381

检查集群状态可以发现6487 的槽号为0了
删除6387
命令：redis-cli --cluster del-node ip:端口 6387节点ID
redis-cli --cluster del-node 192.168.111.147:6387 e4781f644d4a4e4d4b4d107157b9ba8144631451

16 DockerFile
1 是什么？
· Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。

2 官网：· https://docs.docker.com/engine/reference/builder/
3 构建三步骤：
· 编写Dockerfile文件
· docker build命令构建镜像
· docker run依镜像运行容器实例
4 DockerFile构建过程
· Dockerfile内容基础知识
· 1：每条保留字指令都必须为大写字母且后面要跟随至少一个参数
· 2：指令按照从上到下，顺序执行
· 3：#表示注释
· 4：每条指令都会创建一个新的镜像层并对镜像进行提交
· Docker执行Dockerfile的大致流程
· （1）docker从基础镜像运行一个容器
· （2）执行一条指令并对容器作出修改
· （3）执行类似docker commit的操作提交一个新的镜像层
· （4）docker再基于刚提交的镜像运行一个新容器
· （5）执行dockerfile中的下一条指令直到所有指令都执行完成
5 编写DockerFile常用命令
· FROM
基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from
· MAINTAINER
镜像维护者的姓名和邮箱地址
· RUN
容器构建时需要运行的命令
两种格式–shell和exec 一般用shell
shell格式：比如
RUN yum -y install vim
RUN是在 docker build时运行
· EXPOSE
当前容器对外暴露出的端口
· WORKDIR
指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点
· USER
指定该镜像以什么样的用户去执行，如果都不指定，默认是root
· ENV
用来在构建镜像过程中设置环境变量
比如：
ENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；
也可以在其它指令中直接使用这些环境变量，
比如：WORKDIR $MY_PATH
· ADD
将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包
· COPY
类似ADD，拷贝文件和目录到镜像中。 将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
COPY src dest
COPY [“src”, “dest”]
<src源路径>：源文件或者源目录
<dest目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。
· VOLUME
容器数据卷，用于数据保存和持久化工作
· CMD
指定容器启动后的要干的事情
cmd也是两种格式shell 和exec
注意
Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换
它和前面RUN命令的区别
CMD是在docker run 时运行。
RUN是在 docker build时运行。
· ENTRYPOINT
也是用来指定一个容器启动时要运行的命令
类似于 CMD 指令，但是ENTRYPOINT不会被docker run后面的命令覆盖， 而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序
命令格式：
ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参。
当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令

案例如下：假设已通过 Dockerfile 构建了 nginx:test 镜像：

运行时就变成：docker run -c /etc/nginx/new.conf
优点
在执行docker run的时候可以指定 ENTRYPOINT 运行所需的参数。
注意
如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。
6 构建命令：· docker build -t 新镜像名字:TAG .
7 编写的样例如下：要求· Centos7镜像具备vim+ifconfig+jdk8

FROM centos
MAINTAINER zzyyzzyybs@126.com
ENV MYPATH /usr/local
WORKDIR $MYPATH
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u171-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAV{A}_{H}OME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JR{E}_{H}OME/lib:$CLASSPATH
ENV PATH $JAV{A}_{H}OME/bin:$PATH
EXPOSE 80

17 Docker网络
1 查看docker网络模式命令：docker network ls
2 能干啥？
· 容器间的互联和通信以及端口映射
· 容器IP变动时候可以通过服务名直接网络通信而不受到影响
3 网络模式总体介绍

· bridge模式：使用–network bridge指定，默认使用docker0

· host模式：使用–network host指定—容器借用主机的ip
· none模式：使用–network none指定–只有lo了
· container模式：使用–network container:NAME或者容器ID指定 --举例运行容器1和容器2 可以看到公用网络搭桥eth0,如果容器1关闭的话，容器2就只有lo了，

4 容器实例内默认网络IP生产规则—· docker容器内部的ip是有可能会发生改变的
5 自定义网络：· 自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）

Docker 运行的基本流程为：

1 用户是使用 Docker Client 与 Docker Daemon 建立通信，并发送请求给后者。
2 Docker Daemon 作为 Docker 架构中的主体部分，首先提供 Docker Server 的功能使其可以接受 Docker Client 的请求。
3 Docker Engine 执行 Docker 内部的一系列工作，每一项工作都是以一个 Job 的形式的存在。
4 Job 的运行过程中，当需要容器镜像时，则从 Docker Registry 中下载镜像，并通过镜像管理驱动 Graph driver将下载镜像以Graph的形式存储。
5 当需要为 Docker 创建网络环境时，通过网络管理驱动 Network driver 创建并配置 Docker 容器网络环境。
6 当需要限制 Docker 容器运行资源或执行用户指令等操作时，则通过 Execdriver 来完成。
7 Libcontainer是一项独立的容器管理包，Network driver以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作。

18 Docker-compose容器编排

1 是什么？
Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器
· Docker-Compose是Docker官方的开源项目， 负责实现对Docker容器集群的快速编排。

2 能干嘛？
docker建议我们每一个容器中只运行一个服务,因为docker容器本身占用资源极少,所以最好是将每个服务单独的分割开来但是这样我们又面临了一个问题？
如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfile然后在构建镜像,构建容器,这样累都累死了,所以docker官方给我们提供了docker-compose多服务部署的工具
例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。。。。。。
Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。
可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。
3 去哪下？
· 官网
https://docs.docker.com/compose/compose-file/compose-file-v3/
· 官网下载
https://docs.docker.com/compose/install/
· 安装步骤

curl -L “https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname-s)-$(uname -m)” -o /usr/local/bin/docker-compose
或国内的curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-uname -s-uname -m > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
docker-compose --version

· 卸载步骤
如果你使用curl方式安装，卸载命令为？
rm /usr/local/bin/docker-compose

4 Compose核心概念
· 一文件
· docker-compose.yml
· 两要素
· 服务（service）
· 一个个应用容器实例，比如订单微服务、库存微服务、mysql容器、nginx容器或者redis容器
· 工程（project）
· 由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。

5 Compose使用的三个步骤
· 编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
· 使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。
· 最后，执行docker-compose up命令 来启动并运行整个应用程序，完成一键部
6 Compose 常用命令

docker-compose -h # 查看帮助
docker-compose up # 启动所有docker-compose服务
docker-compose up -d # 启动所有docker-compose服务并后台运行
docker-compose down # 停止并删除容器、网络、卷、镜像。
docker-compose config # 检查配置
docker-compose config -q # 检查配置，有问题才有输出
docker-compose restart # 重启服务
docker-compose start # 启动服务
docker-compose stop # 停止服务
docker-compose ps # 展示当前docker-compose编排过的运行的所有容器

7 编写compose文件，举例如下:

version: “3”
services:
microService:
image: zzyy_docker:1.6
container_name: ms01
ports:
- “6001:6001”
volumes:
- /app/microService:/data
networks:
- atguigu_net
depends_on:
- redis
- mysql
redis:
image: redis:6.0.8
ports:
- “6379:6379”
volumes:
- /app/redis/redis.conf:/etc/redis/redis.conf
- /app/redis/data:/data
networks:
- atguigu_net
command: redis-server /etc/redis/redis.conf
mysql:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: ‘123456’
MYSQL_ALLOW_EMPTY_PASSWORD: ‘no’
MYSQL_DATABASE: ‘db2021’
MYSQL_USER: ‘zzyy’
MYSQL_PASSWORD: ‘zzyy123’
ports:
- “3306:3306”
volumes:
- /app/mysql/db:/var/lib/mysql
- /app/mysql/conf/my.cnf:/etc/my.cnf
- /app/mysql/init:/docker-entrypoint-initdb.d
networks:
- atguigu_net
command: --default-authentication-plugin=mysql_native_password #解决外部无法访问
networks:
atguigu_net:

19 Docker轻量级可视化工具Portainer
1 是什么？
Portainer 是一款轻量级的应用，它提供了图形化界面，用于方便地管理Docker环境，包括单机环境和集群环境
2 安装
· 官网
· https://www.portainer.io/
· https://docs.portainer.io/v/ce-2.9/start/install/server/docker/linux
· docker命令安装
docker run -d -p 8000:8000 -p 9000:9000 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer
· 第一次登录需创建admin，访问地址：xxx.xxx.xxx.xxx:9000
用户名，直接用默认admin
密码记得8位，随便你写

· 设置admin用户和密码后首次登陆

· 选择local选项卡后本地docker详细信息展示

· 上一步的图形展示，能想得起对应命令吗？

20 Docker容器监控之CAdvisor+InfluxDB+Granfana
1 执行命令：docker stats 可以看到

· 问题

通过docker stats命令可以很方便的看到当前宿主机上所有容器的CPU,内存以及网络流量等数据，一般小公司够用了。。。。
但是，
docker stats统计结果只能是当前宿主机的全部容器，数据资料是实时的，没有地方存储、没有健康指标过线预警等功能

2 是什么？
· 一句话· CAdvisor监控收集+InfluxDB存储数据+Granfana展示图表
· CAdvisor

· InfluxDB

· Granfana

3 容器编码这三个进行启动

version: ‘3.1’
volumes:
grafana_data: {}
services:
influxdb:
image: tutum/influxdb:0.9
restart: always
environment:
- PRE_CREATE_DB=cadvisor
ports:
- “8083:8083”
- “8086:8086”
volumes:
- ./data/influxdb:/data
cadvisor:
image: google/cadvisor
links:
- influxdb:influxsrv
command: -storage_driver=influxdb -storage_driver_db=cadvisor -storage_driver_host=influxsrv:8086
restart: always
ports:
- “8080:8080”
volumes:
- /:/rootfs:ro
- /var/run:/var/run:rw
- /sys:/sys:ro
- /var/lib/docker/:/var/lib/docker:ro
grafana:
user: “104”
image: grafana/grafana
user: “104”
restart: always
links:
- influxdb:influxsrv
ports:
- “3000:3000”
volumes:
- grafana_data:/var/lib/grafana
environment:
- HTTP_USER=admin
- HTTP_PASS=admin
- INFLUXDB_HOST=influxsrv
- INFLUXDB_PORT=8086
- INFLUXDB_NAME=cadvisor
- INFLUXDB_USER=root
- INFLUXDB_PASS=root

4 服务启动后访问
· 浏览cAdvisor收集服务，http://ip:8080/

· 第一次访问慢，请稍等
· cadvisor也有基础的图形展现功能，这里主要用它来作数据采集
· 浏览influxdb存储服务，http://ip:8083/
· 浏览grafana展现服务，http://ip:3000
ip+3000端口的方式访问,默认帐户密码（admin/admin）
配置数据源

配置面板panel