学习视频

docker视频地址：https://b23.tv/BV1og4y1q7M4/p1

Docker 学习

入门 ：常用命令、commit容器

docker精髓：容器数据卷、DockerFile、Docker网络

企业实战：Docker Compose（容器的整合管理），Docker swarm（管理docker 集群），CI/CD（持续集成持续部署） jenkins流水线。

Docker 概述

Docker 为什么出现？

一款产品：开发-上线 两套环境！应用环境，应用配置！

开发 — 运维。问题：我在我的电脑上可以运行！版本更新，导致服务不可用！对于运维来说，考验就十分大

环境配置是十分麻烦的，每一个机器都要部署环境（集群Redis，ES，Hadoop。。。）费时费力

发布一个项目（jar + （Redis MySql JDK ES）），项目能不能带上换件安装打包！

之前在服务器配置一个应用的环境Reids MySql jdk ES Hadoop 配置超麻烦，不能够跨平台。

Windows 最后发布到linux！

传统：开发jar，运维来做环境的配置！

现在：开发导包部署上线，一套流程做完！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sm2FQSKM-1590407845895)(docker.images/image-20200517141924417.png)]

Docker 通过隔离机制，可以将服务器利用到极致！

Docker 历史

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2S0A6Wjb-1590407845897)(docker.images/image-20200517144653924.png)]

聊聊 Docker

Docker 是基于GO 语言开发的！开源项目！

官网：https://hub.docker.com/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4rps2Bpw-1590407845898)(docker.images/image-20200517145103799.png)]

文档地址：https://docs.docker.com/ Docker文档是超级详细的！

仓库地址：https://hub.docker.com/ git push pull

Docker 能干嘛

虚拟机技术

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EfNA7mmQ-1590407845899)(docker.images/image-20200517150519941.png)]

虚拟机技术缺点：

1、资源占用十分多

2、冗余步骤多

3、启动很慢！

容器技术

容器化技术不是模拟的一个完成的操作系统，是运行在操作系统上的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oZyAbv0T-1590407845901)(docker.images/image-20200517150425922.png)]

比较Docker 和 虚拟机技术的不同：

• 传统的虚拟机，虚拟出硬件（内核、cpu、内存），在虚拟的硬件上运行一个完整的操作系统，然后在这个系统上安装和运行软件。
• 容器技术，容器内的应用直接运行在宿主机上，容器是没有自己的内核的用的是操作系统的内核，所以很轻便。
• 每个容器间是相互隔离的，每个容器内都有一个属于自己的文件系统，互不影响。
• 容器能极大的利用资源

DevOps（开发、运维）

应用更快速的交付和部署

传统：一堆帮助文档，安装程序

Docker：打包镜像，发布测试，一键运行

更便捷的升级和扩缩容
使用了Docker 之后，我们部署应用就和搭积木一样！

项目打包为一个镜像，扩展服务器。拿到镜像到服务器上运行即可。

更简单的系统运维

在容器化之后，我们的开发，测试环境都是高度一致的。

更高效的计算资源利用

Docker 是内核级别的虚拟化，可以再一个物理机上运行很多的容器实例！服务器的性能可以被压榨到极致。

Docker 安装

Docker 的基本组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kJ3YWw37-1590407845901)(docker.images/image-20200517152504543.png)]

• docker 客户端可以构建镜像，拉取镜像，运行镜像（变成容器）
• docker 服务器，他是一个后台进程，里面有很多的image。我们运行image会产生一个容器。可以把image理解成类，容器就是类的实例对象。也就是说每个image运行产生的容器是不一样。
• docker 仓库就是存放镜像的地方。
• 镜像（image）
  • docker 镜像就好比是一个模板，可以通过这个模板来创建容器服务。tomcat镜像==>run==>tomcat容器（理解成一台服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）。
• 容器（container）
  • Docker 利用容器技术，可以独立运行一个或者一个组应用。容器是通过镜像来创建的。
  • 启动，停止，删除，基本命令！
  • 目前可以把这个容器理解为一个简易的linux 系统。
• 仓库（repository）
  • 仓库就是存放镜像的地方！
  • 仓库分为共有仓库和私有仓库！
    • Docker hub (默认是国外的)
    • 阿里云，网易云…都有容器服务器（加速镜像下载）

安装Docker

官方文件：https://docs.docker.com/engine/install/centos/

# 这里的操作系统是CentOS7.6# 查看内核版本，内核版本大于3.10及以上 才能安装新版的docker
uname -r# 查看系统的详细信息
cat /etc/os-release
# 更新yum软件包索引
sudo yum makecache fast# 删除以前的版本
sudo yum remove docker \docker-client \docker-client-latest \docker-common \docker-latest \docker-latest-logrotate \docker-logrotate \docker-engine
# 需要安装的包
sudo yum install -y yum-utils# 设置镜像的仓库
sudo yum-config-manager \--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo# 这是官方文档提供的，国外的下载很慢，选用国内的 https://download.docker.com/linux/centos/docker-ce.repo# 安装docker  docker-ce 社区 ee是企业版本的
# 公式里面也是设置版本的
sudo yum install docker-ce docker-ce-cli containerd.io# 启动docker 
sudo systemctl start docker# 查看docker 的信息
docker version

# 测试hello world
docker run hello-world
# 可以发现，如果在本地仓库找不到镜像，就会从远程拉取

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U5As6W3p-1590407845902)(docker.images/image-20200517155636126.png)]

了解：卸载docker

# 卸载依赖
sudo yum remove docker-ce docker-ce-cli containerd.io
# 删除目录
sudo rm -rf /var/lib/docker# /var/lib/docker docker默认资源路径

设置阿里云镜像加速

阿里云地址：https://homenew.console.aliyun.com/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WpUdRhDM-1590407845903)(docker.images/image-20200517143928718.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MFwpdHme-1590407845903)(docker.images/image-20200517144041281.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TlSJG3Pr-1590407845904)(docker.images/image-20200517155833265.png)]

回顾HelloWorld流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OZDYhEfN-1590407845904)(docker.images/image-20200517155636126.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-knfTJ6sS-1590407845905)(docker.images/image-20200517160525638.png)]

底层原理

Docker是怎么工作的？

Docker 是一个Clien-Server 结构的系统，Docker 的守护进程运行主机上。我们可以通客户端访问（Socket）！

DockerServer 接收到DockerClient 的指令，就会执行这个命令！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lEpY6Qm5-1590407845905)(docker.images/image-20200517160941516.png)]

Docker 为什么比虚拟机快？

1、Docker 有着比虚拟机更少的抽象层

2、 Docker 利用的是宿主机的内核，VM 需要 Guest OS（客户端操作系统）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OhQ5pzni-1590407845906)(docker.images/image-20200517161224766.png)]

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

下面的图有问题：现在docker也支持windows系统了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aabp26cM-1590407845908)(docker.images/image-20200517161702738.png)]

Docker 常用命令

帮助命令

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

帮助文档的地址 https://docs.docker.com/reference/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-13rfbCK1-1590407845909)(docker.images/image-20200517162441151.png)]

镜像命令

**docker images **

# 查看本地安装的镜像,不能看到一些docker 内部的镜像
$ docker images
# 查看所有的镜像
$ docker images -a
# 查看所有镜像的id 
$ docker images -q -a
$ docker images -aq

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4iPYE1t5-1590407845910)(docker.images/image-20200517163106594.png)]

docker search image

一般都是去hub上找,都不用search命令找镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lzUiShcJ-1590407845911)(docker.images/image-20200517163401687.png)]

docker pull image

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BoBAB7eE-1590407845912)(docker.images/image-20200517163711374.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-112EHT9p-1590407845913)(docker.images/image-20200517163732938.png)]

docker rmi image

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wKGuE8jp-1590407845913)(docker.images/image-20200517164344184.png)]

# 删除镜像
$ docker rmi 容器id|容器名字
# 删除全部镜像
$ docker rmi -f `docker images -qa`
# 或者是
$ docker rmi -f $(docker images -qa)# rmi 删除镜像
# -f 强制删除，镜像有容器也能删除（停止的容器） 

容器命令

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

docker pull centos

新建容器并启动

docker run [可选参数] image# 参数说明
--name=xxx 容器名字，用来区分容器
-d				 后台方式运行
-it(-i -t) 使用交互方式运行，可以使用镜像运行成容器，在使用容器直接执行我们的命令
-p				 指定容器的端口 -p 8080:8080-p ip:主机端口:容器端口-p 主机端口:容器端口（常用）-p 容器端口容器端口-P 				 随机指定端口（暴露出所有的端口）# 测试 : 启动并进入容器(启动bash执行器，centos默认也是bash)
[root@haitao ~]# docker run -it centos /bin/bash
[root@12f33dcf0796 /]# echo $SHELL # 查看当前的shell执行器
/bin/bash
[root@74d8a9107de7 /]# ls # 查看容器内的centos，基础版本，很多命令都是不完整的！
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@12f33dcf0796 /]# exit # 退出交互模式
exit

列出容器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-daf7mX95-1590407845914)(docker.images/image-20200517171117069.png)]

退出容器

exit # 交互模式下，直接退出，停止容器
ctrl + p + q # 已进入容器的shell的情况下，退出容器（不停止容器）

删除容器

docker rm 容器id|容器名字	# 只能删除停止的容器，可以递归删除
docker rm -f 容器id|容器名字	# 删除容器，强制删除，容器正在运行也能删除
docker rm [-f] $(docker ps -qa) # 删除全部的容器
docker rm [-f] `$(docker ps -qa)` # 删除全部的容器
docker ps -qa | xargs docker rm [-f] # 删除全部的容器# xargs 是Linux提供的将管道的输出结果作为下一个命令的输入

启动和停止容器的操作

docker start 容器id|容器名字 		# 启动容器
docker restart 容器id|容器名字	# 重启容器
docker stop 容器id|容器名字			# 停止当前正在运行到容器
docker kill 容器id|容器名字			# 强制停止当前容器（stop停止）

常用其他命令（对容器的操作）

后台启动容器

# 命令 docker run -d 镜像名|镜像id
[root@haitao /]# docker run -d centos# 问题docker ps。发现容器停止了# 常见问题，docker 容器使用后台运行，就必须要有一个前台进程（-it进入交互模式就是前台进程）。docker发现没有应用，就会自动停止。# 比如nginx 容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了。

查看日志命令

[root@haitao /]# docker logs --helpUsage:  docker logs [OPTIONS] CONTAINER # 容器的表示Fetch the logs of a containerOptions:--details        Show extra details provided to logs-f, --follow         Follow log output--since string   Show logs since timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)--tail string    Number of lines to show from the end of the logs (default "all")-t, --timestamps     Show timestamps--until string   Show logs before a timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)# 自己编写shell脚本（产生日志）
# /bin/bash 指定linux 默认的shell执行器
# -c 在容器的控制台执行内容[root@haitao /]# docker run -d centos /bin/bash -c "while true;do echo haitaoss;sleep 1; done;"
1d18de7e76d39bea90cb95baf77a26aff22e1085ee01c1be7940f9cf7ee3476e#  查看容器的日志，-f --tail -t 都是帮助文档提示的
[root@haitao /]# docker logs -f --tail 10 -t 1d18de7e76d39bea90cb95baf77a26aff22e1085ee01c1be7940f9cf7ee3476e
2020-05-17T09:44:13.484858554Z haitaoss
2020-05-17T09:44:14.486079085Z haitaoss
2020-05-17T09:44:15.488527532Z haitaoss
2020-05-17T09:44:16.489815756Z haitaoss

查看容器的进程信息

[root@haitao /]# docker run -d centos /bin/bash -c "sleep 10;" # 运行一个容器,为了防止别太快退出，先休眠10秒
04bffaecd07049b42b42a0e1bee2c883677e0caf0fbdfabdcf5f7fcf8bcd8ade
[root@haitao /]# docker top 04bffaecd # 查看容器里面的进程信息
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                72759               72742               0                   17:52               ?                   00:00:00            /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 10

查看容器的元数据

# 命令 docker inspect --help 
[root@haitao /]# docker inspect --helpUsage:  docker inspect [OPTIONS] NAME|ID [NAME|ID...]Return low-level information on Docker objectsOptions:-f, --format string   Format the output using the given Go template-s, --size            Display total file sizes if the type is container--type string     Return JSON for specified type# 具体使用      
docker inspect 容器id:容器名字# 测试
[root@haitao /]# docker run -d centos /bin/bash -c "while true;do echo haitaoss;sleep 10;done;"
[root@haitao /]# docker inspect 70b883

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OtrfO6b8-1590407845916)(docker.images/image-20200517180817919.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kTmlYD8E-1590407845916)(docker.images/image-20200517180923233.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y019kI2h-1590407845918)(docker.images/image-20200517181130845.png)]

进入当前正在运行的容器

# 通常我们的容器都是使用后台方式运行的，需要进入容器，修改一些配置# 命令
docker exec -it 容器id|容器名字 命令# 测试
[root@haitao /]# docker exec --helpUsage:  docker exec [OPTIONS] CONTAINER COMMAND [ARG...]Run a command in a running container # 需要输入要执行的命令才能成功进入，即容器后面时必须接命令的Options:-d, --detach               Detached mode: run command in the background--detach-keys string   Override the key sequence for detaching a container-e, --env list             Set environment variables-i, --interactive          Keep STDIN open even if not attached--privileged           Give extended privileges to the command-t, --tty                  Allocate a pseudo-TTY-u, --user string          Username or UID (format: <name|uid>[:<group|gid>])-w, --workdir string       Working directory inside the container
[root@haitao /]# docker exec -it 953c57a1ab3d /bin/bash 
# /bin/bash 的执行效果就是生成一个bash命令的的shell。可以在linux 中测试# 方式二
docker attach 容器id|容器名字# docker exec # 使用容器内正在运行的终端，执行我们输入的命令（可以利用这个打开新的终端，方便我们操作）
# docker attach # 进入容器当前运行的终端。不会启动新的进程！(不能输入命令只能静静的看着)

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

# 命令 (容器关闭了也能拷贝)
docker cp 容器id|容器名字:/xx  /path

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hZUdFWjc-1590407845919)(docker.images/image-20200517183541624.png)]

小结(有全部的命令清单)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8AKxs6rB-1590407845920)(docker.images/image-20200517184316351.png)]

docker的命令是十分多的，上面我们学习的那些都是最常用的容器和镜像命令，之后我们还会学习很多命令。

attach		Attach to a running container 			#当前she11 下attach 连接指定运行镜像
build 		Build an image from a Dockerfile 		#通过Dockerfile 定制镜像
commit		Create a new image from a container changes		#提交当前容器为新的镜像
cp		Copy files/fo1ders from the containers filesystem to the host path		#从容器中拷贝指定文件或者目录到宿主机中create		Create a new container		#创建一个新的容器，同run,但不启动容器
diff			Inspect changes on a container's fi lesys tem 		#查看docker 容器变化
events		Get real time events from the server			#从docker 服务获取容器实时事件
exec			Run a command in an existing container		#在已存在的容器上运行命令
export		Stream the contents of a container as a tar archive		#导出容器的内容流作为一个tar归档文件[对应import ]history		Show the history of an image		#展示一个镜像形成历史
images		List images		#列出系统当前镜像
import		Create a new filesystem image from the contents of a tarba11 #从tar包 中的内容创建- -一个新的文件系统映像[对应export]info			Display sys tem-wi de information		#显示系统相关信息
inspect		Return 1ow-1eve1 information on a container		#查看容器详细信息
ki11			Ki11 a running container			# ki11 指定docker容器
load			Load an image from a tar archive			#从一个tar包中加载一个镜像[对应save]
login			Register or Login to the docker registry server			#注册或者登陆一个docker源服务器
logout		Log out from a Docker registry server		#从当前Docker registry退出
logs			Fetch the logs of a container		#输出当前容器日志信息
port			Lookup the public-facing port which is NAT-ed to PRIVATE_ PORT		#查看映射端口对应的容器内部源端pause			Pause a11 processes within a container		#暂停容器
ps				List containers		#列出容器列表
pull			Pull an image or a repository from the docker registry server		#从docker镜像源服务器拉取指定镜像或者库镜像
push			Push an image or a repository to the dlocker registry server	#推送指定镜像或者库镜像至docker源服务器
restart		Restart a running container		#重启运行的容器
rm				Remove one or more containers	#移除一个或者多个容器
rmi				Remove one or more i mages		#移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或-f强制删除]
run				Run a command in a new container		#创建一个新的容器并运行一个命令
save			Save an image to a tar archive			#保存一个镜像为一个tar 包[对应load]
search		Search for an image on the Docker Hub		#在docker hub 中搜索镜像
start			Start a stopped containers			#启动容器
stop			Stop a running containers				#停止容器
tag				Tag an image into a repository	#给源中镜像打标签
top				Lookup the running processes of a container		#查看容器中运行的进程信息
unpause		unpause a paused container			#取消暂停容器
version 	Show the docker vers ion information		#查看docker版本号
wait			Block until a container stops。then print its exit code		#截取容器停止时的退出状态值

作业练习

Docker 安装nginx

# 1.去官网查看你想下载的nginx版本
# 2. dokcer pull nginx:latest
# 启动nginx
# -d 后台运行
# -p 暴露容器内的80端口，成宿主主机的8081端口上
# --name 默认是当前镜像的名字
$ docker run -d -p 8081:80 --name nginx01 nginx:latest# 3.测试是否能使用
curl localhost:8081
# 测试外网是否能访问
curl 本机ip:8081# 4.进入容器，查看nginx服务的信息
[root@haitao /]# docker exec -it ngin01 /bin/bash
root@cfa54c2f2c9b:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx

端口暴露的概念

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KJyEvZgc-1590407845922)(docker.images/image-20200517200336789.png)]

思考问题：我们每次改动nginx配置文件，都需要进入容器内部？十分的麻烦，我要是可以在容器外部提供一个映射路径，实现在容器外部修改文件，容器内就可以自动修改？ -v 数据卷！

Docker 安装一个tomcat

# 官方的使用
# 我们之前的启动都是后台启动，停止了容器之后，容器还是可以查到的。docker run -it --rm 一般用来测试，用完就删除（删除容器，也删除镜像）
# 关键参数是 --rm
docker run -it --rm tomcat# 下载在启动
docker pull tomcat:latest# 启动tomcat
docker run -d -p 8080:8080 --name tomcat01 tomcat# 进入容器
docker exec -it tomcat01 /bin/bash# 发现问题：1.linux命令少了。2.没有webapps。[root@haitao /]# docker exec -it tomcat01 /bin/bash
root@d5092cd41952:/usr/local/tomcat# ls -l
total 124
-rw-r--r--. 1 root root 18982 May  5 20:40 BUILDING.txt
-rw-r--r--. 1 root root  5409 May  5 20:40 CONTRIBUTING.md
-rw-r--r--. 1 root root 57092 May  5 20:40 LICENSE
-rw-r--r--. 1 root root  2333 May  5 20:40 NOTICE
-rw-r--r--. 1 root root  3255 May  5 20:40 README.md
-rw-r--r--. 1 root root  6898 May  5 20:40 RELEASE-NOTES
-rw-r--r--. 1 root root 16262 May  5 20:40 RUNNING.txt
drwxr-xr-x. 2 root root  4096 May 16 12:05 bin
drwxr-xr-x. 1 root root    22 May 17 12:10 conf
drwxr-xr-x. 2 root root  4096 May 16 12:05 lib
drwxrwxrwx. 1 root root   177 May 17 12:10 logs
drwxr-xr-x. 2 root root   134 May 16 12:05 native-jni-lib
drwxrwxrwx. 2 root root    30 May 16 12:05 temp
drwxr-xr-x. 2 root root     6 May 16 12:05 webapps
drwxr-xr-x. 7 root root    81 May  5 20:37 webapps.dist
drwxrwxrwx. 2 root root     6 May  5 20:36 work
root@d5092cd41952:/usr/local/tomcat# ls webapps.dist/
ROOT/         docs/         examples/     host-manager/ manager/      
root@d5092cd41952:/usr/local/tomcat# cp webapps.dist/* webapps/
cp: -r not specified; omitting directory 'webapps.dist/ROOT'
cp: -r not specified; omitting directory 'webapps.dist/docs'
cp: -r not specified; omitting directory 'webapps.dist/examples'
cp: -r not specified; omitting directory 'webapps.dist/host-manager'
cp: -r not specified; omitting directory 'webapps.dist/manager'
root@d5092cd41952:/usr/local/tomcat# cp -r  webapps.dist/* webapps/
root@d5092cd41952:/usr/local/tomcat# 

思考问题：我们以后要部署项目，如果每次都要进入容器是不是十分麻烦？我要是可以在容器外部提供一个映射路径：webapps。实现我们在外部部署项目，就自动同步到内部就好了！

部署 ES + Kibana

# es 暴露的端口很多！
# es 十分的耗内存
# es 的数据一般需要放置到安全目录！挂载
# --net somenetwork ? 网络配置# 启动elasticsearch
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch# 启动了 linux就非常卡， docker stats 查看cpu状态
# es 是十分耗内存的
# 测试es 是否启动成功
[root@haitao /]# curl localhost:9200
{"name" : "vmYagbl","cluster_name" : "elasticsearch","cluster_uuid" : "YAhlrSbgQq-i1MON_up9Vg","version" : {"number" : "5.6.12","build_hash" : "cfe3d9f","build_date" : "2018-09-10T20:12:43.732Z","build_snapshot" : false,"lucene_version" : "6.6.1"},"tagline" : "You Know, for Search"
}# 查看CPU 的状态
$ docker stats # 关闭elasticsearch 增加运行环境参数
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms256m -Xmx256m" elasticsearch

作业：使用kibana连接es？思考网络如何才能连接过去

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2pQNR6mH-1590407845922)(docker.images/image-20200517211554256.png)]

可视化

• protainer (先用这个)

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

• Rancher（CI/CD再用）

什么是portainer？

官方文档

https://hub.docker.com/r/portainer/portainer

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMjJlSu4-1590407845923)(docker.images/image-20200517212621785.png)]

https://portainer.readthedocs.io/en/latest/deployment.html

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xn4qdzRd-1590407845925)(docker.images/image-20200517212508817.png)]

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

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

访问测试

http:ip:8088

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jOWxa78a-1590407845925)(docker.images/image-20200517212831845.png)]

选择local

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M6Lf70l8-1590407845927)(docker.images/image-20200517213035452.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uRwviTyq-1590407845928)(docker.images/image-20200517213056372.png)]

平时不会用，测试万万即可

Docker 镜像讲解

镜像是什么

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HjgmP8sL-1590407845928)(docker.images/image-20200517213234342.png)]

Docker镜像加载原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TXeDW8Wz-1590407845931)(docker.images/image-20200517213345991.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cj5yu1Yf-1590407845932)(docker.images/image-20200517213455729.png)]

虚拟机启动时分钟级别的，容器启动时秒级别的。因为容器使用的内核就是操作系统本身的，当你运行服务器，内核已经加载完毕了，容器在使用的时候就不需要再次加载内核，直接使用宿主机的内核。又因为linux 的发行版都是在unix 内核上的改变，所以很多东西是一样的，但我们下载一个linux镜像的时候，你会发现下载的文件很少，因为很多基本的unix的文件，我们服务器就有，他不会下载，直接使用服务器的。

虚拟机启动，要引导，所以很慢。

分层理解

查看 拉取镜像的元数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NylE6XIM-1590407845932)(docker.images/image-20200517214442597.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o9w4NLpb-1590407845933)(docker.images/image-20200517214833723.png)]

理解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q89OmgjR-1590407845934)(docker.images/image-20200517214513714.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CTH9CqO8-1590407845935)(docker.images/image-20200517214532352.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sJfyrDSF-1590407845936)(docker.images/image-20200517214548230.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kWB0mFhx-1590407845937)(docker.images/image-20200517214614372.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uoXeAMQS-1590407845938)(docker.images/image-20200517214625960.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3TuNS3t6-1590407845939)(docker.images/image-20200517220214109.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l2AU8j1n-1590407845940)(docker.images/image-20200517221003539.png)]

commit 镜像

命令

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

实战测试

启动默认的tomcat，给tomcat添加web项目

需要注意，启动镜像的时候，必须暴露容器内部端口。否则commit之后别人是无法映射端口的。

$ docker run -d  -P  tomcat # -P 直接暴露全部端口
$ docker run -d  -p 8080  tomcat # 只暴露8080，随机的映射在宿主机上
$ docker run -d  -p 8080:8080  tomcat # 指定暴露在8080上

[root@haitao /]# docker run -d -p 8011:8080 tomcat
ba89d1dd242fab7c3351b49faf0a6886b87e82c6f15653c4b788c0214b6d90a0
[root@haitao /]# curl localhost:8011
<!doctype html><html lang="en"><head><title>HTTP Status 404 – Not Found</title><style type="text/css">body {font-family:Tahoma,Arial,sans-serif;} h1, h2, h3, b {color:white;background-color:#525D76;} h1 {font-size:22px;} h2 {font-size:16px;} h3 {font-size:14px;} p {font-size:12px;} a {color:black;} .line {height:1px;background-color:#525D76;border:none;}</style></head><body><h1>HTTP Status 404 – Not Found</h1><hr class="line" /><p><b>Type</b> Status Report</p><p><b>Description</b> The origin server did not find a current representation for the target resource or is not willing to disclose that one exists.</p><hr class="line" /><h3>Apache Tomcat/9.0.35</h3></body></html>
[root@haitao /]# docker exec -it ba89d1dd242 /bin/bash
root@ba89d1dd242f:/usr/local/tomcat# cp -r webapps.dist/* webapps/

将我们操作过的容器，提交成一个新的镜像。提交到本地仓库

[root@haitao /]# docker commit -a="haitao" -m="add webapps" b0b3b0207d94 tomcat02:1.0
sha256:fb9ae6e5a42b15a9316d2c0c9324bdb59a1d90bdd480f2d0f5ad71fafbd98410

查看本地镜像

[root@haitao /]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat03              1.0                 55a5d3b6849e        6 seconds ago       652MB
tomcat02              1.0                 fb9ae6e5a42b        11 minutes ago      652MB
tomcat                latest              1b6b1fe7261e        26 hours ago        647MB
redis                 latest              33c654ea77ff        36 hours ago        104MB
nginx                 latest              9beeba249f3e        42 hours ago        127MB
portainer/portainer   latest              2869fc110bf7        8 weeks ago         78.6MB
centos                latest              470671670cac        4 months ago        237MB
elasticsearch         latest              5acf0e8da90b        20 months ago       486MB

运行我们的镜像

[root@haitao /]# docker run -d tomcat03:1.0
321035b2529d3362e7fa5b2f521755d0111c4a4358a059048fe80dc2e822f617

测试是否开启成功

[root@haitao /]# curl localhost:8011<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8" /><title>Apache Tomcat/9.0.35</title><link href="favicon.ico" rel="icon" type="image/x-icon" /><link href="favicon.ico" rel="shortcut icon" type="image/x-icon" /><link href="tomcat.css" rel="stylesheet" type="text/css" /></head>

总结：如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像。就好比虚拟机的快照！

容器数据卷

什么是容器数据卷

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WsmEfd7e-1590407845941)(docker.images/image-20200518121418457.png)]

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

使用数据卷

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

docker run -it -v 主机目录:容器目录# 测试
# 将容器内的目录和我们主机的目录绑定起来
# 这种挂载可以理解成java中对象的引用，多个引用都指向同一个地址。
$ docker run -it -d -v /home/test:/home centos /bin/bash# 启动容器之后可以通过 docker inpsect 容器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nSbRdLUX-1590407845942)(docker.images/image-20200518132252677.png)]

测试文件的同步

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IBSyAVbY-1590407845943)(docker.images/image-20200518133420802.png)]

再来测试！

1. 停止容器
2. 宿主机上修改文件
3. 启动容器
4. 容器内的数据依旧是同步的!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1cezESwZ-1590407845943)(docker.images/image-20200518133929133.png)]

好处：我们以后只需要在本地修改文件即可，容器内会自动同步！我的理解的容器和主机操作的文件都是同一个硬盘文件，只不过这个文件有两个引用，一个在宿主机上，一个在容器中。

实战：安装mysql

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

# 拉取镜像
docker pull mysql# 启动mysql
-d 后台运行
-e 环境变量参数
-v 卷挂载
[root@haitao /]# docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -v /home/mysql/conf:/etc/mysql/conf.d \
> -v /home/mysql/data:/var/lib/mysql mysql# 启动成功之后，我们在本地使用mysql 客户端工具连接mysql 服务# 在本地测试创建一个数据库，数据会同步到我们主机上。

假设我们将容器删除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4I4pjqK-1590407845944)(docker.images/image-20200518135737815.png)]

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

具名和匿名挂载

# 匿名挂载
-v 容器内路径！
[root@haitao /]# docker run -d -P --name nginx01 -v /etc/nginx nginx# 查看所有的 volume 的情况
[root@haitao /]# docker volume ls  
DRIVER              VOLUME NAME
local               2bbed36e9b3d8603c06bc3e15fee127ba584a9488fa55a88eb8ddff402168cc7# 这里发现，这种就是匿名挂载，我们 -v 只写了容器内的路径，没写主机上的路径# 具名挂载
# -v 卷名:/容器内路径
-v xx:容器目录 # xx 是个名字不是目录，要想表示目录的写 / 
docker run  -d -P --name nginx02 -v juming:/etc/nginx nginx# 查看所有的 volume 的信息
[root@haitao /]# docker volume ls
DRIVER              VOLUME NAME
local               2bbed36e9b3d8603c06bc3e15fee127ba584a9488fa55a88eb8ddff402168cc7 # 匿名的
local               juming # 具名的# 查看volume 的物理位置
[root@haitao /]# docker volume inspect juming
[{"CreatedAt": "2020-05-18T04:44:08+08:00","Driver": "local","Labels": null,"Mountpoint": "/var/lib/docker/volumes/juming/_data","Name": "juming","Options": null,"Scope": "local"}
]

所有的docker容器内的卷，没有指定目录（具名或者匿名）的情况下都是在**/var/lib/docker/volumes/xxx/_data**

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

# 如何确定是具名挂载还是匿名挂载，还是指定路径挂载！
-v 容器内路径 				 # 匿名挂载
-v 卷名:容器内路径			# 具名挂载
-v /path:容器内路径 	 # 指定路径挂载。使用 / 开头

扩展：

# -v 的时候可以通过ro rw 改变容器对文件读写权限，默认是rw
ro readonly 	# 只读
rw readwrite  # 可读可写# 一旦设置了容器权限， 容器对我们挂载出来的内容就有限定了！
[root@haitao /]# docker run  -P --name nginx04 -v juming:/etc/nginx:ro nginx
[root@haitao /]# docker run  -P --name nginx04 -v juming:/etc/nginx:rw nginx# ro 只要看到就说明这个路径下面的文件只能通过宿主机来操作，容器内部是无法操作的！

初始DockeFile

DockerFile 就是用来构建docker 镜像的构建文件！命令脚本！先体验一下！

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

# 创建一个dockerfile 文件，名字可以自定义，建议 DockFile
# 文件中的内容，指定参数（大写）FROM centos
VOLUME ["volume01","volume02"]
CMD echo "-----end------"
CMD /bin/bash
# 这里的每个命令，就是镜像的一层！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zyllNwv8-1590407845951)(docker.images/image-20200518144108054.png)]

启动自己创建的文件

$ docker run  -it 424139dc3434

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IsEJUlXE-1590407845951)(docker.images/image-20200518144611564.png)]

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

先在容器内数据卷创建一个文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-00LDAetr-1590407845952)(docker.images/image-20200518144903018.png)]

再从宿主机中找一下

[root@haitao home]# find /var/lib/docker/volumes/ -name "container.txt"

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FYdaGLHj-1590407845953)(docker.images/image-20200518144846388.png)]

或者查看容器的元数据

[root@haitao data]# docker inspect 94fd3c31cfef

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rTj016KV-1590407845954)(docker.images/image-20200518145242543.png)]

可以发现在宿主机上确实有这个对应的挂载目录。

这种方式我们未来使用的十分多，因为我们通常会构建自己的镜像！

假设构建镜像的时候没有挂在卷，要手动镜像挂载。-v 卷名:容器内路径！会很麻烦

数据卷容器（容器间同步数据）

多个mysql 同步数据！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZTZavcdV-1590407845954)(docker.images/image-20200518145857508.png)]

# 启动3个容器，通过我们刚才自己写的镜像启动（因为指定了数据源）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2iNaJOl-1590407845955)(docker.images/image-20200518150047784.png)]

# 启动第二个容器，这个容器继承docker01 的数据卷
[root@haitao /]# docker run -it --name docker02 --volumes-from docker01 424139dc3434# 进入docker01 在数据卷中创建文件
[root@haitao data]# docker attach docker01
[root@e59304d67bd9 /]# cd volume01
[root@e59304d67bd9 volume01]# touch 2.xx# 查看docker02 是否能同步到docker02 数据卷的内容
[root@haitao /]# docker attach docker02
[root@91127ecebb72 volume01]# ls /volume01/     
2.xx# 可以看到docker01 数据卷的内容，同步到docker01上。
# docker01 叫数据卷容器，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afge9Pg1-1590407845956)(docker.images/image-20200518151126219.png)]

# 测试：可以删除docker01，查看一下docker02 和docker03是否还可以访问共享的数据卷。
# 测试结果：依旧可以访问。所以容器间数据卷的共享是双向拷贝的概念。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4G0Fwc4X-1590407845956)(docker.images/image-20200518152011300.png)]

这种方式的使用场景是，多个mysql共享数据库文件的操作。

[root@haitao /]# docker run -d -P -e MYSQL_ROOT_PASSWORD=root -v data:/var/lib/mysql/ -v conf:/etc/mysql/conf.d --name mysql01 mysql
0f12904a5e03a4c103c9b13a1be73fc5b8794d21b8ffc4ae5d5340b1a3600f4d
[root@haitao /]# docker run -d -P -e MYSQL_ROOT_PASSWORD=root  --name mysql02 --volumes-from mysql01 mysql
4d38a69ad0a45bccacb8b74be1e0d4ca3cdcb813630a46a7d5cd16d646c7987b# 这个时候，可以实现两个容器数据同步！

总结：

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

• 持久化到本地的方式，匿名挂载、具名挂载、指定路径挂载。

• 匿名挂载和具名挂载会将容器内的目录内容默认拷贝到 /var/lib/docker/volumes/xxx/_data/

• 指定路径挂载，是将宿主机的目录的内容覆盖到容器的目录中。如果宿主机没有该目录，会在宿主机中创建出目录。

• 注意：覆盖可能不够准确，应该是，删除挂载容器的目录的内容，在将我们的目录内容复制进去。

  $ docker run -d -P -v /home/tomcat-webapps:/usr/local/tomcat/webapps --name tomcat01 tomcat# 步骤
  # 1.先判断宿主机有没有该目录，没有就创建
  if [[ ! -d /home/tomcat-webapps: ]];thenmkdir -p /home/tomcat-webapps
  fi
  # 2.删除容器内的目录的
  rm -rf /usr/local/tomcat/webapps
  # 3. 将宿主机的内容复制上去
  cp -r /home/tomcat-webapps/* /usr/local/tomcat/webapps
  # 注意：宿主机和容器的挂载目录是双向拷贝，这就数据的同步，以及容器删除之后，宿主机上还保存着信息。
  

DockerFile

DockerFile 介绍

dockerfile 是用来构建docker进行的文件！命令参数脚本！

构建步骤：

1. 编写一个dockerfile 文件
2. docker build 构建成为一个镜像
3. docker run 运行镜像
4. docker push 发布镜像（DockerHub，阿里云镜像仓库！）

查看一下官方是怎么做的？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XYDRxg55-1590407845957)(docker.images/image-20200518153451300.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N5knP7Dl-1590407845957)(docker.images/image-20200518153430746.png)]

FROM scratch # 这是镜像的根，所有镜像都是在他上面添加的
ADD centos-7-x86_64-docker.tar.xz / # 添加centos 的镜像LABEL \ # 设置 标签org.label-schema.schema-version="1.0" \org.label-schema.name="CentOS Base Image" \org.label-schema.vendor="CentOS" \org.label-schema.license="GPLv2" \org.label-schema.build-date="20200504" \org.opencontainers.image.title="CentOS Base Image" \org.opencontainers.image.vendor="CentOS" \org.opencontainers.image.licenses="GPL-2.0-only" \org.opencontainers.image.created="2020-05-04 00:00:00+01:00"CMD ["/bin/bash"]

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

官方既然可以制作镜像，那我们也可以！

DockerFile构建过程

基础知识：

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eZaL6Bci-1590407845958)(docker.images/image-20200518154223425.png)]

dockerfile 是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件。这个文件十分简单！

Docker 镜像逐渐成为了企业交付的标准，必须要掌握！

DockerFile：它是构建文件，定义了一切的步骤，源代码。

DockerImage：它是通过DockerFile构建生成的镜像，最终发布和运行的产品。

DockerContainer：它是一个容器，DockerImage 运行在它里面。

DockerFile的指令

以前的话我们都是使用别人的，现在我们知道了这些常用的指令后，我们来练习自己写一个镜像！

FROM 				# 基础镜像，一切从这里开始构建
MAINTAINER	# 镜像是谁写的，姓名+邮箱
RUN					# 镜像构建的时候需要运行的命令。# 可以使用镜像执行操作，比如FROM centos,如果centos 中有 yum，可以使用yum 安装软件# 比如 yum install -y vim net-tools
ADD					# 能自动帮我们解压文件，到指定目录# ADD XX.tar /app/WORKDIR			# 镜像的工作目录
VOLUME			# 挂载的目录
EXPOSE			# 暴露端口配置
CMD					# 指定这个容器启动的时候要运行的命令。只有最后一个会生效，可被替代。
ENTRYPOINT	# 指定这个容器启动的时候要运行的命令，也只有最后一个会生效，但是可以追加命令。
ONBUILD			# 当构建一个被继承的 DockerFile 的时候就会运行 ONBUILD 的指令。触发指令。
COPY				# 类似ADD，将我们文件拷贝到镜像中。
ENV					# 构建的时候设置环境变量！# CMD 和 ENTRYPOINT 示例
# 效果都是一样的，使用 [] 嵌套多个命令比较好看
CMD java -jar /app.jar
CMD ["java","-jar","/app.jar"]
ENTRYPOINT java -jar /app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NMQtEtFq-1590407845959)(docker.images/image-20200518154801494.png)]

实战测试

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yoNwe2ll-1590407845959)(docker.images/image-20200518160436432.png)]

创建一个自己的CentOS

# 1.编写dockerfile 文件
[root@haitao dockerfile]# cat mydockerfile-centos 
FROM centos
MAINTAINER haitao<1486504210@qq.com>ENV MYPATH /usr/local
WORKDIR $MYPATH
# 可以执行命令，安装软件
RUN yum -y install vim
RUN yum -y install net-toolsEXPOSE 80CMD echo $MYPATH
CMD echo "----end---"
CMD /bin/bash# 2.通过这个文件构建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名[:tag] ./
[root@haitao dockerfile]# docker build -f ./mydockerfile-centos -t mycentos ./# 3. 运行测试

对比：之前的原生centos

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CmcmtlNS-1590407845960)(docker.images/image-20200518162631869.png)]

我们增加之后镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CULo1FD2-1590407845961)(docker.images/image-20200518162515385.png)]

我们可以列出构建镜像的历史记录。docker history container

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pbfpdXM7-1590407845961)(docker.images/image-20200518163004195.png)]

我们平时拿到一个镜像，可以研究一下他是怎么构建的

CMD 和 ENTRYPOINT 的区别

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

测试cmd

# 编写 dockerfile 文件
[root@haitao dockerfile]# vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]# build 构建镜像
[root@haitao dockerfile]# docker build -f ./dockerfile-cmd-test -t cmdtest ./# run 运行，发现我们的ls -a 命令生效
[root@haitao dockerfile]# docker run -it cmdtest:latest
.   .dockerenv  dev  home  lib64       media  opt   root  sbin  sys  usr
..  bin         etc  lib   lost+found  mnt    proc  run   srv   tmp  var# 想追加一个命令 l 变成 ls -al
[root@haitao dockerfile]# docker run -it cmdtest:latest l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"l\": executable file not found in $PATH": unknown.
ERRO[0000] error waiting for container: context canceled # cmd 的情况下 l 替换了 CMD ["ls","-a"]命令， 而 l 不是命令会报错！

测试 ENTYPOINT

# 编写 dockerfile
[root@haitao dockerfile]# vim dockerfile-entrypoint-test
FROM centos
# ENTRYPOINT ls 这种写法不会追加，我们运行容器是的参数，会直接执行ls 命令
ENTRYPOINT ["ls"]  # 得需要 [""] 写法才能追加命令
EOF# 构建镜像
[root@haitao dockerfile]# docker build -f ./dockerfile-entrypoint-test -t entrypoint ./# 执行镜像
[root@haitao /]# docker run -it  entrypoint:latest -al
total 0
drwxr-xr-x.   1 root root   6 May 17 23:36 .
drwxr-xr-x.   1 root root   6 May 17 23:36 ..
-rwxr-xr-x.   1 root root   0 May 17 23:36 .dockerenv
lrwxrwxrwx.   1 root root   7 May 11  2019 bin -> usr/bin
drwxr-xr-x.   5 root root 360 May 17 23:36 dev# 可以使用ENTRYPOINT 机制，实现启动的时候顺序执行多个命令
# 这种使用 & 顺序执行多个命令，可以应用在 CMD 下。区别就是CMD 默认的被覆盖了
[root@haitao dockerfile]# docker run -it  entrypoint:latest -al && cd / && ls -al

DockerFile 中很多命令都十分相似，我么你需要了解他们的区别。最好的学习就是对比他们然后测试效果！

实战：Tomcat镜像

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6uA1DY8D-1590407845962)(docker.images/image-20200518165716368.png)]

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

FROM centos
MAINTAINER haitao<1486504210@qq.com># 拷贝文件到容器中
COPY ./readme.txt /usr/local/readme.txt# 创建一个目录保存我们的东西
RUN mkdir /opt/module && mkdir /opt/software# 使用ADD 指令，会帮我们自动解压(所以不用COPY)
ADD ./apache-tomcat-9.0.34.tar.gz /opt/module
ADD ./jdk-8u144-linux-x64.tar.gz /opt/module# 安装基本的软件
RUN yum install -y vim
RUN yum install -y net-tools# 设置环境变量
ENV MYPATH /opt/module# jdk 的环境变量
ENV JAVA_HOME /opt/module/jdk1.8.0_144
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV PATH $PATH:$JAVA_HOME/bin# 设置工作目录
WORKDIR $MYPATH# 暴露端口
EXPOSE 8080# 容器启动的时候就执行命令
CMD /opt/module/apache-tomcat-9.0.34/bin/startup.sh && tail -F /opt/module/apache-tomcat-9.0.34/logs/catalina.out

3、构建我们的镜像

# 查看docker build 帮助命令
[root@haitao home]# docker build --helpUsage:  docker build [OPTIONS] PATH | URL | -Build an image from a Dockerfile
Options:-f, --file string             Name of the Dockerfile (Default is 'PATH/Dockerfile') # 默认会找这个文件# 构建镜像
[root@haitao home]# docker build -t mytomcat ./

4、运行镜像测试

# 运行我们的镜像，暴露8080。之所以能暴露8080,是我们Dockerfile 写了 EXPOSE 8080
[root@haitao home]# docker run -d  -p 8080:8080 --name mytomcat \
-v /home/tomcat/webapps:/opt/module/apache-tomcat-9.0.34/webapps \
-v /home/tomcat/logs:/opt/module/apache-tomcat-9.0.34/logs \
mytomcat# 进入容器，可以看到工作目录的变化
[root@haitao home]# docker exec -it 920fa55c99dbfb8ff2b7c44604eb225297d6e171620fc4d47aea7fe6ed7b6ff2 /bin/bash
[root@920fa55c99db module]# pwd
/opt/module
[root@920fa55c99db module]# ls
apache-tomcat-9.0.34  jdk1.8.0_144
[root@920fa55c99db module]# java -version
java version "1.8.0_144"
Java(TM) SE Runtime Environment (build 1.8.0_144-b01)
Java HotSpot(TM) 64-Bit Server VM (build 25.144-b01, mixed mode)

4、访问测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y5aPthi2-1590407845963)(docker.images/image-20200518173701843.png)]

5、发布项目到挂载目录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yUs9rDQ4-1590407845963)(docker.images/image-20200518173642045.png)]

6、访问我们发布的项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EbLhOgCG-1590407845964)(docker.images/image-20200518173726429.png)]

发现：项目部署成功，可以直接访问ok！

我们以后开发的步骤：需要掌握Dockerfile的编写！我们之后的一切都是使用docker镜像来发布运行！

发布我们的镜像

DockerHub

1. 地址 https://hub.docker.com/注册一个自己的账号！

2. 确定这个账号可以登录

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

4. 在本地的docker server中登录你的账号

   [root@haitao /]# docker login --helpUsage:  docker login [OPTIONS] [SERVER]Log in to a Docker registry.
   If no server is specified, the default is defined by the daemon.Options:-p, --password string   Password--password-stdin    Take the password from stdin-u, --username string   Username# 登录
   [root@haitao /]# docker login -u haitaoss
   Password: 
   WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
   Configure a credential helper to remove this warning. See
   https://docs.docker.com/engine/reference/commandline/login/#credentials-storeLogin Succeeded
   

   5、登陆完毕后就可以提交镜像了，就是一部 docker push xx

   # 这个镜像名字不合法    
   [root@haitao /]# docker push mytomcat
   The push refers to repository [docker.io/library/mytomcat]
   0683de282177: Waiting 
   denied: requested access to the resource is denied# 我们上传的镜像必须有xxx/image:tag
   # 解决办法：可以重新build 一个镜像。或者使用 docker tag 修改镜像的信息
   [root@haitao /]# docker tag --helpUsage:  docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
   [root@haitao /]# docker tag mytomcat:latest haitao/tomcat:1.0[root@haitao /]# docker images
   REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
   haitao/tomcat         1.0                 a0145b0684f8        42 minutes ago      713MB
   mytomcat              latest              a0145b0684f8        42 minutes ago      713MB# 重新push 一下。自己发布的镜像尽量带上版本号（符合docker镜像的规范）
   [root@haitao /]# docker push haitao/tomcat:1.0
   The push refers to repository [docker.io/haitao/tomcat]
   Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)

   提交的时候也是按照印象的层级来进行提交的！

发布到阿里云镜像服务上

1、登录阿里云

​ https://cr.console.aliyun.com/cn-hangzhou/instances/repositories

2、 找到容器镜像服务

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQu4vlLi-1590407845965)(docker.images/image-20200518181030078.png)]

3、创建命令空间

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K5ctYiI1-1590407845965)(docker.images/image-20200518181137077.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uq9o6MZb-1590407845966)(docker.images/image-20200518181418882.png)]

4、创建容器仓库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GD0mYOwz-1590407845967)(docker.images/image-20200518181443914.png)]

5、查看仓库的细节，可以看到如何push

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r72hQCVP-1590407845968)(docker.images/image-20200518181836670.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pNrTODdG-1590407845969)(docker.images/image-20200518181909763.png)]

6、 push本地镜像到仓库上

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E3TLEP95-1590407845969)(docker.images/image-20200518182316789.png)]

阿里云容器镜像的就参考官方说明

小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7QhZRY3G-1590407845970)(docker.images/image-20200518182359340.png)]

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mXsxOsvf-1590407845971)(docker.images/image-20200518182608895.png)]

Docker网络原理

理解网络

清空所有环境

测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pPK0TYtQ-1590407845972)(docker.images/image-20200518183559903.png)]

三个网络

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FE8pJ2mw-1590407845973)(docker.images/image-20200518183739242.png)]

# 运行一个镜像
[root@haitao /]# docker run -d -P --name tomcat01 tomcat# 查看容器内部网络地址 ip addr ， 发现容器启动的时候会得到一个 eth0@if273 ip地址。这是docker0 分配的！
[root@haitao /]# docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00inet 127.0.0.1/8 scope host lovalid_lft forever preferred_lft forever
272: eth0@if273: <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 0inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0valid_lft forever preferred_lft forever# 思考 linux 能不能ping通 容器内部！
[root@haitao /]# 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.228 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.178 ms# linux 可以ping 通docker 容器内部

原理

1. 我们没启动一个docker 容器，docker 就会给docker 容器分配一个ip，我们只需要安装了docker，就会有一个网卡docker0。docker0 和容器的网络是桥接模式，使用的技术是linux 的veth-pari技术！

再次测试 ip addr

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dk2glVe6-1590407845973)(docker.images/image-20200518184928616.png)]

2.在启动一个容器，发现又多了一对网卡！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hdptbqhW-1590407845974)(docker.images/image-20200518185223158.png)]

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

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

[root@haitao ~]# docker exec -it tomcat02 /bin/bash
root@818e5323f518:/usr/local/tomcat# 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.200 ms# 结论，容器和容器之间是可以互相ping 通的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D57JJrZN-1590407845974)(docker.images/image-20200518205025989.png)]

结论：tomcat01 和 tomact02 是供用一个路由器docker0。

所有的容器不指定网络的情况下，都是docker0 路由的，docker会给我们容器分配一个默认的可以IP。

这个ip的可选值。查看docker0 的ip可知，255*255 再减去全0全1的ip。

172.17.0.1/16
172.17.0.1 在计算机里面是 000000000.00000000.00000000.00000000 这样的32位计算出来的
/16 表示的是16位，即32中前面的16位是网段，后面的16位是可随机分配的，即255*255 个

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i2lpom9T-1590407845975)(docker.images/image-20200518205259087.png)]

总结

Docker 使用的是linux 的桥接。我们安装了docker会自动在宿主机上生成一个Docker 容器的网桥（路由器，网卡），名叫 docker0。

通过这个网卡我们的宿主机就能和容器进行通信。

而容器间的通信，也是通过网卡进行间接通信的。

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

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

注意：docker每次启动都会重新分配ip。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jxUj5ZIR-1590407845976)(docker.images/image-20200518212405556.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PcwDaIzU-1590407845976)(docker.images/image-20200518212539783.png)]

–link

思考一个场景，我们编写了一个微服务，databse url=ip; 项目不重启，数据库IP换掉了，我们希望通过名字来访问，而不是ip。该怎么做？

[root@haitao _data]# docker exec -it tomcat03 ping tomcat02
ping: tomcat02: Name or service not known# 解决办法，创建容器的时候使用 --link 参数
[root@haitao _data]# docker run -d -P --name tomcat04 --link tomcat01 tomcat
ae0d878fc4a6cb43a196791fa96bf572103653ef3449d230201eb5a3a4fbc4fa
[root@haitao _data]# docker exec -it tomcat04 ping tomcat01
PING tomcat01 (172.17.0.2) 56(84) bytes of data.
64 bytes from tomcat01 (172.17.0.2): icmp_seq=1 ttl=64 time=0.219 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=2 ttl=64 time=0.121 ms# 原理是，在创建的容器的hosts 文件添加了我们 link的主机的ip信息。
[root@haitao _data]# docker exec -it tomcat04 cat /etc/hosts
172.17.0.2      tomcat01 02801e5a4ce6 # 前面的ip 就是我们 tomcat01的ip。后面关联着的是 容器名 容器id
172.17.0.5      ae0d878fc4a6 # 查看tomcat01 的ip验证一下
[root@haitao _data]# docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00inet 127.0.0.1/8 scope host lovalid_lft forever preferred_lft forever
272: eth0@if273: <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 0inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0# --link 关联的ip是单向的，我们可以查看tomcat01 的hosts文件验证一下。
[root@haitao _data]# docker exec -it tomcat01 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.2      02801e5a4ce6# 所以 --link的原理是在创建容器的时候，在hosts文件中添加了对方容器的ip信息。
# 基于这个原理，我们可以自己实现 --link的操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KqIDgIBA-1590407845977)(docker.images/image-20200518204614857.png)]

探究-- link 的原理

使用docker inspect 容器 查看容器的信息信息

[root@haitao _data]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
ae0d878fc4a6        tomcat              "catalina.sh run"   18 minutes ago      Up 18 minutes       0.0.0.0:32801->8080/tcp   tomcat04
d1b9d88306e0        tomcat              "catalina.sh run"   49 minutes ago      Up 49 minutes       0.0.0.0:32800->8080/tcp   tomcat03
818e5323f518        tomcat              "catalina.sh run"   About an hour ago   Up About an hour    0.0.0.0:32799->8080/tcp   tomcat02
02801e5a4ce6        tomcat              "catalina.sh run"   About an hour ago   Up About an hour    0.0.0.0:32798->8080/tcp   tomcat01
[root@haitao _data]# docker inspect ae0d878fc4a6

[{"Id": "ae0d878fc4a6cb43a196791fa96bf572103653ef3449d230201eb5a3a4fbc4fa","Created": "2020-05-18T02:46:17.368916094Z","Path": "catalina.sh","Name": "/tomcat04","Platform": "linux","HostConfig": {"Links": ["/tomcat01:/tomcat04/tomcat01" // 容器的主机配置中有link的信息。// 结果是会在当前主机的host文件中，写入tomcat01 的ip信息],"Mounts": [],"NetworkSettings": {"Bridge": "","SandboxID": "9e108bdf694d4d09b18061a704e67c7b25d6e6ce727e0852bf007a98c0473610","HairpinMode": false,"LinkLocalIPv6Address": "","LinkLocalIPv6PrefixLen": 0,"Ports": {"8080/tcp": [{"HostIp": "0.0.0.0","HostPort": "32801"}]},"Gateway": "172.17.0.1","Networks": {"bridge": {"IPAMConfig": null,"Links": null,"Aliases": null,"NetworkID": "659076c5109a93bd4866b5e8dc3e503ad4a12b77dc6bf77b8174f86e71b268c3","EndpointID": "54c21ccd01520c88fd6b1fecb8633c96dab7cda67e9a89f2fdd138e4f1dceed5","Gateway": "172.17.0.1","IPAddress": "172.17.0.5","IPPrefixLen": 16,"IPv6Gateway": "","GlobalIPv6Address": "","GlobalIPv6PrefixLen": 0,"MacAddress": "02:42:ac:11:00:05","DriverOpts": null}}}}
]

总结：–link 就是在我们host配置中增加了172.17.0.2 tomcat01 02801e5a4ce6

我们现在玩Docker 已经不建议使用–link了！

我们需要自定义网络！不适用docker0

docker0 的问题，他不支持容器名连接访问！需要使用–link 或者修改容器的host文件

自定义网络

查看所有的网络

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aScyk8VA-1590407845978)(docker.images/image-20200518214104458.png)]

网络模式

• bridge ： 桥接，docker默认的方式（自己创建网络也使用bridge模式）
• none：不配置网络
• host：仅主机共享网络
• container：容器内网络联通！（用得少，局限性很大）

测试

# 我们直接运行一个镜像，默认是有 --net bridge。而这个bridge就是docker0
[root@haitao _data]# docker run -d -P --net bridge tomcat# docker0特点：默认；域名不能访问，但是可以通过--link，或者直接修改host文件。# 我们可以自定义一个网络，
-driver bridge 	# 桥接模式，默认也是桥接
-subnet 192.168.0.0/16 # 子网ip，/16 设置网段是前16位，即网段是192.168
-gateway 192.168.0.1	 # 一般设置成子网加1
[root@haitao _data]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet# 查看网络是否出创建成功
[root@haitao _data]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
659076c5109a        bridge              bridge              local
626c408cf8c2        host                host                local
8cfb1c2bf3d1        mynet               bridge              local
03078a9aa2b2        none                null                local

查看我们创建网络的详细信息
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JqiA6sUZ-1590407845978)(docker.images/image-20200518215555479.png)]

创建容器是使用我们自己的网络
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jzWSqmKc-1590407845979)(docker.images/image-20200518215828247.png)]

自定义网络的好处

# 发现没有使用--link 创建的容器，也没有修改容器的hosts文件，也能通过容器名字 ping 通
[root@haitao _data]# docker exec -it tomcat01 ping tomcat02
PING tomcat02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.155 ms
64 bytes from tomcat02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.112 ms

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

好处：不同的集群使用不同的网络，保证互不干扰。

网络联通

自定义网络的问题

# 我们自定义的网络和docker0 不在一个网段中，导致无法通信。# 我们可以测试一下
[root@haitao _data]# docker exec -it tomcat04 ping tomcat01
ping: tomcat01: Name or service not known# 所以我们需要打通容器和网络的连接，可以使用docker network connection

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3HJwV42F-1590407845980)(docker.images/image-20200518221200616.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zJ8qjfCc-1590407845981)(docker.images/image-20200518221701548.png)]

# 测试tomcat04 打通我们的mynet
[root@haitao _data]# docker network connect mynet tomcat04
[root@haitao _data]# docker network inspect mynet# 联通就是简单的将tomcat04 添加到mynet 的网络中，这样子tomcat04就能连接到mynet网络，从而连接到tomcat01# 官方说法是，一个容器两个ip地址！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P9UwtJ3A-1590407845981)(docker.images/image-20200518222035752.png)]

# tomcat04 添加到mynet 网络之后。尽管网段不同，也能联通mynet网络下面的所有网络。
# 总之就是，同一个网络下面的容器，是可以互相通信的。
[root@haitao _data]# docker exec -it tomcat04 ping tomcat01
PING tomcat01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.135 ms
64 bytes from tomcat01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.122 ms
64 bytes from tomcat01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.141 ms[root@haitao _data]# docker exec -it tomcat02 ping tomcat04
PING tomcat04 (192.168.0.4) 56(84) bytes of data.
64 bytes from tomcat04.mynet (192.168.0.4): icmp_seq=1 ttl=64 time=0.070 ms
64 bytes from tomcat04.mynet (192.168.0.4): icmp_seq=2 ttl=64 time=0.074 ms

结论：假设要跨网络（网段）连接别的容器，就需要使用docker network connect NETWORK CONTAINER

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BYWOqhWG-1590407845982)(docker.images/image-20200518222813209.png)]

实战部署redis集群

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tlgvgBJd-1590407845983)(docker.images/image-20200518222954526.png)]

shell 脚本！

# 创建网卡
[root@haitao _data]# docker network create redis --subnet 192.169.0.0/16 --gateway 192.169.0.1# 通过脚本创建六个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 192.169.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done# 通过脚本直接启动六个redis
for port in $(seq 1 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 192.169.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \
done# 创建集群
# 注意，redis这个容器只安装了sh 执行器没有bash
[root@haitao /]# docker exec -it redis-1  /bin/sh
/data # redis-cli --cluster create \
192.169.0.11:6379 \
192.169.0.12:6379 \
192.169.0.13:6379 \
192.169.0.14:6379 \
192.169.0.15:6379 \
192.169.0.16:6379 \
--cluster-replicas 1# 整体控制台输出
/data # redis-cli --cluster create \
> 192.169.0.11:6379 \
> 192.169.0.12:6379 \
> 192.169.0.13:6379 \
> 192.169.0.14:6379 \
> 192.169.0.15:6379 \
> 192.169.0.16:6379 \
> --cluster-replicas 1
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 192.169.0.15:6379 to 192.169.0.11:6379
Adding replica 192.169.0.16:6379 to 192.169.0.12:6379
Adding replica 192.169.0.14:6379 to 192.169.0.13:6379
M: abf26db7d7a5cf8e1f8d458cc3a66faf665ec74e 192.169.0.11:6379slots:[0-5460] (5461 slots) master
M: 7c895458224749865a9c892387fad17bec97b7fd 192.169.0.12:6379slots:[5461-10922] (5462 slots) master
M: c0c9b814c173be41c1c3af96cc275dbbb641da63 192.169.0.13:6379slots:[10923-16383] (5461 slots) master
S: baf4d935a363682fdc694b8ce75c4ab4a68a4c6c 192.169.0.14:6379replicates c0c9b814c173be41c1c3af96cc275dbbb641da63
S: 8fb70b5d0cc7de86100a09da392c6de6161e9c46 192.169.0.15:6379replicates abf26db7d7a5cf8e1f8d458cc3a66faf665ec74e
S: 308ed2459a90be0d11d3ea5f4c666d839328a7c5 192.169.0.16:6379replicates 7c895458224749865a9c892387fad17bec97b7fd
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
...
>>> Performing Cluster Check (using node 192.169.0.11:6379)
M: abf26db7d7a5cf8e1f8d458cc3a66faf665ec74e 192.169.0.11:6379slots:[0-5460] (5461 slots) master1 additional replica(s)
S: baf4d935a363682fdc694b8ce75c4ab4a68a4c6c 192.169.0.14:6379slots: (0 slots) slavereplicates c0c9b814c173be41c1c3af96cc275dbbb641da63
S: 8fb70b5d0cc7de86100a09da392c6de6161e9c46 192.169.0.15:6379slots: (0 slots) slavereplicates abf26db7d7a5cf8e1f8d458cc3a66faf665ec74e
M: c0c9b814c173be41c1c3af96cc275dbbb641da63 192.169.0.13:6379slots:[10923-16383] (5461 slots) master1 additional replica(s)
S: 308ed2459a90be0d11d3ea5f4c666d839328a7c5 192.169.0.16:6379slots: (0 slots) slavereplicates 7c895458224749865a9c892387fad17bec97b7fd
M: 7c895458224749865a9c892387fad17bec97b7fd 192.169.0.12:6379slots:[5461-10922] (5462 slots) master1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-czmi6Wwv-1590407845983)(docker.images/image-20200518225201275.png)]

docker 搭建redis集群完成！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-be0COVj8-1590407845984)(docker.images/image-20200518225512614.png)]

我们使用了docker之后，所有的技术都会慢慢的变得简单起来！

SpringBoot微服务打包Docker镜像

1. 构建springBoot项目
2. 打包应用
3. 编写Dockfile
4. 构建镜像
5. 发布运行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IHEXjfJf-1590407845984)(docker.images/image-20200519101340367.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ECij4KaM-1590407845985)(docker.images/image-20200519101229525.png)]

以后我们使用了Docker之后，给别人交付的就是一个镜像即可！

到了这里我们已经完全够用了Docker！