Docker Swarm简单教程

??Swarm是Docker公司推出管理docker几乎所有的集群平台都使用GO语言开发，代码开源https://github.com/docker/swarm， 它是将一群Docker宿主机成为单一的虚拟主机，Swarm使用标准的Docker API接口是其前端的访问入口。

??换句话说，各种形式Docker Client(compose,docker-py等)可以直接和Swarm通信，甚至Docker它本身可以很容易地与Swarm集成极大地方便了用户移植基于单节点的系统Swarm上，同时Swarm内置了对Docker支持网络插件，跨主机容器集群服务跨主机容器集群服务。

??Docker Swarm 和 Docker Compose 一样，都是 Docker 但不同的是，官方容器安排项目，Docker Compose 它是在单个服务器或主机上创建多个容器的工具 Docker Swarm 容器集群服务可以在多个服务器或主机上创建。显然，微服务的部署 Docker Swarm 会更合适。

??从 Docker 1.12.0 版本开始，Docker Swarm 已经包含在 Docker 引擎中（docker swarm），服务发现工具已经内置，我们不需要像以前那样配置 Etcd 或者 Consul 服务发现配置。

??Swarm deamon只是调度器(Scheduler)加路由器(router),Swarm不运行容器，只接受Docker对于客户端发送的请求，调度合适的节点来操作容器，即使Swarm由于某原因挂断，集群中的节点也会照常运行，放置Swarm重建后，他将收集重建集群信息。

??从结构图中可以看出 Docker Client使用Swarm对 集群(Cluster)调度使用。

??从上图可以看出，Swarm是典型的master-slave通过发现服务选举结构manager。manager是中心管理节点，每个节点node上运行agent接受manager通过统一管理，集群将自动通过Raft协议分布式选举manager无需额外的发现和服务支持，节点避免了单点的瓶颈问题，内置了DNS负载平衡和对外部负载平衡机制的综合支持

??嵌入式集群的管理和安排docker引擎的SwarmKit，可以在docker启动初始化swarm或添加现有模式或添加现有模式swarm

??一个节点是docker引擎集群的一个实例。您还可以将其视为Docker节点。您可以在单个物理计算机或云服务器上运行一个或多个节点，但生产集群部署通常包括分布在多个物理和云计算机上Docker节点。

??部署应用程序swarm，请提交服务定义 管理器节点。管理器节点(manager nodes)被称为任务的工作单位分配 给工作节点(worker nodes)。

??Manager节点还执行维护所需集群状态所需的安排和集群管理功能。Manager节点选择单个领导来执行安排任务。接收并执行从管理器节点分配的任务。

??默认情况下，管理器节点也将服务作为工作节点运行，但您可以将其配置为只操作管理器任务和只操作管理器节点。代理程序在每个工作节点上运行，并报告分配给它的任务。工作节点将分配的任务的当前状态通知管理器节点，使管理器能够保持每个工人的预期状态。

??node是加入到swarm集群中的一个docker引擎实体，可以在一台物理机上运行多个node，node分为：

• manager nodes，即管理节点，执行集群管理功能，维护集群状态，选择一个leader节点执行调度任务。
• worker nodes，即工作节点，接收和执行任务参与容器集群负载调度，仅用于承载task。

  一个服务是任务的定义，管理机或工作节点上执行。它是群体系统的中心结构，是用户与群体交互的主要根源。创建服务时，你需要指定要使用的容器镜像。

  创建一个服务，指定了容器所使用的镜像和容器运行的命令; service是运行在worker nodes上的task的描述，service的描述包括使用哪个docker 镜像，以及在使用该镜像的容器中执行什么命令。

  任务是在docekr容器中执行的命令，Manager节点根据指定数量的任务副本分配任务给worker节点

  一个任务包含了一个容器及其运行的命令。task是service的执行实体，task启动docker容器并在容器中执行任务。

• docker swarm：集群管理，子命令有 init, join, leave, update。（docker swarm --help查看帮助）
• docker service：服务创建，子命令有 create, inspect, update, remove, tasks。（docker service–help查看帮助）
• docker node：节点管理，子命令有 accept, promote, demote, inspect, update, tasks, ls, rm。（docker node --help查看帮助）

  Swarm在调度(scheduler)节点（leader节点）运行容器的时候，会根据指定的策略来计算最适合运行容器的节点，目前支持的策略有：spread, binpack, random.

1）Random
  顾名思义，就是随机选择一个Node来运行容器，一般用作调试用，spread和binpack策略会根据各个节点的可用的CPU, RAM以及正在运行的容器的数量来计算应该运行容器的节点。

2）Spread
  在同等条件下，Spread策略会选择运行容器最少的那台节点来运行新的容器，binpack策略会选择运行容器最集中的那台机器来运行新的节点。

  使用Spread策略会使得容器会均衡的分布在集群中的各个节点上运行，一旦一个节点挂掉了只会损失少部分的容器。

3）Binpack
  Binpack策略最大化的避免容器碎片化，就是说binpack策略尽可能的把还未使用的节点留给需要更大空间的容器运行，尽可能的把容器运行在一个节点上面。

1）批量创建服务
  建立容器之前先创建一个overlay的网络，用来保证在不同主机上的容器网络互通的网络模式

2）强大的集群的容错性
  当容器副本中的其中某一个或某几个节点宕机后，cluster会根据自己的服务注册发现机制，以及之前设定的值--replicas n，

  在集群中剩余的空闲节点上，重新拉起容器副本。整个副本迁移的过程无需人工干预，迁移后原本的集群的load balance依旧好使！

  不难看出，docker service其实不仅仅是批量启动服务这么简单，而是在集群中定义了一种状态。Cluster会持续检测服务的健康状态并维护集群的高可用性。

3）服务节点的可扩展性
  Swarm Cluster不光只是提供了优秀的高可用性，同时也提供了节点弹性扩展或缩减的功能。当容器组想动态扩展时，只需通过 scale 参数即可复制出新的副本出来。

  仔细观察的话，可以发现所有扩展出来的容器副本都run在原先的节点下面，如果有需求想在每台节点上都run一个相同的副本，方法其实很简单，只需要在命令中将 "--replicas n" 更换成 "--mode=global" 即可！

• 复制服务（–replicas n）
  将一系列复制任务分发至各节点当中，具体取决于您所需要的设置状态，例如“–replicas 3”。

• 全局服务（–mode=global）
  适用于集群内全部可用节点上的服务任务，例如 "--mode=global" 。如果大家在 Swarm 集群中设有 7 台 Docker 节点，则全部节点之上都将存在对应容器。

4）调度机制
  所谓的调度其主要功能是cluster的server端去选择在哪个服务器节点上创建并启动一个容器实例的动作。它是由一个装箱算法和过滤器组合而成。每次通过过滤器（constraint）启动容器的时候，swarm cluster 都会调用调度机制筛选出匹配约束条件的服务器，并在这上面运行容器。

------------------Swarm cluster的创建过程包含以下三个步骤----------------------

• 1）发现Docker集群中的各个节点，收集节点状态、角色信息，并监视节点状态的变化
• 2）初始化内部调度（scheduler）模块
• 3）创建并启动API监听服务模块

  一旦创建好这个cluster，就可以用命令docker service批量对集群内的容器进行操作，非常方便！

  在启动容器后，docker 会根据当前每个swarm节点的负载判断，在负载最优的节点运行这个task任务，用"docker service ls" 和"docker service ps + taskID"可以看到任务运行在哪个节点上。容器启动后，有时需要等待一段时间才能完成容器创建。

机器环境(四台机器，centos7.x系统)

IP：192.168.13.130 ；主机名：host-192-168-13-130 ；担任角色：swarm manager

IP：192.168.13.131 ；主机名：host-192-168-13-131 ；担任角色：swarm node

IP：192.168.13.132 ；主机名：host-192-168-13-132 ；担任角色：swarm node

IP：192.168.13.133 ；主机名：host-192-168-13-133 ；担任角色：swarm node

  1、修改 hosts 信息

# 编辑修改 192.168.13.130 服务器的 /etc/hosts 文件为以下内容
$ vim /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.13.130  host-192-168-13-130
192.168.13.131  host-192-168-13-131
192.168.13.132  host-192-168-13-132
192.168.13.133  host-192-168-13-133

  2、将 hosts 文件同步到其他节点

# 将 hosts 文件同步到 host-192-168-13-131 节点
$ scp /etc/hosts root@192.168.13.131:/etc/hosts

# 将 hosts 文件同步到 host-192-168-13-132 节点
$ scp /etc/hosts root@192.168.13.132:/etc/hosts

# 将 hosts 文件同步到 host-192-168-13-133 节点
$ scp /etc/hosts root@192.168.13.133:/etc/hosts

   3、设置防火墙

  关闭三台机器上的防火墙。如果开启防火墙，则需要在所有节点的防火墙上依次放行 2377/tcp（管理端口）、7946/udp（节点间通信端口）、4789/udp（overlay 网络端口）端口。

# 关闭防火墙
$ systemctl disable firewalld.service
$ systemctl stop firewalld.service

  防火墙开发端口(命令含义)

• –zone #作用域
• –add-port=80/tcp #添加端口，格式为：端口/通讯协议
• –permanent #永久生效，没有此参数重启后失效

# 添加规则
$ firewall-cmd --zone=public --add-port=2377/tcp --permanent
$ firewall-cmd --zone=public --add-port=7946/udp--permanent
$ firewall-cmd --zone=public --add-port=4789/udp--permanent

# 重启防火墙
$ firewall-cmd --reload

  4、安装docker并配置加速器(在四台主机都要安装)

  安装过程省略不写

$ docker swarm init --advertise-addr 192.168.13.130
Swarm initialized: current node (z2n633mty5py7u9wyl423qnq0) is now a manager.
 
To add a worker to this swarm, run the following command:
 
    # 这就是添加节点的方式(要保存初始化后token，因为在节点加入时要使用token作为通讯的密钥)
    docker swarm join --token SWMTKN-1-2lefzq18zohy9yr1vskutf1sfb2a590xz9d0mjj2m15zu9eprw-2938j5f50t35ycut0vbj2sx0s 192.168.31.43:2377  
 
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

  上面命令(docker swarm join)执行后，该机器自动加入到 swarm 集群。这个会创建一个集群token，获取全球唯一的 token，作为集群唯一标识。

  后续将其他节点加入集群都会用到这个token值。其中，--advertise-addr 参数表示其它swarm中的worker节点使用此ip地址与manager联系。命令的输出包含了其它节点如何加入集群的命令。

  如果当前节点中已经有 swarm,则会出现以下错误：

$ docker swarm init --advertise-addr 192.168.13.130
Error response from daemon: This node is already part of a swarm. Use "docker swarm leave" to leave this swarm and join another one.

  解决方式很简单：离开之前的swarm即可：

  这里的leave就是在集群中删除节点，-f参数强制删除，执行完在重新执行OK

$ docker swarm leave -f

# 192.168.13.131 服务器加入到集群中（在192.168.13.131服务器上执行当前命令）
$ docker swarm join --token SWMTKN-1-2lefzq18zohy9yr1vskutf1sfb2a590xz9d0mjj2m15zu9eprw-2938j5f50t35ycut0vbj2sx0s 192.168.13.130:2377

# 192.168.13.132 服务器加入到集群中（在192.168.13.132服务器上执行当前命令）
$ docker swarm join --token SWMTKN-1-2lefzq18zohy9yr1vskutf1sfb2a590xz9d0mjj2m15zu9eprw-2938j5f50t35ycut0vbj2sx0s 192.168.13.130:2377

# 192.168.13.133 服务器加入到集群中（在192.168.13.133服务器上执行当前命令）
$ docker swarm join --token SWMTKN-1-2lefzq18zohy9yr1vskutf1sfb2a590xz9d0mjj2m15zu9eprw-2938j5f50t35ycut0vbj2sx0s 192.168.13.130:2377

  当前命令需要在 swarm manager所在的节点执行

$ docker node ls
ID                            HOSTNAME              STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
odudl9jtsh9outjeqpvep97of *   host-192-168-13-130   Ready               Active              Leader              19.03.13
rks3yfgf0on9vianshk00z4gw     host-192-168-13-131   Ready               Active                                  19.03.13
wfdmpemouhxmsorc555znl92a     host-192-168-13-132   Ready               Active                                  19.03.13
jsj8jtontfa6lzqg659mkw3z9     host-192-168-13-133   Ready               Active                                  19.03.12

  swarm集群中node的 availability 状态可以为 active 或者drain，其中：

• active状态下，node可以接受来自manager节点的任务分派；
• drain状态下，node节点会结束task，且不再接受来自manager节点的任务分派（也就是下线节点）

  上线和下线的操作分为：主动上下线(在需要上下线所在的服务器上执行命令) 和 被动上下线(在manager上执行命令)

  主动上下线

# 下线操作
$ docker swarm leave -f

# 上线操作
$ docker swarm join --token SWMTKN-1-2lefzq18zohy9yr1vskutf1sfb2a590xz9d0mjj2m15zu9eprw-2938j5f50t35ycut0vbj2sx0s 192.168.13.130:2377

  被动上下线

# 下线操作
$ docker node update --availability drain host-192-168-13-133

# 上线操作
$ docker node update --availability active host-192-168-13-133

  Docker 1.12版本提供服务的Scaling、health check、滚动升级等功能，并提供了内置的dns、vip机制，实现service的服务发现和负载均衡能力

# 创建网络
$ docker network create -d overlay nginx_net
a52jy33asc5o0ts0rq823bf0m

# 查看网络
$ docker network ls | grep nginx_net
a52jy33asc5o        nginx_net           overlay             swarm

  在这里创建一个只有一个副本(--replicas 1)的nginx服务，使用的是latest tag的nginx镜像

$ docker service create --replicas 1 --network nginx_net --name my_nginx -p 80:80 nginx
olexfmtdf94sxyeetkchwhehg
overall progress: 1 out of 1 tasks
1/1: running   [==================================================>]
verify: Service converged

  在manager-node节点上使用上面这个覆盖网络创建nginx服务：其中，–replicas 参数指定服务由几个实例组成。

  查看正在运行服务的列表

$ docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
fh3fd9hs0yo7        my_nginx            replicated          1/1                 nginx:latest        *:80->80/tcp

  查询到哪个节点正在运行该服务。

$ docker service ps my_nginx
ID                  NAME                IMAGE               NODE                  DESIRED STATE       CURRENT STATE         ERROR                              PORTS
091xwdq64ntp        my_nginx.1          nginx:latest        host-192-168-13-132   Running             Running 3 hours ago

  当然，如果只是通过service启动容器，swarm也算不上什么新鲜东西了。Service还提供了复制（类似k8s里的副本）功能。可以通过 docker service scale 命令来设置服务中容器的副本数比如将上面的my_nginx容器动态扩展到4个.

$ docker service scale my_nginx=4
my_nginx scaled to 4
overall progress: 4 out of 4 tasks
1/4: running   [==================================================>]
2/4: running   [==================================================>]
3/4: running   [==================================================>]
4/4: running   [==================================================>]
verify: Service converged

  和创建服务一样，增加scale数之后，将会创建新的容器，这些新启动的容器也会经历从准备到运行的过程，过一分钟左右，服务应该就会启动完成.

  如果想要在每个节点都启动一个服务，则可以使用如下的命令；

$ docker service create --mode=global --network nginx_net --name my_nginx -p 80:80 nginx

  执行完命令之后可以看到，之前my_nginx容器只在manager-node节点上有一个实例，而现在又增加了3个实例。这4个副本的my_nginx容器分别运行在这三个节点上，登陆这三个节点，就会发现已经存在运行着的my_nginx容器

  特别需要清楚的一点：如果一个节点宕机了（即该节点就会从swarm集群中被踢出），则Docker应该会将在该节点运行的容器，调度到其他节点，以满足指定数量的副本保持运行状态。

  将 host-192-168-13-133 宕机后或将 host-192-168-13-133 的docker服务关闭，那么它上面的task实例就会转移到别的节点上。当 host-192-168-13-133 节点恢复后，它转移出去的task实例不会主动转移回来，只能等别的节点出现故障后转移task实例到它的上面。使用命令"docker node ls"，发现 host-192-168-13-133 节点已不在swarm集群中了(状态为：Down)。

# 查看node节点列表
$ docker node ls
ID                            HOSTNAME              STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
odudl9jtsh9outjeqpvep97of *   host-192-168-13-130   Ready               Active              Leader              19.03.13
rks3yfgf0on9vianshk00z4gw     host-192-168-13-131   Ready               Active                                  19.03.13
wfdmpemouhxmsorc555znl92a     host-192-168-13-132   Ready               Active                                  19.03.13
jsj8jtontfa6lzqg659mkw3z9     host-192-168-13-133   Ready               Active                                  19.03.12

# 关闭 host-192-168-13-133 的docker（在host-192-168-13-133服务器执行如下命令）
$ service docker stop

# 查看运行状态
$ docker node ls
ID                            HOSTNAME              STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
odudl9jtsh9outjeqpvep97of *   host-192-168-13-130   Ready               Active              Leader              19.03.13
rks3yfgf0on9vianshk00z4gw     host-192-168-13-131   Ready               Active                                  19.03.13
wfdmpemouhxmsorc555znl92a     host-192-168-13-132   Ready               Active                                  19.03.13
jsj8jtontfa6lzqg659mkw3z9     host-192-168-13-133   Down                Active                                  19.03.12

# 启动 host-192-168-13-133 的docker（在host-192-168-13-133服务器执行如下命令）
$ service docker start

# 再次查看运行状态,可以发现服务已经自动注册
$ docker node ls
ID                            HOSTNAME              STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
odudl9jtsh9outjeqpvep97of *   host-192-168-13-130   Ready               Active              Leader              19.03.13
rks3yfgf0on9vianshk00z4gw     host-192-168-13-131   Ready               Active                                  19.03.13
wfdmpemouhxmsorc555znl92a     host-192-168-13-132   Ready               Active                                  19.03.13
jsj8jtontfa6lzqg659mkw3z9     host-192-168-13-133   Ready               Active                                  19.03.12

  先创建一个service，副本个数为1

$ docker service create --replicas 1 --network nginx_net --name my_nginx -p 80:80 nginx
uowm44evezclt3a6rsm2e9ban
overall progress: 1 out of 1 tasks 
1/1: running   [==================================================>] 
verify: Service converged

  查看 task 所在的位置，这里可以看到运行的节点在 host-192-168-13-131

$ docker service ps my_nginx
ID                  NAME                IMAGE               NODE                  DESIRED STATE       CURRENT STATE                ERROR                              PORTS
cb0gn9nqkdz5        my_nginx.1          nginx:latest        host-192-168-13-131   Running             Running about a minute ago 

  停掉 host-192-168-13-131 的docker

$ service docker stop

  再次查看 task 所在的位置

$ docker service ps my_nginx
ID                  NAME                IMAGE               NODE                  DESIRED STATE       CURRENT STATE            ERROR                              PORTS
2ytr9benzckx        my_nginx.1          nginx:latest        host-192-168-13-132   Running             Running 16 seconds ago                                      
cb0gn9nqkdz5         \_ my_nginx.1      nginx:latest        host-192-168-13-131   Shutdown            Running 4 minutes ago 

  这里可以发现 task 已经成功的从 host-192-168-13-131 转移到了 host-192-168-13-132节点

  这样就会把所有节点上的所有容器（task任务实例）全部删除了

$ docker service rm my_nginx

  上面我们只是对单独的一个nginx服务进行的集群部署，那如果要统一编排多个服务呢？

  docker 三剑客中有个compose 这个就是对单机进行统一编排的，它的实现是通过docker-compose.yml的文件，这里我们就可以结合compose和swarm进行多服务的编排.

  我们这里要部署的服务有三个(nginx服务，visualizer服务，portainer服务) 都是集群 GUI 管理服务docker service 部署的是单个服务，我们可以使用 docker stack 进行多服务编排部署

# 创建文件夹
$ mkdir testswarm && cd testswarm 

# 编写docker-compose.yml文件
$ cat >> docker-compose.yml <<END version: "3" services: nginx: image: nginx ports: - 8888:80 deploy: mode: replicated replicas: 3 visualizer: image: dockersamples/visualizer ports: - "8080:8080" volumes: - "/var/run/docker.sock:/var/run/docker.sock" deploy: mode: replicated replicas: 1 placement: constraints: [node.role == manager] portainer: image: portainer/portainer ports: - "9000:9000" volumes: - "/var/run/docker.sock:/var/run/docker.sock" deploy: mode: replicated replicas: 1 placement: constraints: [node.role == manager] END

$ docker stack deploy -c docker-compose.yml deploy_deamon
Creating network deploy_deamon_default
Creating service deploy_deamon_portainer
Creating service deploy_deamon_nginx
Creating service deploy_deamon_visualizer

  通过上面的执行过程可以看出这样创建会默认创建一个网络并使用它，名字都是我们给的名字的前缀加上服务名

$ docker service ls
ID                  NAME                       MODE                REPLICAS            IMAGE                             PORTS
kum62wwxl7i4        deploy_deamon_nginx        replicated          2/3                 nginx:latest                      *:8888->80/tcp
i99zy9738y85        deploy_deamon_portainer    replicated          0/1                 portainer/portainer:latest        *:9000->9000/tcp
3b4fq2y54ann        deploy_deamon_visualizer   replicated          0/1                 dockersamples/visualizer:latest   *:8080->8080/tcp

# 查看deploy_deamon_nginx 服务
$ docker service ps deploy_deamon_nginx
ID                  NAME                        IMAGE               NODE                  DESIRED STATE       CURRENT STATE                 ERROR                              PORTS
lu8eq9gqsd43        deploy_deamon_nginx.1       nginx:latest        host-192-168-13-133   Running             Running about a minute ago                                       
dduslkswlt1r        deploy_deamon_nginx.2       nginx:latest        host-192-168-13-132   Running             Running about a minute ago                                       
kuxa146m7skb        deploy_deamon_nginx.3       nginx:latest        host-192-168-13-133   Running             Running 53 seconds ago

# 查看 deploy_deamon_portainer 服务
$ docker service ps deploy_deamon_portainer
ID                  NAME                            IMAGE                        NODE                  DESIRED STATE       CURRENT STATE            ERROR                              PORTS
nwwft2w2ll99        deploy_deamon_portainer.1       portainer/portainer:latest   host-192-168-13-130   Running             Starting 1 second ago

  1、访问 portainer 应用，地址为：http://192.168.13.130:9000/

  2、点击具体的服务可以查看到所在的节点信息

  3、点击节点可以查看task任务的详情日志

  在Docker版本1.12之后swarm模式原生支持覆盖网络(overlay networks)，可以先创建一个覆盖网络，然后启动容器的时候启用这个覆盖网络，这样只要是这个覆盖网络内的容器，不管在不在同一个宿主机上都能相互通信，即跨主机通信！不同覆盖网络内的容器组之间是相互隔离的（相互ping不通）。

  swarm模式的覆盖网络包括以下功能：

• 1）可以附加多个服务到同一个网络。
• 2）默认情况下，service discovery为每个swarm服务分配一个虚拟IP地址(vip)和DNS名称，使得在同一个网络中容器之间可以使用服务名称为互相连接。
• 3）可以配置使用DNS轮循而不使用VIP
• 4）为了可以使用swarm的覆盖网络，在启用swarm模式之间你需要在swarm节点之间开放以下端口：
• 5）TCP/UDP端口7946 – 用于容器网络发现
• 6）UDP端口4789 – 用于容器覆盖网络

$ docker network create --driver overlay --opt encrypted --subnet 10.10.19.0/24 ngx_net

  参数解释：

• --opt encrypted 默认情况下swarm中的节点通信是加密的。在不同节点的容器之间，可选的--opt encrypted 参数能在它们的vxlan流量启用附加的加密层。
• --subnet 命令行参数指定overlay网络使用的子网网段。当不指定一个子网时，swarm管理器自动选择一个子网并分配给网络。

$ docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
d7aa48d3e485        bridge              bridge              local            
9e637a97a3b9        docker_gwbridge     bridge              local            
b5a41c8c71e7        host                host                local            
7f4fx3jf4dbr        ingress             overlay             swarm            
3x2wgugr6zmn        ngx_net             overlay             swarm            
0808a5c72a0a        none                null                local

  由上可知，Swarm当中拥有2套覆盖网络。其中"ngx_net"网络正是我们在部署容器时所创建的成果。而"ingress"覆盖网络则为默认提供。

  Swarm 管理节点会利用 ingress 负载均衡以将服务公布至集群之外，在将服务连接到这个创建的网络之前，网络覆盖到 manager 节点。上面输出的 SCOPE 为 swarm 表示将服务部署到Swarm时可以使用此网络。

  在将服务连接到这个网络后，Swarm只将该网络扩展到特定的 worker 节点，这个 worker 节点被swarm调度器分配了运行服务的任务。

  在那些没有运行该服务任务的worker节点上，网络并不扩展到该节点。

$ docker service create --replicas 3 --network ngx_net --name my-test -p 80:80 nginx

  上面名为"my-test"的服务启动了3个task，用于运行每个任务的容器都可以彼此通过overlay网络进行通信。Swarm集群将网络扩展到所有任务处于Running状态的节点上。

$ docker service ls
ID            NAME     REPLICAS  IMAGE  COMMAND
dsaxs6v463g9  my-test  3/3       nginx

  在manager-node节点上，通过下面的命令查看哪些节点有处于running状态的任务：

docker service ps my-test
ID                         NAME       IMAGE  NODE          			DESIRED STATE  CURRENT STATE          ERROR
8433fuiy7vpu0p80arl7vggfe  my-test.1  nginx  host-192-168-13-131    Running        Running 2 minutes ago
f1h7a0vtojv18zrsiw8j0rzaw  my-test.2  nginx  host-192-168-13-132    Running        Running 2 minutes ago
ex73ifk3jvzw8ukurl8yu7fyq  my-test.3  nginx  host-192-168-13-133	Running        Running 2 minutes ago

  可见三个节点都有处于running状态的任务，所以my-network网络扩展到三个节点上。

  可以通过查询服务来获得服务的虚拟IP地址，如下：

$ docker service inspect --format='{ 
        {json .Endpoint.VirtualIPs}}' my-test
[{ 
        "NetworkID":"7f4fx3jf4dbrp97aioc05pul4","Addr":"10.255.0.6/16"},{ 
        "NetworkID":"3x2wgugr6zmn1mcyf9k1du27p","Addr":"10.10.19.2/24"}]

  默认情况下，当创建了一个服务并连接到某个网络后，swarm会为该服务分配一个VIP。此VIP根据服务名映射到DNS。在网络上的容器共享该服务的DNS映射，所以网络上的任意容器可以通过服务名访问服务。

  在同一overlay网络中，不用通过端口映射来使某个服务可以被其它服务访问。Swarm内部的负载均衡器自动将请求发送到服务的VIP上，然后分发到所有的 active 的 task 上。

例如：
  在同一个网络中添加了一个centos服务，此服务可以通过名称my-test访问前面创建的nginx服务：

$ docker service create --name my-centos --network ngx_net centos 

  查询centos运行在哪个节点上（上面创建命令执行后，需要一段时间才能完成这个centos服务的创建）

$ docker service ps my-centos
ID                         NAME             IMAGE   NODE   					DESIRED STATE  CURRENT STATE            ERROR
e03pqgkjs3l1qizc6v4aqaune  my-centos.1      centos  host-192-168-13-131  	Running        Preparing 4 seconds ago

  登录centos运行的节点（由上可知是node2节点），打开centos的交互shell：

$ docker ps
CONTAINER ID        IMAGE                    COMMAND                  CREATED             STATUS            NAMES
e4554490d891        centos:latest            "/bin/bash"             About an hour ago   Up About an hour   my-centos.1.9yk5ie28gwk9mw1h1jovb68ki

  进入到容器的内部，查看

$ docker exec -ti my-centos.1.9yk5ie28gwk9mw1h1jovb68ki /bin/bash
root@4bdcce0ee63e:/# nslookup my-test
Server: 127.0.0.11
Address 1: 127.0.0.11
  
Name: my-test
Name: tasks.my-test
Address 1: 10.10.19.4 my-test.1.8433fuiy7vpu0p80arl7vggfe
Address 2: 10.10.19.5 my-test.2.f1h7a0vtojv18zrsiw8j0rzaw
Address 3: 10.10.19.6 my-test.3.ex73ifk3jvzw8ukurl8yu7fyq
Address 2: 10.10.19.7 my-test.4.cyu73jd8psupfhken23vvmpud
Address 3: 10.10.19.3 my-test.5.btorxekfix4hcqh4v83dr0tzw

# 从centos容器内部，通过wget来访问my-test服务中运行的nginx网页服务器
root@4bdcce0ee63e:/# wget -O- my-test 
Connecting to my-test (10.10.19.2:80)
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...

  Swarm的负载均衡器自动将HTTP请求路由到VIP上，然后到一个active的task容器上。它根据round-robin选择算法将后续的请求分发到另一个active的task上。

  在创建服务时，可以配置服务直接使用DNS round-robin而无需使用VIP。这是通过在创建服务时指定 --endpoint-mode dnsrr 命令行参数实现的。当你想要使用自己的负载均衡器时可以使用这种方式。

例如：
  注意：使用DNS round-robin方式创建服务，不能直接在命令里使用-p指定端口

$ docker service create --replicas 3 --name my-dnsrr-nginx --network ngx_net --endpoint-mode dnsrr nginx

  查看服务的运行情况

$ docker service ps my-dnsrr-nginx
ID                         NAME              IMAGE  NODE          			DESIRED STATE  CURRENT STATE          ERROR
65li2zbhxvvoaesndmwjokouj  my-dnsrr-nginx.1  nginx  host-192-168-13-131     Running        Running 2 minutes ago
5hjw7wm4xr877879m0ewjciuj  my-dnsrr-nginx.2  nginx  host-192-168-13-132  	Running        Running 2 minutes ago
afo7acduge2qfy60e87liz557  my-dnsrr-nginx.3  nginx  host-192-168-13-133  	Running        Running 2 minutes ago

  当通过服务名称查询DNS时，DNS服务返回所有任务容器的IP地址：

# 进入容器
root@4bdcce0ee63e:/# nslookup my-dnsrr-nginx
Server:    127.0.0.11
Address 1: 127.0.0.11
  
Name:      my-dnsrr-nginx
Address 1: 10.10.19.10 my-dnsrr-nginx.3.0sm1n9o8hygzarv5t5eq46okn.my-network
Address 2: 10.10.19.9  my-dnsrr-nginx.2.b3o1uoa8m003b2kk0ytl9lawh.my-network
Address 3: 10.10.19.8  my-dnsrr-nginx.1.55za4c83jq9846rle6eigiq15.my-network

  需要注意的是：一定要确认VIP的连通性

  通常Docker官方推荐使用dig，nslookup或其它DNS查询工具来查询通过DNS对服务名的访问。因为VIP是逻辑IP，ping并不是确认VIP连通性的正确的工具。

   由于项目需要使用到了 rocketmq, 想要依托于 docker-compose 的强大功能来实现快速的部署集群；

   最初我是想在一台服务器上来实现 两个 nameserver 和 两个主的 brokerserver, 但是这样有一个问题就是 主的 brokerserver 对外提供的服务端口（需要暴露到宿主机的端口）是固定，这样由于在一台服务器上对外暴露重复端口明显是不能运行的。

   所以呢我就要在docker-compose中限定一下：多个 主的 brokerserver 服务不能防止在同一个服务上，并且最好 同一组的备用brokerserver 不要和 主的 brokerserver 防止在同一天服务器上；但是呢这个约束放置条件呢？由此引出了以下内容

   通常情况下控制防止条件可以通过 deploy.placement.constraints 属性来进行控制，例如：

version: "3"
  # 部分内容省略
  portainer:
    image: portainer/portainer
    ports:
      - "9000:9000"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock"
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints: [node.role == manager]

   其中 constraints: [node.role == manager] 表示 当前 portainer 的容器只会放置在 swarm 集群中的管理节点。

   常用的还有以下操作：

• constraints: [node.hostname == test1.spuddy.org] – 表示当前服务只会防止在主机 hostname 为 test1.spuddy.org 的节点

   但是这些常用的可能满足不了我的需求，我希望的是可以自定义属性，来作为判断条件。

   以下只是我创建的伪docker-compose 配置文件，只是为了演示功能；其中“fake_tomcat”只是我编写的一个伪程序，它在请求的端口上侦听；它没有做任何实际的工作

  tomcat:
    image: sweh/test:fake_tomcat
    deploy:
      replicas: 2
      placement:
        constraints: [node.labels.Tomcat == true ]
    volumes:
      - "/myapp/apache/certs:/etc/pki/tls/certs/myapp"
      - "/myapp/apache/logs:/etc/httpd/logs"
      - "/myapp/tomcat/webapps:/usr/local/apache-tomcat-8.5.3/webapps"
      - "/myapp/tomcat/logs:/usr/local/apache-tomcat-8.5.3/logs"
    ports:
      - "8443:443"

   根据上面的添加的约束条件（constraints: [node.labels.Tomcat == true ]），可以看到这里的判断条件是 node.labels.Tomcat 属性为 true 时才会将当前容器放置到服务器中。