Docker

概述

Docker基于Go语言开发
官网https://www.docker.com/

底层原理

Docker 是一个Client - Service 结构的系统，Docker的守护进程运行在主机上。通过Socket从客户端访问。
DockerService 接收到 Docker - Client 的指令，就会执行这个命令。

docker比虚拟机快的原因：

1. Docker有着比虚拟机更少的抽象层
2. Docker利用的是宿主机的内核，vm需要是Gutest OS

所以，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统，避免引导，虚拟机是加载Guest OS，分钟级别的，而docker 是利用宿主机的操作系统，省略了这个复杂的过程，秒级。

常用命令

systemctl start docker  # 启动docker
docker version  		# 显示docker的版本信息
docker info     		# 显示docker的系统信息，包括镜像和容器的数量
docker --help  			# 帮助命令
1
2
3
4

帮助文档地址：https://docs.docker.com/engine/reference/commandline/docker/

镜像命令

查看镜像

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

搜索镜像

docker search mysql # 搜索镜像
docker search mysql --filter=STARS=200 # 搜索储来的镜像及时STARS大于200的
1
2

下载镜像

docker pull mysql # 下载镜像
docker pull mysql:5.7 # 指定版本下载
1
2

删除镜像

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

容器命令

注意：有了镜像才可以创建容器
下载一个centos 镜像来测试

docker pull centos
1

新建容器并启动

docker run [可选参数] 镜像名 bashShell 

# 参数说明
--name="Name" 容器名字 tomact01 tomcat02 ,用来区分容器
-d 			  后台方式运行
-it			  使用交互方式运行，进入容器查看内容
-p 			  指定容器端口  -p  8080:8080
	-p ip:主机端口：容器端口
	-p 主机端口：容器端口（常用）
	-p 容器端口
	容器端口
-P			  随机指定端口

# 测试，启动并进入容器
docker run -it centos /bin/bash
ls
exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

列出所用运行的容器

docker ps [可选参数]   # 列出当前正在运行的容器
# 参数说明：        
-a      # 列出当前正在运行的容器+带出历史运行过的容器
-n=?    # 显示最近创建的容器
-q      # 只显示容器的编号

1
2
3
4
5
6

退出容器

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     # 启动容器
docker restart 容器id    # 重启容器
docker stop 容器id       # 停止当前正在运行的容器
docker kill 容器id       # 强制停止当前容器
1
2
3
4

常用其它命令

后台启动容器

docker run -d 镜像名

docker run -d centos

# 问题docker ps，发现 centos 停止了

# 常见的坑： docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
# nginx ，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了
1
2
3
4
5
6
7
8

查看日志

docker logs -tf --tail 容器，没有日志

# 自己编写一段shell脚本
docker run -d centos /bin/sh -c "while true;do echo zhangsan;sleep 5;done"

# 显示日志
-tf   # 显示日志
--tail number  # 要显示日志条数
docker logs -tf --tail 10 容器id
1
2
3
4
5
6
7
8
9

查看容器中进程信息

docker top 容器id
1

查看镜像的元数据

docker inspect 容器id
1

进入当前正在运行的容器

# 我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置

docker exec -it 容器id bashShell 

# 测试
docker exec -it dece7bd1254 /bin/bash

# 方式二：
docker attach 容器id 

# 测试
docker attach dece7bd1254 
正在执行当前的代码...


# docker exec    # 进入容器后开启一个新的终端，可以在里面操作（常用）
# docker attach  # 进入容器正在执行的终端，不会启动新的进程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

docker cp 容器id:容器内路径 目的的主机路径

# 测试
docer cp dece7bd1254:/home/test.java /home

# 拷贝是一个手动过程，未来我们使用 -v 卷的技术，可以实现
1
2
3
4
5
6

常用命令总结

attach                # 当前 shell 下 attach 连接指定运行环境
build				  # 通过 Dockerfile 定制镜像
commit				  # 提交当前容器为新的镜像
cp				      # 从容器中拷贝指定文件或者目录到宿主机中
create				  # 创建一个新的容器，同 run ,但不启动容器
diff    			  # 查看 docker 容器变化
events				  # 从 docker 服务获取容器实时事件
exec				  # 在已存在的容器上运行命令
export				  # 导出容器的内容流作为一个 tar 归档文件[对应 import]
history				  # 展示一个镜像形成历史
images				  # 列出系统当前镜像
import				  # 从 tar 包中的内容创建一个新的文件系统映像[对应 export]
info				  # 显示系统相关信息
inspect     		  # 查看容器详细信息
kill      			  # kill指定 docker 容器
load				  # 从一个 tar 包中加载一个镜像[对应 save]
login				  # 注册或者登录一个 docker 源服务器
logout				  # 从当前 Docker registry 退出
logs				  # 输出当前容器日志信息
port				  # 查看映射端口对应的容器内部源端口
pause				  # 暂停容器
ps					  # 列出容器列表
pull				  # 从 docker 镜像源服务器拉取指定镜像或者库镜像
push  				  # 推送指定镜像或者库镜像至docker源服务器
restart				  # 重启运行的容器
rm					  # 移除一个或者多个容器
rmi					  # 移除一个过着多个镜像[无容器使用镜像才可以移除，否则需删除相关容器才可以继续或 -f 强制删除]
run 				  # 创建一个新的容器并运行一个命令
save				  # 保存一个镜像为一个 tar 包[对应 load]
search				  # 在 docker hub 中搜索镜像
start  				  # 启动容器
stop				  # 停止容器
tag					  # 给源中镜像打标签
top 				  # 查看容器中运行的进程信息
unpause				  # 取消暂停容器
version				  # 查看 docker 版本号
wait				  # 截取容器停止时的退出状态值
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

Docker部署软件

部署Ngins

# 1.搜索镜像 search 建议去docker搜索，可以看到帮助文档 https://hub.docker.com/
# 2.下载镜像 pull  
# 3.运行测试


# 测试
docker pull nginx
# -d 后台运行
# --name 给容器命名
# -p  宿主机端口：容器内端口
docker run -d --name nginx01 -p 3344:80 nginx

curl localhost:3344

# 进入容器
docker exec -it nginx01 /bin/bash
# 查看nginx 配置
whereis nginx
# 查看nginx 配置
cd /etc/nginx
ls
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

部署Tomcat

# 官方的使用
docker run -it --rm tomcat:9.0

# 之前启动都是后台，停止了容器之后，容器还是可以查到  docker run -it --rm ,一般用来测试，用完就删除

# 下载启动tomcat
docker pull tomcat

# 启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat

# 测试访问没有问题

# 进入容器
docker exec -it tomcat01 /bin/bash

# 发现问题：1.linux命令少了 2.没有webapps 
# 问题原因:默认是最小的镜像，所有不必要的都剔除掉，保证最小可运行的环境

# 将webapps.dist文件夹中的内容拷贝到webapps中
cp -r webapps.dist/* webapps

# 本地访问 http://192.168.241.128:3355/
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

elasticsearch8.0 不支持JDK8，支持JDK17

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

# 启动 elasticsearch 
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.17.5

# 测试
curl localhost:9200

docker stats # 查看 cpu 的状态

# 赶紧关闭，增加内存的限制，修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.17.5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

可视化

• portainer (先用这个)

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

• 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

# 访问测试 http://192.168.241.128:8088

1
2
3
4
5

commit镜像

docker commit 提交容器成为一个新的副本

# 命令和git原理类似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]

# 测试
docker commit -m="add webapps content" -a="yancheng" dece7bd1254 tomcat02:1.0
1
2
3
4
5
6
7

容器数据卷

如果数据都在容器中，那么我们容器删除，数据就丢失了！需求：数据可以持久化
容器之间可以有一个数据共享的技术！Docker 容器中产生的数据，同步到本地！
这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面！

总结：容器的持久化和同步操作！容器间也是可以数据共享的！

使用数据卷

# 方式一：直接使用命令来挂载 -v
docker run -it -v 主机目录：容器内目录

# 测试
docker run -it -v /home/ceshi:/home centos /bin/bash

# 查看是否挂载成功
docker inspect dece7bd1254 

# 查看文件内容
cat test.java

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

MySql数据持久化

# 获取镜像
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 容器名字
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

# 启动成功之后，我们在本地使用 sqlyog 来测试一下
# 连接服务器的3310  和容器内的3306映射
# 在本地测试创建一个数据库，查看一下我们映射的路径是否ok

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

假设我们将容器删除，发现我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能

具名和匿名挂载

# 匿名挂载
-v 容器内路径
docker run -d -P --name nginx01 -v /ect/nginx nginx

# 查看所有的 volume 的情况
docker volume ls

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

# 具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

docker volume ls

# 通过 -v 卷名：容器内路径
# 查看一下这个卷
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

所有的docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/xxx/_data
我们通过具名挂载可以方便的找到我们的一个卷，大多数情况使用具名挂载

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

拓展：

# 通过 -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就说明这个路径只能通过宿主机来操作，容器内部是无法操作的
1
2
3
4
5
6
7
8
9

DockerFile初识

Dockerfile 就是用来构建docker 镜像的构建文件！
通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每个命令都是一层

# 创建一个dockerfile文件，名字可以随机 建议 Dockerfile
# 文件中的内容指令大写
FROM centos

VOLUME ["volume01","volume02"] # 这个卷和外部一定有一个同步目录

CMD echo "-------end-----"

CMD /bin/bash

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

# 生成自己的镜像文件
docker build -f /home/docker-test-volume/dockerfile1 -t yancheng/centos:1.0 .

# 启动自己的容器
docker run -it e46264sfd /bin/bash

# 查看当前容器信息
docker inspect e46264sfd 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这种方式未来使用的非常多，因为我们通常会构建自己的镜像
假设构建镜像的时候没有挂载卷，要手动镜像挂载 -v 卷名:容器内路径

数据卷容器

多个 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 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-form mysql01 mysql:5.7

# 这个时候可以实现两个容器数据同步
1
2
3
4
5

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

DockerFile

DockerFile介绍

dockerfile 是用来构建docker镜像的文件
构建步骤：

• 编写一个dockerfile 文件
• docker build 构建成为一个镜像
• docker run 运行镜像
• docker push 发布镜像（DockerHub、阿里云镜像仓库）

很多官方镜像都是基础包，很多功能都没有，我们通常会自己搭建自己的镜像。

DockerFile构建过程

基础知识：

1. 每个保留关键字（指令）都是必须是大写字母
2. 执行从上到下顺序执行
3. #表示注释
4. 每一个指令都会创建提交一个新的镜像层，并提交！

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单
Docker镜像逐渐成为企业交付的标准！！！
步骤：开发，部署，上线，运维
DockerFile：构建文件，定义了一切的步骤，源代码
DockerImages：通过 DockerFile 构建生成的镜像，最终发布和运行的产品
Docker容器：容器就是镜像运行起来提供服务器

DockerFile指令

FROM 			# 基础镜像，一切从这里开始构建
MAINTAINER		# 镜像是谁写的，姓名+邮箱
RUN				# 镜像构建的时候需要运行的命令
ADD				# 步骤：tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR			# 镜像的工作目录
VOLUME			# 挂载目录
EXPOSE			# 指定对外端口
CMD				# 指定这个容器启动的时候要运行的命令，只有最后一个生效，可被替代
ENTRYPOINT		# 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD			# 当构建一个被集成 DockerFile 这个的时候会运行 ONBUILD 的指令，触发指令
COPY 			# 类似ADD,将我们文件拷贝到镜像中
ENV				# 构建的时候设置环境变量
1
2
3
4
5
6
7
8
9
10
11
12

实战测试

Docker Hub 中 99% 镜像都是从这个基础镜像过来的 FROM scratch,然后配置需要的软件和配置来进行的构建

创建一个自己的centos

# 1.编写Dockerfile的文件
# 查看文件内容
cat mydockerfile-centos

# mydockerfile-centos 文件内容
FROM centos
MAINTAINER yancheng<2416677458@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

# 2.通过这个文件构建镜像
docker build -f mydockerfile-centos -t mycentos:1.0 .

# 查看生成的镜像
docker images

# 进入新生成的镜像
docker run -it mycentos:1.0

# pwd：显示目前的目录
pwd

# 查看镜像的构建过程
docker history 镜像id
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

CMD 和 ENTRYPOINT 区别

CMD  	 	# 指定一个容器启动的时候运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT 	# 指定这个容器启动的时候运行的命令，可以追加命令
1
2

测试CMD

vim dockerfile-cmd-test

# 编写 dockerfile 文件
FROM centos:7
CMD ["ls","-a"]

# 构建镜像
docker build -f dockerfile-cmd-test -t cmd-test .

# 运行run
docker run dd42342sfd

# 想追加一个命令 -l    ls -al
docker run dd42342sfd -l # 报错

# CMD 的情况下 -l 替换了CMD ["ls","-a"] 命令，-l 不是命令所以报错

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

测试ENTRYPOINT

vim dockerfile-cmd-entrypoint

# 编写 dockerfile 文件
FROM centos:7
ENTRYPOINT ["ls","-a"]

# 构建镜像
docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .

# 运行run
docker run dd42366sfd

# 我们的追加命令，是直接拼接在我们的 ENTRYPOINT 命令的后面
docker run dd42366sfd -l 

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

实战Tomcat

1. 准备镜像文件 tomcat 压缩包 ，jdk压缩包
   

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

   vim Dockerfile 
   1

   FROM centos:7
   MAINTAINER yancheng<2416677458@qq.com>
   
   COPY readme.txt /usr/local/readme.txt
   
   ADD jdk-8u333-linux-x64.tar.gz /usr/local/
   ADD apache-tomcat-9.0.64.tar.gz /usr/local/
   
   RUN yum -y install vim
   RUN yum -y install net-tools
   
   ENV MYPATH /usr/local
   WORKDIR $MYPATH
   
   ENV JAVA_HOME /usr/local/jdk1.8.0_33
   ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
   ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.64
   ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.64
   ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
   
   EXPOSE 8080
    
   CMD /usr/local/apache-tomcat-9.0.64/bin/startup.sh && tail -f /usr/local/apache-tomcat-9.0.64/logs/catalina.out
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23

3. 构建镜像

   docker build -t centos-tomcat .
   1

   构建成功后显示：
   
   构建成功后查看镜像
   

4. 启动镜像

   docker run -d -p 9090:8080 --name centos-tomcat -v /home/yancheng/build/tomcat/test:/usr/local/apache-tomcat-9.0.64/webapps/test -v /home/yancheng/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.64/logs centos-tomcat
   1

5. 访问测试

   docker ps # 查看正在运行的容器
   docker exec -it 3815d70316e /bin/bash # 进入容器
   1
   2

   

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

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    
web-app>
1
2
3
4
5
6
7

```bash

```
1
2
3

发布自己的镜像

发布到DokcerHub

登录

docker login -u 用户名
1

生成新的带本版好的镜像

docker tag 镜像id 新的镜像名称：版本
1

推送

docker push chenrelease/centos-tomcat:1.0
1

发布到阿里云

1. 登录阿里云
2. 找到容器镜像服务
3. 创建命名空间
4. 创建容器镜像
5. 浏览阿里云信息

Docker网络

理解Docker0

linux 可以ping 通 docker 容器内部

原理：

1. 我们没启动一个docker容器，docker就会给docker容器分配一个ip,我们只要安装了docker, 就会有一个网卡docker0
   桥接模式，使用的技术是 evth-pair 技术
2. 在启动一个容器测试，发现又多了一对网卡

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

3. 我们来测下tomcat01 和 tomcat02 是否可以ping通

docker exec -it tomcat02 ping 172.18.0.2
# 结论：容器和容器之间是可以互相ping通的
1
2

结论：tomcat01 和 tomcat02 是公用的一个路由器， docker0
所有的 容器不指定网络的情况下，都是 docker0 路由的， docker 会给我们的容器分配一个默认的可用IP

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

Docker 中的所有的网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）
只要容器删除，对应网桥一对就没了

–link

docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known

# 如何解决？
# 通过--link 既可以解决了网络连通问题
docker run -d -P --name tomcat03 --link tomcat02 tomcat
docker exec -it tomcat03 ping tomcat02

# 反向可以ping 通吗？
docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known
1
2
3
4
5
6
7
8
9
10
11

通过 --link ，其实这个tomcat03 就是在本地配置了tomcat02 配置

本质探究： --link 就是我们在hosts 配置中增加了一个 172.18.0.3 tomcat02 31285143c2
现在Docker已经不建议使用 --link 了
自定网络，不适用docker0
docker0问题：他不支持容器名连接访问

自定义网络

查看所有的docker网络

docker network ls
1

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

测试：

# 我们直接启动的命令 --net birdge, 而这个就是我们的docker0
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat

# docker0特点：默认，域名不能访问，--link可以打通连接
# 我们可以自定义一个网络
# --driver bridge 
# --subnet 192.168.0.0/16
# --gateway 192.168.0.1
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
docker network ls

# 我们自己的网路就创建好了
docker network inspect mynet

docker run -d -P --name tomcat-net-01 --net mynet tomcat
docker run -d -P --name tomcat-net-02 --net mynet tomcat
docker network inspect mynet

# 再次测试ping连接
docker exec -it tomcat-net-01 ping 192.168.0.3

# 现在不使用--link也可以ping 名字
docker exec -it tomcat-net-01 ping tomcat-net-02
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 都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络
好处：
redis - 不同的集群使用不同的网络，保证集群是安全和健康的
mysql - 不同的集群使用不同的网络，保证集群是安全和健康的

网络连通

docker network connect [OPTIONS] NETWORK CONTAINER

# 测试打通 tomcat01 -mynet
docker network connect mynet tomcat01
docker network inspect mynet

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

# 01 连通ok
docker exec -it tomcat01 ping tomcat-net-01

# 02 打不通
docker exec -it tomcat02 ping tomcat-net-01
1
2
3
4
5
6
7
8
9
10
11
12
13

结论：假设要跨网络操作别人，就需要使用docker network connect 连通

部署redis 集群

# 创建网卡
docker network create redis --subnet 172.358.0.0/16

# 通过脚本创建六个redis配置
for port in $(seq 1 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

# 查看
cat redis.conf

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 reids --ip 172.38.0.1${port} redis:5.0.0-alpine3.11 redis-server /etc/redis/redis.conf; \

docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net reids --ip 172.38.0.11 redis:5.0.0-alpine3.11 redis-server /etc/redis/redis.conf; \

docker run -p 6372:6379 -p 16372:16379 --name redis-1 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net reids --ip 172.38.0.12 redis:5.0.0-alpine3.11 redis-server /etc/redis/redis.conf; \
...

# 创建集群
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

# docker搭建reids集群完成
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
38
39
40
41
42
43
44

SpringBoot微服务打包Docker镜像

1. 架构springboot项目
2. 打包应用
3. 编写dockerfile

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
1
2
3
4
5

4. 构建镜像
5. 发布运行