docker入门到企业全面详细教程

最新推荐文章于 2024-07-03 10:43:34 发布

weixin_44511845

最新推荐文章于 2024-07-03 10:43:34 发布

阅读量516

点赞数 2

分类专栏： # docker 文章标签： docker java linux

本文链接：https://blog.csdn.net/weixin_44511845/article/details/108700130

版权

docker 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

docker安装

安装docker

环境查看

# 系统内核是 3.10 以上的
[root@localhost /]# uname -r
3.10.0-957.el7.x86_64

# 系统版本
[root@localhost /]# cat /etc/os-release 
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

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

安装

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

# 3.设置镜像仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo # 默认是国外镜像，特别慢
    
# 推荐使用国内镜像加速
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  企业版
yum install docker-ce docker-ce-cli containerd.io

# 5.启动docker
systemctl start docker

# 6.使用docker version查看是否安装成功
[root@localhost /]# docker version
Client: Docker Engine - Community
 Version:           19.03.12
 API version:       1.40
 Go version:        go1.13.10
 Git commit:        48a66213fe
 Built:             Mon Jun 22 15:46:54 2020
 OS/Arch:           linux/amd64
 Experimental:      false

Server: Docker Engine - Community
 Engine:
  Version:          19.03.12
  API version:      1.40 (minimum version 1.12)
  Go version:       go1.13.10
  Git commit:       48a66213fe
  Built:            Mon Jun 22 15:45:28 2020
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.2.13
  GitCommit:        7ad184331fa3e55e52b890ea95e65ba581ae3429
 runc:
  Version:          1.0.0-rc10
  GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
 docker-init:
  Version:          0.18.0
  GitCommit:        fec3683
  
# 7.hello-world
docker run hello-word
[root@localhost /]# docker run hello-word
Unable to find image 'hello-word:latest' locally
docker: Error response from daemon: pull access denied for hello-word, repository does not exist or may require 'docker login': denied: requested access to the resource is denied.
See 'docker run --help'.
[root@localhost /]# docker run hello-world
WARNING: IPv4 forwarding is disabled. Networking will not work.

Hello from Docker!
This message shows that your installation appears to be working correctly.

# 8.查看一下下载的这个hello-world 镜像
[root@localhost /]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
redis               latest              1319b1eaa0b7        4 weeks ago         104MB
hello-world         latest              bf756fb1ae65        8 months ago       13.3kB

卸载docker

# 1.卸载依赖
yum remove docker-ce docker-ce-cli containerd.io

# 2.删除资源
rm -rf /var/lib/docker

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

阿里云镜像加速

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://o50kqwao.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

docker运行流程

在这里插入图片描述

底层原理

docker是怎么工作的？

Docker是一个Client-Server结构的系统，Docker的守护进程运行在主机上。通过Socket从客户端访问！
DockerServer 接收到Docker-Client的指令，就会执行这个命令！
在这里插入图片描述

docker为什么比vm快？

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

2、docker 利用的是宿主机的内核，vm需要是Guest OS。
在这里插入图片描述

所以说，新建一个容器的时候，docker不需要向虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载 GuestOS，分钟级别的，而docker是利用宿主机的操作系统吗，省略了这个复杂的过程，秒级！
在这里插入图片描述

docker的常用命令

帮助命令

docker version  # 显示docker的版本信息
docker info     # 显示docker
docker 命令 --help

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

镜像命令

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

[root@localhost ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
redis               latest              1319b1eaa0b7        4 weeks ago         104MB
hello-world         latest              bf756fb1ae65        8 months ago        13.3kB

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

# 可选项
Options:
  -a, --all             # 列出所有镜像 
  -q, --quiet           # 只显示镜像的id

docker search搜索镜像

[root@localhost ~]# docker search mysql
NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
mysql                             MySQL is a widely used, open-source relation…   9931                [OK]                
mariadb                           MariaDB is a community-developed fork of MyS…   3634                [OK]                
# 可选项，通过收藏来过滤
 --filter=STARS=3000   # 搜索出来的镜像就是STARS大于3000的

docker pull下载镜像

# 下载镜像 docker pull 镜像名[:tag]
[root@localhost ~]# docker pull mysql
Using default tag: latest  # 如果不写 tag，默认就是 latest
latest: Pulling from library/mysql
bf5952930446: Already exists  # 分层下载，docker image的核心 联合文件系统
8254623a9871: Pull complete 
938e3e06dac4: Pull complete 
ea28ebf28884: Pull complete 
f3cef38785c2: Pull complete 
894f9792565a: Pull complete 
1d8a57523420: Pull complete 
6c676912929f: Pull complete 
3cdd8ff735c9: Pull complete 
4c70cbe51682: Pull complete 
e21cf0cb4dc3: Pull complete 
28c36cd3abcc: Pull complete 
Digest: sha256:6ded54eb1e5d048d8310321ba7b92587e9eadc83b519165b70bbe47e4046e76a  # 签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest  # 真实地址

# 二者等价
 docker pull mysql
 docker pull docker.io/library/mysql:latest
 
# 指定版本下载
docker pull mysql:5.7

docker rmi删除镜像

docker rmi -f 容器id  # 删除指定的容器
docker rmi -f 容器id 容器id 容器id  # 删除多个容器
docker rmi -f $(docker images -aq)  # 删除全部容器

容器命令

以centos为例

docker pull centos

新建容器并启动

docker run [可选参数] image

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

# 测试并进入容器
[root@localhost ~]# docker run -it centos /bin/bash
[root@2f4ce01c3f40 /]# ls 
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr

# 从容器中退回主机
[root@2f4ce01c3f40 /]# exit
exit
[root@localhost ~]#

列出所有容器

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

[root@localhost ~]# docker ps -a
[root@localhost ~]# docker ps

退出容器

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

删除容器

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

启动和停止容器

docker start 容器id    # 启动容器
docker restart 容器id  # 重启容器
docker stop 容器id     # 停止当前正在运行的容器 
docker kill 容器id     # 强制停止当前容器

常用其他命令

后台启动容器

# 命令 docker run -d 镜像名
[root@localhost ~]# docker run -d centos
936fcd4b623538267bc05b82410e8d44c93151f53b225add61fb618ca3b77271
[root@localhost ~]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
02a8a7995bcd        redis               "docker-entrypoint.s…"   2 weeks ago         Up 4 hours          0.0.0.0:6379->6379/tcp   redis

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

查看日志

docker logs -f -t --tail
# 显示日志
-tf            # 显示日志
--tail number  # 要显示日志的条数

查看容器中进程信息

# 命令 docker top 容器id
[root@localhost ~]# docker top 02a8a7995bcd
UID        PID          PPID       C       STIME        TTY        TIME          CMD
polkitd    63215        63196      0       11:36         ?         00:00:33      redis-server *:6379

查看镜像的元数据

 # 命令
 docker inspect 容器id

进入当前正在运行的容器

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

# 命令
docker exec -it 容器id bashShell
# 方式二
docker attach 容器id

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

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

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

[root@localhost home]# docker attach ec2a944f8d7a
[root@ec2a944f8d7a home]# ls
[root@ec2a944f8d7a home]# touch b.java
[root@ec2a944f8d7a home]# ls
b.java
[root@ec2a944f8d7a home]# exit
exit
[root@localhost home]# docker cp ec2a944f8d7a:/home/b.java /home
[root@localhost home]# ls
a.java  b.java  xx

命令大全

attach		Attach to a running container 					#当前shell下 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 container's 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					#展示一个镜像形成历史
import 		Create a new filesystem image from the contents of a tarball		#从tar包中的内容创建一个新的文件系统映像[对应export]
info		Display system-wide information					#显示系统相关信息
inspect 	Return low-level information on a container		#查看容器详细信息
ki11		Kill a running container						#kill指定docker容器
1oad	 	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 退出
1ogs	 	Fetch the logs of a container					#输出当前容器日志信息
port 		Lookuf the public-facing port which is NAT-ed to PRIVATE_PORT	#查看映射端口对应的容器内部源端口
pause 		Pause all processes within a container			#暂停容器
ps 			List containers									#列出容器列表
pu11		Pu1l 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						#移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或-f强制删除]
run 		Run a command in a new container				#创建一个新的容器并运行一个命令
save 		save an image to a tar archive					#保存一个镜像为一个tar包[对应1oad]
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 runling processes of a container		#查看容器中运行的进程信息
unpause 	Unpause a paused container						#取消暂停容器
version 	show the docker version information				#查看docker版本号
wait 		Block until a container stops，then print its exit code		#截取容器停止时的退出状态值

docker镜像详解

镜像是什么

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

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

如何得到镜像：

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

docker镜像加载原理

UnionFS（联合文件系统）

我们下载是看到的一层层文件就是这个

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系统是一样的，包含boot加载器和内核。当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]
# 将我们操作过的容器通过commit提交为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像。

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

容器数据卷

什么是容器数据卷

docker的理念

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

数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！

如何将数据可以持久化呢？容器之间可以有一个数据共享的技术！docker容器中产生的数据，可以同步到本地。

这就是卷技术，目录的挂载，将我们容器的目录挂载到linux上。

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

使用数据卷

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

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

[root@localhost home]# docker run -it -v /home/ceshi:/home centos /bin/bash

#  启动起来时我们可以通过 docker inspect 容器id

在这里插入图片描述

容器卷内外数据同步双向绑定

具名和匿名挂载

# 匿名挂载
-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:/ect/nginx nginx
# 通过 -v 卷名:容器内路径
# 所有的docker容器内的卷，没有指定目录的情况下都是在 /var/1ib/docker/volumes/xxxx/_data

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

拓展

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

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

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

数据容器卷

多个 mysql 同步数据

在这里插入图片描述

docker run -it --name docker03 --volumes-from docker0l centos:1.0
# 测试：可以删除docker01，查看一下docker02和docker03是否还可以访问这个文件
# 测试依旧可以访问

在这里插入图片描述

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

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

Dockerfile

初识

Dockerfile 就是用来构建docker 镜像的构建文件

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

VOLUME ["volume01","volume02"]

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

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

在这里插入图片描述

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

介绍

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

构建步骤：
1、编写一个dockerfile文件

2、docker build构建成为一个镜像

3、docker run 运行镜像

4、docker push 发布镜豫（DockerHub、阿里云镜像仓库）

dockerFile构建过程

基础知识：

1、每个保留关键字（指令）都是必须是大写字母

2、执行从上到下顺序执行

3、# 表示注释

4、每一个指令都会创建提交一个新的镜像层，并提交！

在这里插入图片描述

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

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

步骤：开发，部署，运维。。。缺一不可！

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

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

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

dockerFile的指令

FROM				# 基础镜镜像，一切从这里开始构建
MAINTAINER			# 镜像是谁写的，姓名+邮箱
RUN					# 镜像构建的时候需要运行的命令
ADD					# 步骤：tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR				# 镜像的工作目录 进入容器时的目录
VOLUME				# 挂载的目录
EXPOST				# 保留端口配置
CMD					# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT			# 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD				# 当构建一个被继承DockerFile这个时候就会运行ONBUILD 的指令。触发指令。
COPY				# 类似ADD，将我们文件拷贝到镜像中
ENV					# 构建的时候设置环境变量！比如给mysql设置默认密码

创建自己的centos

# 1.编写DockerFile的文件
[root@localhost home]# cat mydockerfile-centos 
FROM centos 
MAINTAINER xx<xxx@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 dockerfile文件路径 -t 镜像名:[tag]
Successfully built e2bd75cfe070
Successfully tagged mycentos:0.1

# 3.我们可以通过 命令 查看 镜像的变更历史 ，我们平时拿到一个镜像，可以研究一下他是怎么做的。
docker history 镜像id

docker网络

docker0

在这里插入图片描述

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

# 查看容器的内部网络地址 ip addr  发现容器启动的时候会得到一个ethoaif262ip地址，docker分配的

[root@localhost ~]# docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
26: eth0@if27: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever


# 思考：linux能不能 ping 通容器内部
[root@localhost ~]# ping 172.17.0.3
PING 172.17.0.3 (172.17.0.3) 56(84) bytes of data.
64 bytes from 172.17.0.3: icmp_seq=1 ttl=64 time=0.145 ms
64 bytes from 172.17.0.3: icmp_seq=2 ttl=64 time=0.055 ms
64 bytes from 172.17.0.3: icmp_seq=3 ttl=64 time=0.061 ms
# linux 可以ping 通 docker 容器内部
# 容器和容器之间也是可以ping通的

原理

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

容器的网卡都是一对对的
evth-pair就是一对的虚拟设备接口，他们都是成对出现的，一段连着协议，一段彼此相连

正因为有这个特性，evth-pair充当一个桥梁，连接各种虚拟网络设备

Openstac，Docker容器之间的连接，OVS的连接，都是使用 evth-pair技术

容器和容器之间也是可以ping通的原理

在这里插入图片描述

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

小结

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

在这里插入图片描述

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

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

–link

docker0问题：他不支持容器名连接访问

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

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

# 如何解决呢？
# 通过--link 既可以解决了网络连通问题
[root@localhost ~]# docker run-d-P--name tomcat03--link tomcat02 tomcat
5ca72d80ebb048d3560df1400af03130f37ece244be2a54884336aace2106884
[root@localhost ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.18.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.18.0.3): icmp_seq=1 tt1=64 time=0.100 ms
64 bytes from tomcat02(172.18.0.3): icmp_seq=2 tt1=64 time=0.066 ms
64 bytes from tomcat02 (172.18.0.3): icmp_seq=3 tt1=64 time=0.067 ms

–link 就是我们在hosts配置中增加了一个172.18.0.3(tomcat ip) tomcat02312857784cd4

现在已经不适用–link了。

自定义网络

插卡所有的docker网络

[root@localhost ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
8c95e3be5799        bridge              bridge              local
165671b50e3a        host                host                local
370a77e15c89        none                null                local

网络模式

bridge : 桥接 docker （默认）

none : 不配置网络

host : 和宿主机共享网络

container : 容器网络连通！（用的少！局限很大）

测试

# 我们直接启动命令 --net brideg,而这个就是我们的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
# 创建自己的网络
[root@localhost ~]# docker network create--driver bridge --subnet 192.168.0.0/16--gateway 192.168.0.1 mynet
eb21272b3a35ceaba11b4aa5bbff131c3fb09c4790f0852ed4540707438db052

[root@localhost ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
[root@localhost ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
# 自定义网络docker已经帮我们维护好了对应的关系，推荐平时使用这个

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

在这里插入图片描述

redis部署集群

在这里插入图片描述

启动6个redis容器，上面三个是主，下面三个是备！

使用shell脚本启动！

# 创建redis集群网络
docker network create redis --subnet 172.38.0.0/16

# 通过脚本创建六个redis配置
[root@localhost /]# 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

# 查看创建的六个redis
[root@localhost /]# cd /mydata/
[root@localhost mydata]# \ls
redis
[root@localhost mydata]# cd redis/
[root@localhost redis]# ls
node-1  node-2  node-3  node-4  node-5  node-6

# 查看redis-1的配置信息
[root@localhost redis]# cd node-1
[root@localhost node-1]# ls
conf
[root@localhost node-1]# cd conf/
[root@localhost conf]# ls
redis.conf
[root@localhost conf]# cat 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.11
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes

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 redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

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

docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 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@localhost conf]# docker exec -it redis-1 /bin/sh
/data # ls
appendonly.aof  nodes.conf
/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: c5551e2a30c220fc9de9df2e34692f20f3382b32 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: d12ebd8c9e12dbbe22e7b9b18f0f143bdc14e94b 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 825146ce6ab80fbb46ec43fcfec1c6e2dac55157 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 9f810c0e15ac99af68e114a0ee4e32c4c7067e2b 172.38.0.14:6379
   replicates 825146ce6ab80fbb46ec43fcfec1c6e2dac55157
S: e370225bf57d6ef6d54ad8e3d5d745a52b382d1a 172.38.0.15:6379
   replicates c5551e2a30c220fc9de9df2e34692f20f3382b32
S: 79428c1d018dd29cf191678658008cbe5100b714 172.38.0.16:6379
   replicates d12ebd8c9e12dbbe22e7b9b18f0f143bdc14e94b
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: c5551e2a30c220fc9de9df2e34692f20f3382b32 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: 79428c1d018dd29cf191678658008cbe5100b714 172.38.0.16:6379
   slots: (0 slots) slave
   replicates d12ebd8c9e12dbbe22e7b9b18f0f143bdc14e94b
M: d12ebd8c9e12dbbe22e7b9b18f0f143bdc14e94b 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: e370225bf57d6ef6d54ad8e3d5d745a52b382d1a 172.38.0.15:6379
   slots: (0 slots) slave
   replicates c5551e2a30c220fc9de9df2e34692f20f3382b32
S: 9f810c0e15ac99af68e114a0ee4e32c4c7067e2b 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 825146ce6ab80fbb46ec43fcfec1c6e2dac55157
M: 825146ce6ab80fbb46ec43fcfec1c6e2dac55157 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 Compose

简介

以前使用docker我们使用，DockerFile build run 手动去操单个容器。如果有100个微服务，并且之间相互还有依赖关系。

此时可以使用，Docker Comepose 来轻松高效的管理容器。定义运行多个容器。

理解

Compose是docker官方的开源项目，需要安装。

Dockerfile 让程序在任何地方运行。

Compose

version: '2.0'
services:
  web:
    build: .
    ports:
    - "5000:5000"
    volumes:
    - .:/code
    - logvolume01:/var/log
    links:
    - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

Compose重要的概念

服务services，容器（例如 web 、redis 、 mysql…）
项目project，一组关联的容器（例如博客 web+mysql）

安装

下载

sudo curl -L "https://github.com/docker/compose/releases/download/1.27.3/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 这个可能快点
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

授权

sudo chmod +x /usr/local/bin/docker-compose

查看

[root@localhost bin]# docker-compose version
docker-compose version 1.25.5, build 8a1c60f6
docker-py version: 4.1.0
CPython version: 3.7.5
OpenSSL version: OpenSSL 1.1.0l  10 Sep 2019

体验

地址 : https://docs.docker.com/compose/gettingstarted/

官网提供了一个Python 应用案例，计数器

应用 app.py
Dockerfile 应用打包为镜像
Docker-compose yaml文件（定义整个服务，需要的环境。web、redis）完整的上线服务
启动compose项目（docker-compose up）
停止:docker-compose down

docker-compose，通过编写yaml配置文件，可以通过compose 一键启动、停止所有服务

yaml规则

docker-compose.yaml 核心

https://docs.docker.com/compose/compose-file/

# yaml 有3层

version: ''  # 版本
services:	# 服务
  服务1: web
    # 服务配置
    images
    build
    network
    ......
  服务2: redis
  	......
# 其他配置 网络/卷、全局规则
volumes:
networks:
configs:

详情见官网官方文档

实战

编写项目微服务

HelloController

package com.example.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    StringRedisTemplate redisTemplate;

    @GetMapping("/hello")
    public String hello(){
        Long views = redisTemplate.opsForValue().increment("views");
        return "welcome,views:"+views;
    }

}

Dockerfile 构建镜像

FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=8080"]

EXPOSE 8080

ENTRYPOINT ["java","-jar","/app.jar"]

docker-compose.yml 编排项目

version: '3.8'
services:
  demoapp:
    build: .
    image: demoapp
    depends_on:
      - redis
    ports:
      - "8080:8080"
  redis:
    image: "library/redis:alpine"

放到服务器 docker-compose up

[root@localhost bin]# cd /home/demoapp/
[root@localhost demoapp]# ll
总用量 24964
-rw-r--r--. 1 root root 25551439 9月  20 16:35 demo-0.0.1-SNAPSHOT.jar
-rw-r--r--. 1 root root      181 9月  20 16:35 docker-compose.yml
-rw-r--r--. 1 root root      124 9月  20 16:35 Dockerfile

假设项目要重新部署打包

docker-compose up --build

[root@localhost demoapp]# docker-compose up
Creating network "demoapp_default" with the default driver
Pulling redis (library/redis:alpine)...
alpine: Pulling from library/redis
df20fa9351a1: Pull complete
9b8c029ceab5: Pull complete
e983a1eb737a: Pull complete
de9de2cb6149: Pull complete
6a04900c891e: Pull complete
be5e938aa8ff: Pull complete
Digest: sha256:4015d7a6a0901920a3adfae3a538bf8489325738153948f95ca2b637944bdfe5
Status: Downloaded newer image for redis:alpine
Building demoapp
Step 1/5 : FROM java:8
8: Pulling from library/java
5040bd298390: Pull complete
fce5728aad85: Pull complete
76610ec20bf5: Pull complete
60170fec2151: Pull complete
e98f73de8f0d: Pull complete
11f7af24ed9c: Pull complete
49e2d6393f32: Pull complete
bb9cdec9c7f3: Pull complete
Digest: sha256:c1ff613e8ba25833d2e1940da0940c3824f03f802c449f3d1815a66b7f8c0e9d
Status: Downloaded newer image for java:8
 ---> d23bdf5b1b1b
Step 2/5 : COPY *.jar /app.jar
 ---> 4026bcebc5f5
Step 3/5 : CMD ["--server.port=8080"]
 ---> [Warning] IPv4 forwarding is disabled. Networking will not work.
 ---> Running in 2585df64f569
Removing intermediate container 2585df64f569
 ---> a79d3dadf1a2
Step 4/5 : EXPOSE 8080
 ---> [Warning] IPv4 forwarding is disabled. Networking will not work.
 ---> Running in 25e8ea77523b
Removing intermediate container 25e8ea77523b
 ---> 31a83a90c8ef
Step 5/5 : ENTRYPOINT ["java","-jar","/app.jar"]
 ---> [Warning] IPv4 forwarding is disabled. Networking will not work.
 ---> Running in 661d751a0234
Removing intermediate container 661d751a0234
 ---> b4fe5fc478b0

Successfully built b4fe5fc478b0
Successfully tagged demoapp:latest
WARNING: Image for service demoapp was built because it did not already exist. To rebuild this image you must use `docker-compose build` or `docker-compose up --build`.
Creating demoapp_redis_1 ... done
Creating demoapp_demoapp_1 ... done
Attaching to demoapp_redis_1, demoapp_demoapp_1
redis_1    | 1:C 20 Sep 2020 10:05:43.136 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
redis_1    | 1:C 20 Sep 2020 10:05:43.136 # Redis version=6.0.8, bits=64, commit=00000000, modified=0, pid=1, just started
redis_1    | 1:C 20 Sep 2020 10:05:43.136 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
redis_1    | 1:M 20 Sep 2020 10:05:43.138 * Running mode=standalone, port=6379.
redis_1    | 1:M 20 Sep 2020 10:05:43.138 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
redis_1    | 1:M 20 Sep 2020 10:05:43.138 # Server initialized
redis_1    | 1:M 20 Sep 2020 10:05:43.138 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
redis_1    | 1:M 20 Sep 2020 10:05:43.138 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo madvise > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled (set to 'madvise' or 'never').
redis_1    | 1:M 20 Sep 2020 10:05:43.138 * Ready to accept connections
demoapp_1  | 
demoapp_1  |   .   ____          _            __ _ _
demoapp_1  |  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
demoapp_1  | ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
demoapp_1  |  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
demoapp_1  |   '  |____| .__|_| |_|_| |_\__, | / / / /
demoapp_1  |  =========|_|==============|___/=/_/_/_/
demoapp_1  |  :: Spring Boot ::        (v2.3.4.RELEASE)
demoapp_1  | 
demoapp_1  | 2020-09-20 10:05:46.593  INFO 1 --- [           main] com.example.demo.DemoApplication         : Starting DemoApplication v0.0.1-SNAPSHOT on 7777be96fd45 with PID 1 (/app.jar started by root in /)
demoapp_1  | 2020-09-20 10:05:46.597  INFO 1 --- [           main] com.example.demo.DemoApplication         : No active profile set, falling back to default profiles: default
demoapp_1  | 2020-09-20 10:05:48.044  INFO 1 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Multiple Spring Data modules found, entering strict repository configuration mode!
demoapp_1  | 2020-09-20 10:05:48.047  INFO 1 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Bootstrapping Spring Data Redis repositories in DEFAULT mode.
demoapp_1  | 2020-09-20 10:05:48.087  INFO 1 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Finished Spring Data repository scanning in 17ms. Found 0 Redis repository interfaces.
demoapp_1  | 2020-09-20 10:05:49.227  INFO 1 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
demoapp_1  | 2020-09-20 10:05:49.274  INFO 1 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
demoapp_1  | 2020-09-20 10:05:49.274  INFO 1 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.38]
demoapp_1  | 2020-09-20 10:05:49.436  INFO 1 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
demoapp_1  | 2020-09-20 10:05:49.437  INFO 1 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 2614 ms
demoapp_1  | 2020-09-20 10:05:50.366  INFO 1 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
demoapp_1  | 2020-09-20 10:05:50.919  INFO 1 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
demoapp_1  | 2020-09-20 10:05:50.933  INFO 1 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 5.264 seconds (JVM running for 6.282)

测试

[root@localhost ~]# curl localhost:8080
{"timestamp":"2020-09-20T10:14:24.484+00:00","status":404,"error":"Not Found","message":"","path":"/"}[root@localhost ~]# curl localhost:8080/hello
welcome,views:1[root@localhost ~]# curl localhost:8080/hello

小结：
未来项目只要有docker-compose文件。修可以按照这个规则，启动编排容器。
公司项目有 docker-compose 就可以直接启动。
网上开源项目有 docker-compose 可以一键搞定。

Docker Swarm

工作模式

在这里插入图片描述

创建集群

1、生成主节点 init

2、加入（管理者、worker）

在这里插入图片描述

初始化节点 docker swarm init

docker swarm join 加入节点

# 获取令牌  有两种角色
docker swarm join-token manager
docker swarm join-token worker

在这里插入图片描述

加了两个work，和一个manager，现在两主(1、4服务器)两从(2、3服务器)

在这里插入图片描述

Raft协议

双主双从 : 假设一个节点挂了，其他节点是否可以用？

Raft协议 : 保证大多数节点存活才可以用，只要>1台 , 集群至少>3台

实验:

1、将docker1机器停止，宕机。那么双主的情况，另一个主节点也不能使用了。主节点至少需要有3台

体验

docker service

体验：创建服务、动态扩展服务、动态更新服务

在这里插入图片描述

灰度发布：金丝雀发布

在这里插入图片描述

docker run容器启动！不具有扩缩容器
docker service服务！具有扩缩容器，滚动更新！

查看服务

在这里插入图片描述

动态扩缩容（两种方法都一样）

在这里插入图片描述

服务在集群中的任意一个节点都可以访问。服务可以有多个副本动态扩缩容实现高可用！

概念总结

swarm

集群的管理和编号。docker可以初始化一个swarm集群，其他节点可以加入。（管理、工作者）

Node

就是一个docker节点。多个节点就组成了一个网络集群。（管理、工作者）

Service

任务，可以在管理节点或者工作节点来运行。核心。用户访问的就是这个

Task

容器内的命令，细节任务

在这里插入图片描述

命令 - > 管理 - > api - > 调度 - > 工作节点（创建Task容器维护创建!）

Docker Stack

docker-compose 单机部署项目！
Docker Stack 部署，集群部署！

# 单机
docker-compose up -d wordpress.yaml
# 集群
docker stack deploy wordpress.yaml

# docker-compose 文件
version: '3.4'
services:
  mongo:
    image: mongo
    restart: always
    networks: 
      - mongo_network
    deploy:
      restart_policy:
        condition: on-failure
      replicas: 2
  mongo-express: 
    image: mongo-express
    restart: always
    networks: 
      - mongo_network
    ports:
      - target: 8081
        published: 80
        protocol: tcp
        mode: ingress
    environment:
      ME_CONFIG_MONGODB_SERVER: mongo
      ME_CONFIG_MONGODB_PORT: 27017
    deploy:
      restart_policy:
        condition: on-failure
      replicas: 1
networks:
  mongo_network:
    external: true