MySQL主从复制 - docker实践
- 主服务器3307
- 从服务器3308
- 主从同步
- 测试
Redis分布式存储方式
- hash取余分区
- 一致性hash算法分区
- 哈希槽分区
Redis分布式存储3主3从 - docker实践
- 3主3从搭建
- 集群读写
- 主从容错切换迁移
- 主从扩容
- 主从缩容
从此处获得6388节点的id,以便删除用
再次检查,发现6388已被删除
Dockerfile理论">Dockerfile理论
- 说明
- 构建步骤
- 解析过程
表示注释
- dockerfile常用保留字指令
  - from
  - MAINTAINER
  - RUN
  - EXPOSE
  - WORKDIR
  - USER
  - EVN
  - ADD
  - COPY
  - VOLUME
  - CMD
在交互式启动模式中由日志打印,说明tomcat容器启动了,访问浏览器可以看到猫说明运行了catalina.sh
docker run xxx 后面跟了 /bin/bash 会导致 Dockerfile参数替换为 CMD [‘/bin/bash’,”run”],所以tomcat没有打印日志: tomcat容器也启动了,但是访问浏览器看不到猫说明没有运行了catalina.sh
Dockerfile实践
- 自定义centos镜像
安装vim编辑器
安装ifconfig命令查看网络IP
安装java8及lib库
ADD 是相对路径jar,把jdk-8u181-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
配置java环境变量
- 运行
- 再体会联合文件系统
- 虚悬镜像
自定义ubuntu镜像
总结
Dockerfile发布微服务
Docker网络
- 是什么
会产生一个名为docker0的虚拟网桥
默认创建3大网络模式:bridge、host、none
- 作用
- 网络模式
- docker平台结构图解
Docker-compose容器编排
- 是什么
- 能干什么
- 下载安装卸载
- 步骤
- 常用命令
- compose微服务编排
  - 不使用compose
基础镜像使用java
作者
VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
将jar包添加到容器中并更名为zzyy_docker.jar
运行jar包
暴露6001端口作为微服务
- 存在的问题
- 使用compose

MySQL主从复制 - docker实践

docker pull mysql:5.7

主服务器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

docker ps

cd /mydata/mysql-master/conf
vi 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

docker restart mysql-master
docker ps

docker exec -it mysql-master /bin/bash
mysql -uroot -p
root

CREATE USER 'slave'@'%' IDENTIFIED BY '123456';
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';

从服务器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

cd /mydata/mysql-slave/conf
vi my.cnf

[mysqld]
#设置server_id,同一局域网中需要唯一
server_id=102

#指定不需要同步的数据库名称
binlog-ignore-db=mysql

#开启二进制日志功能
log-bin=mall-mysql-slave1-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表示siave将复制事件写进自己的二进制日志
log_slave_updates=1

#slave设置为只读(具有super权限的用户除外)
read_only=1

docker restart mysql-slave
docker ps

主从同步

docker ps
docker exec -it mysql-master /bin/bash
mysql -uroot -p
root
show master status

#注意看File、Position下一步要用

docker ps
docker exec -it mysql-slave /bin/bash
mysql -uroot -p
root

change master to master_host='192.168.199.200', master_user='slave', master_password='123456', master_port=3307,master_log_file='mall-mysql-bin.000001', master_log_pos=617, master_connect_retry=30;

show slave status \G;
#关注两个参数：Slave_IO_Running:No、Slave_SQL_Running:No

#slave中开启主从同步
start slave;

show slave status \G;
#关注两个参数：Slave_IO_Running:Yes、Slave_SQL_Running:Yes

测试

Redis分布式存储方式

hash取余分区

键key对应的数据缓存到了 **hash(key) % n**上，n代表构成集群的机器数量。
缺点很明显：机器数量变化会导致数据变得不可控（例如宕机、扩容）

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

当我们需要存储一个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上。

优点

容错性
假设Node C宕机，可以看到此时对象A、B、D不会受到影响，只有C对象被重定位到Node D。一般的，在一致性Hash算法中，如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响。简单说，就是C挂了，受到影响的只是B、C之间的数据，并且这些数据会转移到D进行存储。
扩展性
数据量增加了，需要增加一台节点NodeX，X的位置在A和B之间，那收到影响的也就是A到X之间的数据，重新把A到X的数据录入到X上即可，不会导致hash取余全部数据重新洗牌

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

总结
为了在节点数目发生改变时尽可能少的迁移数据

将所有的存储节点排列在收尾相接的Hash环上，每个key在计算Hash后会顺时针找到临近的存储节点存放。
而当有节点加入或退出时仅影响该节点在Hash环上顺时针相邻的后续节点。

优点
加入和删除节点只影响哈希环中顺时针方向的相邻的节点，对其他节点无影响。

缺点
数据的分布和节点的位置有关，因为这些节点不是均匀的分布在哈希环上的，所以数据在进行存储时达不到均匀分布的效果。

哈希槽分区

为什么出现

解决一致性hash算法的数据倾斜问题

是什么

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

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

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

哈希槽计算

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

Redis分布式存储3主3从 - docker实践

3主3从搭建

#关闭防火墙
systemctl stop firewalld

#启动docke服务
systemctl start docker

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

docker ps -a

解释：
--cluster-enabled yes 开启redis集群
--appendonly yes      开启持久化

docker exec -it redis-node-1 /bin/bash

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

#--cluster-replicas 1表示一个主一个从

docker exec -it redis-node-1 /bin/bash
redis-cli -p 6381

#查看自己节点信息
cluster info

#查看集群信息
cluster nodes

815ba86809a25408fb03e82dbd46e6a3cc72d1ef 192.168.199.200:6381@16381 myself,master - 0 1645725728000 1 connected 0-5460
c8bf17dad5099dbeb108c95dabdb576532d3ab15 192.168.199.200:6382@16382 master - 0 1645725728772 2 connected 5461-10922
2e992fe9926f0fbe9b9efcce9f61073e2f94e49e 192.168.199.200:6383@16383 master - 0 1645725729786 3 connected 10923-16383

a488d23223894189c479374c1904687a1490dcb2 192.168.199.200:6386@16386 slave 815ba86809a25408fb03e82dbd46e6a3cc72d1ef 0 1645725728000 1 connected

6f1e869aecb6f8d3ef98b59023de5ce10ba580aa 192.168.199.200:6384@16384 slave c8bf17dad5099dbeb108c95dabdb576532d3ab15 0 1645725728000 2 connected

4ca218418d355f77c086fe5ec19ec06139b76fdc 192.168.199.200:6385@16385 slave 2e992fe9926f0fbe9b9efcce9f61073e2f94e49e 0 1645725727000 3 connected


从上看出主从关系: 6381(6386)、6382(6384)、6383(6385)
# slave后面的id表示从节点是某个主节点的从

集群读写

docker exec -it redis-node-1 /bin/bash

redis-cli -p 6381 -c
#注意: -c 表示集群模式操作,如果不加由于key是按照hash槽存储的,本机上会部分读写失败
#存储过程中会重定向到其他节点,如下图

docker exec -it redis-node-1 /bin/bash

redis-cli --cluster check 192.168.199.200:6381

主从容错切换迁移

测试一: 
搭建好之后的主从关系是6381(6386)、6382(6384)、6383(6385)
现在将6381停掉,发现6386变成了master
再次启动6381,发现6381变成了从机

docker stop redis-node-1
docker exec -it redis-node-2 /bin/bash
redis-cli -p 6382 -c
cluster nodes
exit
redis-cli --cluster check 192.168.199.200:6382

测试二:
现在将6386停掉,发现6381变成了master
再次启动6386,发现6386变成了从机
此时恢复成了原来的节点状态

docker stop redis-node-6
docker exec -it redis-node-2 /bin/bash
redis-cli -p 6382 -c
cluster nodes
exit
redis-cli --cluster check 192.168.199.200:6382

主从扩容

3主3从变为4主4从

docker run -d --name redis-node-7 --net host --privileged=true -v /data/redis/share/redis-node-7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387

docker run -d --name redis-node-8 --net host --privileged=true -v /data/redis/share/redis-node-8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388

docker ps

docker exec -it redis-node-7 bash
redis-cli --cluster add-node 192.168.199.200:6387 192.168.199.200:6381
# 新加入的6387拜访原来的主节点6381,请求进入集群作为主节点

redis-cli --cluster check 192.168.199.200:6381
# 此时6387已作为master加入了集群,但是槽位是空的,下面需要分配槽位

# 分配槽位,4094=16384/4,接着输入6387(master,0 slot)节点真实id,通过上面的check可以看到
redis-cli --cluster reshard 192.168.199.200:6381
4096
5fd78a4f4f4626a9ab54a040c80c059ab09da82d
all

redis-cli --cluster check 192.168.199.200:6381
# 检查之后发现,6387节点分配了槽位,并且是其他3个master各自匀一点分给6387节点

docker exec -it redis-node-7 bash

redis-cli --cluster add-node 192.168.199.200:6388 192.168.199.200:6387 --cluster-slave --cluster-master-id 5fd78a4f4f4626a9ab54a040c80c059ab09da82d

redis-cli --cluster check 192.168.199.200:6382
# 4主4从完成

主从缩容

将redis集群恢复成3主3从：

先清除从节点6388
将清出来的槽点重新分配
再删除6387
恢复成为3主3从 ```shell redis-cli —cluster check 192.168.199.200:6382
从此处获得6388节点的id,以便删除用

redis-cli —cluster del-node 192.168.199.200:6388 078d219b9ee983ffa26ec2c4488cc0a1fb43f90a

redis-cli —cluster check 192.168.199.200:6382

再次检查,发现6388已被删除

```shell
redis-cli --cluster reshard 192.168.199.200:6381
# 此处将6387的4096个槽位分3批移(1000,1000,2096)到其他3个节点
# 过程中需要输入:分配槽点数、接收节点id、源节点id...   done
1000
815ba86809a25408fb03e82dbd46e6a3cc72d1ef    (6381节点id)
5fd78a4f4f4626a9ab54a040c80c059ab09da82d    (6387节点id)
done
# 此时 check 发现6381新增了1000个槽点,6387减少了1000个槽点.我们继续分配

redis-cli --cluster reshard 192.168.199.200:6381
1000
c8bf17dad5099dbeb108c95dabdb576532d3ab15    (6382节点id)
5fd78a4f4f4626a9ab54a040c80c059ab09da82d    (6387节点id)
done

redis-cli --cluster reshard 192.168.199.200:6381
2096
2e992fe9926f0fbe9b9efcce9f61073e2f94e49e    (6383节点id)
5fd78a4f4f4626a9ab54a040c80c059ab09da82d    (6387节点id)
done

# 此时check 发现6387上槽点为0,其他3个节点增加了一些槽点

# 当然你也可以一次性将4096个槽点分配给6381一个主节点

redis-cli --cluster check 192.168.199.200:6382
# 检查确认6387槽点数为0

redis-cli --cluster del-node 192.168.199.200:6387 5fd78a4f4f4626a9ab54a040c80c059ab09da82d

redis-cli --cluster check 192.168.199.200:6382
# 检查确认6387已被删除,至此恢复3主3从

Dockerfile理论

说明

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。

构建步骤

编写Dockerfile文件
docker build构建镜像
docker run 依镜像运行容器

解析过程
基础知识
1. 每条指令必须大写，且后面最少跟一个参数
2. 指令从上到下一次执行
3. 表示注释
4. 每条指令都会创建一个新的镜像层进行提交
docker执行Dockerfile的大致流程
1. docker从基础镜像运行一个容器
2. 执行一条指令对容器做出修改
3. 执行类似 docker commit 的操作提交一个新的镜像层
4. docker再基于新提交的指令运行一个新容器
5. 执行dockerfile中的下一条指令直到所有指令都执行完毕
总结：
1. 从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段
  1. Dockerfile是软件的原材料
    1. Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
  2. Docker镜像是软件的交付品
    1. Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时会真正开始提供服务;
  3. Docker容器则可以认为是软件镜像的运行态，也即依照镜像运行的容器实例
    1. Docker容器，容器是直接提供服务的。
2. Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

dockerfile常用保留字指令

from

基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from

MAINTAINER

镜像维护者的姓名和邮箱地址

RUN

容器构建时（docker build）需要运行的命令
两种格式：

shell格式
1. RUN <命令行命令>，<命令行命令>等同于在终端操作的shell命令
2. 例如：RUN yum -y install net-tools
exec格式
1. RUN ["可执行文件","参数1","参数2"]
2. 例如：RUN ["./test.php","dev","offline"]等价于RUN ./test.php dev offline
  EXPOSE
  当前容器对外暴露出的端口
  WORKDIR
  指定创建容器后，终端默认登陆进来的工作命令
  USER
  指定镜像以什么样的用户执行，如果不指定，默认root
  EVN
  用来在构建镜像过程中设置环境变量
  例如：ENV MY_PATH /usr/mytest WORKDIR $MY_PATH
  ADD
  将宿主机命令下的文件拷贝进镜像且会自动处理url和解压tar压缩包
  COPY
  类似ADD，拷贝文件和目录到镜像中。将从构建上下文目录中<原文件>的文件/目录复制到新的一层的镜像内的<目标路径>位置
  例如：COPY src dest COPY ["src","dest"]
  VOLUME
  容器数据卷，用于数据保存和持久化工作
  CMD
  指定容器启动后要干的事情。

CMD 指令格式和 RUN 相似，也是两种格式：

shell 格式：CMD <命令>
exec 格式：CMD ["可执行文件","参数1","参数2"...]
参数列表格式：CMD ["参数1","参数2",... ]，在指定了 **ENTRYPOINT**指令后，用 CMD指定具体的参数

注意：

Dockfile中可以有多个 CMD 指令，但只有最后一个生效，CMD会被 docker run xxx之后的参数替换。参考tomcat的Dockerfile演示：
- 官网最后一行命令：
  - EXPOSE 8080
  - CMD ['catalina.sh',"run"]
- 我们演示自己的覆盖操作：
  - docker run -it -p 8080:8080 57800e5b1cbf /bin/bash
他和RUN命令的区别
- CMD是在docker run 时运行
- RUN是在docker build时运行 ```shell docker search tomcat:8 docker pull billygoo/tomcat8-jdk8 docker images docker run -it -p 8080:8080 30ef4019761d
  在交互式启动模式中由日志打印,说明tomcat容器启动了,访问浏览器可以看到猫说明运行了catalina.sh

ctrl+c 关闭tomcat容器 docker run -it -p 8080:8080 30ef4019761d /bin/bash

docker run xxx 后面跟了 /bin/bash 会导致 Dockerfile参数替换为 CMD [‘/bin/bash’,”run”],所以tomcat没有打印日志: tomcat容器也启动了,但是访问浏览器看不到猫说明没有运行了catalina.sh

<a name="PrVcZ"></a>
### ENTRYPOINT
也是用来指定一个容器启动时要运行的命令。类似于CMD指令，但是ENTRYPOINT不会被docker run后面的命令覆盖，而且这些命令行参数会被当作参数送给ENTRYPOINT指令指定的程序

命令格式：<br />`ENTRYPOINT [ "<executeable>" , "<param1>" , "<param2>" ,...]`<br />ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参。<br />当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令，他两个组合会变成`<ENTRYPOINT> "<CMD>"`

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

ENTRYPOINT [ "nginx", "-c"]  #定参
CMD["/etc/nginx/nginx.conf"]  #变参

是否传参	按照dockerfile编写执行	传参运行
Docker命令	docker run nginx:test	docker run nginx:test /etc/nginx/new.conf
衍生出的实际命令	nginx -c /etc/nginx/nginx.conf	nginx -c /etc/nginx/new.conf

优点：在执行docker run的时候可以指定ENTRYPOINT运行所需的参数。
注意：如果Dockerfile 中如果存在多个ENTRYPOINT指令，仅最后一个生效。

Dockerfile实践

自定义centos镜像

说明

要求：Centos7镜像具备vim+ifconfig+jdk8. 注意：docker pull centos是最新的,后面使用安装vim会出错，索引应该使用centos7.或者也可以到清华大学开源软件镜像站解决报错问题。
jdk下载
1. https://www.oracle.com/java/technologies/downloads/#java8 x64 Compressed Archive
2. https://mirrors.yangxingzhen.com/jdk/
  拉取centos7的镜像
```
docker pull centos:centos7
```
  编写Dockerfile
```shell FROM centos:centos7 MAINTAINER qinmeng1654400317@qq.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-8u181-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置

ADD jdk-8u181-linux-x64.tar.gz /usr/local/java/

配置java环境变量

ENV JAVA_HOME /usr/local/java/jdk1.8.0_181 ENV JRE_HOME $JAVA_HOME/jre ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH ENV PATH $JAVA_HOME/bin:$PATH

EXPOSE 80

CMD echo $MYPATH CMD echo “success———————ok” CMD /bin/bash

![image.png](https://cdn.nlark.com/yuque/0/2022/png/1269469/1645847322393-15757e69-276c-4883-9c97-bed157756c73.png#clientId=uc176ec89-6e38-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=116&id=u940c9493&margin=%5Bobject%20Object%5D&name=image.png&originHeight=130&originWidth=740&originalType=binary&ratio=1&rotation=0&showTitle=false&size=15703&status=done&style=none&taskId=u75b86d21-7398-4ebb-b36c-69e36089068&title=&width=657.7777777777778)
<a name="vwzSZ"></a>
### 构建
```shell
docker build -t centos7_java8:1.5 .

假如使用了最新版本的centos则会报错：
Error: Failed to download metadata for repo 'appstream': Cannot prepare internal mirrorlist: No URLs in mirrorlist

运行

docker run -it centos7_java8:1.5 /bin/bash

# 测试centos7中的软件
vi hello
ifconfig
java
javac

再体会联合文件系统

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

虚悬镜像

仓库名、标签都是的镜像，俗称dangling image。构建失败或出错会生成虚悬镜像，最好删除！
查看命令： docker image ls -f dangling=true
删除： docker image prune

自定义ubuntu镜像

请到清华大学开源软件镜像站选择软件源稳定的版本（这里使用 16.04 版本，尽量不要选择最新版本），将版本对应的源信息复制到文件 /etc/apt/sources.list
到 docker官方仓库找到对应ubuntu版本的镜像

docker pull ubuntu:16.04

FROM ubuntu:16.04
MAINTAINER zzyy<zzyybs@126.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN apt-get update
RUN apt-get install net-tools
#RUN apt-get install -y iproute2
#RUN apt-get install -y inetutils-ping

EXPOSE 80

CMD echo $MYPATH
CMD echo "install inconfig cmd into ubuntu success--------------ok"
CMD /bin/bash

docker build -t ubuntu_net:1.1 .

docker images

docker run -it ubuntu_net:1.1 /bin/bash

ifconfig

总结

Dockerfile发布微服务

port:6001

localhost:6001/get 返回随机整数

用idea package打包放到/myfile_springboot/下,在该目录下编辑Dockerfile文件

# 基础镜像使用java
FROM java:8

# 作者
MAINTAINER zzyy

# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp

# 将jar包添加到容器中并更名为zzyy_docker.jar
ADD spring_demo-0.0.1-SNAPSHOT.jar zzyy_docker.jar

# 运行jar包
RUN bash -c 'touch /zzyy_docker.jar'

ENTRYPOINT ["java","-jar","/zzyy_docker.jar"]

#暴露6001端口作为微服务
EXPOSE 6001

docker build -t spring_demo:0.0.1 .

docker images

docker run -d -p 6001:6001 spring_demo:0.0.1

#测试
http://192.168.199.200:6001/get

Docker网络

是什么

docker不启动，默认网络情况 ifconfig
1. ens33
2. io
3. virbr0
  1. 在CentOS7的安装过程中如果有选择相关虚拟化的的服务安装系统后，启动网卡时会发现有一个以网桥连接的私网地址的virbr0网卡(virbr0网卡：它还有一个固定的默认IP地址192.168.122.1)，是做虚拟机网桥的使用的，其作用是为连接其上的虚机网卡提供 NAT访问外网的功能。
  2. 我们之前学习Linux安装，勾选安装系统的时候附带了libvirt服务才会生成的一个东西，如果不需要可以直接将libvirtd服务卸载，yum remove libvirt-libs.x86_64
docker启动之后 ```shell systemctl start docker ifconfig
会产生一个名为docker0的虚拟网桥

docker network ls

默认创建3大网络模式:bridge、host、none

<a name="R1oOO"></a>
## 常用基本命令
```shell
help:
docker network --help

创建网络:
docker network create xxx网络名字

查看:
docker network ls

查看网络数据源:
docker network inspect xxx网络名字

删除网络:
docker network rm xxx网络名字

作用

容器间的互联和通信以及端口映射
容器IP变动时候可以通过服务名直接网络通信而不受到影响
网络模式
总体介绍
| 网路模式 | 简介 | 命令 | | —- | —- | —- | | bridge模式 | 为每一个容器分配、设置IP等，并将容器连接到一个docker0
虚拟网桥，默认为该模式。 | —network bridge，默认使用docker0 | | host模式 | 容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口。 | —network host | | none模式 | 容器有独立的Network namespace，但并没有对其进行任何网络设置，如分配veth pair和网桥连接，IP等。 | —network none | | container模式 | 新创建的容器不会创建自己的网卡和配置自己的IP，而是和一个指定的容器共享IP、端口范围等。 | —network container:NAME或者容器ID |

docker容器内部的ip有可能会改变

docker run -it --name u1 ubuntu bash
ctrl+p+q
docker inspect u1| tail -n 20
# ip:172.17.0.2

docker run -it --name u2 ubuntu bash
ctrl+p+q
docker inspect u2| tail -n 20
# ip:172.17.0.3

docker stop u2

docker run -it --name u3 ubuntu bash
ctrl+p+q
docker inspect u3| tail -n 20
# ip:172.17.0.3

案例说明

bridge

是什么

Docker 服务默认会创建一个 docker0 网桥（其上有一个 docker0 内部接口），该桥接网络的名称为docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口的 IP 地址和子网掩码，让主机和容器之间可以通过网桥相互通信。

docker network inspect bridge | grep name
# "com.docker.network.bridge.name": "docker0",

ifconfig | grep docker
# docker0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500

说明

Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。

docker run 的时候，没有指定network的话默认使用的网桥模式就是bridge，使用的就是docker0。在宿主机ifconfig,就可以看到docker0和自己create的network(后面讲)eth0，eth1，eth2……代表网卡一，网卡二，网卡三……，lo代表127.0.0.1，即localhost，inet addr用来表示网卡的IP地址

网桥docker0创建一对对等虚拟设备接口一个叫veth，另一个叫eth0，成对匹配。

整个宿主机的网桥模式都是docker0，类似一个交换机有一堆接口，每个接口叫veth，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair）；
每个容器实例内部也有一块网卡，每个接口叫eth0；
docker0上面的每个veth匹配某个容器实例内部的eth0，两两配对，一一匹配。

通过上述，将宿主机上的所有容器都连接到这个内部网络上，两个容器在同一个网络下,会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。

案例

docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8

ip addr | tail -n 8
#查看宿主机的IP地址内容

docker exec -it tomcat81 bash
ip addr
# 查看网卡

docker exec -it tomcat82 bash
ip addr
# 查看网卡

#此时在tomcat81上 ping tomcat82 的地址可以通 ping 172.17.0.5
#此时在tomcat82上 ping tomcat81 的地址可以通 ping 172.17.0.4
#但是通过网络容器名称ping不通ping tomcat81/tomcat82

host

是什么

直接使用宿主机的 IP 地址与外界进行通信，不再需要额外进行NAT 转换。

说明

容器将不会获得一个独立的Network Namespace，而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。

案例

docker run -d --network host --name tomcat83 billygoo/tomcat8-jdk8

# host模式下-p参数无效,端口号会以主机端口号为主,重复时则递增
# 解决:使用docker的其他网络模式,例如--network=bridge,或者直接无视

docker inspect tomcat83 | tail -n 20
# IPAddress为空
# 此时直接用使用宿主机IP端口可直接访问到猫 http://192.168.199.200:8080/

docker exec -it tomcat83 bash
# 发现网路情况和宿主机 ifconfig 的情况一样,有lo,ens33,docker0

none

是什么

禁用网络功能，只有lo标识(就是127.0.0.1表示本地回环)

说明

在none模式下，并不为Docker容器进行任何网络配置。也就是说，这个Docker容器没有网卡、IP、路由等信息，只有一个lo，需要我们自己为Docker容器添加网卡、配置IP等。

案例

docker run -d -p 8084:8080 --network none --name tomcat84 billygoo/tomcat8-jdk8

docker inspect tomcat84 | tail -n 20
# "Networks": {"none": {}}

docker exec -it tomcat84 bash
ip addr
# 发现只有一个lo网卡

container

是什么

container⽹络模式：新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。

案例

docker run -d -p 8085:8080 --name tomcat85 billygoo/tomcat8-jdk8
docker run -d -p 8086:8080 --network container:tomcat85 --name tomcat86  billygoo/tomcat8-jdk8

# docker: Error response from daemon: conflicting options: port publishing and the container type network mode
# 相当于tomcat86和tomcat85公用同一个ip同一个端口，导致端口冲突。本案例用tomcat演示不合适

docker run -it --name alpine1 alpine /bin/sh
docker run -it --network container:alpine1 --name alpine2 alpine /bin/sh

# alpine1中 
ip addr
# alpine2中 
ip addr
# 发现网卡信息一样 19: eth0@if20

exit 或者 docker stop alpine1
# alpine2中 
ip addr
# 发现 alpine2 中只剩下lo了,eth0网卡消失

docker start alpine1
# alpine2中 
ip addr
# 发现 alpine2 中只剩下lo了,eth0网卡未能出现
exit 或者 docker stop alpine2
docker start alpine2
# alpine2中 
ip addr
# 发现 alpine2 中只剩下lo了,eth0网卡又出现了

Alpine Linux 是一款独立的、非商业的通用 Linux 发行版，专为追求安全性、简单性和资源效率的用户而设计。可能很多人没听说过这个 Linux 发行版本，但是经常用 Docker 的朋友可能都用过，因为他小，简单，安全而著称，所以作为基础镜像是非常好的一个选择，可谓是麻雀虽小但五脏俱全，镜像非常小巧，不到 6M的大小，所以特别适合容器打包。

自定义网络

自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通)

docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8

# 分别进入容器ip addr,ping对方IP能通,但是ping容器名称不通

docker network create qm_network
docker network ls

docker run -d -p 8081:8080 --network qm_network --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --network qm_network --name tomcat82 billygoo/tomcat8-jdk8

# 分别进入容器ip addr,ping对方IP能通,而且ping容器名称也可以通

docker平台结构图解

从其架构和运行流程来看，Docker 是一个 C/S 模式的架构，后端是一个松耦合架构，众多模块各司其职。

Docker 运行的基本流程为：

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

Docker-compose容器编排

是什么

Docker-Compose是Docker官方的开源项目，负责实现对Docker容器集群的快速编排。

Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器

能干什么

docker建议我们每一个容器中只运行一个服务,因为docker容器本身占用资源极少,所以最好是将每个服务单独的分割开来但是这样我们又面临了一个问题？

如果我需要同时部署好多个服务,难道要每个服务单独写Dockerfile然后在构建镜像,构建容器,这样累都累死了,所以docker官方给我们提供了docker-compose多服务部署的工具

例如要实现一个Web微服务项目，除了Web服务容器本身，往往还需要再加上后端的数据库mysql服务容器，redis服务器，注册中心eureka，甚至还包括负载均衡容器等等。。。。。。

Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。

可以很容易地用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。

下载安装卸载

官网官方下载

curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

docker-compose --version

# 卸载
rm /usr/ local/ bin/ docker-compose

步骤

编写Dockerfile定义各个微服务应用并构建出对应的镜像文件
使用docker-compose.yml定义一个完整业务单元，安排好整体应用中的各个容器服务。最后，执行docker-compose up命令

来启动并运行整个应用程序，完成—键部署上线

常用命令

docker-compose -h                           # 查看帮助
docker-compose up                           # 启动所有docker-compose服务
docker-compose up -d                        # 启动所有docker-compose服务并后台运行
docker-compose down                         # 停止并删除容器、网络、卷、镜像。
docker-compose exec  yml里面的服务id                 # 进入容器实例内部  docker-compose exec docker-compose.yml文件中写的服务id /bin/bash
docker-compose ps                      # 展示当前docker-compose编排过的运行的所有容器
docker-compose top                     # 展示当前docker-compose编排过的容器进程
docker-compose logs  yml里面的服务id     # 查看容器输出日志
docker-compose config     # 检查配置
docker-compose config -q  # 检查配置，有问题才有输出
docker-compose restart   # 重启服务
docker-compose start     # 启动服务
docker-compose stop      # 停止服务

compose微服务编排

注意：

maven下载地址
springboot版本选择以及依赖选择
测试项目地址

不使用compose
改造升级微服务工程docker_boot,编写Dockerfile
构建镜像 docker build -t docker_demo:0.0.1 .
建立MySQL实例
建立redis实例
运行微服务docker run -d -p 6001:6001 docker_demo:0.0.1
以上3个容器实例运行成功 docker ps
swagger接口测试 http://localhost:你的微服务端口/swagger-ui.html#/ ```shell
基础镜像使用java
FROM java:8

作者

MAINTAINER zzyy

VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp

VOLUME /tmp

将jar包添加到容器中并更名为zzyy_docker.jar

ADD docker_demo-0.0.1-SNAPSHOT.jar zzyy_docker.jar

运行jar包

RUN bash -c ‘touch /zzyy_docker.jar’ ENTRYPOINT [“java”,”-jar”,”/zzyy_docker.jar”]

暴露6001端口作为微服务

EXPOSE 6001

```shell
docker run -p 3306:3306 --name mysql8 --privileged=true -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -v /zzyyuse/mysql/logs:/logs -v /zzyyuse/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:8

#进入MySQL建库,建表

docker run  -p 6379:6379 --name redis608 --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

#假如运行docker_demo镜像服务之后,调用添加接口报错如下：
java.sql.SQLException: null,  message from server: "Host '172.17.0.1' is blocked because of many connection errors; u                                                  nblock with 'mysqladmin flush-hosts'"
#考虑是数据库连接错误次数太多了,重启mysql8容器即可

存在的问题

先后顺序要求固定，先mysql+redis才能微服务访问成功
多个run命令……
容器间的启停或宕机，有可能导致IP地址对应的容器实例变化，映射出错，要么生产IP写死(可以但是不推荐)，要么通过服务调用

使用compose
新建网桥 docker network create atguigu_net
编写 docker-compose.yml 文件
修改微服务工程
1. yml文件 mysql和redis通过服务名访问，注意是按照 docker-comose.yml文件里面服务名字！是mysql，不是mysql8
2. 上传
3. 编写Dockerfile,同上
4. 构建镜像 docker build -t docker_demo:0.0.1 .
执行 docker-compose up 或者 docker-compose up -d
进入MySQL实例建库建表
swagger测试
1. 进入MySQL查看数据变化
2. 进入redis-cli 执行keys *查看
3. 进入docker-demo 查看同一级目录下面的日志文件logfile.log
关停: 编排文件目录下执行 docker-compose stop ```shell version: “3”

services: microService: image: docker_demo:0.0.1 container_name: docker_demo001 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:8 environment: MYSQL_ROOT_PASSWORD: ‘root’ #这里和jdbc配置的一样 MYSQL_ALLOW_EMPTY_PASSWORD: ‘no’ MYSQL_DATABASE: ‘test’ MYSQL_USER: ‘qqmm’ #这里是用root新增的一个用户 MYSQL_PASSWORD: ‘qqmm123’ 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: ```

docker 高级

MySQL主从复制 - docker实践

主服务器3307

从服务器3308

主从同步

测试

Redis分布式存储方式

hash取余分区

一致性hash算法分区

为什么出现

原理

优点

缺点

总结

哈希槽分区

为什么出现

是什么

哈希槽计算

Redis分布式存储3主3从 - docker实践

3主3从搭建

集群读写

主从容错切换迁移

主从扩容

主从缩容

从此处获得6388节点的id,以便删除用

再次检查,发现6388已被删除

Dockerfile理论

说明

构建步骤

解析过程

表示注释

dockerfile常用保留字指令

from

MAINTAINER

RUN

EXPOSE

WORKDIR

USER

EVN

ADD

COPY

VOLUME

CMD

在交互式启动模式中由日志打印,说明tomcat容器启动了,访问浏览器可以看到猫说明运行了catalina.sh

docker run xxx 后面跟了 /bin/bash 会导致 Dockerfile参数替换为 CMD [‘/bin/bash’,”run”],所以tomcat没有打印日志: tomcat容器也启动了,但是访问浏览器看不到猫说明没有运行了catalina.sh

Dockerfile实践

自定义centos镜像

说明

拉取centos7的镜像

编写Dockerfile

安装vim编辑器

安装ifconfig命令查看网络IP

安装java8及lib库

ADD 是相对路径jar,把jdk-8u181-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置

配置java环境变量

运行

再体会联合文件系统

虚悬镜像

自定义ubuntu镜像

总结

Dockerfile发布微服务

Docker网络

是什么

会产生一个名为docker0的虚拟网桥

默认创建3大网络模式:bridge、host、none

作用

网络模式

总体介绍

docker容器内部的ip有可能会改变

案例说明

bridge

是什么

说明

案例

host

是什么

说明

案例

none

是什么