Docker!Docker!Docker!

Docker

感谢秦老师,视频跳转连接 https://www.bilibili.com/video/BV1og4y1q7M4

Docker概述

Docker为什么会出现?

一款产品:开发–上线 两套环境 ->应用环境,应用配置.

开发 ---- 运维 问题:我在我的电脑上可以运行! 版本更新导致服务不可用,对于运维来说考验十分大

开发即运维!

环境配置十分麻烦,每个机器都要部署环境(集群Redis,ES,Hadoop…) 费时费力

发布一个项目 (jar + (Redis MySQL jdk ES)) ,项目能不能带上环境安装打包?

之前在服务器配置一个应用的环境Redis MySQL jdk ES Hadoop , 配置超麻烦,不能跨平台

Windows开发,发布到Linux上.

传统:开发打包成jar ,运维来做环境部署.

现在:开发打包部署上线,一套流程做完.

比如一个安卓应用 java – apk – 发布 (应用商店) --张三使用apk – 安装即可用

java – jar (环境) – 打包项目带上环境 (镜像) --(Docker仓库:商店) — 下载我们发布的镜像 – 直接运行即可

Docker的思想来自于集装箱

JRE – 多个应用 (端口冲突) – 原来都是交叉的

隔离:Docker核心思想–>打包装箱. 每个箱子是互相隔离的

Docker给以上的问题,提出了解决方案.

虚拟机技术缺点:

1, 资源占用十分多

2, 冗余步骤多

3, 启动很慢

Docker的历史

Docker能干嘛

容器化技术

容器化技术并不是模拟一个完整的操作系统

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

• 传统虚拟机，虚拟出一条硬件，运行一个 完整的操作系统，然后在这个系统上安装和运行软件
• 容器内的应用直接运行在宿主机的内容， 容器是没有自己的内核的,也没有虚拟我们的硬件,所以就轻便了
• 每个容器间是相互隔离的,每个容器内部都有一个属于自己的文件系统,互不影响

DevOps(开发,运维)

应用更快速的交付和部署

传统:一堆帮助文档,安装程序

Docker:打包镜像发布测试,一键运行

更便捷的升级和扩缩容

使用了Docker之后,我们部署应用就和搭积木一样

项目打包为一个镜像,水平扩展服务器A,服务器B

更简单的系统运维系统

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

更高效的计算资源利用

1核2g的服务器 可以同时运行几十个tomcat?!!!

Docker是内核级别的虚拟化,可以在一个物理机上运行很多的容器实例

服务器的性能可以被压榨到极致!

Docker安装

Docker的基本组成

镜像(image):

docker镜像就好比是一个模板,可以通过这个模板来创建容器服务,tomcat镜像–>run—>tomcat01容器(提供服务器).通过这个镜像可以创建多个容器(最终服务运行或者项目运行就是在容器中的).

容器(container):

Docker利用容器技术,独立运行一个或者-个组应用 ,通过镜像来创建的。启动,停止,删除，基本命令!
目前就可以把这个容器理解为就是一个简易的linux系统.

仓库(repository):

仓库就是存放镜像的地方.

仓库分为公有仓库和私有仓库.

Docker Hub(默认是国外的)

像阿里云之类的大型企业都有容器服务器(配置镜像加速)

安装Docker

环境准备

1. 需要会一点点的Linux基础
2. CentOS 7
3. 我们使用Xshell连接远程服务器进行操作

环境查看

# 系统版本
[root@iZm5eicbmpex37r3ecz3h7Z ~]# cat /etc/os-release
NAME="Aliyun Linux"
VERSION="2.1903 LTS (Hunting Beagle)"
ID="alinux"
ID_LIKE="rhel fedora centos"
VERSION_ID="2.1903"
PRETTY_NAME="Aliyun Linux 2.1903 LTS (Hunting Beagle)"
ANSI_COLOR="0;31"
HOME_URL="https://www.aliyun.com/"

安装

帮助文档 https://docs.docker.com/engine/install/centos/

# 1.卸载旧版本
$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
# 2.需要的安装包
$ sudo yum install -y yum-utils

# 3.设置镜像仓库
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo		# 默认是国外的!很慢!
    
$ sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo # 阿里云镜像 快

# 更新yum软件包索引
yum makecache fast

# 4.安装docker	docker-ce 社区版 ee 企业版
$ sudo yum install docker-ce docker-ce-cli containerd.io

# 5.启动docker
$ sudo systemctl start docker

# 6.使用docker version查看是否安装成功

# 7.使用hello owrld测试
$ sudo docker run hello-world

# 判断images是否下载成功
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              bf756fb1ae65        4 months ago        13.3kB

了解:卸载docker

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

阿里云镜像加速

登录阿里云找到容器服务

找到镜像加速地址

配置使用

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://pdprqq44.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

回顾HelloWorld流程

run的运行流程图

底层原理

Docker是怎么工作的?

Docker是一个Client -Server结构的系统, Docker的守护进程运行在主机上。通过Socket从客户端访问.

DockerServer接收到Docker-Client的信息,就会执行这条命令.

Docker为什么比VM快?

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

2. Docker利用的是宿主机的内核,vm是需要Guest OS.

3. 

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

   

   学习完毕所有的命令,再回过头来看这段理论就会很清晰.

Docker命令

帮助命令

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

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

镜像命令

docker images 查看所有本机上的镜像

REPOSITORY  镜像的仓库源
TAG			镜像的标签
IMAGE ID	镜像的id
CREATED		镜像的创建时间
SIZE		镜像的大小

-a,  --all		# 列出所有镜像
-q,  --quiet	# 列出所有镜像id,一般-ap连用

docker search搜索镜像

[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker search mysql
NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   9500                [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3444                [OK]                
mysql/mysql-server                Optimized MySQL Server Docker images. Create…   696                                     [OK]
centos/mysql-57-centos7           MySQL 5.7 SQL database server                   75                                      
mysql/mysql-cluster               Experimental MySQL Cluster Docker images. Cr…   69                                      
centurylink/mysql                 Image containing mysql. Optimized to be link…   61     
# 可选项 通过收藏过滤
--filter=stars=3000	搜索出来的镜像就是STARS大于3000的 
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker search mysql --filter=stars=3000 
NAME                DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql               MySQL is a widely used, open-source relation…   9500                [OK]                
mariadb             MariaDB is a community-developed fork of MyS…   3444                [OK] 

docker pull下载镜像

# 下载镜像 docker pull 镜像名[:tag]
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker pull mysql
Using default tag: latest	# 如果不写tag.默认就是latest
latest: Pulling from library/mysql	# 分层下载. docker image核心 联合文件系统
5b54d594fba7: Pull complete 
07e7d6a8a868: Pull complete 
abd946892310: Pull complete 
dd8f4d07efa5: Pull complete 
076d396a6205: Pull complete 
cf6b2b93048f: Pull complete 
530904b4a8b7: Pull complete 
fb1e55059a95: Pull complete 
4bd29a0dcde8: Pull complete 
b94a001c6ec7: Pull complete 
cb77cbeb422b: Pull complete 
2a35cdbd42cc: Pull complete 
Digest: sha256:dc255ca50a42b3589197000b1f9bab2b4e010158d1a9f56c3db6ee145506f625 # 签名
Status: Downloaded newer image for mysql:latest	
docker.io/library/mysql:latest 	# 真实地址

# 等价
docker pull mysql
docker pull docker.io/library/mysql:latest

# 指定版本下载
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
5b54d594fba7: Already exists 	# 联合文件系统特性,已存在的直接复用
07e7d6a8a868: Already exists 
abd946892310: Already exists 
dd8f4d07efa5: Already exists 
076d396a6205: Already exists 
cf6b2b93048f: Already exists 
530904b4a8b7: Already exists 
a37958cbebcf: Pull complete 
04960017f638: Pull complete 
e1285def0d2a: Pull complete 
670cb3a9678e: Pull complete 
Digest: sha256:e4d39b85118358ffef6adc5e8c7d00e49d20b25597e6ffdc994696f10e3dc8e2
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

docker rmi删除镜像

[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker rmi -f 镜像id  # 删除指定的镜像
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker rmi -f 镜像id 镜像id 镜像id 	# 删除多个容器
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker rmi -f $(docker images -aq)  # 删除全部镜像

(增删改查)

容器命令

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

docker pull centos

新建容器并启动

docker run [可选参数] image
# 参数说明
--name="Name" 	容器名字 tomcat01 tomcat02 用来区分同期
-d				后台方式运行(nohup)
-it				使用交互方式运行,进入容器查看内容
-p				指定容器的端口  -p 8080:8080
	-p ip:主机端口:容器端口
	-p 主机端口:容器端口 (常用)
	-p 容器端口
	容器端口
-P				随即指定端口

# 测试, 启动并进入容器
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker run -it centos /bin/bash
[root@ba30042453f7 /]# 
[root@ba30042453f7 /]# ls   # 查看容器内的centos,基础版本,很多命令都是不完善的
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

# 从容器中退回主机
[root@ba30042453f7 /]# exit
exit
[root@iZm5eicbmpex37r3ecz3h7Z ~]# ls
tgz

列出所有运行的容器

docker ps
	# 列出当前正在运行的容器
-a	# 列出当前正在运行的容器+历史运行过的容器
-n=? # 显示最近创建的容器
-q	# 只显示容器的编号
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                          PORTS               NAMES
ba30042453f7        centos              "/bin/bash"         3 minutes ago       Exited (0) About a minute ago                       wonderful_hawking
f6ea189c0505        bf756fb1ae65        "/hello"            47 minutes ago      Exited (0) 47 minutes ago                           zen_bassi
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker ps -aq
ba30042453f7
f6ea189c0505

退出容器

exit 	# 直接停止容器并退出
Ctrl + p + q # 容器不停止退出

删除容器

docker rm 容器id  				# 删除指定的容器,不能删除正在运行的容器
docker rm -f $(docker ps -aq)	 # 递归删除所有的容器
docker ps -aq|xargs docker rm 	 # 删除所有的容器

启动和停止容器的操作

docker start 容器id		# 启动容器
docker restart 容器id		# 重启容器
docker stop 容器id		# 停止容器
docker kill 容器id		# 强制停止容器

常用其他命令

后台启动容器

docker run -d 镜像名	# 后台启动
# 问题: docker ps,发现centos静止了

# 常见的坑:docker容器使用后台运行,就必须要有一个前台进程,docker发现没有应用,就会自动停止
# nginx,容器启动后,发现自己没有提供服务,就会立刻停止,就是没有程序了

查看日志命令

docker logs -f -t --tail  10 容器id

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

查看容器中进程信息ps

docker top 容器id

查看容器元数据

docker inspect 容器id  # 查看容器信息

进入当前正在运行的容器

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

# 命令
docker exec -it 容器id bashShell

# 方式二
docker attach 容器id
正在执行的代码....

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

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

docker attach 容器id		# 进入容器
docker cp 容器id:/文件路径	/目标主机路径 	# 拷贝文件到主机
# 拷贝是一个手动过程,未来我们使用	-v	卷的技术,可以实现

小结

attach 	Attach to a running container						#当前sheil卜attach住按指定您行谎你
build	Build an image from a Dockerfile					#通过Dockerfile定制镜像
commit	Create a new image from a container changes			#提交当前容器为新的镜像
cp	Copy files/folders from the containers filesystem to the host path	#从容器中拷贝指定文件或者目录到宿主机中
create	Create a new container								#创建一个新的容器，同run,但不启动容器
diff	Inspect changes on a containers filesystem			#查看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 tarball #从tar包中的内容创建一个新的文件系统映僧[对应export]
info	Display system-wide information						#显示系统相关信息
inspect Return 1ow-leve1 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 fromLa Docker registry server				#从当前Docker registry 退出
1ogs	Fetch the 1ogs 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 docker registry server	#推送指定镜像或者库镜像至docker源服务器
restart	Restart a running container							#重启运行的容器
rm	Remove one or more containers							#移除一个或者多个容器
rmi	Remove one or more images								#移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或-个强制删除]
run	Run a command in a new container						#创建一个新的容器并运行一个命令
save	Save an image toa 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 reposi tory							#给源中镜像打标签
top	Lookup the running processes of a container				#查看容器中运行的进程信息
unpause	Unpause a paused container							#取消暂停容器
version	Show the docker vers ion information				#查看docker 版本号
wait	B1ock until a container stops， then print its exit code # 截取容器停止时的退出状态值

docker的命令十分多,上面我们学习的是最常用的容器和镜像命令,之后会学更多

作业练习

docker安装nginx

# 搜索镜像 search 建议去docker hub上搜索
# 下载镜像 pull
# 运行测试

[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
nginx               latest              602e111c06b6        3 weeks ago         127MB
centos              latest              470671670cac        3 months ago        237MB

# -d 后台执行
# --name 给容器命名
# -p 宿主机端口:容器内部端口  (映射)
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker run -d --name nginx01 -p 8070:80 nginx
83505a20805b0891e43e895097a7c84a1450a65b0d1b83e54880fafa7b8ef8a5
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
83505a20805b        nginx               "nginx -g 'daemon of…"   9 seconds ago       Up 8 seconds        0.0.0.0:8070->80/tcp   nginx01

# 进入容器
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker exec -it nginx01 /bin/bash
root@83505a20805b:/# ls
bin  boot  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
root@83505a20805b:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@83505a20805b:/# cd /etc/nginx
root@83505a20805b:/etc/nginx# ls
conf.d  fastcgi_params  koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params  uwsgi_params  win-utf

# 退出容器
root@83505a20805b:/etc/nginx# exit
exit
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
83505a20805b        nginx               "nginx -g 'daemon of…"   8 minutes ago       Up 8 minutes        0.0.0.0:8070->80/tcp   nginx01

# 停止容器运行
[root@iZm5eicbmpex37r3ecz3h7Z ~]# docker stop 83505a20805b
83505a20805b

我们现在每次改动nginx配置文件,都需要进入容器内部,十分麻烦,我要是可以在容器外部提供一个映射额路径,打到在容器外部提供一个映射路径,达到在容器外修改文件,容器内部就可以自动修改. 数据卷技术 -v

docker安装tomcat

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

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

# 下载再启动
docker pull tomcat

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

# 测试访问没有问题,但是404,因为webapps中没有项目,需要把webapps.dist下的东西拷贝到webapps中

docker安装ES+Kibana

问题?不可以使用kibana直接连接ES,因为他们是互相隔离的,那么如何解决呢?

可视化

• portainer(先用这个)

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

• Rancher(CI/CD再用)

什么是potainer?

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

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

访问测试: htp://ip:8088/ (第一次访问较慢,但是我加载很快,嘻嘻~)
通过它来访问了:

Docker镜像

镜像是什么

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

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

如何得到镜像:

• 从远程仓库下载
• 朋友拷贝给你
• 自己制作一个DockerFile

Docker镜像加载原理

UnionFD(联合文件系统)

我们下载的时候看到的一层层就是这个

UnionFS (联合文件系统) : Union文件系统( UnionFS )是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为一次提交来一层层的叠加 ,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像) ,可以制作各种具体的应用镜像。
特性: 一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录

Docker镜像加载原理

docker的镜像实际上由一层一层的文件 系统组成,这种层级的文件系统UnionFS.
bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统,在Docker镜像的最底层是bootfs.这-层与我们典型的Linux/Unix系统是一样的,包含boo加载器和内核。当boot加载完成之后整个内核就都在内存中了,此时内存的使用权已由bootfs转交给内核,此时系统也会卸载bootfs.
rootfs (root file system) , 在bootfs之上。包含的就是典型Linux系统中的/dev, /proc, /bin, /etc等标准目录和文件。rootfs就是各种不同的操作系统发行版,比如Ubuntu , Centos等等。

平时我们安装进虚拟机的CentOS都是好几个G,为什么Docker这里才200M?

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

虚拟机是分钟级的,容器是秒级

分层理解

分层的镜像

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

思考:为什么Docker镜像要采用这种分层的结构呢?
最大的好处,我觉得莫过于是资源共享了!比如有多个镜像都从相同的Base镜像构建而来,那么宿主机只需在磁盘上保留一份base镜像,同时内存中也只需要加载一份base镜像 ,这样就可以为所有的容器服务了,而且镜像的每一层都可以被共享。
查看镜像分层的方式可以通过docker image inspect命令!

理解:

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

在添加额外的镜像层的同时,镜像始终保持是当前所有镜像的组合,理解这一点非常重要。 下图中举了一个简单的例子,每个镜像层包含3个文件,而镜像包含了来自两个镜像层的6个文件。

上图中的镜像层跟之前图中的略有区别,主要目的是便于展示文件。
下图中展示了一个稍微复杂的三层镜像,在外部看来整个镜像只有6个文件,这是因为最上层中的文件7是文件5的一个更新版本。

这种情况下,上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。
Docker通过存储引擎(新版本采用快照机制)的方式来实现镜像层堆栈,并保证多镜像层对外展示为统一的文件系统。
Linux.上可用的存储引擎有AUFS. Overlay2、 Device Mapper, Btrfs 以及ZFS.顾名思义,每种存储引擎都基于Linux中对应的文件系统或者块设备技术,并且每种存储引擎都有其独有的性能特点。
Docker在Windows.上仅支持windowsfilter -种存储引擎,该引擎基于NTFS文件系统之上实现了分层和CoW[1]。
下图展示了与系统显示相同的三层镜像。所有镜像层堆叠并合并,对外提供统一的视图。

特点

Docker镜像都是只读的,当容器启动时, 一个新的可写层被加载到镜像的顶部!
这一层就是我们通常说的容器层,容器之下的都叫镜像层!

commit镜像

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

实战测试

# 启动一个默认的tomcat

# 发现这个默认的tomcat webapps下没有项目,官方的默认镜像下就是没有文件的

# 我们自己拷贝进去基本的文件,然后提交

# 将我们操作过的容器通过commit提交为新的镜像,我们以后就用我们修改过的镜像就可以,这就是我们一个修改过的镜像

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像
就好比我们以前学习VM时候，快照!

到这里就算docker入门了.

容器数据卷

什么是容器数据卷

docker的理念回顾

将应用和环境打包成一个镜像

问题:如果数据都在容器中,如果我们将容器删除,数据就会丢失

需求:数据可以持久化

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

这就是卷技术,目录的挂载,将我们容器内的目录,挂载到Linux上面.

一句话:容器的持久化和同步操作,荣期间也是可以数据共享的

使用数据卷

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

docker run -it -v 主机目录:容器内目录	

# 测试
[root@iZm5eicbmpex37r3ecz3h7Z es]# docker run -it -v /home/ceshi:/home centos /bin/bash       

# 启动之后,查看容器元信息
docker inspect 容器id  

测试文件的同步

再来测试

1.停止容器

2.主机上修改文件

3.启动容器

4.容器内的数据依旧是同步的

好处 :我们以后修改只需要在本地修改即可,容器内会自动同步

实战:安装mysql

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

# 获取镜像
[root@iZm5eicbmpex37r3ecz3h7Z /]# docker pull mysql:5.7

# 运行容器,需要做数据挂载 . 安装启动mysql时,一定要有密码
# 官方测试
$ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

# 启动mysql
-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 

# 启动成功之后,在本地使用Navicat连接测试一下
# Navicat连接到服务器的3310 --- 3310与容器内的3306映射,连接成功

# 在本地测试创建一个数据库,查看一下我们映射的路径是否ok
# 成功

如果我们将容器删除,我们挂载到本地的数据卷依旧不会丢失,这就实现了容器数据持久化功能.

具名和匿名挂载

# 匿名挂载
-d -P --name nginx01 -v /etc/nginx nginx
-v 容器内路径 	-P 随机映射端口

# 查看所有的卷的情况
[root@iZm5eicbmpex37r3ecz3h7Z /]# docker volume ls
local               0b2e6680ba0d6dcc8b141b7efb4661da724688b3789ebc03880e099c2deda420

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

# 具名挂载
[root@iZm5eicbmpex37r3ecz3h7Z /]# docker volume ls
DRIVER              VOLUME NAME
local               0b2e6680ba0d6dcc8b141b7efb4661da724688b3789ebc03880e099c2deda420
local               64e78ed3b5fbb992a4cc1eb6f68ea094afbf07d681872fca9dfe29bee4d11d54
local               juming-nginx

# 通过 -v 卷名:容器内路径
# 查看一下这个卷
[root@iZm5eicbmpex37r3ecz3h7Z /]# docker volume inspect juming-nginx

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

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

# 如何确定是具名挂载还是匿名挂载,还是指定路径挂载
-v 容器内路径	 		 # 匿名挂载
-v 卷名:容器内路径			# 具名挂载
-v /宿主机路径:容器内路径   # 指定路径挂载,一般是/开头的,指绝对路径

拓展:

# 通过 -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,就说明这个路径只能通过宿主机来操作,容器内无法操作
# 默认rw

初识DockerFile

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

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

# 创建一个dockerfile文件,名字可以随意,建议还是dockerfile
# 文件中的内容 指令(大写) 参数
FROM centos

VOLUME ["volume01","volume02"]

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

# 这里的每个命令,就是镜像的一层
# 执行dockerfile
docker build -f /home/docker-test-volume/dockerfile1 -t kangyuan/centos:1.0 .

# 启动自己写的image

这个目录就是我们生成镜像的时候自动挂载的,数据卷目录

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

查看一下挂载的路径

# 新建一个文件
[root@5a096611a0e1 /]# cd volume01
[root@5a096611a0e1 volume01]# ls
[root@5a096611a0e1 volume01]# touch container.txt
[root@5a096611a0e1 volume01]# ls
container.txt

# 测试一下我们刚才的文件是否同步了
[root@iZm5eicbmpex37r3ecz3h7Z home]# cd /var/lib/docker/volumes/63f56582dd79cac81b74f14256738103d0a950539edbafd6b8dbfe06c53ac91b/_data
[root@iZm5eicbmpex37r3ecz3h7Z _data]# ls
container.txt

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

假设构建镜像时没有挂载卷,要手动镜像挂载 -v 卷名:容器内路径

数据卷容器

多个容器同步数据

# 启动3个容器,通过我们刚才自己的镜像启动
docker run -it --name=docker01 kangyuan/centos:1.0
docker run -it --name docker02 --volumes-from docker01 kangyuan/centos:1.0

# 测试删除docker01,查看docker02和docker03是否还可以访问volume01中的文件
# 测试结果发现依旧可以访问

多个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-from mysql01 mysql:5.7 

# 这个时候,可以实现两个容器数据同步

结论:

容器之间配置信息的传递,数据卷容器的生命周期一直持续到没有容器使用为止

但是一旦你持久化到了本地,这个时候,本地的数据是不会删除的

DockerFile

dockerfile是用来构建docker镜像的文件 命令参数脚本

构建步骤:

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

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

跳转到了github,发现就是一个Dockerfile

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

官方既然可以制作镜像,我们当然也可以

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					# 构建的时候设置环境变量

以前我们是使用别人的,现在我们知道了这些指令,练习自己写一个镜像

实战测试

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

创建一个自己的CentOS

# 1.编写dockerfile文件
[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# cat mydockerfile-centos 
FROM centos
MAINTAINER kangyuan<[email protected]>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80

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

# 2.通过这个文件构建镜像 
# 命令 docker build -f dockerfile文件路径 -t 镜像名[:tag] .(这里有个点)
Successfully built 1134d387377e
Successfully tagged mycentos:0.1

# 3.测试运行

对比:之前的原生的centos

我们增加之后的镜像

我们可以列出本地镜像的变更历史

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

CMD与ENTRYPOINT的区别

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

测试CMD

# 编写dockerfile文件
[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]

# 构建镜像
[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .

# run运行,发现我们的ls -a生效
[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# docker run cmdtest
.
..
.dockerenv
bin
dev
etc
home
lib
lib64

# 想追加一个命令 -l 发现报错 (ls -al)
[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# docker run cmdtest -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不是命令所以就会报错

测试ENTRYPOINT

[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# vim dockerfile-cmd-entrypoint
FROM centos
ENTRYPOINT ["ls","-a"]

[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# docker build -f dockerfile-cmd-entrypoint -t entrypoint-test .
[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# docker run entrypoint-test
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found

# 我们的追加命令,是直接拼接在我们的ENTRYPOINT命令的后面
[root@iZm5eicbmpex37r3ecz3h7Z dockerfile]# docker run entrypoint-test -l
total 56
drwxr-xr-x   1 root root 4096 May 17 02:13 .
drwxr-xr-x   1 root root 4096 May 17 02:13 ..
-rwxr-xr-x   1 root root    0 May 17 02:13 .dockerenv
lrwxrwxrwx   1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 17 02:13 dev
drwxr-xr-x   1 root root 4096 May 17 02:13 etc
drwxr-xr-x   2 root root 4096 May 11  2019 home
lrwxrwxrwx   1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx   1 root root    9 May 11  2019 lib64 -> usr/lib64
drwx------   2 root root 4096 Jan 13 21:48 lost+found

Dockerfile中很多命令都十分的相似,我们需要了解他们的区别,最好的学习就是对比然后测试

实战:Tomcat镜像

1. 准备镜像文件tomcat压缩包,jdk压缩包
2. 编写dockerfile文件,官方命名Dockerfile,build会自动寻找这个文件,就不需要-f指定了

FROM centos
MAINTAINER kangyuan<[email protected]>

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u152-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-8.5.24.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_152
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.24
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.24
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

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

3. 构件镜像

docker build -t diytomcat . 

4. 启动镜像

docker run -d -p 3030:8080 --name kangyuantomcat 
-v /root/dockertest/test:/usr/local/apache-tomcat-8.5.24/webapps/test 
-v /root/dockertest/tomcatlogs/:/usr/local/apache-tomcat-8.5.24/logs diytomcat

5. 访问测试 成功
6. 发布项目(由于做了卷挂载,我们直接在本地编写项目就可以发布了)

  <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>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>







Hello World!

<%
System.out.println("-------my test web logs-------");
%>

发现:项目部署成功,可以直接访问.

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

发布自己的镜像

DockerHub

1. 地址 https://hub.docker.com/ 注册自己的账号
2. 确定这个账号可以登录
3. 在我们服务器上提交自己的镜像

[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker login --help

Usage:  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@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker login -u imdeemo
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-store

Login Succeeded

4. 登录完毕后就可以提交镜像了.就是一步docker push

# push自己的镜像到服务器上
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker push diytomcat        
The push refers to repository [docker.io/library/diytomcat]
222e77312b5e: Preparing 
aa99731ac7f3: Preparing 
450eefc399f6: Preparing 
f9028fc5fdeb: Preparing 
0683de282177: Preparing 
denied: requested access to the resource is denied # 拒绝

# 解决方案:增加一个tag
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker tag diytomcat imdeemo/diytomcat
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
diytomcat             latest              6368ed9615df        42 minutes ago      695MB
imdeemo/diytomcat     latest              6368ed9615df        42 minutes ago      695MB
# push,自己发布的镜像尽量带上版本号
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker push imdeemo/diytomcat:latest

提交中:

提交的时候也是按照镜像的层级来进行提交的

阿里云镜像服务

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

# 参考阿里云给的示例

小结

Docker网络原理

理解Docker0

清空所有环境

测试

三个网络

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

[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker run -d -P --name tomcat01 tomcat

# 查看容器的内部网络地址 ip addr,发现容器启动的时候会得到一个eth0@if67 ip地址,docker分配的
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# 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
66: eth0@if67: <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
       
# 思考,linux能不能ping通容器内部
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# 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.068 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.060 ms
64 bytes from 172.17.0.2: icmp_seq=3 ttl=64 time=0.065 ms

# linux可以ping通docker容器内部

原理

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

   再次测试ip addr

2. 再启动一个容器测试,发现又多了一对网卡

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

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

      [root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker exec -it tomcat02 ping 172.17.0.2
      
      # 结论: 容器和容器之间是可以互相ping通的
      

      绘制一个网络模型图:

      

   结论:tomcat01和tomcat02是共用的一个路由器,docker0

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

小结

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

Docker中的所有的网络接口都是虚拟的,虚拟的转发效率高.(内网传递文件)

只要容器删除,对应网桥一对就没了.

–link

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

[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker exec -it tomcat01 ping tomcat02
ping: tomcat02: Name or service not known

# 如何可以解决呢
# 通过--link就可以解决网络连通问题
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
434fab3886a930372a75935b23abb2da4df07d1d860143c258769961e8b93e5a
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# 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.070 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.054 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.074 ms

# 反向可以ping通吗? 不行,因为没有配置
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker exec -it tomcat02 ping tomcat03 
ping: tomcat03: Name or service not known

探究:inspect

其实这个tomcat03就是在本地配置了tomcat02的地址

# 查看hosts配置,在这里发现
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# 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 a8be6dc01d63
172.17.0.4      434fab3886a9

本质探究 --link就是我们在hosts配置中增加了一个172.17.0.3 tomcat02 a8be6dc01d63

我们现在用Docker已经不建议使用 --link了

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

docker0问题:它不支持容器名连接访问

自定义网络

容器互联

查看所有的docker网络

网络模式

bridge: 桥接docker(默认,自己创建也是用bridge模式)

none: 不配置网络

host: 和宿主机共享网络

container: 容器网络连通(用得少,局限很大)

测试

# 我们直接启动的命令	--net bridge, 而这个就是我们的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 	范围 192.168.0.2~192.168.255.255
# --gateway 192.168.0.1
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
940e573879d97543226f71d368dc4a2662f1641c13959b41737d965936403bcb
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
9ba63ff11231        bridge              bridge              local
3b094ea4e3d3        host                host                local
940e573879d9        mynet               bridge              local
ad203cf4b20d        none                null                local

[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
058ac0a65032477c198fd3536aa7e720641655aec3943be1ee552b330b23815e
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker run -d -P --name tomcat-net-02 --net mynet tomcat 
4a6e38ec160660e70ef5e46112422052144b0b304352ae91f6fda7f8c3655686
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "940e573879d97543226f71d368dc4a2662f1641c13959b41737d965936403bcb",
        "Created": "2020-05-17T15:25:39.52346407+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "058ac0a65032477c198fd3536aa7e720641655aec3943be1ee552b330b23815e": {
                "Name": "tomcat-net-01",
                "EndpointID": "a955df5a5000239de6ef1aad9058df34b380d293ec1819303e87ef9709193ec5",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "4a6e38ec160660e70ef5e46112422052144b0b304352ae91f6fda7f8c3655686": {
                "Name": "tomcat-net-02",
                "EndpointID": "1f4f1dcf76e52919b4f6ef8d1ee128d50a5535293f0eed743a302e18fe290a06",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

# 再次测试ping连接
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.110 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.064 ms

# 现在不适用--link也可以ping名字了
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# 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.036 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.065 ms

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

好处:

redis- 不同的集群使用不同的网络,保证集群是安全和健康的

mysql- 不同的集群使用不同的网络,保证集群是安全和健康的

网络连通

# 测试打通tomcat01 - mynet
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker network connect mynet tomcat01

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

# 一个容器两个ip地址	
# 好比 阿里云服务:公网ip 私网ip

# 01可以ping通
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.081 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.070 ms

# 02依旧打不通
[root@iZm5eicbmpex37r3ecz3h7Z tomcatlogs]# docker exec -it tomcat02 ping tomcat-net-01 
ping: tomcat-net-01: Name or service not known

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

实战:部署Redis集群

shell脚本

# 创建网卡
docker network create redis --subnet 172.38.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

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; \

docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

# 创建集群
[root@iZm5eicbmpex37r3ecz3h7Z /]# docker exec -it redis-1 /bin/sh

/data # 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
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: bc3aff4049d9610330f51b58871769f8ac827c63 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: 6af312198899e48ff01b1ee4a4158f7510e12d0b 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: c4f207bf3beb7ff1ac6142ab7b40166d57d34463 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: b2b335eb0306a36d23c9962b09f1ceed720200cc 172.38.0.14:6379
   replicates c4f207bf3beb7ff1ac6142ab7b40166d57d34463
S: c5bbf3ef339568f7d63000855d42ef366e52aba7 172.38.0.15:6379
   replicates bc3aff4049d9610330f51b58871769f8ac827c63
S: 5768864a0132bbc9139f16d1cf21b20868f66511 172.38.0.16:6379
   replicates 6af312198899e48ff01b1ee4a4158f7510e12d0b
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 172.38.0.11:6379)
M: bc3aff4049d9610330f51b58871769f8ac827c63 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 6af312198899e48ff01b1ee4a4158f7510e12d0b 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: b2b335eb0306a36d23c9962b09f1ceed720200cc 172.38.0.14:6379
   slots: (0 slots) slave
   replicates c4f207bf3beb7ff1ac6142ab7b40166d57d34463
S: 5768864a0132bbc9139f16d1cf21b20868f66511 172.38.0.16:6379
   slots: (0 slots) slave
   replicates 6af312198899e48ff01b1ee4a4158f7510e12d0b
S: c5bbf3ef339568f7d63000855d42ef366e52aba7 172.38.0.15:6379
   slots: (0 slots) slave
   replicates bc3aff4049d9610330f51b58871769f8ac827c63
M: c4f207bf3beb7ff1ac6142ab7b40166d57d34463 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

docker搭建redis集群完成

Springboot微服务打包Docker镜像

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

到这里我们就完全够用了Docker.

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

Docker Compose

Docker Swarm

CI/CD Jenkins