[嵌入式]docker集群多服务一键部署详解（docker-compose、Swarm、Stack）

Docker-Compose 多容器部署工具

概述

Docker-Compose项目是Docker官方的开源项目，是用于定义和运行多容器 Docker 应用程序的工具。负责实现对Docker容器集群的快速编排。 通过 Compose，可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

Docker-Compose将所管理的容器分为三层，分别是工程（project），服务（service）以及容器（container）。Docker-Compose运行目录下的所有文件（docker-compose.yml，extends文件或环境变量文件等）组成一个工程，若无特殊指定工程名即为当前目录名。

一个工程当中可包含多个服务，每个服务中定义了容器运行的镜像，参数，依赖。一个服务当中可包括多个容器实例，Docker-Compose并没有解决负载均衡的问题，因此需要借助其它工具实现服务发现及负载均衡。

Docker-Compose的工程配置文件默认为docker-compose.yml，可通过环境变量COMPOSE_FILE或-f参数自定义配置文件，其定义了多个有依赖关系的服务及每个服务运行的容器。

使用一个Dockerfile模板文件，可以让用户很方便的定义一个单独的应用容器。在工作中，经常会碰到需要多个容器相互配合来完成某项任务的情况。例如要实现一个Web项目，除了Web服务容器本身，往往还需要再加上后端的数据库服务容器，甚至还包括负载均衡容器等。

Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。 Docker-Compose项目由Python编写，调用Docker服务提供的API来对容器进行管理。因此，只要所操作的平台支持Docker API，就可以在其上利用Compose来进行编排管理。

Docker-Compose 安装及卸载

Docker-compose安装

• 安装 Docker Compose 可以通过下面命令自动下载适应版本的 Compose，并为安装脚本添加执行权限

# 要安装其他版本的 Compose，请替换 v2.2.2。
sudo curl -L "https://get.daocloud.io/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

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

• 查看安装是否成功

docker-compose -v

• 创建软链：

ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

Docker-compose卸载

apt-get remove docker-compose

docker-compose 常用命令

• ps：列出所有运行容器

docker-compose ps

• logs：查看服务日志输出

docker-compose logs [options] [SERVICE...]
# 选项包括
–no-color	关闭颜色。默认情况下，docker-compose将对不同的服务输出使用不同的颜色来区分
-f 			跟踪日志输出
。
# 示例
docker-compose logs

• up：使用当前目录下的compose-up.yaml文件构建、启动、更新容器

  • 当服务的配置发生更改时，可使用 docker-compose up 命令更新配置

    此时，Compose 会删除旧容器并创建新容器，新容器会以不同的 IP 地址加入网络，名称保持不变，任何指向旧容起的连接都会被关闭，重新找到新容器并连接上去

docker-compose up [options] [--scale SERVICE=NUM...] [SERVICE...]
# 选项包括：
-d 					# 在后台运行服务容器
--force-recreate 	# 强制重新创建容器，不能与-no-recreate同时使用
-no-recreate 		# 如果容器已经存在，则不重新创建，不能与–force-recreate同时使用
-no-color 		# 不用颜色来区分不同的服务的控制输出
-no-deps 		# 不启动服务所链接的容器
-no-build 		# 不自动构建缺失的服务镜像
-build 			# 在启动容器前构建服务镜像
-V, --renew-anon-volumes		# 重新创建匿名卷，而不是从以前的容器中检索数据
-abort-on-container-exit 		# 如果任何一个容器被停止，则停止所有容器。不能与-d同时使用
-t, -timeout TIMEOUT 			# 停止容器时候的超时（默认为10秒）
-remove-orphans 				# 删除服务中没有在compose.yaml文件中定义的容器
--scale SERVICE=NUM			# 将Compose.yaml中的SERVICE服务扩展到NUM个实例，快速实现一个负载均衡（单节点）
								# 该参数会覆盖Compose.yaml文件中的“scale”设置(如果存在)。
								# 注意：如果Compose.yaml中设置了ports配置（端口绑定）
								# ，当使用scale参数拓展到多个实例时，会端口冲突，需删除Compose.yaml中的ports配置

# 示例
docker-compose up --force-recreate -d

• port：显示某个容器端口所映射的公共端口

docker-compose port [options] SERVICE PRIVATE_PORT
# 选项包括：
–protocol=proto		指定端口协议，TCP（默认值）或者UDP
–index=index		如果同意服务存在多个容器，指定命令对象容器的序号（默认为1）
# 示例：下面命令可以输出 eureka 服务 8761 端口所绑定的公共端口
docker-compose port eureka 8761

• build：构建或者重新构建服务容器。

  服务容器一旦构建后，将会带上一个标记名。可以随时在项目目录下运行docker-compose build来重新构建服务

docker-compose build [options] [--build-arg key=val...] [SERVICE...]
# 选项包括：
–compress 	通过gzip压缩构建上下环境
–force-rm 	删除构建过程中的临时容器
–no-cache 	构建镜像过程中不使用缓存
–pull 		始终尝试通过拉取操作来获取更新版本的镜像
-m, –memory MEM		为构建的容器设置内存大小
–build-arg key=val	为服务设置build-time变量
# 示例：
docker-compose build

• stop：停止已运行的服务的容器

docker-compose stop [options] [SERVICE...]
# 选项包括
-t, –timeout TIMEOUT 停止容器时候的超时（默认为10秒）
# 示例
docker-compose stop eureka

• start：启动指定服务已存在的容器

docker-compose start [SERVICE...]
# 示例
docker-compose start eureka

• restart：重启项目中的服务

docker-compose restart [options] [SERVICE...]
# 选项包括：
-t, –timeout TIMEOUT	指定重启前停止容器的超时（默认为10秒）
# 示例：
docker-compose restart

• rm：删除所有或指定（停止状态的）服务的容器

docker-compose rm [options] [SERVICE...]
# 选项包括：
–f, –force	强制直接删除，包括非停止状态的容器
-v			删除容器所挂载的数据卷
# 示例
docker-compose rm eureka

• kill：通过发送 SIGKILL 信号来强制停止指定服务的容器

docker-compose kill [options] [SERVICE...]
# 选项包括：
-s	来指定发送的信号
# 示例
docker-compose kill eureka
docker-compose kill -s SIGINT

• push：推送服务依的镜像

docker-compose push [options] [SERVICE...]
# 选项包括：
–ignore-push-failures  忽略推送镜像过程中的错误

• pull：下载服务镜像

docker-compose pull [options] [SERVICE...]
# 选项包括：
–ignore-pull-failures	忽略拉取镜像过程中的错误
–parallel	多个镜像同时拉取
–quiet		拉取镜像过程中不打印进度信息
# 示例
docker-compose pull

• scale：设置指定服务运行容器的个数，以 service=num 形式指定

docker-compose scale user=3 movie=3

• run：在一个服务上执行一个命令

docker-compose run web bash

• down：停止并删除所有容器、网络、卷、镜像。

docker-compose down [options]
# 选项包括：
–rmi type		删除镜像，类型必须是：all，删除compose文件中定义的所有镜像；local，删除镜像名为空的镜像
-v, –volumes	删除已经在compose文件中定义的和匿名的附在容器上的数据卷
–remove-orphans	删除服务中没有在compose中定义的容器
# 示例
docker-compose down

• pause：暂停一个服务容器

docker-compose pause [SERVICE...]

• uppause：恢复处于暂停状态中的服务

docker-compose unpause [SERVICE...]

• config：验证并查看compose文件配置

docker-compose config [options]
# 选项包括：
–resolve-image-digests 	将镜像标签标记为摘要
-q, –quiet 		只验证配置，不输出。 当配置正确时，不输出任何内容，当文件配置错误，输出错误信息
–services 		打印服务名，一行一个
–volumes 		打印数据卷名，一行一个

• create：为服务创建容器

docker-compose create [options] [SERVICE...]
# 选项包括：
–force-recreate		重新创建容器，即使配置和镜像没有改变，不兼容–no-recreate参数
–no-recreate		如果容器已经存在，不需要重新创建，不兼容–force-recreate参数
–no-build		不创建镜像，即使缺失
–build			创建容器前，生成镜像

Docker-compose 模板文件

简介及示例模板

Compose允许用户通过一个docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。 Compose模板文件是一个定义服务、网络和卷的YAML文件。Compose模板文件默认路径是当前目录下的docker-compose.yml，可以使用.yml或.yaml作为文件扩展名。

Docker-Compose标准模板文件应该包含version、services、networks 三大部分，最关键的是services和networks两个部分。

示例模板

version: '3'

networks:
  front-tier:
    driver: bridge
  back-tier:
    driver: bridge

services:
  web:
    image: dockercloud/hello-world
    ports:
      - 8080
    networks:
      - front-tier
      - back-tier

  redis:
    image: redis
    links:
      - web
    networks:
      - back-tier

  lb:
    image: dockercloud/haproxy
    ports:
      - 80:80
    links:
      - web
    networks:
      - front-tier
      - back-tier
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock 

Compose目前有三个版本分别为Version 1，Version 2，Version 3，Compose区分Version 1和Version 2（Compose 1.6.0+，Docker Engine 1.10.0+）。Version 2支持更多的指令。Version 1将来会被弃用。

启动应用

创建一个webapp目录，将docker-compose.yaml文件拷贝到webapp目录下，使用docker-compose启动应用。

docker-compose up -d

Docker-compose.yml 配置说明

• version：指定 docker-compose.yml 文件的写法格式

• services：多个容器集合

• build：指定为构建镜像上下文路径。相对路径、绝对路径均可

  服务除了可以基于指定的镜像，还可以基于一份Dockerfile，在使用up启动时执行构建任务，构建标签是build，可以指定Dockerfile所在文件夹的路径。Compose将会利用Dockerfile自动构建镜像，然后使用镜像启动服务容器。

  • context：上下文路径。
  • dockerfile：指定构建镜像的 Dockerfile 文件名。使用dockerfile文件来构建时，必须指定构建路径
  • args：添加构建参数，这是只能在构建过程中访问的环境变量。可选
  • labels：设置构建镜像的标签。
  • target：多层构建，可以指定构建哪一层。

build: ./dir
---------------
build:
    context: /path/to/build/dir
    dockerfile: Dockerfile
    args:
      buildno: 1
    labels:
      - "com.example.description=Accounting webapp"
      - "com.example.department=Finance"
      - "com.example.label-with-empty-value"
    target: prod
    
# build都是一个目录，如果要指定Dockerfile文件需要在build标签的子级标签中使用dockerfile标签指定。
# 如果同时指定image和build两个标签，那么Compose会构建镜像并且把镜像命名为image值指定的名字。

• container_name：指定自定义容器名称，而不是生成的默认名称（<项目名称><服务名称><序号>）。

container_name: my-web-container

• command：覆盖容器启动后默认执行的命令

  在用命令行运行容器时，有的容器需要在命令中加入附加的命令行参数，这就需要加在compose文件的服务中的command中。这一个参数没有什么固定的模式，建议按照对应容器的镜像的使用说明来决定是否需要加，加什么。

command: bundle exec thin -p 3000
----------------------------------
command: ["bundle","exec","thin","-p","3000"]

• cap_add，cap_drop：添加或删除容器拥有的宿主机的内核功能。
• depends_on：设置依赖关系。
  • docker-compose up ：以依赖性顺序启动服务。在以下示例中，先启动 db 和 redis ，才会启动 web。
  • docker-compose up SERVICE ：自动包含 SERVICE 的依赖项。在以下示例中，docker-compose up web 还将创建并启动 db 和 redis。
  • docker-compose stop ：按依赖关系顺序停止服务。在以下示例中，web 在 db 和 redis 之前停止。
  • 注意：web 服务不会等待 redis db 完全启动 之后才启动。

cap_add:
  - ALL # 开启全部权限

cap_drop:
  - SYS_PTRACE # 关闭 ptrace权限

version: "3.7"
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres

• dns：配置 dns 服务器，可以是一个值或列表

dns: 8.8.8.8
------------
dns:
    - 8.8.8.8
    - 9.9.9.9

• dns_search：配置 DNS 搜索域，可以是一个值或列表

dns_search: example.com
------------------------
dns_search:
    - dc1.example.com
    - dc2.example.com

• env_file：从文件中获取环境变量，可以指定一个文件路径或路径列表，其优先级低于 environment 指定的环境变量

env_file: .env
---------------
env_file:
    - ./common.env

• environment添加环境变量。可以使用数组或字典、任何布尔值，布尔值需要用引号引起来，以确保 YML 解析器不会将其转换为 True 或 False

environment:
    RACK_ENV: development
    SHOW: 'ture'
-------------------------
environment:
    - RACK_ENV=development
    - SHOW=ture

• expose：暴露端口，但不映射到宿主机，只被连接的服务访问。

expose:
    - "3000"
    - "8000"

• ports：对外暴露的端口定义，和 expose 对应

  注意：ports属性是物理机和集群网络中服务（而不是ingress）之间的映射，容器访问ingress网络中的某个地址时，是无法根据端口做转发的。

  若使用了ports，则该服务会生成两个虚拟ip，一个是服务间通信的overlay网络虚拟ip，一个是用于映射服务端口到物理机端口的ingress网络虚拟ip，这时服务注册到注册中心（比如nacos）的ip很可能会是ingress网络虚拟ip，最终会导致基于注册中心服务发现的gateway路由和feign调用不通（超时）。

  解决方案为：

  1. 若不用暴露端口给物理机，则只使用expose暴露端口到集群网络，这种可以注册正确的虚拟ip到注册中心

  2. 若必须暴露端口给物理机，则配置文件中设定容器虚拟网段

     spring:
       application:
         name: @artifactId@
       cloud:
         inetutils:
           ignored-interfaces: eth.*
           preferred-networks: 192.168.0
     

     详见：https://my.oschina.net/woniuyi/blog/4984748

# 暴露端口信息。格式：- "宿主机端口:容器暴露端口"，或者只是指定容器的端口，宿主机会随机映射端口。
ports:
- "8763:8763"
- "8763:8763"

# 当使用HOST:CONTAINER格式来映射端口时，如果使用的容器端口小于60可能会得到错误得结果，因为YAML将会解析xx:yy这种数字格式为60进制。所以建议采用字符串格式。

• extra_hosts：添加容器内主机名映射。类似 docker client --add-host。

extra_hosts:
 - "somehost:162.242.195.82"
 - "otherhost:50.31.209.229"
 
 
# 以上会在此服务的内部容器中 /etc/hosts 创建一个具有 ip 地址和主机名的映射关系：
162.242.195.82  somehost
50.31.209.229   otherhost

• healthcheck：用于检测 docker 服务是否健康运行。

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
  interval: 1m30s # 设置检测间隔
  timeout: 10s # 设置检测超时时间
  retries: 3 # 设置重试次数
  start_period: 40s # 启动后，多少秒开始启动检测程序

• image：指定服务所使用的镜像名称或镜像ID。如果镜像在本地不存在，Compose将会尝试拉取镜像。

# 以下格式都可以：
image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd # 镜像id

• links：将指定容器连接到当前连接，可以设置别名，避免ip方式导致的容器重启动态改变的无法连接情况。

  在用命令行部署容器的时候，经常会需要在一个容器里面访问另外一个容器，这个时候就需要用到 --link参数，一般的使用形式为 --link [引用的其他容器名]:[容器内代表引用容器的字段]。被 --link A:B形式引用的A容器会以[A 的 ip：port] ： 'B’的形式出现在容器内的/etc/hosts文件里。也就是说，经过 --link 引入的其他容器A将自己的地址和端口赋给了字段B。在容器内需要获得A的时候，可以直接使用字段B。

  注意：在v3版本的compose file中，links属性是会自动被 docker stack deploy命令忽略的，因为在v3中，links的功能已经移除。作为替代的是networks属性。

links:
    # 指定服务名称:别名 
    - docker-compose-eureka-server:compose-eureka
    # 仅指定服务名称（同时作为别名）
    - db

• logs：日志输出信息

--no-color          单色输出，不显示其他颜.
-f, --follow        跟踪日志输出，就是可以实时查看日志
-t, --timestamps    显示时间戳
--tail              从日志的结尾显示，--tail=200

• network_mode：设置网络模式

network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"

• networks：配置容器连接的网络，引用顶级 networks 下的条目 。
  • 建立一个和services参数并级的networks参数，在networks参数下，可以设立一个或者多个的网络，形成一个网络的networks列表。
    • external: true ：可以使用该属性引用已创建好了外部网络，实现跨堆栈的网络共享
  • 在每个服务里面可以添加networks属性，该属性下可以包括一个或者多个在先前建立的网络列表中的网络名称，表示该服务在这些网络中可以用这些服务的名称来在其他服务中访问。有时因为各种原因，服务的名称和其他容器内访问的字段会不一致，这个时候还可以在网络名称后面再加一级，aliases别名，别名可以发挥和服务本身的名字一样的作用，在其所属的network中被其他服务访问。
    • aliases ：同一网络上的其他容器可以使用服务名称或此别名来连接到对应容器的服务。

networks:
  some-network:
    # 使用自定义驱动程序
    driver: custom-driver-1
  other-network:
    # 引用外部网络
    external: true
services:
  some-service:
    networks:
      some-network:
        aliases:
         - alias1
      other-network:
        aliases:
         - alias2

• restart

  • no：是默认的重启策略，在任何情况下都不会重启容器。
  • always：容器总是重新启动。
  • on-failure：在容器非正常退出时（退出状态非0），才会重启容器。
  • unless-stopped：在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

  注：swarm 集群模式，请改用 restart_policy。

restart: "no"
------------------------------
restart: always
------------------------------
restart: on-failure
------------------------------
restart: unless-stopped

• security_opt：修改容器默认的 schema 标签。

security-opt：
  - label:user:USER   # 设置容器的用户标签
  - label:role:ROLE   # 设置容器的角色标签
  - label:type:TYPE   # 设置容器的安全策略标签
  - label:level:LEVEL  # 设置容器的安全等级标签

• tmpfs：在容器内安装一个临时文件系统。可以是单个值或列表的多个值。

tmpfs: /run
------------------------------
tmpfs:
  - /run
  - /tmp

• volumes：将主机的数据卷或着文件挂载到容器里

  可以直接使用 [HOST:CONTAINER]格式，或者使用[HOST:CONTAINER:ro]格式，后者对于容器来说，数据卷是只读的，可以有效保护宿主机的文件系统。 Compose的数据卷指定路径可以是相对路径，使用 . 或者 … 来指定相对目录。

  volumes对应命令行中的 -v 选项，其本身的意义并没有发生什么变化。但是，由于volume在yml文件中是以字符串的形式存在的，所以像 $PWD 这样的写法是不能被接受的，要改成相对路径或绝对路径。

# 数据卷的格式可以是下面多种形式
volumes:
  # 只是指定一个路径，Docker 会自动在创建一个数据卷（这个路径是容器内部的）。
  - /var/lib/mysql
  # 使用绝对路径挂载数据卷
  - /opt/data:/var/lib/mysql
  # 以 Compose 配置文件为中心的相对路径作为数据卷挂载到容器。
  - ./cache:/tmp/cache
  # 使用用户的相对路径（~/ 表示的目录是 /home/<用户目录>/ 或者 /root/）。
  - ~/configs:/etc/configs/:ro
  # 已经存在的命名的数据卷。
  - datavolume:/var/lib/mysql
  
# 如果不使用宿主机的路径，可以指定一个volume_driver。

• volumes_from：从另一个服务或容器挂载其数据卷

volumes_from:
   - service_name    
     - container_name

• ulimits：覆盖容器默认的 ulimit。

ulimits:
  nproc: 65535
  nofile:
    soft: 20000
    hard: 40000

Docker Swarm 集群管理

概述

Docker Swarm 是 Docker 的集群管理工具。它将 Docker 主机池转变为单个虚拟 Docker 主机，使得容器可以组成跨主机的子网网络。Docker Swarm 提供了标准的 Docker API，所有任何已经与 Docker 守护程序通信的工具都可以使用 Swarm 轻松地扩展到多个主机。

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

支持的工具包括但不限于以下各项：

• Dokku
• Docker Compose
• Docker Machine
• Jenkins

Docker Swarm 优点

• 任何规模都有高性能表现

对于企业级的 Docker Engine 集群和容器调度而言，可拓展性是关键。任何规模的公司——不论是拥有五个还是上千个服务器——都能在其环境下有效使用 Swarm。

经过测试，Swarm 可拓展性的极限是在 1000 个节点上运行 50000 个部署容器，每个容器的启动时间为亚秒级，同时性能无减损。

• 灵活的容器调度

Swarm 帮助 IT 运维团队在有限条件下将性能表现和资源利用最优化。Swarm 的内置调度器（scheduler）支持多种过滤器，包括：节点标签，亲和性和多种容器部策略如 binpack、spread、random 等等。

• 服务的持续可用性

Docker Swarm 由 Swarm Manager 提供高可用性，通过创建多个 Swarm master 节点和制定主 master 节点宕机时的备选策略。如果一个 master 节点宕机，那么一个 slave 节点就会被升格为 master 节点，直到原来的 master 节点恢复正常。

此外，如果某个节点无法加入集群，Swarm 会继续尝试加入，并提供错误警报和日志。在节点出错时，Swarm 现在可以尝试把容器重新调度到正常的节点上去。

• 和 Docker API 及整合支持的兼容性

Swarm 对 Docker API 完全支持，这意味着它能为使用不同 Docker 工具（如 Docker CLI，Compose，Trusted Registry，Hub 和 UCP）的用户提供无缝衔接的使用体验。

• Docker Swarm 为 Docker 化应用的核心功能（诸如多主机网络和存储卷管理）提供原生支持

开发的 Compose 文件能（通过 docker-compose up ）轻易地部署到测试服务器或 Swarm 集群上。Docker Swarm 还可以从 Docker Trusted Registry 或 Hub 里 pull 并 run 镜像。

• 集群模式，当修改了服务的配置后无需手动重启服务。并且只有集群中的manager才能管理集群中的一切（包括服务、容器都归它管，在一个woker节点上无法操作容器）

节点

swarm 集群由管理节点（manager）和工作节点（work node）构成。

• swarm mananger：负责整个集群的管理工作包括集群配置、服务管理等所有跟集群有关的工作。一个 Swarm 集群可以有多个管理节点，但只有一个管理节点可以成为 leader，leader 通过 raft 协议实现。

  为了利用swarm模式的容错功能，Docker建议根据组织的高可用性要求实现奇数个节点。当您拥有多个管理器时，您可以从管理器节点的故障中恢复而无需停机。

  • N个管理节点的集群容忍最多损失 (N-1)/2 个管理节点。
  • Docker建议一个集群最多7个管理器节点。

• work node：即图中的 available node，主要负责运行相应的服务来执行任务（task）。工作节点是任务执行节点，管理节点将服务 (service) 下发至工作节点执行。管理节点默认也作为工作节点。也可以通过配置让服务只运行在管理节点。

服务和任务

任务 （Task）是 Swarm 中的最小的调度单位，目前来说就是一个单一的容器。

服务 （Services） 是指一组任务的集合，服务定义了任务的属性。服务有两种模式：

• replicated services （复制服务）按照一定规则在各个工作节点上运行指定个数的任务。
• global services （全局服务）每个工作节点上运行一个此任务。

两种模式通过 docker service create 的 --mode 参数指定。下图展示了容器、任务、服务的关系。

路由网格

service 通过 ingress load balancing 来发布服务，且 swarm 集群中所有 node 都参与到 ingress 路由网格（ingress routing mesh） 中，访问任意一个 node+PublishedPort 即可访问到服务。

当访问任何节点上的端口8080时，Docker将请求路由到活动容器。在群节点本身，端口8080可能并不实际绑定，但路由网格知道如何路由流量，并防止任何端口冲突的发生。

路由网格在发布的端口上监听分配给节点的任何IP地址。对于外部可路由的IP地址，该端口可从主机外部获得。对于所有其他IP地址，只能从主机内部访问。

Swarm 集群的搭建

准备工作

• 二个或二个以上可以通过网络进行通信的Linux主机或虚拟机，并安装了Docker（加入开机自启），或者使用docker-machine 创建三台虚拟机。swarm 不需要单独安装，安装了 docker 就自带了该软件

• 已安装Docker Engine 1.12或更高版本

• 关闭所有主机上的防火墙或者开放以下端口：

  • TCP协议端口 2377 ：集群管理端口

  • TCP协议端口 7946 ：节点之间通讯端口（不开放则会负载均衡失效）

  • UDP协议端口 4789 ：overlay网络通讯端口

  • 防火墙相关命令：

    # 查看firewalld防火墙状态
    systemctl status firewalld
    
    # 查看所有打开的端口 
    firewall-cmd --zone=public --list-ports
    
    # 防火墙开放端口（更新firewalld防火墙规则后生效）
    firewall-cmd --zone=public --add-port=要开放的端口/tcp --permanent
    # 选项：
    –zone 				# 作用域
    –add-port=80/tcp 	# 添加端口，格式为：端口/通讯协议
    –permanent 			#永久生效，没有此参数重启后失效
    # 示例：
    firewall-cmd --zone=public --add-port=3306/tcp --permanent
    
    # firewalld防火墙关闭接口（更新firewalld防火墙规则后生效）
    firewall-cmd --zone=public --remove-port=要关闭的端口/tcp --permanent
    
    # 更新firewalld防火墙规则（并不中断用户连接，即不丢失状态信息）
    firewall-cmd --reload
    
    # 启动firewalld防火墙
    systemctl start firewalld
    # 关闭firewalld防火墙：
    systemctl stop firewalld
    # 开机禁用firewalld防火墙
    systemctl disable firewalld
    # 开机启用firewalld防火墙： 
    systemctl enable firewalld
    

• 分别修改机器的主机名，更改成 swarm01，swarm02 …

  hostnamectl set-hostname swarm01
  

  
  

创建docker swarm集群

1.master主机上初始化swarm。执行 docker swarm init 命令的节点自动成为管理节点。

docker swarm init

# 注：如果主机有多个网卡，拥有多个IP，必须使用 --advertise-addr 指定 IP。
# 示例：
docker swarm init --advertise-addr 192.168.99.100

# 执行命令后会给出加入这个swarm的命令
Swarm initialized: current node (4a8mo8cekpe0vpk0ze963avw9) is now a manager.

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

    docker swarm join --token SWMTKN-1-4lzr2216s61ecbyayyqynjwybmxy5y5th5ru8aal2a0d1t2vn3-ekdgf4swlz8fiq4nnzgnbhr5u 192.168.99.100:2377

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

2.在node主机上执行命令加入swarm

docker swarm join --token SWMTKN-1-4lzr2216s61ecbyayyqynjwybmxy5y5th5ru8aal2a0d1t2vn3-ekdgf4swlz8fiq4nnzgnbhr5u 192.168.99.100:2377

3.查看集群信息。集群的大部分命令需要在管理节点中才能运行

# 查看 swarm 集群状态
docker info
# 查看集群节点信息
docker node ls

Swarm 集群管理常用命令

docker swarm：管理集群

# 初始化一个swarm
docker swarm init [OPTIONS]
# 选项：
--advertise-addr string		# 发布的地址（格式：<ip|interface>[:port]）
--force-new-cluster			# 强制从当前状态创建一个新的集群（去除本地之外的所有管理器身份）
--cert-expiry duration		# 节点证书有效期(ns|us|ms|s|m|h)(默认为2160h0m0s)
--data-path-addr string     # 用于数据路径通信的地址或接口(格式: <ip|interface>)
--data-path-port uint32 	# 用于数据路径流量的端口号(1024 - 49151)。如果没有值，则默认端口号4789
--dispatcher-heartbeat duration		# 调度程序的心跳周期(ns|us|ms|s|m|h)(默认为5s)
--listen-addr node-addr		# 监听地址(格式: <ip|interface>[:port]) (默认 0.0.0.0:2377)

# 查看加入节点到集群的命令及令牌(token)
docker swarm join-token [OPTIONS] (worker|manager)
# 选项：
-q, --quiet    # 只显示令牌
	--rotate   # 使旧令牌无效并生成新令牌
# 查看加入工作节点到集群的命令及令牌
docker swarm join-token worker
# 查看加入管理节点到集群的命令及令牌
docker swarm join-token manager

# 将节点加入swarm集群，作为一个manager或worker
docker swarm join [OPTIONS] HOST:PORT
# 选项：
--advertise-addr string   # 发布的地址 (格式: <ip|interface>[:port])
--availability string     # 节点的可用性 ("active"|"pause"|"drain") (default "active")
--data-path-addr string   # 用于数据路径通信的地址或接口 (格式: <ip|interface>)
--listen-addr node-addr   # 监听地址 (格式: <ip|interface>[:port]) (default 0.0.0.0:2377)
--token string            # 进入的swarm集群的令牌     

# 主动退出集群，让节点处于down状态（在需要退出Swarm集群的节点主机上执行命令）
docker swarm leave [OPTIONS]
# 选项：
-f, --force		# 强制。Manager若要退出 Swarm 集群，需要加上强制选项
## 移除一个work-node节点主机的完整步骤：
# 1.在管理节点上操作，清空work-node节点的容器。id 可以使用命令 docker node ls 查看
docker node update --availability drain [id]
# 2.在work-node节点主机上操作，退出集群
docker swarm leave
# 3，在管理节点上操作，删除work-node节点
docker node rm [id]
# 若想解散整个集群，则需先移除所有work-node节点主机，然后所有管理节点也退出集群

# 更新 swarm 集群的配置
docker swarm update [OPTIONS]
# 选项：
--autolock							# 更改管理器自动锁定设置(true|false)
--cert-expiry duration         		# 节点证书有效期(ns|us|ms|s|m|h)(默认为2160h0m0s)
--dispatcher-heartbeat duration		# 调度程序心跳周期(ns|us|ms|s|m|h)(默认为5s)

docker node：管理swarm集群节点

# 查看集群中的节点
docker node ls
#选项：
-f, --filter filter   	# 根据所提供的条件过滤输出。(格式：key=value)
							# 目前支持的过滤器是：id, label, name, membership[=accepted|pending]
											   # , role[manager|worker]
-q, --quiet				# 只显示id

# 查看运行的一个或多个及节点任务数，默认当前节点
docker node ps [OPTIONS] [NODE...]
#选项：
-f, --filter filter   	# 根据所提供的条件过滤输出
-q, --quiet				# 只显示id

# 将worker角色升级为manager
docker node promote NODE [NODE...]
# 将manager角色降级为worker
docker node demote NODE [NODE...]

# 查看节点的详细信息，默认json格式
docker node inspect 主机名
# 查看节点信息平铺格式
docker node inspect --pretty 主机名

# 从swarm中删除一个节点
docker node rm 主机名
# 从swarm中强制删除一个节点
docker node rm -f 主机名

# 更新一个节点
docker node update [options] 主机名
# 选项
--label-add list		# 添加节点标签(key=value)
--label-rm list 		# 删除节点标签
--role string           # 更改节点角色 ("worker"|"manager")
--availability active/pause/drain	# 设置节点的状态
                # active  正常
                # pause   暂停。调度程序不向节点分配新任务，但是现有任务仍然保持运行
                # drain   排除自身work任务。调度程序不向节点分配新任务，且会关闭任何现有任务并在可用节点上安排它们

docker service：服务管理

# 列出服务列表
docker service ls

# 列出服务任务信息
docker service ps [OPTIONS] SERVICE [SERVICE...]
# 选项：
	--no-trunc			# 显示完整的信息
-f, --filter filter   	# 根据所提供的条件过滤输出。过滤只运行的任务信息："desired-state=running"
-q, --quiet				# 只显示任务id

# 查看服务内输出
docker service logs [OPTIONS] SERVICE|TASK
# 选项：
	--details        # 显示提供给日志的额外细节
-f, --follow         # 跟踪日志输出
	--since string   # 显示自时间戳 (2013-01-02T13:23:37Z) 或相对时间戳 (42m for 42 minutes) 以来的日志
-n, --tail string    # 从日志末尾显示的行数(默认为“all”)
-t, --timestamps     # 显示时间戳


# 更新服务的相关配置
docker service update [options] 服务名
# 选项
--args "指令"			# 容器加入指令
--image IMAGE		 # 更新服务容器镜像
--rollback				# 回滚服务容器版本
--network-add 网络名	  # 添加容器网络
--network-rm 网络名	  # 删除容器网络
--reserve-cpu int			# 更新分配的cpu
--reserve-memory bytes		# 更新分配的内存(示例：512m)
--publish-add 暴露端口:容器端口		# 映射容器端口到主机
--publish-rm 暴露端口:容器端口		# 移除暴露端口
--endpoint-mode dnsrr		 # 修改负载均衡模式为dnsrr
--force						 # 强制重启服务
--config-rm 配置文件名称		 # 删除配置文件
--constraint-add list		 # 新增一个容忍 
--constraint-rm list		 # 移除一个容忍 
--placement-pref-add pref	 # 新增一个偏好 
--placement-pref-rm pref	 # 移除一个偏好
--config-add 配置文件名，target=/../容器内配置文件名		# 添加新的配置文件到容器内


# 查看服务详细信息，默认json格式
docker service inspect [OPTIONS] 服务名 [SERVICE...]
# 查看服务信息平铺形式
docker service inspect --pretty 服务名

# 删除服务
docker service rm [OPTIONS] 服务名 [SERVICE...]

# 缩容扩容服务容器副本数量
docker service scale 服务名=副本数 [SERVICE=REPLICAS...]

# 创建一个服务。一般搭建好 Swarm 集群后，使用 docker stack 部署应用，此处仅作了解
docker service create [OPTIONS] IMAGE [COMMAND] [ARG...]
# 选项：
--name string			# 指定容器名称
--replicas int			# 指定副本数
--network 网络名		  # 添加网络组
--mode string			# 服务模式（复制或全局）(replicated | global)
--reserve-cpu int		# 预留的cpu
--reserve-memory bytes	# 预留的内存(512m)
--limit-cpu	int			# 限制CPU
--limit-memory bytes	# 限制内存(512m)
-l,	--label list			# 服务的标签(key=value)
--container-label list		# 容器标签(key=value)
-p, --publish 暴露端口:容器端口	  # 映射容器端口到主机
-e,	--env MYVAR=myvalue			# 配置环境变量
-w,	--workdir string			# 指定工作目录(示例：/tmp)
-restart-condition string		# 满足条件时重新启动（no | always | on-failure | unless-stopped）
--restart-delay duration		# 重新启动尝试之间的延迟 (ns/us/ms/s/m/h)
--restart-max-attempts int		# 放弃前的最大重启次数
--restart-window duration			# 用于评估重启策略的窗口 (ns/us/ms/s/m/h)
--stop-grace-period duration		# 强制杀死容器前的等待时间 (ns/us/ms/s/m/h)
--update-delay duration				# 更新之间的延迟（ns/us/ms/s/m/h）（默认 0s）
--update-failure-action	string		# 更新失败的操作（"pause"停止|"continue"继续）（默认pause）
--update-max-failure-ratio float	# 更新期间容忍的失败率
--update-monitor duration			# 每次任务更新后监控失败的持续时间（ns/us/ms/s/m/h）（默认 0s）
--update-parallelism int			# 同时更新的最大任务数(0表示一次更新全部任务)(默认为1)  
--endpoint-mode string				# 负载均衡模式(vip or dnsrr) (默认 "vip")
--rollback-monitor 20s		  	    # 每次容器与容器之间的回滚时间间隔
--rollback-max-failure-ratio .数值	# 回滚故障率如果小于百分比允许运行（“.2”为%20）
--mount type=volume,src=volume名称,dst=容器目录	 # 创建volume类型数据卷
--mount type=bind,src=宿主目录,dst=容器目录			# 创建bind读写目录挂载
--mount type=bind,src=宿主目录,dst=容器目录,readonly	 # 创建bind只读目录挂载
--config source=docker配置文件,target=配置文件路径		# 创建docker配置文件到容器本地目录

docker config：管理配置文件

# 查看已创建配置文件
docker config ls [OPTIONS]
# 选项：
-f, --filter filter   	# 根据所提供的条件过滤输出
-q, --quiet				# 只显示id

# 查看配置详细信息
docker config inspect 配置文件名

# 删除配置
docker config rm CONFIG [CONFIG...]

# 创建配置文件
docker config create 配置文件名 本地配置文件
# 示例：新建配置文件并添加新配置文件到服务
# 1.创建配置文件
docker config create nginx2_config nginx2.conf 
# 2.删除旧配置文件
docker service update --config-rm ce_nginx_config 服务名
# 3.添加新配置文件到服务
ocker service update --config-add src=nginx2_config,target=/etc/nginx/nginx.conf ce_nginx

docker network：管理网络

# 查看集群网络列表
docker network ls

# 将容器连接到集群网络中
$ docker network connect [OPTIONS] NETWORK CONTAINER
# 选项
    --alias strings				# 为容器添加网络范围的别名
    --driver-opt string		·	# 指定网络驱动程序
    --ip string					# 指定IPv4地址(如172.30.100.104)
    --ip6 string				# 指定IPv6地址(例如，2001:db8::33)
    --link list					# 添加到另一个容器的链接
    --link-local-ip string		# 为容器添加一个链接本地地址
# 示例
docker network connect mynet nginx

# 断开一个容器与集群网络的连接
$ docker network disconnect [OPTIONS] NETWORK CONTAINER
# 选项
	-f, --force		# 强制容器从网络断开连接  

# 显示一个或多个集群网络的详细信息
$ docker network inspect [OPTIONS] NETWORK [NETWORK...]
# 选项
  -f, --format string   # 使用给定的Go模板格式化输出
  -v, --verbose         # 输出详细的诊断信息

# 创建一个集群网络
$ docker network create [OPTIONS] NETWORK
# 选项
      --attachable           # 准许手动容器连接
      --aux-address map      # 网络驱动使用的辅助IPv4或IPv6地址(默认映射[])
      --config-from string   # 要从其中复制配置的网络
      --config-only          # 创建仅配置网络
  -d, --driver string        # 管理网络的驱动程序(默认为“"bridge”)。选项：bridge、overlay、macvlan
      --gateway strings      # 指定IPv4或IPv6主子网网关。示例：172.20.0.1
      --ingress              # 创建群路由-网格网络
      --internal             # 限制外部访问网络
      --ip-range strings     # 从子范围分配容器ip
      --ipam-driver string   # IP管理驱动(默认为“default”)
      --ipam-opt map         # 设置IPAM驱动程序的特定选项(默认map[])
      --ipv6                 # 启用IPv6网络
      --label list           # 在网络中设置元数据
  -o, --opt map              # 设置驱动程序特定选项(默认map[])
      --scope string         # 控制网络的范围
      --subnet strings       # 指定一个CIDR格式的网段。示例：172.20.0.0/24
# 示例：
docker network create -d overlay --attachable apps_net

# 移除所有未使用的集群网络
$ docker network prune [OPTIONS]
# 选项
      --filter filter   # 提供过滤值(e.g. 'until=<timestamp>') 
  -f, --force           # 强制，没有提示确认

# 删除一个或多个集群网络
$ docker network rm NETWORK [NETWORK...]
# 别名：rm, remove

docker secret：管理敏感数据存储

# 查看敏感数据卷列表
$ docker secret ls

# 显示一个或多个敏感数据卷的详细信息
$ docker secret inspect [OPTIONS] SECRET [SECRET...]
# 选项
	--pretty		# 易读的格式打印信息

# 从文件或标准输入创建一个敏感数据卷作为内容
$ docker secret create [OPTIONS] SECRET [file|-]
# 选项
  -d, --driver string            # 指定驱动
  -l, --label list               # 指定标签
      --template-driver string   # 指定模板驱动程序

# 移除一个或多个敏感数据卷
$ docker secret rm SECRET [SECRET...]
# 别名：rm, remove

docker网络管理

参考：https://blog.csdn.net/yrx420909/article/details/105417170

参考：https://www.jianshu.com/p/60bccbdb6af9

参考：http://blog.cxiangnet.cn/2018/10/22/docker%E7%9A%84%E7%BD%91%E7%BB%9C%E6%A8%A1%E5%BC%8Fbridge%E3%80%81host%E3%80%81container-%E3%80%81overlay/

概述

Docker 提供三种 user-defined 网络驱动：bridge，overlay 和 macvlan

overlay 和 macvlan 用于创建跨主机的网络

Swarm 集群产生两种不同类型的流量：

• 控制和管理层面：包括 Swarm 消息管理等，例如请求加入或离开Swarm，这种类型的流量总是被加密的。(涉及到集群内部的hostname、ip-address、subnet、gateway等)
• 应用数据层面：包括容器与客户端的通信等。（涉及到防火墙、端口映射、网口映射、VIP等）

在 Swarm Service 中有三个重要的网络概念：

• Overlay networks ：管理 Swarm 中 Docker 守护进程间的通信。可以将服务附加到一个或多个已存在的 overlay 网络上，使得服务与服务之间能够通信。
• ingress network ：是一个特殊的 overlay 网络，用于服务节点间的负载均衡，处理与群集服务相关的控制和数据流量。当任何 Swarm 节点在发布的端口上接收到请求时，它将该请求交给一个名为 IPVS 的模块。IPVS 跟踪参与该服务的所有IP地址，选择其中的一个，并通过 ingress 网络将请求路由到它。
  初始化或加入 Swarm 集群时会自动创建 ingress 网络，大多数情况下，用户不需要自定义配置，但是 docker 17.05 和更高版本允许你自定义。
• docker_gwbridge ：是一种桥接网络，将 overlay 网络（包括 ingress 网络）连接到一个单独的 Docker 守护进程的物理网络。默认情况下，服务正在运行的每个容器都连接到本地 Docker 守护进程主机的 docker_gwbridge 网络。
  docker_gwbridge 网络在初始化或加入 Swarm 时自动创建。大多数情况下，用户不需要自定义配置，但是 Docker 允许自定义。

在管理节点上查看网络

$ docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
cb0ccb89a988        bridge              bridge              local
0174fb113496        docker_gwbridge     bridge              local
541b62778c0e        host                host                local
8n7xppn5z4j2        ingress             overlay             swarm
369d459f340d        none                null                local

overlay网络驱动程序会创建多个Docker守护主机之间的分布式网络。该网络位于（覆盖）特定于主机的网络之上，允许连接到它的容器（包括群集服务容器）安全地进行通信。Docker透明地处理每个数据包与正确的Docker守护程序主机和正确的目标容器的路由。

自定义overlay 网络

创建用于swarm服务的自定义的overlay网络 命令：

docker network create -d overlay --attachable my-overlay

# 注：overlay 网络创建可以在 Swarm 集群下的任意节点执行，并同步更新到所有节点。

集群中部署了两个服务 nginx、alpine，现在我们进入alpine，去访问nginx。

$ docker exec -it test1.1.oonwl8c5g4u3p17x8anifeubi bash
$ ping nginx
ping: bad address 'nginx'

$ wget 192.168.99.100:8080
Connecting to 192.168.99.100:8080 (192.168.99.100:8080)
index.html           100% |**********************************************************************************************************|   612   0:00:00 ETA

发现集群中的各个服务不能用名称访问的，只能用集群服务发现的路由网络访问，若需要集群中的服务能通过名称进行访问，这就需要用到上面自定义的 overlay 网络。

删除启动的服务，重新创建指定使用自定义网络的服务。

docker service rm nginx alpine
docker service create --name nginx -p 8080:80 --network my-overlay --replicas 3 nginx
docker service create --name alpine --network my-overlay alpine ping www.baidu.com

进入alpine容器中，重新测试下：

$ ping nginx
PING nginx (10.0.0.2): 56 data bytes
64 bytes from 10.0.0.2: seq=0 ttl=64 time=0.120 ms
64 bytes from 10.0.0.2: seq=1 ttl=64 time=0.094 ms
64 bytes from 10.0.0.2: seq=2 ttl=64 time=0.108 ms
$ wget nginx
Connecting to nginx (10.0.0.2:80)
index.html           100% |**********************************************************************************************************|   612   0:00:00 ETA

发现可以通过名称进行集群中的容器间的访问了。

Docker Stack 部署应用

概述

单机模式下，可以使用 Docker Compose 来编排多个服务。Docker Swarm 只能实现对单个服务的简单部署。而Docker Stack 只需对已有的 docker-compose.yml 配置文件稍加改造就可以完成 Docker 集群环境下的多服务编排。

stack是一组共享依赖，可以被编排并具备扩展能力的关联service。

Docker Stack和Docker Compose区别

• Docker stack会忽略了“构建”指令，无法使用stack命令构建新镜像，它是需要镜像是预先已经构建好的。 所以docker-compose更适合于开发场景；
• Docker Compose是一个Python项目，在内部，它使用Docker API规范来操作容器。所以需要安装Docker -compose，以便与Docker一起在您的计算机上使用；Docker Stack功能包含在Docker引擎中。你不需要安装额外的包来使用它，docker stacks 只是swarm mode的一部分。
• Docker stack不支持基于第2版写的docker-compose.yml ，也就是version版本至少为3。然而Docker Compose对版本为2和3的 文件仍然可以处理；
• docker stack把docker compose的所有工作都做完了，因此docker stack将占主导地位。同时，对于大多数用户来说，切换到使用
• 单机模式（Docker Compose）是一台主机上运行多个容器，每个容器单独提供服务；集群模式（swarm + stack）是多台机器组成一个集群，多个容器一起提供同一个服务；

compose.yml deploy 配置说明

docker-compose.yaml文件中deplo参数下的各种配置主要对应了swarm中的运维需求。

docker stack deploy不支持的参数：

（这些参数，就算yaml中包含，在stack的时候也会被忽略，当然也可以为了docker-compose up留着这些配置）

build
cgroup_parent
container_name
devices
tmpfs
external_links
links
network_mode
restart
security_opt
userns_mode

deploy：指定与服务的部署和运行有关的配置。注：只在 swarm 模式和 stack 部署下才会有用。且仅支持 V3.4 及更高版本。

可以选参数：

• endpoint_mode：访问集群服务的方式。3.2版本开始引入的配置。用于指定服务发现，以方便外部的客户端连接到swarm

  • vip：默认的方案。即通过 Docker 集群服务一个对外的虚拟 ip对外暴露服务，所有的请求都会通过这个虚拟 ip 到达集群服务内部的机器，客户端无法察觉有多少个节点提供服务，也不知道实际提供服务的IP和端口。
  • dnsrr：DNS的轮询调度。所有的请求会自动轮询获取到集群 ip 列表中的一个 ip 地址。客户端访问的时候，Docker集群会通过DNS列表返回对应的服务一系列IP地址，客户连接其中的一个。这种方式通常用于使用自己的负载均衡器，或者window和linux的混合应用。

• labels：在服务上设置标签，并非附加在service中的容器上。如果在容器上设置标签，则在deploy之外定义labels。可以用容器上的 labels（跟 deploy 同级的配置） 覆盖 deploy 下的 labels。

• mode：用于指定是以副本模式（默认）启动还是全局模式

  • replicated：副本模式，复制指定服务到集群的机器上。默认。
  • global：全局模式，服务将部署至集群的每个节点。类似于k8s中的DaemonSet，会在每个节点上启动且只启动一个服务。

• replicas：用于指定副本数，只有mode为副本模式的时候生效。

• placement：主要用于指定容忍和偏好。这个参数在运维的时候尤为关键

  • constraints(容忍)：表示服务可以部署在符合容忍限定的节点上，包含了：

    node attribute	matches	example
    node.id	节点id	node.id == 2ivku8v2gvtg4
    node.hostname	节点主机名	node.hostname != node-2
    node.role	节点角色 (manager/worker)	node.role == manager
    node.platform.os	节点操作系统	node.platform.os == windows
    node.platform.arch	节点架构	node.platform.arch == x86_64
    node.labels	用户定义的labels	node.labels.security == high
    engine.labels	Docker 引擎的 labels	engine.labels.operatingsystem == ubuntu-14.04

  • preferences(偏好)：表示服务可以均匀分布在指定的标签下。

  • preferences 只有一个参数，就是spread，其参数值为节点的属性，即容忍表中的内容

    例如：node.labels.zone这个标签在集群中有三个值，分别为west、east、north，那么服务中的副本将会等分为三份，分布到带有三个标签的节点上。

  • max_replicas_per_node：3.8版本中开始引入的配置。控制每个节点上最多的副本数。

    注意：当 最大副本数*集群中可部署服务的节点数<副本数，会报错

• resources：用于限制服务的资源，这个参数在运维的时候尤为关键。

  示例：配置 redis 集群运行需要的 cpu 的百分比 和 内存的占用。避免占用资源过高出现异常。

  • limit：用于限制最大的资源使用数量
    • cpus：cpu占比，值的格式为百分比的小数格式
    • memory：内存的大小。示例：512M
  • reservation：为最低的资源占用量。
    • cpus
    • memory

• restart_policy：容器的重启策略

  • condition：重启的条件。可选 none，on-failure 或者 any（默认值：any）。
  • delay：尝试重启的时间间隔（默认值：5s）。
  • max_attempts：最大尝试重启容器的次数，超出次数，则不再尝试（默认值：一直重试）。
  • window：判断重启是否成功之前的等待时间（一个总的时间，如果超过这个时间还没有成功，则不再重启）。

• rollback_config：更新失败时的回滚服务的策略。3.7版本加入。和升级策略相关参数基本一致。

• update_config：配置应如何更新服务，对于配置滚动更新很有用。

  • parallelism：同时升级[回滚]的容器数
  • delay：升级[回滚]一组容器的时间间隔
  • failure_action：若更新[回滚]失败之后的策略：continue、 pause、rollback(仅在update_config中有) 。默认 pause
  • monitor：容器升级[回滚]之后，检测失败的时间检测 (支持的单位：ns|us|ms|s|m|h)。默认为 5s
  • max_failure_ratio：最大失败率
  • order：升级[回滚]期间的操作顺序。可选：stop-first（串行回滚，先停止旧的）、start-first（并行回滚，先启动新的）。默认 stop-first 。注意：只支持v3.4及更高版本

compose.yml 文件示例

version: "3"		# 版本号，deploy功能是3版本及以上才有的
services:			# 服务，每个服务对应配置相同的一个或者多个docker容器
  redis:			# 服务名，自取
    image: redis:alpine		# 创建该服务所基于的镜像。使用stack部署，只能基于镜像
    ports: 			# 容器内外的端口映射情况
      - "1883:1883"
      - "9001:9001"
    networks:		# 替代了命令行模式的--link选项
      - fiware
    volumes: 		# 容器内外数据传输的对应地址
      - "/srv/mqtt/config:/mqtt/config:ro"
      - "/srv/mqtt/log:/mqtt/log"
      - "/srv/mqtt/data/:/mqtt/data/"
    command: -dbhost stack_mongo # 命令行模式中跟在最后的参数，此条没有固定的格式，建议参照所部署的docker镜像的说明文档来确定是否需要该项、需要写什么
    deploy:
      mode: replicated
      replicas: 6			# replicas模式， 副本数目为1
      endpoint_mode: vip
      labels: 
        description: "This redis service label"
      resources:
        limits:
          cpus: '0.50'
          memory: 50M
        reservations:
          cpus: '0.25'
          memory: 20M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
        window: 120s
      placement:
        constraints:
          - "node.role==worker"		# 部署位置，只在工作节点部署
          - "engine.labels.operatingsystem==ubuntu 18.04"
        preferences:
          - spread: node.labels.zone
      update_config:
        parallelism: 2
        delay: 10s
        order: stop-first

networks:		 # 定义部署该项目所需要的网络
  fiware:

stack 常用命令

docker stack：编排部署应用

# 部署一个新的stack(堆栈)或更新现有的stack。别名：deploy, up
docker stack deploy [OPTIONS] 自定义STACK名称
# 选项：
-c, --compose-file strings		# Compose文件的路径，或从标准输入中读取的“-”
--prune						# 表示削减不再引用的服务。可以把一些down掉的service进行自动清理。
--orchestrator string		# 指定编排模式 (swarm|kubernetes|all)
--resolve-image	string		# 请求仓库来重新解析镜像的摘要和支持的平台。("always"|"changed"|"never") (默认 "always")
--with-registry-auth		# 发送仓库的授权详情到Swarm代理
--orchestrator				# 使用的容器编排服务

# 通过compose.yml文件指令部署
docker stack deploy -c 文件名.yml 自定义STACK名称

# 列出现有堆栈。别名：ls, list
docker stack ls [OPTIONS]

# 列出堆栈中的任务
docker stack ps [OPTIONS] STACK
# 选项：
--no-trunc		# 输出完整信息

# 删除一个或多个堆栈。别名：rm, remove, down
docker stack rm [OPTIONS] STACK [STACK...]
# 选项
	--orchestrator string   # 指定适配器 (swarm|kubernetes|all)

# 列出堆栈中的服务
docker stack services [OPTIONS] STACK

搭建Docker私有仓库–自签名方式

参考：https://developer.aliyun.com/article/303216#slide-3

为了能集中管理创建好的镜像，方便部署服务，可以部署私有的Docker仓库。Docker为了确保安全使用TLS，需要CA认证，可以使用自签名方式。

准备环境

环境：两台Centos 7 虚拟机

• 服务器IP：10.57.220.244 ，作为Docker仓库使用
• 客户端IP：10.57.220.220 ，作为客户端来上传或拉取镜像
• 域名：harbor.paic.com.cn（修改所有主机的 /etc/hosts 文件，添加域名和ip的对应， 格式：ip 域名）

两台机器上均已安装好Docker 版本为 17.03.0-ce

生成自签名证书

在服务器主机上生成自签名证书，创建一个文件夹用于存放证书

mkdir -p certs

# 生成自签名证书
openssl req -newkey rsa:4096 -nodes -sha256 -x509 -days 1825 -keyout `pwd`/certs/harbor.key -out `pwd`/certs/harbor.crt -config openssl_req.cnf

openssl_req.cnf

# 定义输入用户信息选项的"特征名称"字段名，该扩展字段定义了多项用户信息。
distinguished_name = req_distinguished_name

# 如果设为no，那么 req 指令将直接从配置文件中读取证书字段的信息，而不提示用户输入。
prompt = no

[req_distinguished_name]
#国家代码，一般都是CN(大写)
C = CN
#省份
ST = []
#城市
L = City
#企业/单位名称
O = YZT
#企业部门
OU = []
#证书的主域名。注意要和仓库的域名一致
CN = harbor.paic.com.cn

分发自签名证书、指定私有仓库位置

把生成的的 harbor.crt 复制到服务器端和客户端上的 /etc/pki/ca-trust/source/anchors 目录下

\cp ./certs/harbor.crt /etc/pki/ca-trust/source/anchors

指定私有仓库地址。

vi /etc/docker/daemon.json
------------------------------------------------------------------------
{
    "insecure-registries": ["harbor.paic.com.cn"]
}

------------------------------------------------------------------------
# 注意：若仓库的容器的5000端口不是绑定到宿主机的443端口上，则需要指定绑定的宿主机端口
{
    "insecure-registries": ["harbor.paic.com.cn:5000"]
}

更新证书，然后重新启动docker

update-ca-trust;systemctl restart docker

启动容器

运行仓库镜像，如果本地没有相应的镜像会从Docker服务器上下载，然后才启动，可以用docker ps命令查看是否已经有窗口在运行。

docker run -d -p 443:5000 \
--restart=always \
--name registry_https \
-v `pwd`/dockerregister:/var/lib/registry \
-v `pwd`/certs:/home/certs \
-e REGISTRY_HTTP_TLS_CERTIFICATE=/home/certs/harbor.crt \
-e REGISTRY_HTTP_TLS_KEY=/home/certs/harbor.key \
registry

# 说明：
	# -p 443:5000 ：将仓库的容器的5000端口绑定到宿主机443端口上。
		# 因docker访问镜像仓库地址的默认端口号为443，
		# 若仓库的容器的5000端口不绑定到宿主机的443端口上，则push/pull时需指定绑定的宿主机端口
		# 若仓库的容器的5000端口不绑定到宿主机的443端口上，又不想push/pull时指定绑定的宿主机端口，可以使用ngnix进行端口映射
	# -v `pwd`/dockerregister:/var/lib/registry ：指定宿主机的目录保存上传好的docker镜像
	# -v `pwd`/certs:/home/certs ：挂载自签名证书目录

查看容器是否启动成功

# docker ps | grep 容器名
docker ps | grep registry_https

验证：

# 使用curl查看一下仓库的镜像列表。
curl -XGET https://harbor.paic.com.cn:443/v2/_catalog
  # {"repositories":[]}
  
# 使用curl查看一下仓库中某镜像的版本。
curl https://harbor.paic.com.cn:443/v2/redis/tags/list

push/pull 镜像

注意：若仓库的容器的5000端口不是绑定到宿主机的443端口上，则需要指定绑定的宿主机端口

# 打tag
docker tag redis harbor.paic.com.cn/redis
  # 指定端口号 示例：
  # docker tag redis harbor.paic.com.cn:5000/redis

# push镜像
docker push harbor.paic.com.cn/redis
	
# pull镜像
docker pull harbor.paic.com.cn/redis