【Docker】Swarm学习

最新推荐文章于 2024-03-03 12:59:17 发布
最新推荐文章于 2024-03-03 12:59:17 发布
阅读量4.5k 收藏 16
点赞数 7
分类专栏： # Docker 文章标签： docker 学习 运维 容器 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/al6nlee/article/details/130912842
版权

文章目录

什么是Docker Swarm

定义

Swarm是Docker公司推出的用来管理docker集群的平台。它是将一群Docker宿主机变成一个单一的虚拟主机。

Swarm使用标准的Docker API接口作为其前端的访问入口，换言之，各种形式的Docker Client(compose,docker-py等)均可以直接与Swarm通信，甚至Docker本身都可以很容易的与Swarm集成，这大大方便了用户将原本基于单节点的系统移植到Swarm上，同时Swarm内置了对Docker网络插件的支持，用户也很容易的部署跨主机的容器集群服务。

从 Docker 1.12.0 版本开始，Docker Swarm 已经包含在 Docker 引擎中（docker swarm），并且已经内置了服务发现工具

与Docker Compose对比

  • 异
    • Docker Compose 是一个在单个服务器或主机上创建多个容器的工具
    • Docker Swarm 则可以在多个服务器或主机上创建容器集群服务，对于微服务的部署，显然 Docker Swarm 会更加适合。
  • 同
    • 都是 Docker 官方容器编排项目

基本结构图

关键概念

  • Swarm：集群管理工具。子命令有init, join, leave, update。（docker swarm --help查看帮助）

  • Node：一个节点是docker引擎集群的一个实例。您还可以将其视为Docker节点。

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

    您可以在单个物理计算机或云服务器上运行一个或多个节点，但生产群集部署通常包括分布在多个物理和云计算机上的Docker节点。

    要将应用程序部署到swarm，请将服务定义提交给 管理器节点。管理器节点将称为任务的工作单元分派 给工作节点。

    Manager节点还执行维护所需群集状态所需的编排和集群管理功能。Manager节点选择单个领导者来执行编排任务。

    工作节点接收并执行从管理器节点分派的任务。

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

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

工作模式

Node

Service

任务与调度

服务副本与全局服务

Swarm的调度策略

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

  • Random

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

  • Spread

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

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

  • Binpack

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

Swarm的特性

批量创建服务

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

强大的集群的容错性

当容器副本中的其中某一个或某几个节点宕机后，cluster会根据自己的服务注册发现机制，以及之前设定的值–replicas n，在集群中剩余的空闲节点上，重新拉起容器副本。整个副本迁移的过程无需人工干预，迁移后原本的集群的load balance依旧好使！不难看出，docker service其实不仅仅是批量启动服务这么简单，而是在集群中定义了一种状态。Cluster会持续检测服务的健康状态并维护集群的高可用性。

服务节点的可扩展性

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

  • 每台节点都run一个相同的副本

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

  • 复制服务（–replicas n）

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

  • 全局服务（–mode=global）

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

调度机制

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

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

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

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

集群部署

基础架构

机器环境(三台机器，centos系统)

IP：192.168.31.43 主机名：manager43 担任角色：swarm manager

IP：192.168.31.188 主机名：node188 担任角色：swarm node

IP：192.168.31.139 主机名：node139 担任角色：swarm node

准备工作

  • 改主机名

    # 192.168.31.43  主机上执行
[root@manager43 ~]# hostnamectl set-hostname manager43
 
# 192.168.31.188 主机上执行
[root@node188 ~]# hostnamectl set-hostname node188
 
# 192.168.31.139 主机上执行
[root@node139 ~]# hostnamectl set-hostname node139

  • 配置hosts文件(选配置—>本质就是ip的映射)

    [root@manager43 ~]# cat /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
 
192.168.31.43 manager43
192.168.31.188 node188
192.168.31.139 node139

    # 另外两台也同步
[root@manager43 ~]# scp /etc/hosts root@192.168.31.188:/etc/hosts
[root@manager43 ~]# scp /etc/hosts root@192.168.31.139:/etc/hosts

    记得重启，才生效

  • 设置防火墙

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

    [root@manager43 ~]# systemctl disable firewalld.service
[root@manager43 ~]# systemctl stop firewalld.service

  • 安装docker

    详见：https://blog.csdn.net/al6nlee/article/details/129635353

创建Swarm并添加节点

  • 创建Swarm集群

    [root@manager43 ~]# docker swarm init --advertise-addr 192.168.31.43

    上面命令执行后，该机器自动加入到swarm集群。这个会创建一个集群token，获取全球唯一的 token，作为集群唯一标识。后续将其他节点加入集群都会用到这个token值。

    • --advertise-addr xxx.xxx.xxx.xxx参数表示其它swarm中的worker节点使用此ip地址与manager联系。
    • docker swarm leave -f 对于已经加入swarm的节点，想要强制删除，执行这条命令就OK了

  • 查看集群的相关信息

    [root@manager43 ~]# docker info
上面的命令执行后 找到Swarm的关键字，就可以看到相关信息了

[root@manager43 ~]# docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
3jcmnzjh0e99ipgshk1ykuovd *   manager43           Ready               Active              Leader              18.06.0-ce
上面的命令是查看集群中的机器(注意上面node ID旁边那个*号表示现在连接到这个节点上)

  • 添加节点到Swarm集群

    # 192.168.31.188 主机上执行
[root@node188 ~]# docker swarm join --token SWMTKN-1-2lefzq18zohy9yr1vskutf1sfb2a590xz9d0mjj2m15zu9eprw-2938j5f50t35ycut0vbj2sx0s 192.168.31.43:2377
This node joined a swarm as a worker.

# 192.168.31.139 主机上执行
[root@node139 ~]# docker swarm join --token SWMTKN-1-2lefzq18zohy9yr1vskutf1sfb2a590xz9d0mjj2m15zu9eprw-2938j5f50t35ycut0vbj2sx0s 192.168.31.43:2377
This node joined a swarm as a worker.

# 之后在任意一台机子上执行查询集群状态命令
[root@manager43 ~]# docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
3jcmnzjh0e99ipgshk1ykuovd *   manager43           Ready               Active              Leader              18.06.0-ce
vww7ue2xprzg46bjx7afo4h04     node139             Ready               Active                                  18.06.1-ce
c5klw5ns4adcvumzgiv66xpyj     node188             Ready               Active                                  18.06.1-ce

    AVAILABILITY状态说明

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

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

    • 更改AVAILABILITY状态

      [root@manager43 ~]# docker node update --availability drain node139               # 将node139节点下线。如果要删除node139节点，命令是"docker node rm --force node139"
node139
[root@manager43 ~]# docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
3jcmnzjh0e99ipgshk1ykuovd *   manager43           Ready               Active              Leader              18.06.0-ce
vww7ue2xprzg46bjx7afo4h04     node139             Ready               Drain                                   18.06.1-ce
c5klw5ns4adcvumzgiv66xpyj     node188             Ready               Active

在Swarm中部署服务(nginx为例)

  • 创建网络在部署服务

    # 创建网络
[root@manager43 ~]# docker network create -d overlay nginx_net
a52jy33asc5o0ts0rq823bf0m
[root@manager43 ~]# docker network ls | grep nginx_net
a52jy33asc5o        nginx_net           overlay             swarm

  • 部署服务

    [root@manager43 ~]# docker service create --replicas 1 --network nginx_net --name my_nginx -p 80:80 nginx

    其中，–replicas 参数指定服务由几个实例组成。

  • 使用 docker service ls 查看正在运行服务的列表

    [root@manager43 ~]# docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
olexfmtdf94s        my_nginx            replicated          1/1                 nginx:latest        *:80->80/tcp

  • 查询Swarm中服务的信息

    --pretty 使命令输出格式化为可读的格式，不加 --pretty 可以输出更详细的信息：

    [root@manager43 ~]# docker service inspect --pretty my_nginx
ID:             zs7fw4ereo5w7ohd4n9ii06nt
Name:           my_nginx
Service Mode:   Replicated
 Replicas:      1
Placement:
UpdateConfig:
 Parallelism:   1
 On failure:    pause
 Monitoring Period: 5s
 Max failure ratio: 0
 Update order:      stop-first
RollbackConfig:
 Parallelism:   1
 On failure:    pause
 Monitoring Period: 5s
 Max failure ratio: 0
 Rollback order:    stop-first
ContainerSpec:
 Image:         nginx:latest@sha256:b73f527d86e3461fd652f62cf47e7b375196063bbbd503e853af5be16597cb2e
 Init:          false
Resources:
Networks: nginx_net
Endpoint Mode:  vip
Ports:
 PublishedPort = 80
  Protocol = tcp
  TargetPort = 80
  PublishMode = ingress

    # 查询到哪个节点正在运行该服务。如下该容器被调度到manager-node节点上启动了，然后访问http://192.168.31.43即可访问这个容器应用（如果调度到其他节点，访问也是如此）
    [root@manager43 ~] # docker service ps my_nginx
    ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS
    yzonph0zu7km my_nginx.1 nginx:latest manager43 Running Running about an hour ago
    温馨提示：如果上面命令执行后，上面的 STATE 字段中刚开始的服务状态为 Preparing，需要等一会才能变为 Running 状态，其中最费时间的应该是下载镜像的过程
    有上面命令可知，该服务在manager-node节点上运行。登陆该节点，可以查看到nginx容器在运行中
    [root@manager43 ~] # docker ps
    CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
    0dc7103f8030 nginx:latest “nginx -g 'daemon of…” About an hour ago Up About an hour 80/tcp my_nginx.1.yzonph0zu7km0211uj0ro5brj

  • 在Swarm中动态扩展服务(scale)

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

    [root@manager43 ~]# 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数之后，将会创建新的容器，这些新启动的容器也会经历从准备到运行的过程，过一分钟左右，服务应该就会启动完成，这时候可以再来看一下 nginx 服务中的容器

    [root@manager43 ~]# docker service ps my_nginx
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE               ERROR               PORTS
yzonph0zu7km        my_nginx.1          nginx:latest        manager43           Running             Running about an hour ago                      
mlprstt9ds5x        my_nginx.2          nginx:latest        node139             Running             Running 52 seconds ago                         
y09lk90tdzdp        my_nginx.3          nginx:latest        node139             Running             Running 52 seconds ago                         
clolfl3zlvj0        my_nginx.4          nginx:latest        node188             Running             Running 2 minutes ago

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

  • 模拟宕机node节点

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

    将node139宕机后或将node139的docker服务关闭，那么它上面的task实例就会转移到别的节点上。当node139节点恢复后，它转移出去的task实例不会主动转移回来，
只能等别的节点出现故障后转移task实例到它的上面。使用命令"docker node ls"，发现node139节点已不在swarm集群中了(状态为：Down)。
[root@node139 ~]# systemctl stop docker
[root@manager43 ~]# docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
ppk7q0bjond8a58xja7in1qid *   manager43           Ready               Active              Leader              18.06.0-ce
mums8azgbrffnecp3q8fz70pl     node139             Down                Active                                  18.06.1-ce
z3n36maf03yjg7odghikuv574     node188             Ready               Active                                  18.06.1-ce

然后过一会查询服务的状态列表
[root@manager43 ~]# docker service ps my_nginx
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE                ERROR               PORTS
yzonph0zu7km        my_nginx.1          nginx:latest        manager43           Running             Running about an hour ago                       
wb1cpk9k22rl        my_nginx.2          nginx:latest        node188             Running             Running about a minute ago                      
mlprstt9ds5x         \_ my_nginx.2      nginx:latest        node139             Shutdown            Running 4 minutes ago                           
rhbj4bcr4t2c        my_nginx.3          nginx:latest        manager43           Running             Running about a minute ago                      
y09lk90tdzdp         \_ my_nginx.3      nginx:latest        node139             Shutdown            Running 4 minutes ago                           
clolfl3zlvj0        my_nginx.4          nginx:latest        node188             Running             Running 6 minutes ago

上面我们可以发现node139故障后，它上面之前的两个task任务已经转移到node188和manager43节点上了

登陆到node188和manager43节点上，可以看到这两个运行的task任务。当访问192.168.31.188和192.168.31.43节点的80端口，swarm的负载均衡会把请求路由到一个任意节点的可用的容器上
[root@manager43 ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
ae4c5c2e6f3f        nginx:latest        "nginx -g 'daemon of…"   4 minutes ago       Up 4 minutes        80/tcp              my_nginx.3.rhbj4bcr4t2c3y2f8vyfmbi21
0dc7103f8030        nginx:latest        "nginx -g 'daemon of…"   About an hour ago   Up About an hour    80/tcp              my_nginx.1.yzonph0zu7km0211uj0ro5brj
 
[root@node188 ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
a63ef253f7dd        nginx:latest        "nginx -g 'daemon of…"   3 minutes ago       Up 3 minutes        80/tcp              my_nginx.2.wb1cpk9k22rl1ydab7aozl2b5
74a1a1db81d4        nginx:latest        "nginx -g 'daemon of…"   8 minutes ago       Up 8 minutes        80/tcp              my_nginx.4.clolfl3zlvj0ewmh85c2ljnza
 
再次在node188和manager43节点上将从node139上转移过来的两个task关闭
[root@manager43 ~]# docker stop my_nginx.3.rhbj4bcr4t2c3y2f8vyfmbi21
my_nginx.3.rhbj4bcr4t2c3y2f8vyfmbi21
 
[root@node188 ~]# docker stop my_nginx.2.wb1cpk9k22rl1ydab7aozl2b5
my_nginx.2.wb1cpk9k22rl1ydab7aozl2b5
 
再次查询服务的状态列表，发现这两个task又转移到node139上了
[root@manager43 ~]# docker service ps my_nginx
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE             ERROR               PORTS
yzonph0zu7km        my_nginx.1          nginx:latest        manager43           Running             Running 2 hours ago                          
j2q61f8jtzba        my_nginx.2          nginx:latest        node188             Running             Running 24 seconds ago                       
wb1cpk9k22rl         \_ my_nginx.2      nginx:latest        node188             Shutdown            Complete 29 seconds ago                      
mlprstt9ds5x         \_ my_nginx.2      nginx:latest        node139             Shutdown            Running 11 minutes ago                       
oz9wyjuldw1t        my_nginx.3          nginx:latest        manager43           Running             Running 40 seconds ago                       
rhbj4bcr4t2c         \_ my_nginx.3      nginx:latest        manager43           Shutdown            Complete 45 seconds ago                      
y09lk90tdzdp         \_ my_nginx.3      nginx:latest        node139             Shutdown            Running 11 minutes ago                       
clolfl3zlvj0        my_nginx.4          nginx:latest        node188             Running             Running 12 minutes ago    
结论：即在swarm cluster集群中启动的容器，在worker node节点上删除或停用后，该容器会自动转移到其他的worker node节点上

  • Swarm 动态缩容服务(scale)

    # 将my_nginx容器变为1个

    [root@manager43 ~]# docker service scale my_nginx=1
my_nginx scaled to 1
overall progress: 1 out of 1 tasks
1/1:  
verify: Service converged
 
[root@manager43 ~]# docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
zs7fw4ereo5w        my_nginx            replicated          1/1                 nginx:latest        *:80->80/tcp
 
[root@manager43 ~]# docker service ps my_nginx
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE             ERROR               PORTS
yzonph0zu7km        my_nginx.1          nginx:latest        manager43           Running             Running 11 hours ago                         
wb1cpk9k22rl        my_nginx.2          nginx:latest        node188             Shutdown            Complete 9 hours ago                         
mlprstt9ds5x         \_ my_nginx.2      nginx:latest        node139             Shutdown            Shutdown 29 seconds ago                      
rhbj4bcr4t2c        my_nginx.3          nginx:latest        manager43           Shutdown            Complete 9 hours ago                         
y09lk90tdzdp         \_ my_nginx.3      nginx:latest        node139             Shutdown            Shutdown 29 seconds ago      
 
通过docker service ps my_nginx 可以看到node节点上已经为Shutdown状态了
 
在登录到node节点主机上查看
[root@node188 ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                      PORTS               NAMES
f93c0a27374a        nginx:latest        "nginx -g 'daemon of…"   9 hours ago         Exited (0) 44 seconds ago                       my_nginx.2.j2q61f8jtzba9kb3unupkhl25
a63ef253f7dd        nginx:latest        "nginx -g 'daemon of…"   9 hours ago         Exited (0) 9 hours ago                          my_nginx.2.wb1cpk9k22rl1ydab7aozl2b5
[root@node139 ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                   PORTS               NAMES
e8ac2e44f5c4        nginx:latest        "nginx -g 'daemon of…"   9 hours ago         Exited (0) 9 hours ago                       my_nginx.2.mlprstt9ds5xi48u1rzscgfdk
5b031aa5a2cc        nginx:latest        "nginx -g 'daemon of…"   9 hours ago         Exited (0) 9 hours ago                       my_nginx.3.y09lk90tdzdp8cwj6mm5oyr3f
登录node节点，使用docker ps -a 查看，会发现容器被stop而非rm

  • 除了上面使用scale进行容器的扩容或缩容之外，还可以使用docker service update 命令。 可对 服务的启动 参数 进行 更新/修改。

    [root@manager43 ~]# docker service update --replicas 3 my_nginx
my_nginx
overall progress: 3 out of 3 tasks
1/3: running   [==================================================>]
2/3: running   [==================================================>]
3/3: running   [==================================================>]
verify: Service converged
 
[root@manager43 ~]# docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
zs7fw4ereo5w        my_nginx            replicated          3/3                 nginx:latest        *:80->80/tcp
 
[root@manager43 ~]# docker service ps my_nginx
ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE            ERROR               PORTS
yzonph0zu7km        my_nginx.1          nginx:latest        manager43           Running             Running 11 hours ago                        
j3hduzd9pret        my_nginx.2          nginx:latest        node188             Running             Running 18 seconds ago                      
wb1cpk9k22rl         \_ my_nginx.2      nginx:latest        node188             Shutdown            Complete 9 hours ago                        
mlprstt9ds5x         \_ my_nginx.2      nginx:latest        node139             Shutdown            Shutdown 4 minutes ago                      
gng96vc5vqpv        my_nginx.3          nginx:latest        node139             Running             Running 18 seconds ago                      
rhbj4bcr4t2c         \_ my_nginx.3      nginx:latest        manager43           Shutdown            Complete 9 hours ago                        
y09lk90tdzdp         \_ my_nginx.3      nginx:latest        node139             Shutdown            Shutdown 4 minutes ago    
 
docker service update 命令，也可用于直接 升级 镜像等
[root@manager43 ~]# docker service update --image nginx:new my_nginx
 
[root@manager43 ~]# docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
zs7fw4ereo5w        my_nginx            replicated          3/3                 nginx:new           *:80->80/tcp
注意IMAGE列 变成了nginx:new

  • 直接删除my_nginx服务

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

    [root@manager43 ~]# docker service rm my_nginx

Swarm中使用Volume(挂在目录，mount命令)

  • 查看volume帮助

    [root@manager43 ~]# docker volume --help
 
Usage:  docker volume COMMAND
 
Manage volumes
 
Commands:
  create      Create a volume
  inspect     Display detailed information on one or more volumes
  ls          List volumes
  prune       Remove all unused local volumes
  rm          Remove one or more volumes
 
Run 'docker volume COMMAND --help' for more information on a command.

  • 创建一个volume

    [root@manager43 ~]# docker volume create --name testvolume
testvolume
 
# 查看创建的volume
[root@manager43 ~]# docker volume ls
DRIVER              VOLUME NAME
local               testvolume
 
# 查看volume详情
[root@manager43 ~]# docker volume inspect testvolume
[
    {
        "CreatedAt": "2018-10-21T10:50:02+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/testvolume/_data",
        "Name": "testvolume",
        "Options": {},
        "Scope": "local"
    }
]

  • 创建新的服务并挂载testvolume(nginx为例)

    参数src写成source也可以；dst表示容器内的路径，也可以写成target

    [root@manager43 ~]# docker service create --replicas 3 --mount type=volume,src=testvolume,dst=/zjz --name test_nginx nginx
sh7wc8yzcvr0xaedo4tnraj7l
overall progress: 3 out of 3 tasks
1/3: running   [==================================================>]
2/3: running   [==================================================>]
3/3: running   [==================================================>]
verify: Service converged

  • 验证

    # 查看有没有挂载成功(登录各个节点的容器看看有没有指定的目录并创建文件测试)
# 容器中操作
[root@manager43 ~]# docker exec -it 63451219cb4e /bin/bash
root@63451219cb4e:/# cd /zjz/
root@63451219cb4e:/zjz# ls
root@63451219cb4e:/zjz# echo "gen wo xue docker" > docker.txt
root@63451219cb4e:/zjz# ls
docker.txt
 
执行docker volume inspect testvolume 可以看到本地的路径(上面已经执行过了)
本地路径：/var/lib/docker/volumes/testvolume/_data
[root@manager43 ~]# cd /var/lib/docker/volumes/testvolume/_data
[root@manager43 _data]# ls
docker.txt
[root@manager43 _data]# cat docker.txt
gen wo xue docker


还可以将node节点机上的volume数据目录做成软链接
[root@manager43 _data]# ln -s /var/lib/docker/volumes/testvolume/_data /zjz
[root@manager43 _data]# cd /zjz/
[root@manager43 zjz]# ls
docker.txt
[root@manager43 zjz]# echo "123" > 1.txt  
[root@manager43 zjz]# ll
总用量 8
-rw-r--r-- 1 root root  4 10月 21 11:04 1.txt
-rw-r--r-- 1 root root 18 10月 21 11:00 docker.txt
 
# 容器中查看
[root@manager43 zjz]# docker exec -it 63451219cb4e /bin/bash
root@63451219cb4e:/# cd /zjz/
root@63451219cb4e:/zjz# ls
1.txt  docker.txt
root@63451219cb4e:/zjz# cat 1.txt
123
root@63451219cb4e:/zjz# cat docker.txt
gen wo xue docker

  • type为bind的挂载方式

    命令格式：
docker service create --mount type=bind,target=/container_data/,source=/host_data/
其中，参数target表示容器里面的路径，source表示本地硬盘路径
 
# 示例创建并挂载并使用网络
[root@manager43 ~]# docker service create --replicas 1 --mount type=bind,target=/usr/share/nginx/html/,source=/opt/web/ --network nginx_net --name zjz_nginx -p 8880:80 nginx

多服务Swarm集群部署(重点)

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

编写docker-compose.yml文件
[root@manager43 ~]# mkdir testswarm
[root@manager43 ~]# cd testswarm/
[root@manager43 testswarm]# cat docker-compose.yml
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:
      replicas: 1
      placement:
        constraints: [node.role == manager]
 
  portainer:
    image: portainer/portainer
    ports:
      - "9000:9000"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock"
    deploy:
      replicas: 1
      placement:
        constraints: [node.role == manager]
通过这个yml文件部署服务
[root@manager43 testswarm]# 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

通过上面的执行过程可以看出这样创建会默认创建一个网络并使用它，名字都是我们给的名字的前缀加上服务名
查看创建服务
[root@manager43 testswarm]# docker service ls
ID                  NAME                       MODE                REPLICAS            IMAGE                             PORTS
xj2f1t5ax3nm        deploy_deamon_nginx        replicated          3/3                 nginx:latest                      *:8888->80/tcp
ky9qpldr5abb        deploy_deamon_portainer    replicated          1/1                 portainer/portainer:latest        *:9000->9000/tcp
r47ff177x1ir        deploy_deamon_visualizer   replicated          1/1                 dockersamples/visualizer:latest   *:8080->8080/tcp
 
[root@manager43 testswarm]# docker service ps deploy_deamon_nginx
ID                  NAME                    IMAGE               NODE                DESIRED STATE       CURRENT STATE                ERROR               PORTS
z3v4uc1ujsnq        deploy_deamon_nginx.1   nginx:latest        node139             Running             Running about a minute ago                      
jhg3ups0cko5        deploy_deamon_nginx.2   nginx:latest        manager43           Running             Running about a minute ago                      
3e6guv791x21        deploy_deamon_nginx.3   nginx:latest        node188             Running             Running about a minute ago        
 
[root@manager43 testswarm]# docker service ps deploy_deamon_portainer
ID                  NAME                        IMAGE                        NODE                DESIRED STATE       CURRENT STATE                ERROR               PORTS
whyuvy82cvvw        deploy_deamon_portainer.1   portainer/portainer:latest   manager43           Running             Running about a minute ago                      
 
[root@manager43 testswarm]# docker service ps deploy_deamon_visualizer
ID                  NAME                         IMAGE                             NODE                DESIRED STATE       CURRENT STATE            ERROR               PORTS
wge5w1eqykg3        deploy_deamon_visualizer.1   dockersamples/visualizer:latest   manager43           Running             Starting 7 seconds ago
测试

Swarm 容器网络

在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 – 用于容器覆盖网络

  • 在Swarm集群中创建overlay网络

    [root@manager-node ~]# docker network create --driver overlay --opt encrypted --subnet 10.10.19.0/24 ngx_net
    • –opt encrypted 默认情况下swarm中的节点通信是加密的。在不同节点的容器之间，可选的–opt encrypted参数能在它们的vxlan流量启用附加的加密层。
    • –subnet 命令行参数指定overlay网络使用的子网网段。当不指定一个子网时，swarm管理器自动选择一个子网并分配给网络。

  • 查看网络

    [root@manager-node ~]# 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节点上，网络并不扩展到该节点。

  • 将服务连接到overlay网络

    [root@manager-node ~]# docker service create --replicas 5 --network ngx_net --name my-test -p 80:80 nginx

上面名为"my-test"的服务启动了5个task，用于运行每个任务的容器都可以彼此通过overlay网络进行通信。Swarm集群将网络扩展到所有任务处于Running状态的节点上。
[root@manager-node ~]# docker service ls
ID            NAME     REPLICAS  IMAGE  COMMAND
dsaxs6v463g9  my-test  5/5       nginx

在manager-node节点上，通过下面的命令查看哪些节点有处于running状态的任务：
[root@manager-node ~]# docker service ps my-test
ID                         NAME       IMAGE  NODE          DESIRED STATE  CURRENT STATE          ERROR
8433fuiy7vpu0p80arl7vggfe  my-test.1  nginx  node2         Running        Running 2 minutes ago
f1h7a0vtojv18zrsiw8j0rzaw  my-test.2  nginx  node1         Running        Running 2 minutes ago
ex73ifk3jvzw8ukurl8yu7fyq  my-test.3  nginx  node1         Running        Running 2 minutes ago
cyu73jd8psupfhken23vvmpud  my-test.4  nginx  manager-node  Running        Running 2 minutes ago
btorxekfix4hcqh4v83dr0tzw  my-test.5  nginx  manager-node  Running        Running 2 minutes ago
   
可见三个节点都有处于running状态的任务，所以my-network网络扩展到三个节点上。

  • 详细查看某个节点上my-network的详细信息

    [root@manager-node ~]# docker network inspect ngx_net
[
    {
        "Name": "ngx_net",
        "Id": "3x2wgugr6zmn1mcyf9k1du27p",
        "Scope": "swarm",
        "Driver": "overlay",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "10.10.19.0/24",
                    "Gateway": "10.10.19.1"
                }
            ]
        },
        "Internal": false,
        "Containers": {
            "00f47e38deea76269eb03ba13695ec0b0c740601c85019546d6a9a17fd434663": {
                "Name": "my-test.5.btorxekfix4hcqh4v83dr0tzw",
                "EndpointID": "ea962d07eee150b263ae631b8a7f8c1950337c11ef2c3d488a7c3717defd8601",
                "MacAddress": "02:42:0a:0a:13:03",
                "IPv4Address": "10.10.19.3/24",
                "IPv6Address": ""
            },
            "957620c6f7abb44ad8dd2d842d333f5e5c1655034dc43e49abbbd680de3a5341": {
                "Name": "my-test.4.cyu73jd8psupfhken23vvmpud",
                "EndpointID": "f33a6e9ddf1dd01bcfc43ffefd19e19514658f001cdf9b2fbe23bc3fdf56a42a",
                "MacAddress": "02:42:0a:0a:13:07",
                "IPv4Address": "10.10.19.7/24",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.driver.overlay.vxlanid_list": "257"
        },
        "Labels": {}
    }
]

    从上面的信息可以看出在manager-node节点上，名为my-test的服务有一个名为my-test.5.btorxekfix4hcqh4v83dr0tzw和
    my-test.4.cyu73jd8psupfhken23vvmpud的task连接到名为ngx_net的网络上（另外两个节点node1和node2同样可以用上面命令查看）

    [root@node1 ~]# docker network inspect ngx_net
.......
        "Containers": {
            "7d9986fad5a7d834676ba76ae75aff2258f840953f1dc633c3ef3c0efd2b2501": {
                "Name": "my-test.3.ex73ifk3jvzw8ukurl8yu7fyq",
                "EndpointID": "957ca19f3d5480762dbd14fd9a6a1cd01a8deac3e8e35b23d1350f480a7b2f37",
                "MacAddress": "02:42:0a:0a:13:06",
                "IPv4Address": "10.10.19.6/24",
                "IPv6Address": ""
            },
            "9e50fceada1d7c653a886ca29d2bf2606debafe8c8a97f2d79104faf3ecf8a46": {
                "Name": "my-test.2.f1h7a0vtojv18zrsiw8j0rzaw",
                "EndpointID": "b1c209c7b68634e88e0bf5e100fe03435b3096054da6555c61e6c207ac651ac2",
                "MacAddress": "02:42:0a:0a:13:05",
                "IPv4Address": "10.10.19.5/24",
                "IPv6Address": ""
            }
        },
.........
  
[root@node2 web]# docker network inspect ngx_net
........
        "Containers": {
            "4bdcce0ee63edc08d943cf4a049eac027719ff2dc14b7c3aa85fdddc5d1da968": {
                "Name": "my-test.1.8433fuiy7vpu0p80arl7vggfe",
                "EndpointID": "df58de85b0a0e4d128bf332fc783f6528d1f179b0f9f3b7aa70ebc832640d3bc",
                "MacAddress": "02:42:0a:0a:13:04",
                "IPv4Address": "10.10.19.4/24",
                "IPv6Address": ""
            }
        },
        
        
可以通过查询服务来获得服务的虚拟IP地址，如下：
[root@manager-node ~]# 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"}]

    加入ngx_net网络的容器彼此之间可以通过IP地址通信，也可以通过名称通信。

    [root@node2 ~]# docker ps
CONTAINER ID    IMAGE           COMMAND                  CREATED         STATUS             PORTS    NAMES
4bdcce0ee63e    nginx:latest    "nginx -g 'daemon off"   22 minutes ago  Up 22 minutes      80/tcp   my-test.1.8433fuiy7vpu0p80arl7vggfe
  
[root@node2 ~]# docker exec -it 4bdcce0ee63e /bin/bash
root@4bdcce0ee63e:/# ip addr                                                                                          
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default
    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
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
1786: eth0@if1787: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UP group default
    link/ether 02:42:0a:ff:00:08 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 10.255.0.8/16 scope global eth0
       valid_lft forever preferred_lft forever
    inet 10.255.0.6/32 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:aff:feff:8/64 scope link
       valid_lft forever preferred_lft forever
1788: eth1@if1789: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:ac:12:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 1
    inet 172.18.0.3/16 scope global eth1
       valid_lft forever preferred_lft forever
    inet6 fe80::42:acff:fe12:3/64 scope link
       valid_lft forever preferred_lft forever
1791: eth2@if1792: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UP group default
    link/ether 02:42:0a:0a:13:04 brd ff:ff:ff:ff:ff:ff link-netnsid 2
    inet 10.10.19.4/24 scope global eth2
       valid_lft forever preferred_lft forever
    inet 10.10.19.2/32 scope global eth2
       valid_lft forever preferred_lft forever
    inet6 fe80::42:aff:fe0a:1304/64 scope link
       valid_lft forever preferred_lft forever
  
root@4bdcce0ee63e:/# ping 10.10.19.3
PING 10.10.19.3 (10.10.19.3): 56 data bytes
64 bytes from 10.10.19.3: icmp_seq=0 ttl=64 time=0.890 ms
64 bytes from 10.10.19.3: icmp_seq=1 ttl=64 time=0.622 ms
.....-
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.622/0.756/0.890/0.134 ms
  
root@4bdcce0ee63e:/# ping 10.10.19.6
PING 10.10.19.6 (10.10.19.6): 56 data bytes
64 bytes from 10.10.19.6: icmp_seq=0 ttl=64 time=0.939 ms
64 bytes from 10.10.19.6: icmp_seq=1 ttl=64 time=0.590 ms

  • 总结

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

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

    在同一个网络中添加了一个centos服务，此服务可以通过名称my-test访问前面创建的nginx服务：
[root@manager-node ~]# docker service create --name my-centos --network ngx_net centos       
  
查询centos运行在哪个节点上（上面创建命令执行后，需要一段时间才能完成这个centos服务的创建）
[root@manager-node ~]# docker service ps my-centos
ID                         NAME             IMAGE   NODE   DESIRED STATE  CURRENT STATE            ERROR
e03pqgkjs3l1qizc6v4aqaune  my-centos.1      centos  node2  Running        Preparing 4 seconds ago
  
登录centos运行的节点（由上可知是node2节点），打开centos的交互shell：
[root@node2 ~]# 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
  
[root@node2 ~]# 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
Address 1: 10.10.19.2 10.10.19.2
  
  
从centos容器内部，使用特殊查询 查询DNS，来找到my-test服务的所有容器的IP地址：
root@4bdcce0ee63e:/# nslookup tasks.my-test
Server: 127.0.0.11
Address 1: 127.0.0.11
  
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

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

    如下示例（注意：使用DNS round-robin方式创建服务，不能直接在命令里使用-p指定端口）
[root@manager-node ~]# docker service create --replicas 3 --name my-dnsrr-nginx --network ngx_net --endpoint-mode dnsrr nginx
  
[root@manager-node ~]# docker service ps my-dnsrr-nginx
ID                         NAME              IMAGE  NODE          DESIRED STATE  CURRENT STATE          ERROR
65li2zbhxvvoaesndmwjokouj  my-dnsrr-nginx.1  nginx  node1         Running        Running 2 minutes ago
5hjw7wm4xr877879m0ewjciuj  my-dnsrr-nginx.2  nginx  manager-node  Running        Running 2 minutes ago
afo7acduge2qfy60e87liz557  my-dnsrr-nginx.3  nginx  manager-node  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连通性的正确的工具。
Al6n Lee
关注
  • 7
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DockerSwarm学习教程
02-02
Swarm是Docker公司在2014年12月初发布的一套较为简单的工具，用来管理Docker集群，它将一群Docker宿主机变成一个单一的，虚拟的主机。Swarm使用标准的DockerAPI接口作为其前端访问入口，换言之，各种形式的DockerClient(dockerclientingo,docker_py,docker等)均可以直接与Swarm通信。Swarm几乎全部用Go语言来完成开发，上周五，4月17号，Swarm0.2发布，相比0.1版本，0.2版本增加了一个新的策略来调度集群中的容器，使得在可用的节点上传播它们，以及支持更多的Docker命令以及集群驱动。Swarmdeamon只
轻松安装docker并运行docker swarm模式
09-30
主要介绍了安装docker并运行docker swarm模式的相关知识，非常不错，具有参考借鉴价值，需要的朋友一起学习吧
《Docker极简教程》--Docker的高级特性--Docker Swarm的使用
最新发布
喵叔
03-03 1156
Docker Swarm是一个强大的工具，可用于管理容器化应用程序。它提供了集群管理、服务发现、负载均衡等功能，通过Swarm模式实现高可用性和弹性伸缩。我们学习了如何创建和管理Swarm服务、网络和节点，以及部署策略和故障恢复机制。通过这些功能和实践，我们可以更轻松地在生产环境中部署和管理容器化应用程序，提高应用程序的可靠性和可扩展性。
Docker-Swarm集群管理
BASK2311的博客
01-10 3826
Docker Swarm是Docker的集群管理工具，它提供了标准的Docker API，所有任何已经与Docker守护程序通信的工具都可以使用Swarm轻松地扩展到多个主机。支持的工具包括Dokku、Docker Compose、Docker Machine和Jenkins等。compose、machine 和 swarm 是docker 原生提供的三大编排工具，简称docker三剑客。其官网地址复制代码Docker Swarm 和 Docker Compose。
容器技术—docker swarm（二）
weixin_37648525的博客
06-18 2560
基于docker swarm的docker集群已经搭建完成，我们的目的是要在集群中部署应用。swarm集群部署应用最基本的命令是docker service，它的使用方式类似于docker container（也就是我们一直用的docker命令，docker命令是docker container的简写），也和docker container命令一样适合部署单个应用，不能进行编排，只不过一个是用于单机，一个用于集群。下面以在swarm集群中部署nginx为例：默认的情况下，管理节点也是一个工作节点，服务也会部
Docker 学习总结（74）—— Docker Swarm 全面总结
科技D人生
06-05 3696
Swarm 是 Docker 公司推出的用来管理 docker 集群的平台，几乎全部用 GO 语言来完成的开发的，代码开源在 https://github.com/docker/swarm；Docker Swarm 和 Docker Compose 一样，都是 Docker 官方容器编排项目，但不同的是，Docker Compose 是一个在单个服务器或主机上创建多个容器的工具，而 Docker Swarm 则可以在多个服务器或主机上创建容器集群服务，对于微服务的部署，显然 Docker Swarm 会更加
Docker Swarm
Olivier0611的博客
03-13 2万+
1、什么是docker swarm ？ Swarm是Docker公司推出的用来管理docker集群的平台，几乎全部用GO语言来完成的开发的，代码开源在https://github.com/docker/swarm 简单理解就是多台服务器搭建一个docker集群，每个服务器就是集群中的一个节点。 参考：Docker三剑客之Docker Swarm - 一本正经的搞事情 - 博客园 2、docker swarm的几个关键概念 swarm ：集群管理工具 node ：节点，一个节点就是docker
Docker Swarm简介
GSON的博客
04-20 2万+
一、什么是Docker Swarm Swarm是Docker公司推出的用来管理docker集群的平台，几乎全部用GO语言来完成的开发的，代码开源在https://github.com/docker/swarm，它是将一群Docker宿主机变成一个单一的虚拟主机，Swarm使用标准的Docker API接口作为其前端的访问入口，换言之，各种形式的DockerClient(compose,docker-py等)均可以直接与Swarm通信，甚至Docker本身都可以很容易的与Swarm集成，这大大方便了用户将.
Docker系列（十四）：Docker Swarm集群
weixin_34162228的博客
05-03 1782
一、Swarm简介 Swarm是Docker官方提供的一款集群管理工具，其主要作用是把若干台Docker主机抽象为一个整体，并且通过一个入口统一管理这些Docker主机上的各种Docker资源。Swarm和Kubernetes比较类似，但是更加轻便，具有的功能也较kubernetes更少一些。 Swarm 在 Docker 1.12 版本之前属于一个独立的项目，在 Docker 1.12 版本发布...
容器集群管理工具 Docker Swarm
二蛋的博客
06-08 4363
前言中有提到容器编排工具 docker compose ，不过只限于单机。如果现在需要搭建一个集群环境，提供了10台服务器用来部署应用以及其依赖的组件，你会如何部署？重复执行部署操作？如果需要扩缩容，手动处理吗？如果上百个应用，容器如何管理？集群中容器之前如何通信？数据如何管理？很显然，我们需要一个工具帮助我们更快、更高效的做这些事。本文对 Docker Swarm 进行介绍，详细说明在集群环境中如何统一部署、统一管理、统一调度容器。
【Docker】Docker Swarm介绍与环境搭建
热门推荐
morris
10-24 3万+
Docker Swarm是Docker官方推出的容器集群管理工具，基于Go语言实现。使用它可以将多个Docker主机封装为单个大型的虚拟Docker主机，快速打造一套容器云平台。Docker Swarm是生产环境中运行Docker应用程序最简单的方法。作为容器集群管理器，Swarm最大的优势之一就是100%支持标准的Docker API。各种基于标准API的工具比如Compose、docker-py、各种管理软件，甚至 Docker本身等都可以很容易的与Swarm进行集成。
swarmServiceExec:如何在Docker Swarm容器中执行命令
05-08
Docker service exec 介绍 一个不只是运行docker service exec ... 要在容器中执行某些命令，您可以运行docker exec ...但是您只能对在该计算机上运行的容器执行此操作。 如果我们需要在集群中的所有计算机上执行某些操作，该怎么办？ 这是一个罕见的问题，但是如果您蜂拥而至，并且需要在多个容器中执行某些命令，则会遇到麻烦。 您可以在阅读有关此案例的更多信息。 起初，我以为可以解决问题，但 docker inspect在群集中不包含“ Log”（预期结果）。 解决方案是使用ssh，但使用覆盖。 这种方法为我们提供了所需的安全性和灵活性。 这是一个循序渐进的教程。 我还准备了一个简单的Python脚本，可用作您自己实施docker service exec的起点。 警告：本教程完全忽略了安全性。 您应该记住，Docker，Docker A
使用Docker Swarm 搭建Wordpress的方法
09-29
主要介绍了使用Docker Swarm 搭建Wordpress的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
详解Docker Swarm概念与用法
09-29
主要介绍了Docker Swarm概念与用法，帮助大家更好的理解和使用docker容器，感兴趣的朋友可以了解下
在DockerSwarm上部署ApacheStorm
02-26
《本文来自BaqendTechBlog，描述了如何在DockerSwarm，而不是在虚拟机上部署和调配ApacheStorm集群。这个题目很有意思，WolframWingerath将之描述为“真正有趣”的体验，在Tech上你很少能听见这种话。我好奇地问他是什么让使用容器比使用虚拟机更棒？他回答说：作为一名Docker和DockerSwarm的新手，我肯定还有很多不知道的事。不过，在我看来，在Docker上部署（及一般操作）比在虚拟机甚至裸机上更有趣，因为Docker剥离了异构性和许多问题。一旦运行了Docker，你就可以用一行声明语句来启动MongoDB或者Redis的服务器等东西。Docke
The DevOps 2.1 Toolkit Docker Swarm 无水印pdf
11-29
The DevOps 2.1 Toolkit Docker Swarm 英文无水印pdf pdf所有页面使用FoxitReader和PDF-XChangeViewer测试都可以打开 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除
mongo-swarm：在Docker Swarm上引导MongoDB分片集群
02-02
使用单个命令，您可以将Mongos ， Config和Data副本集部署到Docker Swarm上，形成一个高可用性的MongoDB集群，该集群能够在不中断服务的情况下承受多个节点的故障。 Docker堆栈由两个MongoDB副本集，两个Mongos实例...
【Docker】进阶之路：（十三）Docker Swarm
圈小圈DBA的博客
12-13 424
Docker Swarm是Docker官方提供的集群管理工具，它的主要作用是将Docker主机池转变为单个虚拟Docker主机，把若干台Docker主机抽象为一个整体，并且通过一个入口统一管理这些Docker主机上的各种Docke资源。Docker Swarm提供了标准的Docker API,所有任何已经与Docker守护程序通信的工具都可以使用Swarm轻松地扩展到多个主机。
docker || swarm
qq_60271706的博客
07-11 557
Swarm是Docker公司推出的用来管docker的一个集群管理软件。Swarm 可以在多个服务器或主机上创建容器集群服务。swarm 的架构图Swarm是典型的master-slave结构，通过发现服务来选举manager。Swarm的几个关键概念swarm ：一个 swarm 由多个 Docker 主机组成，这些主机在 Warm 模式下运行，充当管理器（管理成员资格和委派）和工作线程（运行 swarm 服务）。Docker 引擎中嵌入的集群管理和编排功能是使用 swarmkit 构建的。
docker swarm实现分布式机器学习
06-13
Docker Swarm是Docker的一种集群管理工具，可以将多个Docker主机组成一个集群，形成一个虚拟的Docker主机，从而实现容器的高可用和负载均衡。在机器学习领域，可以利用Docker Swarm实现分布式机器学习。 首先，需要将机器学习任务拆分成多个子任务，每个子任务可以在一个Docker容器中运行。然后，使用Docker Swarm将这些容器分布在不同的主机上，利用其自带的负载均衡机制，让不同的容器分配到不同的主机上，从而实现分布式计算。 在Docker Swarm中，可以使用Swarm mode来管理和运行分布式应用程序。Swarm mode提供了一些特殊的命令和功能，可以轻松地创建和管理集群，并实现负载均衡、容错和扩展等功能。 需要注意的是，在使用Docker Swarm实现分布式机器学习时，需要考虑到容器之间的通信和数据共享问题，以及任务调度和容器管理等问题。同时，还需要对Docker和Docker Swarm的相关知识有一定的了解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Al6n Lee

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值