Docker入门

# Docker简介

Docker 是一个开源的应用容器引擎，基于Go语言并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

# 应用场景

Web 应用的自动化打包和发布。
自动化测试和持续集成、发布。
在服务型环境中部署和调整数据库或其他的后台应用。
从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

# 优点

# Docker安装

# 基本组成

镜像（Image）：就相当于是一个模板。通过这个模板（镜像）可以创建多个容器。
容器（Container）：容器可以被创建、启动、停止、删除、暂停等。可以理解为一个简易的Linux系统
仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像。

# 安装

环境准备

CentOS
系统内核 3.10 以上

[root@localhost ~]$ uname -r
3.10.0-1127.19.1.el7.x86_64
[root@localhost ~]$ cat /etc/os-release 
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

安装

卸载旧版本(建议切换到root账户进行操作)

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

1
2
3
4
5
6
7
8

需要的安装包
```
yum install -y yum-utils
```
1

设置镜像的仓库为阿里云的

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

更新yum软件包索引
```
yum makecache fast
```
1
安装docker，这里安装docker-ce社区版,-ee为企业版
```
yum install docker-ce docker-ce-cli containerd.io
```
1

启动docker

systemctl start docker
systemctl start docker.service
# service docker restart 重启
# service docker stop 停止
# systemctl enable docker.service 设置开机自启

1
2
3
4
5

查看是否安装
```
docker version
```
1
通过运行hello-world 映像来验证是否正确安装了Docker Engine
```
docker run hello-world
```
1
输入此命令是会先在本地查找是否有hello-world镜像，如果没有就去远程公共仓库下载测试镜像并在容器中运行它。容器运行时，它会打印参考消息并退出

阿里云centos8需要安装依赖：

yum install https://download.docker.com/linux/fedora/30/x86_64/stable/Packages/containerd.io-1.2.6-3.3.fc30.x86_64.rpm

卸载

卸载依赖

yum remove docker-ce docker-ce-cli containerd.io

删除资源

rm -rf /var/lib/docker  #docker 的默认工作路径

# 镜像加速

使用阿里云镜像加速器。阿里云文档 (opens new window)

打开阿里云控制台,选择容器服务
找到容器镜像服务
将操作文档的命令输入到你的机器上

或者网易加速源

vim /etc/docker/daemon.json 编辑配置文件

加入镜像源地址

{
"registry-mirrors": ["http://hub-mirror.c.163.com"] 
}

1
2
3

重启

systemctl daemon-reload
systemctl restart docker.service

1
2

# Docker 常用命令

# 帮助命令

docker version		# 显示docker的版本信息
docker info				# 显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help		# 帮助命令

1
2
3

# 镜像命令

# 查看本地主机上所有的镜像

# 命令
docker images
# 演示
[root@localhost ~]$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        9 months ago        13.3kB
# 镜像的仓库源				标签									id									创建时间						大小

1
2
3
4
5
6
7

# 列出可选项

docker images --help

-a , --all			# 列出所有镜像
-q ， --quiet	 # 只显示镜像的id

1
2
3
4

# 搜索镜像

# 命令
docker serach [镜像名]
# 演示
[root@localhost centos]$ docker search mysql
NAME        DESCRIPTION                   							STARS 		OFFICIAL     		AUTO
MATED
mysql       MySQL is a widely used, open-source relation…   10021       [OK]                
mariadb     MariaDB is a community-developed fork of MyS…   3673        [OK]                
mysql/mysql-server  Optimized MySQL Server Docker images.…    735         			 			[OK]           
# 可选项，通过收藏量来过滤
[root@localhost centos]$ docker search mysql --filter=STARS=3000
NAME        DESCRIPTION                                     STARS      OFFICIAL    AUTOMATED
mysql       MySQL is a widely used, open-source relation…   10021   		[OK]                
mariadb     MariaDB is a community-developed fork of MyS…   3673    		[OK]  
# 搜索出来的镜像是STARS大于3000的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 下载镜像

# 命令
docker pull 镜像名[:tag]
# 演示
[root@localhost centos]$ docker pull mysql
Using default tag: latest		# 如果不写tag，默认是 latest
latest: Pulling from library/mysql
d121f8d1c412: Pull complete 	# 分层下载，docker image的核心 联合文件系统
f3cebc0b4691: Pull complete 
....
Digest: sha256:e1bfe11693ed2052cb3b4e5fa356c65381129e87e38551c6cd6ec532ebe0e808	# 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest	# 真实地址 相当于 docker pull docker.io/library/mysql:latest

# 指定版本下载,只能下载仓库中所存在的版本镜像
[root@localhost centos]$ docker pull mysql:5.7
5.7: Pulling from library/mysql
d121f8d1c412: Already exists 		# 可以看出，分层下载的优势，不同版本镜像公用的内容不会重新下载
f3cebc0b4691: Already exists 
...
277d8f888368: Pull complete 
21f2da6feb67: Pull complete 
....

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 删除镜像

docker rmi -f 镜像id 										# 删除指定镜像
docker rmi -f 镜像id 镜像id 镜像id			 # 删除多个
docker rmi -f $(docker images -aq) 	 	 # 删除全部

1
2
3

# 容器命令

说明：我们有了镜像才可以创建容器，下载一个centos镜像来测试学习

# 命令
docker pull centos

1
2

# 新建容器并启动

# 命令
docker run [可选参数] image

# 参数说明
--name="Name"  容器的名字 Tomcat1 Tomcat2 用来区分容器
-d      			 后台方式运行
-it						 使用交互方式运行，进入容器内查看
-p						 指定容器的端口 -p 8080:8080
		-p ip:主机端口:容器端口
		-p 主机端口:容器端口 （常用）
		-p 容器端口   （没有对外开放端口）
		端口
-P   				（大写P）随机指定端口

1
2
3
4
5
6
7
8
9
10
11
12
13

# 列出所有运行的容器

docker ps 命令
			# 列出当前正在运行的容器
-a		# 列出当前正在运行的容器+历史运行过的容器
-n=？ # 显示前n个最近创建的容器		
-q		# 只显示容器的编号

1
2
3
4
5

# 进入当前正在运行的容器

# 方式一
docker exec -it 容器id (/bin/bash | bash | sh)
# 测试
[root@localhost centos]$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
1584c3c7dd84        centos              "/bin/bash"         31 minutes ago      Up 12 minutes                           centos1
[root@localhost centos]$ docker exec -it 1584c3c7dd84 /bin/bash
[root@1584c3c7dd84 /]$ ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@1584c3c7dd84 /]$ ps -ef
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 04:13 pts/0    00:00:00 /bin/bash
root         14      0  0 04:26 pts/1    00:00:00 /bin/bash
root         28     14  0 04:26 pts/1    00:00:00 ps -ef

# 方式二
docker attach 容器id
# 测试
[root@localhost centos]$ docker attach 1584c3c7dd84
[root@1584c3c7dd84 /]$ 
正在执行当前的代码...

# 区别
# docker exec 	进入容器后开启一个新的终端，可以在里面操作(常用)
# docker attach 进入容器正在执行的终端，不会启动新的进程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 退出容器

exit		# 直接退出
Ctrl + P + Q  #容器不停止退出

1
2

# 删除容器

docker rm 容器id						# 删除指定容器，不能删除在运行的容器，除非强制删除 rm -f
docker rm -f $(docker ps -aq)		# 删除所有容器
docker ps -a -q | xargs docker rm 	# 删除所有容器

1
2
3

# 启动和停止容器

docker start 容器id										# 启动容器 (注意是容器id，不是镜像id)
docker restart 容器id									# 重启容器
docker stop 容器id										# 停止当前正在运行的容器
docker kill 容器id										# 强制停止当前容器

1
2
3
4

# 常用其他命令

# 后台启动容器

# 命令
docker run -d 镜像名
# 演示
[root@localhost centos]$ docker run -d centos
[root@localhost centos]$ docker ps
# 此时docker ps，发现centos 停止了
# 原因：docker容器使用后台运行，就必须要要一个前台进程，docker发现没有应用就会自动停止
# 例如：nginx容器启动后，发现自己没有提供服务就会立刻停止，就是没有程序了

1
2
3
4
5
6
7
8

# 查看日志

# 命令
docker logs -f -t --tail number 容器id

# 可选项
-tf							# 显示日志
--tail number		# 要显示的日志条数

1
2
3
4
5
6

# 查看容器中进程信息

# 命令
docker top 容器id
# 演示
[root@localhost centos]$ docker top 1584c3c7dd84
UID     PID     PPID     C    STIME       TTY        TIME        CMD
root    29802   29785    0    12:13       pts/0      00:00:00    /bin/bash

1
2
3
4
5
6

# 查看镜像的元数据

# 命令
docker inspect 容器id
# 演示
[root@localhost centos]$ docker inspect 1584c3c7dd84
[
    {
        "Id": "1584c3c7dd84731d6eef626544e511df6799d5dc859e83b0af3a5d5667d500d5",
        "Created": "2020-10-06T03:54:00.008738938Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 29802,
.........

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 从容器内拷贝文件到主机

# 命令
docker cp 容器id:容器内路径  目的主机路径
# 演示
# 查看当前目录文件
[root@localhost Downloads]$ ls
1.txt
[root@localhost Downloads]$ docker ps
CONTAINER ID    IMAGE   COMMAND         CREATED          STATUS      PORTS        NAMES
1584c3c7dd84    centos  "/bin/bash"     40 minutes ago    Up 				21 minutes 

# 进入docker容器内部
[root@localhost Downloads]$ docker exec -it 1584c3c7dd84 /bin/bash
[root@1584c3c7dd84 /]$ ls  
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

# home目录下创建2.txt文件并拷贝到主机上
[root@1584c3c7dd84 /]$ cd /home
[root@1584c3c7dd84 home]$ ls
[root@1584c3c7dd84 home]$ touch 2.txt
[root@1584c3c7dd84 home]$ ls
2.txt
[root@1584c3c7dd84 home]$ exit
exit
[root@localhost Downloads]$ docker cp 1584c3c7dd84:/home/2.txt /home/centos/Downloads
[root@localhost Downloads]$ ls
1.txt  2.txt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 小结

docker stats		# 查看cpu状态
docker network  # 查看docke网络

1
2

# 练习

# Docker 安装Nginx

# 1. 搜索镜像
docker search nginx
# 2. 下载镜像
docker pull nginx
# 3. 运行测试
docker run -d --name nginx01 -p 3344:80 nginx
# 4. 访问端口
curl localhost:3344 
# 出现网页内容即成功，外网访问先检查防火墙和安全组设置是否把对于端口打开。

1
2
3
4
5
6
7
8
9

# Docker 安装Tomcat

# 1. 官方的使用,一般用来测试，用完就删
docker run -it --rm tomcat:9.0

# 2. 下载 
docker pull tomcat:9.0
# 3. 启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat
# 4. 测试访问，可能出现404 ，原因是镜像默认是最小运行环境，webapps没有东西。
# 进入容器
[root@localhost Downloads]$ docker exec -it tomcat01 /bin/bash
root@c72f33a3eec6:/usr/local/tomcat# ls
BUILDING.txt     LICENSE  0.README.md      RUNNING.txt  conf  logs            temp     webapps.dist
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin          lib   native-jni-lib  webapps  work
root@c72f33a3eec6:/usr/local/tomcat# cd webapps
root@c72f33a3eec6:/usr/local/tomcat/webapps# ls
root@c72f33a3eec6:/usr/local/tomcat/webapps#																
# 发现没有东西,然后将webapps.dist下的默认网页复制到webapps中
root@c72f33a3eec6:/usr/local/tomcat/webapps# cp ../webapps.dist/* -r ./
root@c72f33a3eec6:/usr/local/tomcat/webapps# 
root@c72f33a3eec6:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager

# 最后访问成功出现Tomcat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

思考：修改项目每次都要进入容器，十分麻烦。是否可以提供一个映射路径到容器外部，在外部放置项目就自动同步到内部？

# 部署es+kibana

# es 暴露的端口很多
# es 十分耗内存 1.xG
# es 的数据一般需要放置到安全目录！挂载
# --net somenetwork？ 网络配置

# 1. 启动 elasticsearch
# 注意： 需要设置es启动的内存限制，否则会卡死。除非物理机配置好
docker run -d --name elasticsearch01 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
# 2. 测试es是否成功
curl localhost:9200

1
2
3
4
5
6
7
8
9
10

# 可视化面版

portainer（先用这个）
Rancher（CI/CD 再用）

什么是portainer？

Docker图形化界面管理工具！提供一个后台面板供我们操作！

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

1
2

测试 ip:8088,进去之后就可以进行相关的操作了

一般不会用！

# Docker 镜像

# 镜像是什么

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

所有的应用，直接打包docker镜像，就可以直接跑起来 !

# 镜像加载原理

unionrs（联合文件系统）

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

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

Docke镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS.

bootfs (boot fie ystem） 主要包含bootloader和kernel，bootloader主要是引导加载kernel，LInux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Uni系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs（rot filesystem），在bootfs之上。包含的就是典型Linux系统中的/dev，/proc，/bin，/etc等标准目录和文件。rots就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。平时我们安装进虚拟机的CentOS都是好几个G，而Docker这里才200M

对于一个精简的OS，rootfs可以很小，只需要包含最基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版boots基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs。

# 分层的理解

分层的镜像

我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层一层的在下载

[root@localhost centos]$ docker pull mysql
Using default tag: latest		# 如果不写tag，默认是 latest
latest: Pulling from library/mysql
d121f8d1c412: Pull complete 	# 分层下载，docker image的核心 联合文件系统
f3cebc0b4691: Pull complete 
1862755a0b37: Pull complete 
489b44f3dbb4: Pull complete 
690874f836db: Pull complete 
.....

1
2
3
4
5
6
7
8
9

思考∶为什么Docker镜像要采用这种分层的结构呢∶

最大的好处，是资源共享了! 比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base 镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。

查看镜像分层的方式可以通过 docker image inspect命令

理解： 所有的Docker 镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。举一个简单的例子，假如基于Ubuntu Linux16.04 创建一个新的镜像，这就是新镜像的第一层;如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像层;如果继续添加一个安全补丁，就会创建第三个镜像层。该镜像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。

下图中举了一个简单的例子：

每个镜像层包含3个文件，而镜像包含了来自两个镜像层的6个文件

上图中的镜像层跟之前图中的略有区别，主要目的是便于展示文件。

下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为上层中的文件7是文件5的一个更新版

这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。Docker通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。

Linux 上可用的存储引擎有AUFS、Overlay2、Device Mper、Brfs以及ZFS。顾名思义，每种存储引擎都基于Linux中对应的文件系统或者块设备技术，并且每种存储引擎都有其独有的性能特点。

Docker在Windows上仅支持windowsfilter 一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和CoW。

下图展示了与系统显示相同的三层镜像。所有镜像层堆叠合并，对外提供统一的视图。

特点

Docker镜像都是只读的，当容器启动时，一个可写层被加载到镜像的顶部!

这一层就是我们通常说的容器层，容器层之下的都叫镜像层!

# Commit 镜像

# 命令
docker commit -m="提交的描述" -a="作者" 容器id 目标镜像名:[TAG]
# 提交容器成为一个新的副本

# 测试
# 1. 启动一个默认的tomcat
# 2. 因为官方镜像默认webapps下面是没有文件的，需要从webapps.dist下拷贝过去
# 3. 将我们操作过的容器通过commit提交为一个镜像!
[root@localhost ~]$ docker commit -m="add webapps" -a="JInterst"  05ee7e31d618 tomcat01:1.0
sha256:97a7217b0fe4cb4473771b7aa0ff81ba793a0a209106bd124528bf046ce07c11
[root@localhost Downloads]$ docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat01              1.0                 97a7217b0fe4        17 seconds ago      652MB

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 容器数据卷

# 什么是容器数据卷

docker的理念回顾

将应用打包成一个镜像！

如果数据都在容器中，那么我们删除容器，数据就会丢失！需求: 数据可以持久化

容器之间可以有一个数据共享的技术! Docker容器中产生的数据，同步到本地！

卷技术！目录的挂载，将我们容器内的目录挂载到Linux上面

# 使用数据卷

方式一：直接使用命令来挂载 -v

# 命令
docker run it -v 主机目录:容器内目录
# 测试 
docker run -it -v /home/test:/home centos /bin/bash
# 启动后，新建连接窗口查看 docker信息
docker inspect 容器id

1
2
3
4
5
6

# 在容器/home下创建文件，主机挂载位置 /home/test 也有这个文件
# 关闭容器，然后再主机修改这个文件内容，容器再次开启也会同步

1
2

好处：以后修改只需要在本地修改即可，容器内会自动同步！

# 实战：安装MySQL

思考： MySQL的数据持久化问题

# 1. 获取镜像
docker pull mysql:5.7
# 运行容器需要做数据挂载, 安装启动mysql需要配置密码！！！
# 官方文档：  docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 相关解释
-d 			后台启动
-p 			端口启动
-v 			卷挂载
-e 			环境配置
--name  容器名字
# 2. 启动命令
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
# 3. 可视化工具连接测试
# 4. 创建一个数据库，查看映射路径是否ok！
# 5. 如果把容器删除，会发现我们挂载到本地的数据卷依旧没有丢失。

这就实现了容器数据持久化功能！！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 具名挂载和匿名挂载

1. 匿名挂载

# 命令
-v 容器内路径
# 测试
[root@localhost ~]$ docker run -d -P --name nginx-testniming -v /etc/nginx nginx
# 查看所有volume(数据卷)的情况
[root@localhost ~]$ docker volume ls
DRIVER              VOLUME NAME
local               2ddf9a6442bd6fce51f0d61450801abb98c29d6a4627c2d1209321bf97e25f02

# 这里发现这种就是匿名挂载，我们在 -v 只写了容器内的路径，没有写容器外的路径！

1
2
3
4
5
6
7
8
9
10

2. 具名挂载

# 命令
-v 卷名:容器内路径
# 测试
[root@localhost ~]$ docker run -d -P --name nginx-testjuming -v juming-nginx:/etc/nginx nginx
e7a90fbb588b139352aaa9090cca4abff35fd23b839faa22c345c63e7c47c489
[root@localhost ~]$ docker volume ls
DRIVER              VOLUME NAME
local               2ddf9a6442bd6fce51f0d61450801abb98c29d6a4627c2d1209321bf97e25f02
local               juming-nginx

# 通过命令查看一下这个卷
[root@localhost ~]$ docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2020-10-07T13:42:48+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

[root@localhost ~]$ cd /var/lib/docker/volumes
[root@localhost volumes]$ ls
2ddf9a6442bd6fce51f0d61450801abb98c29d6a4627c2d1209321bf97e25f02  juming-nginx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

以上测试可以得出：

所有的docker容器内的卷，没有指定目录的情况下多少在/var/lib/docker/volumes/xxxx/_data 也就是docker工作目录的volumes下
我们通常使用具名挂载可以方便的找到我们的一个卷

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

1
2
3
4

拓展：

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

# 一旦这个设置了容器的权限，容器对我们挂载出来的内容就有限定了！
docker run -d -P --name nginx-testjuming-ro -v juming-nginx-ro:/etc/nginx:ro nginx
docker run -d -P --name nginx-testjuming-ro -v juming-nginx-ro:/etc/nginx:rw nginx

#  只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作的！
[root@localhost volumes]$ docker run -d -P --name nginx-testjuming-ro -v juming-nginx-ro:/etc/nginx:ro nginx
8985777c295e5ccd24956dbe0deb1cfdc5963f87cfa09c6c8d1afd8812dd3a6d
[root@localhost volumes]$ docker exec -it 8985777c295e /bin/bash
root@8985777c295e:/# cd /etc/nginx
root@8985777c295e:/etc/nginx# ls
conf.d  fastcgi_params  koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params  uwsgi_params  win-utf
root@8985777c295e:/etc/nginx# touch test-ro.txt
touch: cannot touch 'test-ro.txt': Read-only file system

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 数据卷容器

容器之间的数据共享

多个mysql实现数据共享

docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

docker run -d -p 3311:3306  -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-form mysql01 mysql:5.7

1
2
3

容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。但是一旦你持久化到了本地，这个时候的数据是不会删除的！

# DockerFile

# 初识DockerFile

Dockerfile 就是用来构建docker镜像的构建文件！命令脚本！

通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每个命令多少一层！

# 创建一个dockerfile文件，名字可以随机，建议Dockerfile（build 时默认搜索这个）
# 文件中的内容以 指令（大写）  参数
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "------end--------"
CMD /bin/bash

#这里的每个命令就是镜像的一层

1
2
3
4
5
6
7
8

启动自己写的容器,会发现有我们生产镜像时自动挂载的数据卷目录

这个卷和外部有一个同步的目录

# 命令
docker inspect 容器id

# 找到 Mounts
        "Mounts": [
            {
                "Type": "volume",
                "Name": "177b9ab51fdab933730f14a9341de3b5893050e028dca24f26f0743f0b97b685",
                "Source": "/var/lib/docker/volumes/177b9ab51fdab933730f14a9341de3b5893050e028dca24f26f0743f0b97b685/_data",
                "Destination": "volume01",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "aa14d920ca0e1c0b016793423b2561b8b4bd87407cddcd9fd9194af489c0ff47",
                "Source": "/var/lib/docker/volumes/aa14d920ca0e1c0b016793423b2561b8b4bd87407cddcd9fd9194af489c0ff47/_data",
                "Destination": "volume02",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

然后可以测试一下文件是否同步！（文件是拷贝的）

# 基础知识

镜像构建步骤：
1. 编写一个Dockerfile 文件
2. docker build 构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像（DockerHub、阿里云镜像仓库）
dockerfile基础知识：
1. 每个保留关键字（指令）必须是大写字母
2. 按照从上到下的顺序执行
3. # 表示注释
4. 每一个指令都会提交一个新的镜像层并提交！
回顾

DockerFile:构建文件，定义了一切步骤，源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品！

Docker容器：容器就是镜像运行起来提供服务的

# DockerFile 指令

FROM						# 基础镜像，一切从这里开始构建
MAINTAINER			# 镜像是谁写的，姓名<邮箱>
RUN							# 镜像构建的时候需要运行的命令
ADD							# 创建镜像需要的内容，可以通过url拉取
WORKDIR					# 镜像的工作目录
VOLUME					# 挂载的目录
EXPOSE					# 暴露端口配置
CMD							# 指定这个容器启动的时候需要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT			# 指定这个容器启动的时候需要运行的命令，可以追加命令
ONBUILD					# 当构建一个被继承 DockerFile 这个时候就会运行 ONBUILD 的指令。触发指令
COPY						# 类似ADD ，将我们的文件拷贝到镜像中
ENV							# 构建的时候设置环境变量！

1
2
3
4
5
6
7
8
9
10
11
12

# 实战

# 创建centos镜像

编写Dockerfile的文件

FROM centos
MAINTAINER jinterest<yx@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "---------end-----------"
CMD /bin/bash

1
2
3
4
5
6
7
8
9
10
11
12
13
14

通过这个文件构建镜像

# 命令 注意最后有一个点
docker build -f dockerfile文件路径 -t 镜像名:[tag] .
# 演示
[root@localhost docker-test-build]$ docker build -f /home/docker-test-build/dockerfile -t mycentos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/10 : FROM centos
.....
Successfully built 46329f1b4842
Successfully tagged mycentos:1.0

# 列出本地进行的变更历史
[root@localhost docker-test-build]$ docker history 46329f1b4842
IMAGE               CREATED              CREATED BY                                      SIZE                COMMENT
46329f1b4842        About a minute ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B                  
99cc520c8ece        About a minute ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B                  
7d318c99d7f5        About a minute ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B                  
6a39fbc1f790        About a minute ago   /bin/sh -c #(nop)  EXPOSE 80                    0B                  
b484b409738b        About a minute ago   /bin/sh -c yum -y install net-tools             22.8MB              
3058e49f8ed3        About a minute ago   /bin/sh -c yum -y install vim                   57.3MB              
637e642780c7        About a minute ago   /bin/sh -c #(nop) WORKDIR /usr/local            0B                  
c9b85b2fc51b        About a minute ago   /bin/sh -c #(nop)  ENV MYPATH=/usr/local        0B                  
c3643b28c128        About a minute ago   /bin/sh -c #(nop)  MAINTAINER jinterest<yx@q…   0B                  
0d120b6ccaa8        8 weeks ago          /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B                  
<missing>           8 weeks ago          /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B                  
<missing>           8 weeks ago          /bin/sh -c #(nop) ADD file:538afc0c5c964ce0d…   215MB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Tomcat镜像

准备镜像文件 Tomcat压缩包，jdk压缩包

[root@localhost docker-test-tomcat]$ ls
Dockerfile  jdk-11_linux-x64_bin.tar.gz  readme.txt  tomcat-9.0.38.tar.gz

1
2

编写dockerfile文件,官方命名Dockerfile ，build会自动寻找这个文件，就不需要要-f指定了！

FROM centos
MAINTAINER jinterest<yx@qq.com>

COPY readme.txt /usr/local/readme.txt
ADD jdk-11_linux-x64_bin.tar.gz /usr/local/
ADD tomcat-9.0.38.tar.gz /usr/local
RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk-11
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.38
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.38
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_BASH/bin

EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.38/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.38/bin/logs/catalina.out

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

构建镜像
```
docker build -t diytomcat .
```
1

启动镜像

docker run -d -p 9999:8080 --name divtomcat -v /home/docker-test-tomcat/myweb:/usr/local/apache-tomcat-9.0.38/webapps/myweb -v /home/docker-test-tomcat/tomcatlog/:/usr/local/apache-tomcat-9.0.38/logs diytomcat

访问测试

发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了！）

卷挂载目录下/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                             http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

</web-app>

1
2
3
4
5
6
7
8

卷挂载目录下/index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>hello</title>
</head>
<body>
Hello World!<br/>
<%
System.out.println("666");
%>
</body>
</html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 发布自己的镜像

# DockerHub

地址 https://hub.docker.com/ 注册自己的账号
登录

在我们的服务器上提交自己的镜像

[root@localhost myweb]$ docker login -u 用户名 
Password:

1
2

登录完毕就可以提交镜像了docker push 作者名字/镜像名字:版本号

[root@localhost myweb]$ docker push diytomcat
The push refers to repository [docker.io/library/diytomcat]
20a533853737: Preparing 
5248a8b5c507: Preparing 
1d489b172f07: Preparing 
80f59bc7bc59: Preparing 
291f6e44771a: Preparing 
denied: requested access to the resource is denied # 被拒绝
[root@localhost myweb]$ docker push jinterest/diytomcat:1.0
The push refers to repository [docker.io/jinterest/diytomcat]
An image does not exist locally with the tag: jinterest/diytomcat

# 解决，增加一个tag
[root@localhost myweb]$ docker tag 69cd8018cdd1 jinterest/diytomcat:1.0
# 然后再push就可以了
[root@localhost myweb]$ docker push jinterest/diytomcat:1.0
The push refers to repository [docker.io/jinterest/diytomcat]
20a533853737: Pushing [============>                                      ]  14.58MB/57.26MB
5248a8b5c507: Pushing [==================================================>]  16.15MB
1d489b172f07: Pushing [==>                                                ]  13.33MB/302.4MB
80f59bc7bc59: Pushed 
291f6e44771a: Pushing [=>                                                 ]  5.462MB/215.1MB

# 提交的时候也是按层级提交的 ！！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 阿里云镜像服务

登录阿里云
找到容器镜像服务
创建命名空间
创建容器镜像
按照阿里云文档（很详细）

# 小结

# Docker 网络

# 理解Docker0

测试前先清空所有环境

问题：docker是如何处理容器网络访问的？

[root@localhost ~]$ docker run -d -P --name tomcat01 tomcat

# 查看容器的内部网络地址 ip addr ，发现容器启动的时候会得到一个 eth0@if39 ip地址，docker分配的！
[root@localhost ~]$ docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
38: eth0@if39: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever

1
2
3
4
5
6
7
8
9
10
11
12

思考：linux能不能ping内部？

[root@localhost ~]$ ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.142 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.083 ms
# linux 可以ping通docker容器内部

1
2
3
4
5

原理

我们每启动一个docker容器，docker就会给容器分配一个ip，我们只要安装了docker，就会有一个网卡docker0桥接模式，使用的技术是 veth-pair 技术！
再次ip addr

再启动一个容器测试，会发现又多了一对网卡！

# 我们发现这个容器带来的网卡，都是一对对的
# veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一段连着协议，一段彼此相连
# 正因为有这个特性，veth-pair 充当一个桥梁，连接各种虚拟网络设备的
# OpenStac ， Docker 容器之间的连接 ，osv 的连接，都是使用 veth-pair 技术

1
2
3
4

我们来测试下 tomcat01 和 tomcat02 是否可以ping通！

[root@localhost ~]$ docker exec -it tomcat02 ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.135 ms

# 结论：容器和容器之间是可以互相 ping 通的！

1
2
3
4
5

网络模型图

小结

Docker 使用的是Linux的桥接，宿主机中是一个docker容器的网桥 docker0

docker 中的所有网络接口都是虚拟的。虚拟的转发效率高！（内网传递文件！）

只要删除容器，对应网桥对就没了

# --link

思考一个场景，我们编写了一个微服务，database url=ip∶，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以名字用来进行访问容器?

[root@localhost ~]$ docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known

# 如何可以解决呢?
# 通过--link 既可以解决网络连通问题
[root@localhost ~]$ docker run -d -P --name tomcat03 --link tomcat02 tomcat c4d3b18340f64065dbeb66aad369e74e9966e2a7756978388fbde1fb8109ea9a
[root@localhost ~]$ docker exec -it tomcat03 ping tomcat02 
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.193 ms 

#反向可以ping通吗?
[root@localhost ~]$ docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

1
2
3
4
5
6
7
8
9
10
11
12
13

探究

[root@localhost ~]$ docker network inspect bridge
.........
        "Containers": {
            "7391f35d7b39e654d596ad8227db35daf1d48ba06b96689515af96770eaa8675": {
                "Name": "tomcat02",
                "EndpointID": "d5acbe00b2ba92650e124245d022a9a2f2018ce072a632daa1c604ce8e8e9053",
                "MacAddress": "02:42:ac:11:00:03",
                "IPv4Address": "172.17.0.3/16",
                "IPv6Address": ""
            },
            "7b28e7bae9f3a2841c87b56f552ce9bf193b38c29571f9e2fe67a1865fbb0aba": {
                "Name": "tomcat01",
                "EndpointID": "83fa792f6b78046e90fd6baa97832fcd17f520753fbcffb6fa47730c29ba6e25",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            },
            "c4d3b18340f64065dbeb66aad369e74e9966e2a7756978388fbde1fb8109ea9a": {
                "Name": "tomcat03",
                "EndpointID": "68f9d4da55807485d9d99635af40d436f16a684ae006c021d6d9b4c7e9aefeeb",
                "MacAddress": "02:42:ac:11:00:04",
                "IPv4Address": "172.17.0.4/16",
                "IPv6Address": ""
            }
        },
 .........
 
# 查看 hosts 配置
[root@localhost ~]$ docker exec -it tomcat03 cat /etc/hosts
127.0.0.1       localhost
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.3      tomcat02 7391f35d7b39
172.17.0.4      c4d3b18340f6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

本质：--link 就是我们在hosts 配置中增加了一个172.17.0.3 tomcat02 7391f35d7b39
注意：现在docker已经不建议使用--link
自定义网络！不适用于docker0 ！

Docker0 ：不支持容器名连接访问！

# 自定义网络

docker network --help 查看相关命令

[root@localhost ~]$ docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
5914328caba7        bridge              bridge              local
385fc6f32d02        host                host                local
d439a68e0cb8        none                null                local

1
2
3
4
5

网络模式：

bridge ：桥接 docker 默认
none ：不配置网络
host ：和宿主机共享网络
container ：容器网络连通！（用的少！局限很大）

测试：

# 直接启动的命令 --net bridge 就是我们的docker0
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat
# docker0 特点 ，默认，域名不能访问，--link可以打通连接

1
2
3
4

自定义一个网络：

[root@localhost ~]$ docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
b2d71a6c424d9a6b89a0e217a51d8b904fc8a9fd0b12f2c07059e080cd0c28e8

[root@localhost ~]$ docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
5914328caba7        bridge              bridge              local
385fc6f32d02        host                host                local
b2d71a6c424d        mynet               bridge              local
d439a68e0cb8        none                null                local

# 此时自定义网络已经创建好了
[root@localhost ~]$ docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "b2d71a6c424d9a6b89a0e217a51d8b904fc8a9fd0b12f2c07059e080cd0c28e8",
        "Created": "2020-10-07T23:05:20.433433546+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在自定义网络下运行两个容器：

详情

[root@localhost ~]$ docker run -d -P --name tomcat-net-01 --net mynet tomcat
e3a2df9dae121ef96a076b6cf13cfa2f7038a4c30540c8e1be58d0c58d6c08b9
[root@localhost ~]$ docker run -d -P --name tomcat-net-02 --net mynet tomcat
03bf1d68b678cabca6b57ee6f09ff4220f4f52316de92be40ab9d4eaec93f2a3
[root@localhost ~]$ docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "b2d71a6c424d9a6b89a0e217a51d8b904fc8a9fd0b12f2c07059e080cd0c28e8",
......
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
.......
        "Containers": {
            "03bf1d68b678cabca6b57ee6f09ff4220f4f52316de92be40ab9d4eaec93f2a3": {
                "Name": "tomcat-net-02",
                "EndpointID": "df8e5496cc8474a237010ed46737728d0f46b4992559763c3bda52d74937042d",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "e3a2df9dae121ef96a076b6cf13cfa2f7038a4c30540c8e1be58d0c58d6c08b9": {
                "Name": "tomcat-net-01",
                "EndpointID": "f0db1bd4dfbd86ee6dd00ca451f627b426590e3bf560b2e5d2c4a460e63626ee",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
........

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

此时使用 ping 容器名可以连接上：

[root@localhost ~]$ docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.051 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.053 ms

1
2
3
4

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络！！

好处：不同的集群使用不同的网络，保证集群是安全和健康的

# 网络连通

两个不同网络的容器可以使用 docker network connect [OPTIONS] NETWORK CONTAINER 打通

演示：

[root@localhost ~]$ docker network connect mynet tomcat01
[root@localhost ~]$ docker network inspect mynet

1
2

连通之后就是将 tomcat01 放到了 mynet 网络下

一个容器两个 ip 地址，类似于公网ip 私网ip

root@7b28e7bae9f3:/usr/local/tomcat# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
38: eth0@if39: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
49: eth1@if50: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:c0:a8:00:04 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 192.168.0.4/16 brd 192.168.255.255 scope global eth1
       valid_lft forever preferred_lft forever

1
2
3
4
5
6
7
8
9
10
11
12
13

# Redis集群

运行脚本

shell脚本

#创建网卡
docker network create redis --subnet 172.38.0.0/16 
#通过脚本创建六个redis配置
for port in $(seq 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 启动 
for port in $(seq 6); \
do \
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \
done

# 进入redis容器
docker exec -it redis-1 /bin/sh
# 创建集群
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

dokcer 搭建redis集群完成！

测试

/data # redis-cli -c
127.0.0.1:6379> set a b
-> Redirected to slot [15495] located at 172.38.0.13:6379
OK

# 然后再另一个窗口关闭 redis-3
[root@localhost centos]$ docker stop redis-3
redis-3

# 重新回到redis容器 ，再次get a，查看是否可以得到数据
127.0.0.1:6379> get a
-> Redirected to slot [15495] located at 172.38.0.14:6379
"b"

1
2
3
4
5
6
7
8
9
10
11
12
13

# 关于Mounts denied解决

在使用Docker镜像redis时映射配置文件和映射数据目录的时候，出现如下错误提示：

docker: Error response from daemon: Mounts denied:The paths /docker/redis/data and /docker/redis/redis.conf are not shared from OS X and are not known to Docker.You can configure shared paths from Docker -> Preferences... -> File Sharing.See https://docs.docker.com/docker-for-mac/osxfs/#namespaces for more info.

解决办法：在目录下面-v后面跟的目录使用绝对路径

docker run -d -p 6379:6379 -v $(pwd)/docker/redis/redis.conf:/etc/redis/redis.conf -v $(pwd)/docker/redis/data:/data --name my-redis redis:latest redis-server /etc/redis/redis.conf

# SpringBoot微服务打包Docker镜像

构建Springboot项目
打包应用

编写dockerfile

FROM openjdk:11.0.4
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]

1
2
3
4
5

构建镜像
发布运行！

# Docker容器内时间

docker容器内时间与服务器时间差距8小时，因为原生docker是0时区，但我们服务器采用亚洲上海东八区。

首先进入容器 docker exec -it /bin/sh 查询时间 date -R
创建文件夹mkdir -p /usr/share/zoneinfo/Asia

回到宿主机，复制宿主机里的文件到容器中

docker cp /usr/share/zoneinfo/Asia/Shanghai 容器ID或容器名:/usr/share/zoneinfo/Asia

进入容器

docker exec -it 容器Id或容器名
cp -i /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

1
2

此时可以会报错cp: not writing through dangling symlink '/etc/localtime'

解决方法：

删除容器内的/etc/localtime,重新复制

rm -rf /etc/localtime
cp -i /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

1
2

date 查看时间

参考狂神说 (opens new window) , Docker官网 (opens new window) , 菜鸟教程 (opens new window)

上次更新: 2022/04/01, 15:14:40

← 本地事务&分布式事务 docker实战→