【Docker】进阶之路：（十三）Docker Swarm

Docker Swarm架构与概念

部署 Swarm 集群

Docker Swarm调度策略

滚动升级

Docker Swarm 常用指令

Docker Swarm架构

Docker Swarm 相关概念

Docker Swarm 的特点

Docker Swarm的工作流

1. 准备工作

2. 创建集群

3.加入集群

4.查看集群节点信息

5.删除节点

6.创建服务

7.弹性扩缩容

random

spread

binpack

Docker Swarm指令

Docker Node指令

Docker Service指令

1.Swarm

2.Node

3.Service

4.Task

Docker Swarm架构与概念

Docker Swarm架构

Docker Swarm 相关概念

1.Swarm

2.Node

Docker Swarm是Docker官方提供的集群管理工具，它的主要作用是将Docker主机池转变为单个虚拟Docker主机，把若干台Docker主机抽象为一个整体，并且通过一个入口统一管理这些Docker主机上的各种Docke资源。Docker Swarm提供了标准的Docker API,所有任何已经与Docker守护程序通信的工具都可以使用Swarm轻松地扩展到多个主机。

Swarm 作为一个管理Docker集群的工具，首先需要将 Swarm 部署起来，可以单独将 Swarm 部署在一个节点上。另外，需要一个被管理的 Docker 集群，集群上每一个节点均安装Docker。

集群的管理和编排使用的是嵌入Docker引擎的SwarmKit,可以在Docker初始化时启动Swarm模式或者加入已存在的Swarm。

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

管理节点(managernode):负责整个集群的管理工作，包括集群配置、服务管理等。图所示的available node就是一个管理节点，主要负责运行相应的服务来执行任务(task),即负责管理集群中的节点并向工作节点分配任务。管理节点还具有维护群集状态所需的编排和集群管理功能。管理节点选择单个领导者来执行编排任务。)

工作节点(worker node):接收管理节点分配的任务(Task),运行任务。要将应用程序部署到swam,需将服务定义提交给管理节点；管理节点将称为任务的工作单元分派给工作节点：工作节点接收并执行从管理节点分派的任务。默认情况下，管理节点还将服务作为工作节点运行，但可以将它们配置为仅运行管理任务的管理节点。代理程序在每个工作程序节点上运行，并报告分配给它的任务。工作节点向管理节点通知其分配的任务的当前状态，以便管理可以维持每个工作者的期望状态。

查看节点的命令：

docker node ls

Service是任务的定义，在管理器或工作节点上执行。它是群体系统的中心结构，是用户与群体交互的主要根源。创建服务时，需要指定要使用的容器镜像。在工作节点运行的服务，由多个任名共同组成。

查看服务的命令：

docker service ls

Task是运行在工作节点上的容器，或容器中包含的应用，是集群中调度的最小管理单元。管理节点根据指定数量的任务副本分配任务给工作节点。

1. Docker Engine集成集群管理

使用Docker Engine CLI 创建一个Docker Engine的Swarm模式，以便在集群中部署应用程序服务。

2. 去中心化设计

Swarm角色分为manager节点和worker节点。manager节点故障不影响应用的使用。

3. 扩容缩容

可以声明每个服务运行的容器数量，通过添加或删除容器数自动调整期望的状态。

4. 期望状态协调

Swarm管理器节点不断监视集群状态，并调整当前状态与期望状态之间的差异。例如，设置一个服务运行10个副本容器，如果两个副本的服务器节点崩溃，管理器节点将创建两个新的副本替化崩溃的副本，并将新的副本分配给可用的工作节点。

5. 多主机网络

可以为服务指定overlay网络。当初始化或更新应用程序时，Swarm管理器会自动为overlay网络上的容器分配IP地址。

6. 服务发现

Swarm管理器为集群中的每个服务分配唯一的DNS记录和负载均衡VIP。可以通过Swarm内置的DNS服务器查询集群中每个运行的容器。

7. 负载均衡

实现服务副本负载均衡，提供入口访问。也可以将服务入口暴露给外部负载均衡器以便再次负载均衡。

8. 安全传输

Swarm中的每个节点使用TLS相互验证和加密，确保安全地与其他节点通信。

9. 滚动更新

升级时，逐步将应用服务更新到节点，如果出现问题，可以将任务回滚到先前的版本。

Swarm manager:

● API:接收命令并创建Service对象(创建对象)。

● Orchestrator:为Service对象创建的任务进行编排工作(服务编排)。

● allocater:为各个任务分配IP地址(分配IP)。

● dispatcher:将任务分发到节点(分发任务)。

● scheduler:安排工作节点运行任务。

worker node:

● worker:连接调度器，检查分配的任务(检查任务)。

● executor:执行分配给工作节点的任务(执行任务)。

本节将搭建由一个manager和两个worker构成的集群环境。如表所示。

角色	IP	HOSTNAME
manager	192.168.40.21	docker
worker	192.168.40.22	workder1
worker	192.168.40.23	workder2

由于每个节点名默认为主机名，因此需要修改每台虚拟机的主机名，修改方式如下：

(1)通过“hostname主机名”修改机器的主机名(立即生效，重启后失效)。

(2)通过“hostnamectl set-hostname主机名”修改机器的主机名(立即生效，重启也生效)。

(3)通过“vi/etc/hosts”编辑hosts文件，给127.0.0.1添加主机名(重启生效)。

防火墙开启以下端口或者关闭防火墙：

● TCP端口2377:用于集群管理通信。

● TCP和UDP端口7946:用于节点之间通信。

● UDP端口4789:用于覆盖网络。

在192.168.40.21机器上执行docker swarm init指令，初始化一个新的Swarm集群，该节点会默认初始化为一个管理节点。

通常，第一个加入集群的管理节点将成为Leader,后来加入的管理节点都是Reachable。当前的Leader如果挂掉，那么所有的Reachable将重新选举一个新的Leader。

[root@docker ~]# 
[root@docker ~]# docker swarm init
Swarm initialized: current node (oy9iqo3v0evwqcy9wennhpg8c) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-5nnplalizfbm0y998lifx5pzfbesqia7o9he7h5suuxt7f3ewh-94vtl6ut8z6kfvjrz1idv17ml 192.168.40.21:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

[root@docker ~]#

用192.168.40.21节点为Leader建立了一个Swarm集群，且仅存在192.168.40.21这一个管理节点。

Docker中内置的集群模式自带了公钥基础设施(PK1)系统，使得安全部署容器变得简单。集群中的节点使用传输层安全协议(TLS),对集群中其他节点的通信进行身份验证、授权和加密。管理节点会生成两个令牌，供其他节点加入集群时使用：一个worker令牌，一个manager令牌。每个令牌都包括根CA证书的摘要和随机生成的密钥。当节点加入群集时，加入的节点使用摘要来验证来自远程管理节点的根CA证书；远程管理节点使用密钥来确保加入的节点是批准的节点。

若要向该集群添加管理节点，则管理节点先运行docker swarm join-token manager命令查看管理节点的令牌信息。

[root@docker ~]# docker swarm join-token manager
To add a manager to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-5nnplalizfbm0y998lifx5pzfbesqia7o9he7h5suuxt7f3ewh-ereg5j1wijf6y15foymp49uru 192.168.40.21:2377

[root@docker ~]#

在需要加入的机器上执行上述指令，即可作为从节点加入manager集群中。

在初始化集群后，在其返回的结果中，会提供加入工作节点的指令，用户只需在对应机器上执行这些指令即可；或通过 docker swarm join-token worker 来获取相应的 token 令牌：

[root@docker ~]# docker swarm join-token worker
To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-5nnplalizfbm0y998lifx5pzfbesqia7o9he7h5suuxt7f3ewh-94vtl6ut8z6kfvjrz1idv17ml 192.168.40.21:2377

[root@docker ~]#

在 workerl 和 worker2节点上分别执行上述命令：

[root@docker ~]# docker swarm join --token SWMTKN-1-5nnplalizfbm0y998lifx5pzfbesqia7o9he7h5suuxt7f3ewh-ereg5j1wijf6y15foymp49uru 192.168.40.21:2377
This node joined a swarm as a manager.

[root@docker ~]# docker info
Client: Docker Engine - Community
 Version:    24.0.7
 Context:    default
 Debug Mode: false
 Plugins:
  buildx: Docker Buildx (Docker Inc.)
    Version:  v0.11.2
    Path:     /usr/libexec/docker/cli-plugins/docker-buildx
  compose: Docker Compose (Docker Inc.)
    Version:  v2.21.0
    Path:     /usr/libexec/docker/cli-plugins/docker-compose

Server:
 Containers: 0
  Running: 0
  Paused: 0
  Stopped: 0
 Images: 0
 Server Version: 24.0.7
 Storage Driver: overlay2
  Backing Filesystem: xfs
  Supports d_type: true
  Using metacopy: false
  Native Overlay Diff: true
  userxattr: false
 Logging Driver: json-file
 Cgroup Driver: cgroupfs
 Cgroup Version: 1
 Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
 Swarm: active
  NodeID: 1ndh292wn2kng7syxw2bydv9n
  Is Manager: true
  ClusterID: lxa4kz5ur1on8x2eyfnadego0
  Managers: 3
  Nodes: 3
  Default Address Pool: 10.0.0.0/8  
  SubnetSize: 24
  Data Path Port: 4789
  Orchestration:
   Task History Retention Limit: 5
  Raft:
   Snapshot Interval: 10000
   Number of Old Snapshots to Retain: 0
   Heartbeat Tick: 1
   Election Tick: 10
  Dispatcher:
   Heartbeat Period: 5 seconds
  CA Configuration:
   Expiry Duration: 3 months
   Force Rotate: 0
  Autolock Managers: false
  Root Rotation In Progress: false
  Node Address: 192.168.40.23
  Manager Addresses:
   192.168.40.21:2377
   192.168.40.22:2377
   192.168.40.23:2377
 Runtimes: io.containerd.runc.v2 runc
 Default Runtime: runc
 Init Binary: docker-init
 containerd version: d8f198a4ed8892c764191ef7b3b06d8a2eeb5c7f
 runc version: v1.1.10-0-g18a0cb0
 init version: de40ad0
 Security Options:
  seccomp
   Profile: builtin
 Kernel Version: 3.10.0-1160.el7.x86_64
 Operating System: CentOS Linux 7 (Core)
 OSType: linux
 Architecture: x86_64
 CPUs: 4
 Total Memory: 7.62GiB
 Name: docker
 ID: 273b2025-86a7-406d-8e4a-e9b67cb5cf07
 Docker Root Dir: /var/lib/docker
 Debug Mode: false
 Username: circledba
 Experimental: false
 Insecure Registries:
  192.168.40.21:5000
  127.0.0.0/8
 Registry Mirrors:
  https://i9t81ora.mirror.aliyuncs.com/
 Live Restore Enabled: false

[root@docker ~]#

可以在管理节点上通过docker node ls指令查看集群环境下各个节点的信息：

[root@docker ~]# docker node ls
ID                            HOSTNAME   STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
1ndh292wn2kng7syxw2bydv9n *   worker2    Ready     Active         Reachable        24.0.7
oy9iqo3v0evwqcy9wennhpg8c     docker     Ready     Active         Leader           24.0.7
qxxzeuu0bwsb3pa7thjoiu22i     worker1    Ready     Active         Reachable        24.0.7
[root@docker ~]#

MANAGER STATUS表示节点是属于manager还是worker,值为空则属于worker节点。其取值说明如下：

● Leader:该节点是管理节点中的主节点，负责该集群的集群管理和编排决策。

● Reachable:该节点是管理节点中的从节点，如果Leader节点不可用，则该节点有资格被选为新的Leader。

● Unavailable:该管理节点已不能与其他管理节点通信。如果管理节点不可用，则应该将新的管理节点加入群集，或者将工作节点升级为管理节点。

AVAILABILITY表示调度程序是否可以将任务分配给该节点，其取值说明如下：

● Active:调度程序可以将任务分配给该节点。

● Pause:调度程序不会将新任务分配给该节点，但现有任务仍可以运行。

● Drain:调度程序不会将新任务分配给该节点，并且会关闭该节点所有现有任务，将它们调度在可用的节点上。

删除管理节点之前首先需要将该节点的AVAILABILITY改为Drain,目的是将该节点的服务迁移到其他可用节点上，以确保服务正常。命令格式如下：

docker node update --availability drain节点名称|节点ID

[root@docker ~]# docker node update --availability=drain docker
docker
[root@docker ~]# docker node ls
ID                            HOSTNAME   STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
oy9iqo3v0evwqcy9wennhpg8c *   docker     Ready     Drain          Leader           24.0.7
qxxzeuu0bwsb3pa7thjoiu22i     worker1    Ready     Active         Reachable        24.0.7
1ndh292wn2kng7syxw2bydv9n     worker2    Ready     Active         Reachable        24.0.7
[root@docker ~]#

然后将该管理节点进行降级处理，降级为工作节点，命令格式如下：

docker node demote 节点名称|节点ID

这里只创建了一个管理节点，如果将它降级为工作节点，则没有管理节点了，会导致Swarm集群不可用。因此，执行上述命令时，会抛出异常：

[root@docker ~]# docker node demote docker
Manager docker demoted in the swarm.
[root@docker ~]# docker node ls
Error response from daemon: This node is not a swarm manager. Worker nodes can't be used to view or modify cluster state. Please run this command on a manager node or promote the current node to a manager.
[root@docker ~]#

然后，在已经降级为工作的节点中运行以下命令，离开集群：docker swarm leave

[root@docker ~]# docker swarm leave
Node left the swarm.
[root@docker ~]#

最后，到worker1服务器上查看谁是管理节点:

[root@worker1 ~]# docker node ls
ID                            HOSTNAME   STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
oy9iqo3v0evwqcy9wennhpg8c     docker     Down      Drain                           24.0.7
qxxzeuu0bwsb3pa7thjoiu22i *   worker1    Ready     Active         Leader           24.0.7
1ndh292wn2kng7syxw2bydv9n     worker2    Ready     Active         Reachable        24.0.7
[root@worker1 ~]#

发现worker1是管理节点

在管理节点中删除刚才离开的节点：

docker node rm 节点名称|节点ID

[root@worker1 ~]# docker node rm docker
docker
[root@worker1 ~]# docker node ls
ID                            HOSTNAME   STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
qxxzeuu0bwsb3pa7thjoiu22i *   worker1    Ready     Active         Leader           24.0.7
1ndh292wn2kng7syxw2bydv9n     worker2    Ready     Active         Reachable        24.0.7
[root@worker1 ~]#

至此，Swarm集群的基础操作就完成了。

服务创建操作均只能在管理节点上执行。创建一个nginx服务，该服务会由管理器随机分配到某个集群的节点上进行部署启动。

[root@worker1 ~]# docker service create --replicas 1 --name mynginx -p 80:80 nginx:latest
z7ykn781wbeuq7tf5eayym2sb
overall progress: 1 out of 1 tasks 
1/1: running   [==================================================>] 
verify: Service converged 
[root@worker1 ~]# docker service ls
ID             NAME      MODE         REPLICAS   IMAGE          PORTS
z7ykn781wbeu   mynginx   replicated   1/1        nginx:latest   *:80->80/tcp
[root@worker1 ~]#

可以通过“docker service inspect服务名称服务id”查看服务的详细信息：

[root@worker1 ~]# docker service inspect mynginx
[
    {
        "ID": "z7ykn781wbeuq7tf5eayym2sb",
        "Version": {
            "Index": 406
        },
        "CreatedAt": "2023-12-10T11:06:41.115972782Z",
        "UpdatedAt": "2023-12-10T11:06:41.123618925Z",
        "Spec": {
            "Name": "mynginx",
            "Labels": {},
            "TaskTemplate": {
                "ContainerSpec": {
                    "Image": "nginx:latest@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31",
                    "Init": false,
                    "StopGracePeriod": 10000000000,
                    "DNSConfig": {},
                    "Isolation": "default"
                },
                "Resources": {
                    "Limits": {},
                    "Reservations": {}
                },
                "RestartPolicy": {
                    "Condition": "any",
                    "Delay": 5000000000,
                    "MaxAttempts": 0
                },
                "Placement": {
                    "Platforms": [
                        {
                            "Architecture": "amd64",
                            "OS": "linux"
                        },
                        {
                            "OS": "linux"
                        },
                        {
                            "OS": "linux"
                        },
                        {
                            "Architecture": "arm64",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "386",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "mips64le",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "ppc64le",
                            "OS": "linux"
                        },
                        {
                            "Architecture": "s390x",
                            "OS": "linux"
                        }
                    ]
                },
                "ForceUpdate": 0,
                "Runtime": "container"
            },
            "Mode": {
                "Replicated": {
                    "Replicas": 1
                }
            },
            "UpdateConfig": {
                "Parallelism": 1,
                "FailureAction": "pause",
                "Monitor": 5000000000,
                "MaxFailureRatio": 0,
                "Order": "stop-first"
            },
            "RollbackConfig": {
                "Parallelism": 1,
                "FailureAction": "pause",
                "Monitor": 5000000000,
                "MaxFailureRatio": 0,
                "Order": "stop-first"
            },
            "EndpointSpec": {
                "Mode": "vip",
                "Ports": [
                    {
                        "Protocol": "tcp",
                        "TargetPort": 80,
                        "PublishedPort": 80,
                        "PublishMode": "ingress"
                    }
                ]
            }
        },
        "Endpoint": {
            "Spec": {
                "Mode": "vip",
                "Ports": [
                    {
                        "Protocol": "tcp",
                        "TargetPort": 80,
                        "PublishedPort": 80,
                        "PublishMode": "ingress"
                    }
                ]
            },
            "Ports": [
                {
                    "Protocol": "tcp",
                    "TargetPort": 80,
                    "PublishedPort": 80,
                    "PublishMode": "ingress"
                }
            ],
            "VirtualIPs": [
                {
                    "NetworkID": "g0eptm7cq8m3jrwnudl7dh358",
                    "Addr": "10.0.0.5/24"
                }
            ]
        }
    }
]
[root@worker1 ~]#

可以通过“docker service ps服务名称服务id”查看服务运行在哪些节点上。

[root@worker1 ~]# docker service ps mynginx
ID             NAME        IMAGE          NODE      DESIRED STATE   CURRENT STATE           ERROR     PORTS
q56wd36o13q3   mynginx.1   nginx:latest   worker2   Running         Running 2 minutes ago             
[root@worker1 ~]#

通过“docker service m服务名称服务id”即可删除服务，删除服务仍需在管理节点上执行：

[root@worker1 ~]# docker service rm mynginx
mynginx
[root@worker1 ~]# docker service ls
ID        NAME      MODE      REPLICAS   IMAGE     PORTS
[root@worker1 ~]#

将Service部署到集群以后，可以通过命令弹性扩缩容Service中的容器数量。扩缩容操作均只能在管理节点执行。在Service中运行的容器被称为Task(任务)。

通过“docker service scale服务名称|服务ID=n”可以将Service运行的任务扩缩容为n个。通过“docker service update --replicas n服务名称I服务ID”也可以达到扩缩容的效果。

[root@worker1 ~]# docker service create --replicas 1 --name mynginx -p 80:80 nginx:latest
cwbgary91mwsnlapjdwtldqu4
overall progress: 1 out of 1 tasks 
1/1: running   [==================================================>] 
verify: Service converged 
[root@worker1 ~]# docker service update --replicas 2 mynginx
mynginx
overall progress: 2 out of 2 tasks 
1/2: running   [==================================================>] 
2/2: running   [==================================================>] 
verify: Service converged 
[root@worker1 ~]# docker service ls
ID             NAME      MODE         REPLICAS   IMAGE          PORTS
cwbgary91mws   mynginx   replicated   2/2        nginx:latest   *:80->80/tcp
[root@worker1 ~]#

接下来可以进行缩容：

[root@worker1 ~]# docker service scale mynginx=1
mynginx scaled to 1
overall progress: 1 out of 1 tasks 
1/1: running   [==================================================>] 
verify: Service converged 
[root@worker1 ~]# docker service ls
ID             NAME      MODE         REPLICAS   IMAGE          PORTS
cwbgary91mws   mynginx   replicated   1/1        nginx:latest   *:80->80/tcp
[root@worker1 ~]#

Swarm在调度(scheduler)节点(Leader节点)运行容器的时候，会根据指定的策略来计算最适合运行容器的节点，目前支持的策略有三种，分别是：spread、binpack、random。

random就是随机选择一个节点来运行容器，一般用于调试。spread和binpack策略会根据各个节点的可用的CPU、RAM以及正在运行的容器的数量来计算应该运行容器的节点。

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

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

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

Docker Swarm可以实现服务的平滑升级，即服务不停机更新，客户端无感知。本节通过一个简单示例演示Docker Swarm的平滑升级。

首先部署一个基于nginx的Web应用程序服务，部署在节点上。再创建同一个应用的两个版本.version 1和version 2。

创建一个Dockerfle文件，并使用docker build进行编译。

[root@worker1 ~]# mkdir nginxv1
[root@worker1 ~]# cd nginxv1/
[root@worker1 nginxv1]# touch Dockerfile
[root@worker1 nginxv1]# vi Dockerfile 
[root@worker1 nginxv1]# cat Dockerfile 
FROM nginx
RUN echo 'Swarm:Version 1' > /usr/share/nginx/html/index.html
[root@worker1 nginxv1]# docker build -t nginx:v1 .
[+] Building 15.2s (6/6) FINISHED                                                                                                                                                                                                                                                                                             docker:default
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                                                    0.0s
 => => transferring dockerfile: 170B                                                                                                                                                                                                                                                                                                    0.0s
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                                       0.0s
 => => transferring context: 2B                                                                                                                                                                                                                                                                                                         0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                                                                                                                                                                                                                                        15.2s
 => [1/2] FROM docker.io/library/nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31                                                                                                                                                                                                                          0.0s
 => CACHED [2/2] RUN echo 'Swarm:Version 1' > /usr/share/nginx/html/index.html                                                                                                                                                                                                                                                          0.0s
 => exporting to image                                                                                                                                                                                                                                                                                                                  0.0s
 => => exporting layers                                                                                                                                                                                                                                                                                                                 0.0s
 => => writing image sha256:46b883d4aa8db4a1ae9bb001cbdd24d8f1414c63a206e2a5c36ec318b316d881                                                                                                                                                                                                                                            0.0s
 => => naming to docker.io/library/nginx:v1                                                                                                                                                                                                                                                                                             0.0s
[root@worker1 nginxv1]#  docker images
REPOSITORY   TAG       IMAGE ID       CREATED              SIZE
nginx        v1        46b883d4aa8d   About a minute ago   141MB
[root@worker1 nginxv1]#

注意：为了使得Swarm集群中的每个节点都能访问镜像，这里把生成的镜像上传到镜像仓

库中。

[root@worker1 nginxv1]# docker login
Authenticating with existing credentials...
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
[root@worker1 nginxv1]# docker tag nginx:v1 circledba/nginx:v1
[root@worker1 nginxv1]# docker images
REPOSITORY        TAG       IMAGE ID       CREATED       SIZE
circledba/nginx   v1        46b883d4aa8d   4 hours ago   141MB
circledba         latest    46b883d4aa8d   4 hours ago   141MB
nginx             v1        46b883d4aa8d   4 hours ago   141MB
[root@worker1 nginxv1]# docker rmi circledba
Untagged: circledba:latest
[root@worker1 nginxv1]# docker images
REPOSITORY        TAG       IMAGE ID       CREATED       SIZE
circledba/nginx   v1        46b883d4aa8d   4 hours ago   141MB
nginx             v1        46b883d4aa8d   4 hours ago   141MB
[root@worker1 nginxv1]# docker push circledba/nginx:v1
The push refers to repository [docker.io/circledba/nginx]
e96d604c3ee3: Pushed 
d874fd2bc83b: Mounted from library/nginx 
32ce5f6a5106: Mounted from library/nginx 
f1db227348d0: Mounted from library/nginx 
b8d6e692a25e: Mounted from library/nginx 
e379e8aedd4d: Mounted from library/nginx 
2edcec3590a4: Mounted from library/nginx 
v1: digest: sha256:942caff8ba4ae8a2206855e8e7973eab8ee5badc431f21e36293375dcb6be81a size: 1777
[root@worker1 nginxv1]#

创建Swarm的服务，通过镜像启动容器：

[root@worker1 nginxv1]# docker service create -p 7788:80 --replicas 3 --name myswarmtest circledba/nginx:v1
image circledba/nginx:v1 could not be accessed on a registry to record
its digest. Each node will access circledba/nginx:v1 independently,
possibly leading to different nodes running different
versions of the image.

ij84e6sannxt19l46jr5ln3ah
overall progress: 3 out of 3 tasks 
1/3: running   
2/3: running   
3/3: running   
verify: Service converged 
[root@worker1 nginxv1]#

通过docker service ps myswarmtest查看部署服务的详细信息：

[root@worker1 nginxv1]# docker service ps myswarmtest
ID             NAME            IMAGE                NODE      DESIRED STATE   CURRENT STATE                ERROR     PORTS
jqk1ucso2i38   myswarmtest.1   circledba/nginx:v1   worker2   Running         Running about a minute ago             
inohm2m4lsfa   myswarmtest.2   circledba/nginx:v1   worker1   Running         Running about a minute ago             
yrh6a7mid7ul   myswarmtest.3   circledba/nginx:v1   worker1   Running         Running about a minute ago             
[root@worker1 nginxv1]#

更新Dockerfile,注意将版本号变为2，编译并上传:

[root@worker1 nginxv1]# cat Dockerfile 
FROM nginx
RUN echo 'Swarm:Version 2' > /usr/share/nginx/html/index.html
[root@worker1 nginxv1]# docker build -t circledba/nginx:v2 .
[+] Building 16.0s (6/6) FINISHED                                                           docker:default
 => [internal] load build definition from Dockerfile                                                  0.0s
 => => transferring dockerfile: 170B                                                                  0.0s
 => [internal] load .dockerignore                                                                     0.0s
 => => transferring context: 2B                                                                       0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                      15.4s
 => CACHED [1/2] FROM docker.io/library/nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a  0.0s
 => [2/2] RUN echo 'Swarm:Version 2' > /usr/share/nginx/html/index.html                               0.5s
 => exporting to image                                                                                0.0s
 => => exporting layers                                                                               0.0s
 => => writing image sha256:4975d9408f8d74e69fa2f753ca57d7c4783e2d322180d83bea3a1cfd3a41b48f          0.0s
 => => naming to docker.io/circledba/nignx:v2                                                         0.0s
[root@worker1 nginxv1]# docker push circledba/nignx:v2
The push refers to repository [docker.io/circledba/nignx]
78efc5703dd4: Pushed 
d874fd2bc83b: Mounted from circledba/nginx 
32ce5f6a5106: Mounted from circledba/nginx 
f1db227348d0: Mounted from circledba/nginx 
b8d6e692a25e: Mounted from circledba/nginx 
e379e8aedd4d: Mounted from circledba/nginx 
2edcec3590a4: Mounted from circledba/nginx 
v2: digest: sha256:c40f40f47e84277be1d2a4a555ab3fc7ab3608fd45a9f339e08a4d4a187c4f67 size: 1777
[root@worker1 nginxv1]#

更新之前在Swarm部署的服务，将会发现版本号变成了2:

[root@worker1 nginxv1]# curl 0.0.0.0:7788
Swarm:Version 1
[root@worker1 nginxv1]# docker service update --image circledba/nginx:v2 myswarmtest

image circledba/nginx:v2 could not be accessed on a registry to record
its digest. Each node will access circledba/nginx:v2 independently,
possibly leading to different nodes running different
versions of the image.

myswarmtest
overall progress: 0 out of 3 tasks 
1/3: preparing 
2/3:   
3/3:   
service update paused: update paused due to failure or early termination of task 6o26dg9kmlm3246y63swwcco8
[root@worker1 nginxv1]# 
[root@worker1 nginxv1]# curl 0.0.0.0:7788
Swarm:Version 2
[root@worker1 nginxv1]#

滚动服务更新涉及的操作命令如下：

● docker service create -replicas 3--name redis--update-delay 10s redis:3.0.6

● docker service inspect --pretty redis

● docker service update --image redis:3.0.7 redis

● docker service inspect --pretty redis

● docker service ps redis

通过以上命令方式来配置服务。如果对服务的更新导致重新部署失败，则该服务可以自动回滚到以前的配置，这有助于提升服务的可用性。如表13-2所示，可以在创建或更新服务时设置表中的一个或多个选项。如果未设置值，则使用默认值。

创建或更新服务时的命令选项

选项	默认值	描述
-~rollback-delay	0s	在回滚任务结束后、回滚下一个任务之前要等待的时间。0表示在第一个回滚任务部署完成后立即回滚第二个任务的方法值
--rollback-failure-action	pause	当任务无法回滚时，无论是pause还是continue,都试图回滚其他任务
--rollback-max-failure-ratic	0	在回滚期间容忍的故障率，指定为0~1的浮点数。例如，给定5个任务，故障率0.2会容忍一个任务无法回滚。值为0则表示实例没有故障被容忍，而值为1则表示实例的任何数量的故障都可被容忍
--rollback-monitor	5s	每个任务回滚之后的持续时间，用来监视回滚是否失败。如果任务在此时间段过去之前停止，则认为回滚失败
--rollback-parallelism		并行回滚的最大任务数。默认情况下，一次回滚一个任务。值为0表示所有任务并行回滚

指令		说明
docker node ls		查看集群所有节点
docker node ps		查看当前节点的所有任务
docker node rm节点名称节点ID		删除节点(-f强制删除)
docker node inspect节点名称\|节点ID		查看节点详情
docker node demote节点名称\|节点ID		节点降级，由管理节点降级为工作节点
docker node promote节点名称节点ID		节点升级，由工作节点升级为管理节点
docker node update节点名称\|节点ID		更新节点

docker swarm init

docker swarm join-token worker

查看工作节点的token

docker swarm join-token manager

查看管理节点的token

docker swarm join

指令		说明
docker service create		创建服务
docker service Is		查看所有服务
docker service inspect服务名称\|服务ID		查看服务详情
docker service logs服务名称服务ID		查看服务日志
docker service rm服务名称\|服务ID		删除服务(-f强制删除)
docker service scale服务名称\|服务ID=n		设置服务数量
docker service rollback服务名称\|服务ID		服务回滚
docker service update服务名称\|服务ID		更新服务，其中可以支持扩缩容、回滚、滚动更新等功能。详细用法可通过docker service update-help命令查看