## [Docker](https://so.csdn.net/so/search?q=Docker&spm=1001.2101.3001.7020)学习之路（三） docker 文件 分层理解 数据卷 数据同步



### （一） 个人分层理解

在前文中 有过 拉取Mysql 最新版后 再拉取mysql 5.7.30在下载镜像的时候 提示有些文件已存在！

![image-20200521213604103](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMTIxMzYwNDEwMy5wbmc?x-oss-process=image/format,png)

其实 通过第二章 学习 拉取了许许多多镜像后 终于发现 无论什么镜像 在下载的时候 都不是一个下载[进度条](https://so.csdn.net/so/search?q=进度条&spm=1001.2101.3001.7020) 都是多层 多个进度条下载 有的会提示 Already exists 好像 一个镜像被拆分成了 多层宝塔一般 同时分层下载。

个人理解 ： 这种分层技术 是 docker 强大的功能点之一 会减少很多的冗余文件 每一个镜像 都设置为宝塔形，进行分层 。当某一个镜像 依赖于另一个镜像的分层 时会先判断 该层是否已存在 如果存在 则不下载 ，仅仅下载镜像所需的额外部分。 类似于盖楼房 一层一层的堆积 上层依赖于下层。 那么当删除镜像的时候呢 ，也会查看自己构成镜像的所有层 如果 自己的某层级在被另一个镜像所依赖（使用）则会忽略删除该层。

 正如咱上放的mysql 可能依赖于什么 （举个例子： centos 啊 xxxx等） 那么在第一次pull mysql 时 会判断当前docker 是否含有 这个centos 镜像分层 有的话 则不下载 ，继续下载mysql 镜像所必须要使用的其余分层。 然后一层一层的 下载完后 组成了一个完整的 mysql镜像。

 当我们再次下载 mysql5.7.30的时候 可能 mysql：5.7.30 镜像与mysql 镜像 有使用到相同的层级 那么在pull mysql:5.7.30的时候 会先查询docker 是否含有mysql:5.7.30所要使用的 镜像 ,经查询 发现果然 有的层已经是被在拉取 mysql的时候下载了 ，所以拉取5.7.30的时候回提示 Already exists，由于构建mysql5.7.30其余层没有 则继续下载新的其余的层级。

### （二）数据卷的简单使用

##### （1）数据卷概念

docker 容器虽然好用 ，但是咱发现了一些问题

场景1： 比如，我在安装了mysql 并把mysql 作为数据源 在项目中使用 ,那么不想使用这个容器 或者这个容器出现问题 需要删除时 不是吧mysql 容器中的数据也删除了吗？？ 这不就是我们产后说的，删库跑路吗。 需求：需要 容器数据持久化 或绑定到外部宿主机

场景2： 通过前文 发现了 容器中 无法使用一个Linux命令 ,例如 ll,vim,vi等 那么我们在修改一些配置文件时就很不方便 例如 修改redis ，mongo 等配置文件 ，还需要额外下载vim 等命令 ，每个容器都需要下载，且下载速非常缓慢，这样，肯定是不行的。 需求：外部修改 同步到容器 或类似于宿主机与容器间的端口映射

将宿主机中的某个目录，映射到容器中，这样，在容器中此目录下的修改，即便容器关闭，数据也会保留下来，供宿主机和其他容器访问。

```shell
数据卷是一个可供容器使用的特殊目录，它绕过文件系统，可以提供很多有用的特性：

- 数据卷可以在容器之间共享和重用

- 对数据卷的修改会立马生效

- 对数据卷的更新，不会影响镜像

- 卷会一直存在，直到没有容器使用

```

##### （2）数据卷的简单使用

在run 镜像的时候 使用-v 参数 来实现 宿主目录与虚拟机目录进行[挂载](https://so.csdn.net/so/search?q=挂载&spm=1001.2101.3001.7020)映射

例如 启动一个redis 镜像 设置端口映射 设置别名为aa

```shell
docker run -d  -p 6888:6379 --name aaa -v /test:/data redis

```

发现咱们的宿主机 /test 目录已经与 aaa 容器 /data 目录挂载起来了

![image-20200521221409765](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMTIyMTQwOTc2NS5wbmc?x-oss-process=image/format,png)

使用xshell再打开一个窗口 进行同步测试

 咱们在 容器中新建一个 qqqq.file 文件 ，查看 宿主机中 /test 目录下是否会自动添加

![image-20200521221811218](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMTIyMTgxMTIxOC5wbmc?x-oss-process=image/format,png)

我们再在容器中 输出语句到 qqqq.file中

在容器输出语句到 qqqq.file 也同步到了 外部的 /test目录下的 qqqq.file 文件

![image-20200521222045795](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMTIyMjA0NTc5NS5wbmc?x-oss-process=image/format,png)

那么容器内部 同步到外部 没什么问题了 咱再测测 外部文件同步内部容器

发现外部添加的 leilei.java 文件也同步到了容器内

![image-20200521222230506](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMTIyMjIzMDUwNi5wbmc?x-oss-process=image/format,png)

那么 咱们 关闭容器 是否还能进行同步呢？

首先ctrl+p+q退出容器后 在宿主机上编写 语句 然后从起容器进入内部查看-----发现也同步了

![image-20200521222523702](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMTIyMjUyMzcwMi5wbmc?x-oss-process=image/format,png)
特别需要注意的是:删除文件 也是同步的，无论是删除宿主机上文件 还是容器内部文件都会进行同步删除

咱将整合容器进行删除------
整个容器删除 数据不会同步 意思是 不会因为容器的删除 而删除其挂载在外部宿主机的目录
![image-20200521223023732](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMTIyMzAyMzczMi5wbmc?x-oss-process=image/format,png)

那么做一个小的总结

## 容器内新建 删除 修改文件------------ 宿主机外部挂载的目录 同步 容器删除--------宿主机外部挂载的目录不会同步

##### （3）场景模拟：mysql 数据挂载同步验证

mysql 宰门开发中 是经常使用的菲关系型数据库，为了加深学习印象，所以咱来实战模拟一下 同步容器以及删除容器 好让以后心里有个底

查看自己的以及在运行的容器

![image-20200523143915040](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0MzkxNTA0MC5wbmc?x-oss-process=image/format,png)

首先 pull 镜像 我这里拉取mysql:5.7.30 至于版本问题 可查看docker 镜像库：[docker镜像库](https://hub.docker.com/_/mysql)

```
docker pull mysql:5.7.30
1
```

再持久化运行 指定端口映射 数据卷挂载 设置密码启动

查看到官方 教学 发现 其指定密码时使用了**-e 参数** **此参数 为设置环境变量的意思**

![image-20200523144127855](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0NDEyNzg1NS5wbmc?x-oss-process=image/format,png)

既然咱们要挂载 mysql数据目录 ，那肯定的知道 容器中 mysql 的配置文件路径一个数据存储路径吧！

得 咱不知道 ，浏览官网吧 ，官网果然是上手新事物的第一老师啊！

查阅后 发现 mysql 容器的 **配置文件路径在 /etc/mysql/conf.d** **数据存储路径在/var/lib/mysql**

![image-20200523144429219](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0NDQyOTIxOS5wbmc?x-oss-process=image/format,png)

![image-20200523144530210](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0NDUzMDIxMC5wbmc?x-oss-process=image/format,png)

那么 咱们运行 Mysql的容器的整个命令为

```
docker run -d -p 7000:3306 -v /docker/mysql/conf:/etc/mysql/conf.d -v /docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7.30
1
```

![image-20200523145342405](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0NTM0MjQwNS5wbmc?x-oss-process=image/format,png)

运行成功后 使用咱们的 Navcat 查看

![image-20200523145401300](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0NTQwMTMwMC5wbmc?x-oss-process=image/format,png)

然后再看我们挂载的 /docker/mysql 下时候有容器中的文件-----------果然是有的

![image-20200523145532156](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0NTUzMjE1Ni5wbmc?x-oss-process=image/format,png)

咱们使用navicat 创建一个新的数据库 并在数据库中创建一张表并插入数据 ----然后到 挂载的宿主机目录以及 容器中查看

![image-20200523145928106](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE0NTkyODEwNi5wbmc?x-oss-process=image/format,png)

宿主机目录是有的了

![image-20200523150051579](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MDA1MTU3OS5wbmc?x-oss-process=image/format,png)

咱再查看 容器内

![image-20200523150255534](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MDI1NTUzNC5wbmc?x-oss-process=image/format,png)

为了同步性 我们再容器中吧新建的 leilei 库给删除

![image-20200523150439828](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MDQzOTgyOC5wbmc?x-oss-process=image/format,png)

刷新后 报错 找不到 ‘’‘leilei’ 数据库 说明容器中数据已经被删除掉了 那么我们查看 宿主机总对应挂载的目录/docker/mysql/data/下时候还含有 leilei 文件夹

![image-20200523150547311](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MDU0NzMxMS5wbmc?x-oss-process=image/format,png)

![image-20200523150849680](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MDg0OTY4MC5wbmc?x-oss-process=image/format,png)

那么 咱们说的 数据持久化 到底是什么呢 ？

容器中 新增数据 --同步到了宿主机, 删除数据 --还是同步到了宿主机

咱们最后再进行一个验证
向容器中 添加数据后 删除容器 ，然后在运行一个全新的容器实例 将其数据绑定到 上一个容器数据 目录 ,查看数据是否会被丢失

1.在当前容器中添加数据 -----我这里还是以naicat 添加数据库添加表做演示

添加Learn 数据库 添加表 student 并插入一条数据

![image-20200523151507356](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MTUwNzM1Ni5wbmc?x-oss-process=image/format,png)

2.删除当前容器 -------为了更好演示 直接删除所有容器，，，

![image-20200523151622740](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MTYyMjc0MC5wbmc?x-oss-process=image/format,png)

3.创建新的容器实例 将其数据目录配置目录 与之前Mysql 容器绑定 并指点端口6888

![image-20200523152217924](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MjIxNzkyNC5wbmc?x-oss-process=image/format,png)

1. navicat 链接 查看数据

![image-20200523152355314](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MjM1NTMxNC5wbmc?x-oss-process=image/format,png)

发现数据还是回来了 ----**那么至少证明了 删除整个容器 做不到 删库 更别说跑路了，，，，，，**

![image-20200523152428989](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1MjQyODk4OS5wbmc?x-oss-process=image/format,png)

复制2小标题的总结， 特别特别需要注意以及牢记

容器内新建 删除 修改文件：宿主机外部挂载的目录 同步！！！！要是真有人搞事 删除了 容器内部中挂载目录下的数据 那真的是要删库跑路了。
容器整个删除:宿主机外部挂载的目录不会同步！！！！

### （三）数据卷挂载 之 匿名挂载,具名挂载 ,指定路径挂载

我们上方用的 -v 宿主机路径:容器内路径 那么这种 很明显 是**指定路径挂载**了 **其明确的指定了 容器的目录 挂载到了宿主机的哪个位置**

首先 我们可以查看 所有挂载卷列表

```
docker volume ls
1
```

![image-20200523155518180](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1NTUxODE4MC5wbmc?x-oss-process=image/format,png)

像目前此列表 展示出的所有卷 都是**匿名挂载** ------- **一串唯一且随机的编码 直观上看 不知道其具体的名字 以及挂载到宿主机上的路径**

我们来使用命令来匿名挂载一个容器 — 使用 -v 参数的时候 仅仅指定 容器内部挂载路径 不指定外部 这种命令挂载的卷 都是匿名挂载

```
# -v 后 未指定宿主机路径以及挂载名
docker run -d -v /data redis
12
```

![image-20200523155855175](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE1NTg1NTE3NS5wbmc?x-oss-process=image/format,png)

**具名挂载** ---- **即在容器与宿主机进行挂载的时候指定一个名字**

咱来用命令 试一试

```
#-v 参数后 指点挂载的卷名:/容器内路径
docker run -d -v names:/data --name jumingguazai  redis
12
```

![image-20200523160546785](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE2MDU0Njc4NS5wbmc?x-oss-process=image/format,png)

**那么 怎么查看卷所在的宿主机位置呢？**

```
docker volume inspect 卷名
1
```

![image-20200523161100766](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE2MTEwMDc2Ni5wbmc?x-oss-process=image/format,png)

**我们在挂载的时候 如果未指定目录 其都会挂载到 默认目录 /var/lib/docker/volumes/ 下**

![image-20200523161330635](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzE2MTMzMDYzNS5wbmc?x-oss-process=image/format,png)

在官网 查看 挂载的 时候 发现 挂载 路径后 还可以添加 **:ro** 或者 **:rw** 其实这两个 代表中数据卷 在容器目录中的操作权限

**ro: read only 尽可读** 容器中 不能在 数据卷挂载目录 进行写入 仅可在宿主机上操作

**rw：read write 可读可写 ** 宿主机 容器中 均可操作 数据卷挂载所在目录

使用示例

```
docker run -d -v /docker/redis:/data:rw  --name redisrotest  redis
1
```

我们挂载的时候 不写 其实默认的是使用了 rw 权限 可读 可写

### （四）容器间 数据共享 （同步）

我们前边已经使用 -v 指定路径挂载使容器与宿主机之间进行了数据同步，现在呢开始学习 容器与容器之间使用数据卷进行数据同步

接着使用之前的容器

![image-20200523204449264](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzIwNDQ0OTI2NC5wbmc?x-oss-process=image/format,png)查看容器详细信息

```
docker inspect 容器Id/容器别名
1
```

![image-20200523204637112](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzIwNDYzNzExMi5wbmc?x-oss-process=image/format,png)

发现容器内部的 /data 与宿主机的/docker/redis 挂载的

容器之间 使用数据卷挂载命令 --volumes-from 要挂载容器ID

```
docker run -it --name redis02 --volumes-from redisrotest redis /bin/bash
1
```

![image-20200523210112386](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzIxMDExMjM4Ni5wbmc?x-oss-process=image/format,png)

这个时候 容器一 就相当于是 容器二的父容器

我们还可以再创建一个容器redis03 使其成为容器二的子级容器

```
docker run -it --volumes-from redis02 --name redis03 redis /bin/bash
1
```

![image-20200523215539586](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzIxNTUzOTU4Ni5wbmc?x-oss-process=image/format,png)

几幅图 可以看出 我创建了 redisrotest (容器一) 然后 通过redis 镜像 构建容器二（redis02） 并使用 --volumes-from 绑定到容器一 那么此时 redisrotest 则为 redis02的父级容器 由于数据卷的缘故 他们数据是相互同步的，且同步到宿主机 ，然后呢我又创建了一个容器三（redis03）使redis02 成为其子级 那么 三个容器间 与宿主机则相互串起来了了 数据达到了同步到效果

即：

![image-20200523220910880](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9sZWlsZWlkZXYub3NzLWNuLWNoZW5nZHUuYWxpeXVuY3MuY29tL2ltZy9pbWFnZS0yMDIwMDUyMzIyMDkxMDg4MC5wbmc?x-oss-process=image/format,png)
那么 到了这里 数据卷 容器间 数据卷使用 就结束了 明天开始冲击学习 dockerfile!!!

docker文件分层与数据挂载

## 主实例搭建

- **运行mysql主实例：**



```shell
docker run -p 3306:3306 --name mysql-master \
-v /var/mysql-cluster/mysql-master/log:/var/log/mysql \
-v /var/mysql-cluster/mysql-master/data:/var/lib/mysql \
-v /var/mysql-cluster/mysql-master/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root  \
--restart=always  \
-d mysql:5.7.30

```

- **在mysql的配置文件夹`/var/mysql-cluster/mysql-master/conf`中创建一个配置文件`my.cnf`：** 

```shell
cd /var/mysql-cluster/mysql-master/conf
touch my.cnf

```

- **修改配置文件my.cnf，配置信息如下：**

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

```

- **修改完配置后重启实例：**

```shell
docker restart mysql-master

```

- **进入`mysql-master`容器中：**

```shell
docker exec -it mysql-master /bin/bash

```

- **在容器中使用mysql的登录命令连接到客户端：**

```shell
mysql -uroot -proot

```

- **创建数据同步用户：**

```shell
# 创建账号
CREATE USER 'slave'@'%' IDENTIFIED BY '123456';

# 赋予权限
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';

```

## 从实例搭建

- **运行mysql从实例：**

```shell
docker run -p 3307:3306 --name mysql-slave \
-v /var/mysql-cluster/mysql-slav/log:/var/log/mysql \
-v /var/mysql-cluster/mysql-slave/data:/var/lib/mysql \
-v /var/mysql-cluster/mysql-slave/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root  \
--restart=always  \
-d mysql:5.7.30

```

- **在mysql的配置文件夹`/var/mysql-cluster/mysql-slave/conf`中创建一个配置文件`my.cnf`：**

```shell
touch my.cnf

```

- **修改配置文件my.cnf：**

```properties
[mysqld]
## 设置server_id，同一局域网中需要唯一，且要设置的比master中的server_id要大
server_id=102
## 通过过滤数据库（忽略同步的库 可多个）
binlog-ignore-db=mysql
## 开启二进制日志功能，以备Slave作为其它数据库实例的Master时使用，用 mysql-slave1-bin 作为Binlog日志前缀 
log-bin=mysql-slave1-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=10M
## 设置使用的二进制日志格式（mixed,statement,row)，row表示按行读取，后续可提供第三方Binlog读取工具使用，如canal
binlog_format=row
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
## relay_log配置中继日志
relay_log=mysql-relay-bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
## slave设置为只读（具有super权限的用户除外）
read_only=1

```

- **修改完配置后重启实例：**

```shell
docker restart mysql-slave

```

## 主从库连接

- **首先连接到主数据库的mysql客户端，查看主数据库状态：**

```shell
docker exec -it mysql-master /bin/bash
mysql -uroot -proot
show master status;

```

- **主数据库状态显示如下：**

![image-20210916220043432](https://leileidev.oss-cn-chengdu.aliyuncs.com/img/image-20210916220043432.png)

- **然后进入`mysql-slave`容器中：**

```shell
docker exec -it mysql-slave /bin/bash

```

- **在容器中使用mysql的登录命令连接到客户端：**

```shell
mysql -uroot -proot

```

- **在从数据库中配置主从复制：**

```shell
change master to master_host='172.17.0.8', master_user='slave', master_password='123456', master_port=3306, master_log_file='mysql-bin.000001', master_log_pos=617, master_connect_retry=30;

```

![image-20210915231939809](https://img-blog.csdnimg.cn/img_convert/c641367925775c5576f0581da2a67e8d.png)

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

```shell
show slave status \G;

```

![image-20210916220318026](https://leileidev.oss-cn-chengdu.aliyuncs.com/img/image-20210916220318026.png)

**觉得查看不方便也可以直接连接slave从库，使用navicat执行该命令**

- **从数据库状态显示如下：**

![image-20210916220540328](https://img-blog.csdnimg.cn/img_convert/fb0450f2a61bf0ac5a026ca20fd98973.png)

- **开启主从同步：**

在从库执行下边命令

```shell
start slave;

```

- 查看从数据库状态发现已经同步：

![image-20210916220628216](https://img-blog.csdnimg.cn/img_convert/bab47e135ca718d603db406b72343497.png)

## 主从复制测试

> 主库做的DML 、DDL操作已被从库捕获到且进行了复制操作！主从同步完成！

![image-20210916220734220](https://img-blog.csdnimg.cn/img_convert/fe82ea97383d06373d889ca49e0444a5.png)

docker搭建MySQL主从

# docker

## 一、docker安装



##### 1、下载源码包

```shell
#从网络上下载docker源码包，自己有的可以使用自己的
wget https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/static/stable/x86_64/docker-18.09.0.tgz  --no-check-certificate

```

##### 2、安装

```shell
tar xf docker-18.09.0.tgz
cp docker/* /usr/bin/
#解压缩docker安装包   拷贝命令到/usr/bin下
```

##### 3、为docker注册server服务

```shell
vim /etc/systemd/system/docker.service
#内容如下
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target
  
[Service]
Type=notify
ExecStart=/usr/bin/dockerd -g /opt/docker  
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s
  
[Install]
WantedBy=multi-user.target

```

##### 4、启动docker

```shell
systemctl start docker
```



## 二、[docker命令](https://m.php.cn/manual/view/35997.html#)



```shell
docker images	#统计本地镜像
docker ps 		#查看运行中的进程
docker rename oldname newname     #更改已运行容器名
docker stop name/id		#停止一个正在运行的容器
docker rm -f nginx_02  #删除运行中/运行过的容器nginx_02

```



```shell
docker volume ls	# 查看所有volume的情况
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
docker volume inspect juming-nginx
# 通过-v 卷名：容器内的路径
# 查看一下这个卷

docker volume inspect juming-nginx
[
  {
      "CreatedAt": "2020-08-12T18:15:21+08:00",
      "Driver": "local",
      "Labels": null,
      "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
      "Name": "juming-nginx",
      "Options": null,
      "Scope": "local"
  }
]
#路径为/var/lib/docker/volumes/juming-nginx/_dat

```

所有docker容器内的卷，没有指定目录的情况下都是在`/var/lib/docker/volumes/xxxxx/_data`

我们通过具名挂载可以方便的找到我们的一个卷，大多数情况下使用的是`具名挂载`

```shell
# 如何确定是具名挂载还是匿名挂载，还是指定路径挂载！
-v  容器内路径                   # 匿名挂载
-v  卷名:容器内路径               # 具名挂载
-v /主机路径:容器内路径            # 指定路径挂载
```

拓展

```shell
# 通过 -v 容器内容路径 ro rw 改变读写权限
ro  readonly    # 只读
rw  readwrite   # 可读可写

docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

# ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内容无法操作
```



## 三、B站大紧博主 docker命令

```shell
1、搜索镜像
docker search hello-world

2、下载镜像
docker pull hello-world

3、查看本地所有镜像
docker images

4、查看镜像历史
docker history hello-world

5、将hello-world:latest镜像备份为hello:V2.0
docker tag 旧镜像名:版本号 备份后镜像名:版本号

6、删除镜像
docker rmi hello:V2.0

7、清除未被使用的镜像
docker images prune

8、导出镜像
docker save -o /导出路径/镜像名:版本号 源镜像
例：docker save -o /root/hello:123.tar.gz hello-world:latest

9、导入镜像
docker load -i 本地镜像路径
例：docker load -i /root/hello\:123.tar.gz
或者
docker import 本地镜像路径 docker镜像名:版本号
例：docker import /root/hello\:123.tar.gz hello:1.1

10、查看所有容器
docker ps -a

11、查看所有容器的容器编号(ID号)
docker ps -aq
查看所有正在运行的容器编号
docker ps -q

12、守护进程启动容器/后台启动容器
docker run -dit --name 容器名 镜像名:版本号
例：docker run -dit --name nginx_01 nginx:latest

13、启动容器
docker start 容器名/ID
例：docker start nginx_01

14、停止容器
docker stop 容器名/ID
例：docker stop nginx_01

15、重启容器
docker restart 容器名/ID
例：docker restart nginx_01

16、删除容器
docker rm -f 容器名/ID
例：docker rm -f nginx_01

17、批量删除正在运行的容器
docker rm -f $(docker ps -q)

批量删除未运行的容器
docker rm -f $(docker ps -a | grep Exited | awk '{print $1}')

批量删除所有容器
docker rm -f $(docker ps -aq)

18、创建容器并进入
docker run -it --name 容器名 镜像名:版本号 /bin/bash
例：docker run -it --name nginx_02 nginx:latest /bin/bash

19、进入正在运行的容器
docker exec -it 容器名/ID /bin/bash
例：docker exec -it nginx_02 /bin/bash
或
docker attach 容器名/ID

20、通过容器创建自定义镜像
-a :提交的镜像作者；
-c :使用Dockerfile指令来创建镜像；
-m :提交时的说明文字；
-p :在commit时，将容器暂停。
docker commit -m '说明文字' -a "发布者信息" -p 容器名/ID 生成的镜像名:版本
例：docker commit -m 'hhh' nginx_02 nginx:V1.2.3

21、查看`镜像`全部信息
docker image inspect 镜像名
例：docker image inspect nginx:latest

22、查看`容器`全部信息
docker inspect 容器名/ID
例：docker inspect nginx_01

23、给镜像打标签
docker tag 源镜像名:版本号 标签后镜像名
例：docker tag nginx:latest 192.168.2.60:9999/nginx

24、上传镜像
docker push 带标签的镜像名
例：docker push 192.168.2.60:9999/nginx



```



## 四、创建私有仓库

1、下载镜像

```shell
docker pull registry		#首先拉取仓库镜像
```

2、配置私有仓库 `/etc/docker/daemin.json` 

![](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/202206141510037.jpeg)

```shell
"insecure-registries": ["192.168.2.60:3333"], #添加此段，“，”不可少，ip是本机IP地址
systemctl daemon-reload
systemctl restart docker.service
#registry使用的是5000端口与外部交流的，所以要映射容器内5000端口
```

3、创建容器启动镜像

```shell
docker run -dit --name 容器名  -p 3333:5000 registry 
```

4、镜像上传下载

```shell
#打标签  
docker tag nginx:latest 192.168.59.111:5000/nginx
`私有容器的名字必须是IP:端口的格式`
#上传
docker push 192.168.2.60:3333/nginx

#获取registry的镜像仓库中的镜像信息
curl -XGET http://192.168.2.60:3333/v2/_catalog

#下载
docker pull 192.168.2.60:3333/nginx
```

## 创建共有仓库



## 五、数据卷

1、数据卷的作用

```python
可以将宿主机中的数据和容器中的数据共享

```

2、创建过程

* 1、先创建要映射的目录
* 2、创建容器，和宿主机目录文件进行映射

```shell
docker run -dit --name nginx_01 -p 1234:80 -v /nginx/html:/usr/share/nginx/html nginx:latest
```



## 六、数据卷volumes

1、数据卷增删改查

```python
docker volume create 卷名 #创建数据卷
docker volume inspect 卷名  #查看数据卷详情信息
docker volume ls			#查看所有数据卷
docker volume rm 卷名		#删除数据卷
docker volume prune		 #删除所有未使用的卷
```



2、[补充命令](https://blog.csdn.net/zhanremo3062/article/details/120860327)

```shell
[root@localhost ~]# docker system df
TYPE           TOTAL    ACTIVE       SIZE         RECLAIMABLE
Images           10        6    
2.652GB         1.953GB (73%)
Containers        6        6        6.922MB         0B (0%)
Local Volumes     0        0          0B            0B

```

```shell
#docker system prune
#如果之前的命令展示出 docker 已经占用了太多空间，我们会开始清理。有一个包办一切的命令：
[root@localhost ~]# docker system prune
WARNING! This will remove:
    - all stopped containers # 清理停止的容器
    - all networks not used by at least one container #清理没有使用的网络
    - all dangling images #清理废弃的镜像
    - all build cache #清理构建缓存
Are you sure you want to continue? [y/N] y
Total reclaimed space: 0B

```

```shell
清理none镜像(虚悬镜像)
命令: docker image prune
默认情况下，docker image prune 命令只会清理 虚无镜像（没被标记且没被其它任何镜像引用的镜像）

root@instance-o70no2nw:~# docker image prune
WARNING! This will remove all dangling images.
Are you sure you want to continue? [y/N] y
Total reclaimed space: 0B

清理无容器使用的镜像
命令: docker image prune -a
```



## 七、端口映射使用

创建docker容器的时候分配ip和端口

```shell
docker run -dit --name nginx_03 -P nginx:latest
#创建一个名为nginx_03的容器随机分配端口映射到nginx服务的默认端口

docker run -dit --name nginx_04 -p 2222:80 nginx:latest
#创建一个名为nginx_04的容器，分配宿主机的2222端口映射到80端口

docker run -dit --name nginx_5 -p 172.11.11.22:3333:80 nginx:latest
#指定IP和端口映射到镜像

-P(大写)：随机分配端口
-p(小写)：手动分配端口
```

## 八、网络模式

创建容器并指定使用哪一个网卡

```shell
#创建容器指定和主机使用同一个网卡
docker run -dit --name nginx_01 --network=host nginx:latest
```

```shell
#创建一个容器指定内部使用一个网卡，bridge网卡
docker run -dit --name nginx_02 --network=bridge nginxL:latest
```

```python
bridge网卡：桥接模式，只要使用桥接模式创建的容器，网段都是一样的
```



## 九、network的使用

1、查看系统中的网络模式

```shell
docker network ls		#查看系统中的网络模式

```

2、创建新的网络模式

```shell
docker network create XXX   #创建网络网络模式

docker network create --driver bridge my_bridge  #基于现有的网络模式创建
```

3、通过网络模式断开其中某个容器的网络

```shell
docker network disconnect bridge nginx_01	#断开nginx_01的网络连接
```

4、通过网络模式连接其中断开连接的容器的网络

```shell
docker network connect bridge nginx_01		#连接上nginx_01容器的网络连接
```

5、删除网络模式

```shell
docker network rm my_bridge		#删除我创建的my_bridge网络
```

--------------------------------------------------------------------------
**20230310更新**

docker修改默认镜像和容器的存储位置

**方法一、**

`Docker 默认的位置在/var/lib/docker,当前所有的镜像、容器都存储在这儿。如果你有任何在运行的容器，停止这些容器，并确保没有容器在运行，然后运行以下命令，确定当前Docker使用的存储驱动`

sudo docker info
在输出的信息中，查找Storage Driver那行，并记下：
```shell
Storage Driver: overlay2
```

docker存储根目录：
```shell
Docker Root Dir: /var/lib/docker
```

关闭docker服务：
```shell
sudo systemctl stop docker.service
```
创建一个新的文件夹作为docker镜像新的存储位置，记下这个文件夹的路径:
```shell
sudo mkdir -p /data/docker
```
编辑docker配置文件：

```shell
sudo vim /etc/systemd/system/multi-user.target.wants/docker.service
# 将ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock修改以下内容：
ExecStart=/usr/bin/dockerd --graph=/data/docker --storage-driver=overlay2
```
开启docker来更新配置：
```shell
sudo systemctl daemon-reload
sudo systemctl start docker
```

**方法二、**

使用软链接不需要修改配置文件

将原来的/var/lib/docker/ 目录 移动到 新的目录 我这里新目录是 /data/
```shell
#停服务
systemctl stop docker.server

#移动目录
mv /var/lib/docker/ /data/

#创建软连接
ln -s /data/docker/ /var/lib/
```

docker基础

### 修改网卡名称



* [ ] 首先进入打开==/etc/default/grub==文件

```shell
vim /etc/default/grup
#在 GRUB_CMDLINE_LINUX 这一项中后面添加 net.ifnames=0 biosdevname=0
# 原始内容> GRUB_CMDLINE_LINUX="crashkernel=auto rd.lvm.lv=centos/root rd.lvm.lv=centos/swap rhgb quiet"
新内容> GRUB_CMDLINE_LINUX="crashkernel=auto rd.lvm.lv=centos/root rd.lvm.lv=centos/swap net.ifnames=0 biosdevname=0 rhgb quiet"
```

* [ ] 执行查看网卡命令查看网卡的MAC地址并记录

```shell
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback `00:00:00:00:00:00` brd 00:00:00:00:00:00
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT group default qlen 1000
    link/ether `00:0c:29:1f:25:8b` brd ff:ff:ff:ff:ff:ff
3: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT group default qlen 1000
    link/ether `00:0c:29:1f:25:9f` brd ff:ff:ff:ff:ff:
```

* [ ] 新建网卡命名规则文件

```shell
vim /etc/udev/rules.d/70-persistent-net.rules
# 写入以下内容，需要修改的参数是 ATTR{address} 和 NAME
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:0c:29:1f:25:9f", ATTR{type}=="1", KERNEL=="eth*", NAME="ens34"
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:0c:29:1f:25:8b", ATTR{type}=="1", KERNEL=="eth*", NAME="ens33"
```

* [ ] 添加/修改网卡配置文件

```shell
# vim /etc/sysconfig/network-scripts/ifcfg-ens34
TYPE="Ethernet"
BOOTPROTO="dhcp"
DEFROUTE="yes"
NAME="ens34"
DEVICE="ens34"
ONBOOT="yes"
```

* [ ] 更新 GRUB 配置文件，重启生效

```shell
`grub2-mkconfig -o /boot/grub2/grub.cfg
`reboot
```

linux修改网卡名

# 在win上部署gitlab使python自动上传





### 1、首先安装gitlab软件

略

### 2、在python设置git软件

**打开python的设置  安装好后python会自动检测到   如果检测不到就手动写git.exe的路径**   
![image-20220709173613802](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/202207091736882.png)



**配置gitlab地址与克隆到本地的目录**   
![image-20220709174051315](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/202207091740377.png)



**克隆成功**   
![image-20220709174230001](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/202207091742091.png)



**模拟修改代码，提交代码    （这里只会识别修改过的来提交）**    
![image-20220709174327715](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/202207091743806.png)



**gitlab这边已经发生了改变**   
![image-20220709174623403](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/202207091746430.png)

**网页大概十来秒也发生了改变   还是要视机器性能和网速**   
![image-20220709174732813](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/202207091747836.png)

Docker学习之路（三） docker 文件 分层理解 数据卷 数据同步

主实例搭建

docker

一、docker安装

修改网卡名称

在win上部署gitlab使python自动上传

Docker学习之路（三） docker 文件分层理解数据卷数据同步