月份：2016年12月

管理swarm(1) – swarm模式概述

要Docker Engine在swarm模式下使用，需要从https://github.com/docker/docker/releases安装Docker Engine v1.12.0或更高的版本。或者安装最新版本的Docker for Mac或Docker for Windows Beta。
Docker Engine 1.12引入了本地管理Docker Engines集群的swarm模式，称为swarm。使用Docker CLI创建一个swarm，部署应用服务到swarm和管理swarm行为。

主要功能

  • 集群管理与Docker Engine集成:使用Docker Engine CLI来创建一个你能部署应用服务到Docker Engine的swarm。你不需要其他编排软件来创建或管理swarm。
  • 分散式设计：Docker Engine不是在部署时处理节点角色之间的差异，而是在运行时扮演自己角色。你可以使用Docker Engine部署两种类型的节点，管理器和worker。这意味着你可以从单个磁盘映像构建整个swarm。
  • 声明性服务模型： Docker Engine使用声明性方法来定义应用程序堆栈中各种服务的所需状态。例如，你可以描述由消息队列服务和数据库后端的Web前端服务组成的应用程序。
  • 伸缩性：对于每个服务，你可以声明要运行的任务数。当你向上或向下缩放时，swarm管理器通过添加或删除任务来自动适应，以保持所需状态。
  • 期望的状态协调：swarm管理器节点持续监控群集状态，并调整你描述的期望状态与实际状态之间的任何差异。 例如，如果设置运行一个10个副本容器的服务，这时worker机器托管其中的两个副本崩溃，管理器则将创建两个新副本以替换已崩溃的副本。 swarm管理器将新副本分配给正在运行和可用的worker。
  • 多主机网络：你可以为服务指定覆盖网络(overlay network)。 当swarm管理器初始化或更新应用程序时，它会自动为容器在覆盖网络(overlay network)上分配地址。
  • 服务发现：Swarm管理器节点为swarm中的每个服务分配唯一的DNS名称，并负载平衡运行中的容器。 你可以通过嵌入在swarm中的DNS服务器查询在swarm中运行中的每个容器。
  • 负载平衡：你可以将服务的端口暴露给外部的负载均衡器。 在内部，swarm允许你指定如何在节点之间分发服务容器。
  • 安全通信：swarm中的每个节点强制执行TLS相互验证和加密，以保护其自身与所有其他节点之间的通信。 你可以选择使用自签名根证书或来自自定义根CA的证书。
  • 滚动更新：在上线新功能期间，你可以增量地应用服务更新到节点。 swarm管理器允许你控制将服务部署到不同节点集之间的延迟。 如果出现任何问题，你可以将任务回滚到服务的先前版本。

    • SaltStack事件驱动(4) – event reactor

    salt的reactor系统让你能够对任何事件作出响应。你不只能够在作业和任务完成时作出响应，也能够在服务下线，用户登录，文件被更改和在任何地方发送的自定义事件作出反应。

    reactor配置

    在/etc/salt/master或/etc/salt/master.d/reactor.conf中添加reactor区块来配置reactor(只允许添加一个reactor区块)。
    下面的示例是配置一个匹配minion启动，云资源回收和自定义事件的reactor：

    1. reactor:                            # Salt master配置区块"reactor"
    2.  
    3.   – ‘salt/minion/*/start’:          # 匹配tag "salt/minion/*/start"
    4.     – /srv/reactor/start.sls        # minion启动时应用的一个state文件
    5.     – /srv/reactor/monitor.sls      # 另一个state文件
    6.  
    7.   – ‘salt/cloud/*/destroyed’:       # 可以使用通配符匹配tags
    8.     – /srv/reactor/destroy/*.sls    # 可以使用通配符匹配文件名
    9.  
    10.   – ‘myco/custom/event/tag’:         
    11.     – salt://reactor/mycustom.sls

    reactor的配置非常简单;reactor区块唯一的作用是关联事件tag与要运行reactor SLS文件。reactor是一个独立的线程，所以可以在SLS文件里执行繁重的任务。
    reactor SLS文件具体YAML和Jinja全部的功能，所以你可以使用事件标记和数据执行过滤和测试。
    我们来尝试在demo环境中添加一个reactor来测试这个系统。打开salt-vagrant-demo/saltstack/etc/master文件，添加一个reactor区块：

    1. reactor:
    2.     – ‘my/custom/event/tag’:
    3.     – salt://reactor/customevent.sls

    这个告诉salt master在任何时候一旦发现一个事件包含my/custom/event/tag，则马上调用customevent.sls文件。
    我们学习reactor SLS文件后再创建customevent.sls文件。
    现在先重启salt-master服务(service salt-master restart)使reactor生效。

    reactor SLS文件

    你已经对salt state SLS文件有所了解了，与salt reactor SLS有所以类似的地方。salt state和salt reator SLS文件都是使用YAML和Jinja写的，不过因为它们语法有些不同，且用作不同的目的，它们应该放在不同的目录中(如reactor是在/srv/salt/reactors目录)。

    reactor的类型

    salt reactor有如下几种类型：

  • 远程执行: 在目标minions运行一个执行模块。这个可以通过调用salt命令来完成(包括应用state或highstate)
  • Salt Runners: 通过使用salt-run调用的任务。如HTTP runnner可以触发webhook。
  • Wheel： Wheel命令管理你的salt环境，完成如接收密钥和更新配置设置的任务。

    • 远程执行

    这种类型的reactor是直接与salt执行模块连接。如果你考虑使用salt命令来运行一个远程执行模块，你应该知道salt命令必须包含三个信息：

  • 目标
  • 函数
  • 参数

    • salt reactor中的远程执行也同样需要这三个信息：

    1. <section id>:
    2.   local.<function>:
    3.     – tgt: <target>
    4.     – arg:
    5.         <arguments>

    注意执行模块必须以local为前缀。我们来看在命令行安装一个包是怎样的：

    1. salt ‘myminion’ pkg.install cowsay

    在reactor SLS文件中，应该是按如下配置：

    1. install cowsay on myminion:
    2.   local.pkg.install:
    3.     – tgt: ‘myminion’
    4.     – arg:
    5.       – cowsay

    RUNNER和WHEEL模块

    在reactor中调用Runner模块和Wheel模块语法很简单，因为是在本地执行的函数，不是发送一个命令到远程系统。调用两个模块不需要arg或kwarg参数（除非Runner函数或Wheel函数接收参数）。

    1. clear_the_grains_cache_for_all_minions:
    2.   runner.cache.clear_grains
    1. spin_up_more_web_machines:
    2. runner.cloud.profile:
    3. – prof: centos_6
    4. – instances:
    5.   – web11       
    6.   – web12

    下面是一个wheel示例用来自动接受minion的密钥(在生产环境中你应该增加额外的检查来避免接受恶意minions)。

    1. accept_new_minion:
    2.   wheel.key.accept:
    3.     – match: {{ data[‘id’] }}

    更多的示例

    下面的reactor SLS用来对salt/cloud/*/created事件反应：

    1. new vm alert:
    2.   local.pagerduty.create_event:
    3.     – tgt: minion
    4.     – kwarg:
    5.         description: "New VM {{ data[‘name’] }}"
    6.         details: "New VM on {{ data[‘provider’] }}: {{ data[‘name’] }}"
    7.         service_key: 1162ee51ed6e46239265c969729c48eb
    8.         profile: my-pagerduty-account

    如果你配置了当构建系统完成后触发一个自定义事件，那么你可以使用slack来通知你：

    1. spam slack:
    2.   local.slack_notify.post_message
    3.     – tgt: buildserver
    4.     – kwarg:
    5.         channel: "Development"
    6.         api_key: peWcBiMOS9HrZG15peWcBiMOS9HrZG15"
    7.         message: "Build {{ data[‘build_id’] }} finished with status: {{ data[‘status’] }}"

    salt state

    state执行模块可以用在reactor SLS文件来应用一个salt state，或者触发一个highstate。

    1. {% if data[‘id’] == ‘mysql1’ %}
    2. highstate_run:
    3.   local.state.highstate:
    4.     – tgt: mysql1
    5. {% endif %}

    SaltStack事件驱动(3) – BEACONS

    到目前为止我们已经学习如何通过事件总线监控与salt相关的事件，以及激活一些其它的事件。这时候你可能会想“既然我已经设置了一个能监控和实时反馈事件的动态通信设施，那么我肯定可以利用它来监听其它事情，如系统登录，硬盘使用和数据库服务”。而beacons就是用来做这样的事情的。
    beacons让你能够监控与salt无关的事情以及触发事件。beacon系统允许minion与各种系统进程挂钩并持续监控进程。当监控的系统进程活动发生时，minion就发送一个事件到salt事件总线。
    salt beacons目前能对许多系统活动进行监控和发送事件，包括：

  • 文件系统变动
  • 系统负载
  • 服务状态
  • shell活动，如用户登录
  • 网络和硬盘使用情况

    • 激活一个beacon

    salt beacons的激活不需要对监控的系统进程进行任何更改，一切配置都可以使用salt来做。
    在minion的配置文件中增加如下配置：

    1. beacons:
    2.   inotify:
    3.     home/user/importantfile:
    4.       mask:
    5.         – modify

    beacon监控间隔

    beacons默认以1秒的间隔监控。可以增加一个interval参数来设置一个不同的间隔。如下是设置了5和10秒的间隔：

    1. beacons:
    2.   inotify:
    3.     /etc/httpd/conf.d: {}
    4.     /opt: {}
    5.     interval: 5
    6.   load:
    7.     – 1m:
    8.       – 0.0
    9.       – 2.0
    10.     – 5m:
    11.       – 0.0
    12.       – 1.5
    13.     – 15m:
    14.       – 0.1
    15.       – 1.0
    16.     – interval: 10

    如果一个beacon的更改可能引起重新触发这个beacon的话，设置disable_during_state_run为True以避免循环事件发生。

    增加beacon

    我们准备增加一个beacon来监控一个文件的更改。要配置这个，需要使用inotify beacon和安装python-pyinotify包。因为salt minions没有这个包，首先我们使用salt来安装它。

    安装pyinotify和启动event runner

    增加命令行终端进入salt-vagrant-demo目录，ssh到master:

    1. vagrant ssh master

    在minion1安装python-pyinotify:

    1. sudo salt ‘minion1’ pkg.install python-pyinotify

    输出类似如下：

    1. vagrant@saltmaster:~$ sudo salt ‘minion1’ pkg.install python-pyinotify
    2. minion1:
    3.     ———-
    4.     python-pyinotify:
    5.         ———-
    6.         new:
    7.             0.9.4-1build1
    8.         old:
    9.     python2.7-pyinotify:
    10.         ———-
    11.         new:
    12.             1
    13.         old:

    我们很快就会生成一个事件，在master启动一个event runner并保持登录：

    1. salt-run state.event pretty=True

    让它在终端中运行并继续。

    设置一个beacon

    打开另一个终端进入salt-vagrant-demo目录，ssh进minion1:

    1. vagrant ssh minion1

    编辑minion1的/etc/salt/minion文件，在底部添加如下内容：

    1. beacons:
    2.   inotify:
    3.     /home/vagrant/importantfile:
    4.       mask:
    5.         – modify

    保存文件重启salt minion服务：

    1. sudo service salt-minion restart

    现在beacon已经激活。下面我们创建将要监控的文件。在/home/vagrant/目录创建importantfile:

    1. touch importantfile
    2. echo "some content" > importantfile

    回到salt master刚才运行event runnner的终端，你应该会看到如下输出：

    1. salt/beacon/minion1/inotify//home/vagrant/importantfile {
    2.     "_stamp": "2016-02-03T22:32:09.592113",
    3.     "data": {
    4.         "change": "IN_MODIFY",
    5.         "id": "minion1",
    6.         "path": "/home/vagrant/importantfile"
    7.     },
    8.     "tag": "salt/beacon/minion1/inotify//home/vagrant/importantfile"
    9. }

    记得event runner必须在文件被更改前启动，否则你不会看到事件。

    SaltStack事件驱动(2) – 自定义事件

    除了内置事件，你可以在Salt系统中启用一些其他事件，以及生成你自己的事件。

    presence事件

    激活presence事件会使master定期地查找主动连接的minions。presence事件以一定的间隔在事件总线上触发，事件包含已连接minions列表，以及新连接或已断开的minions列表。
    在salt master配置文件中激活：

    1. presence_events: True

    salt state事件

    激活salt state事件会使在salt state完成每一个函数时发送进度事件。
    在salt master配置文件中激活：

    1. state_events: True

    完成一个state后触发事件

    如果你的作业配置包含多个salt state，你可以增加fire_event参数以使每一个salt state完成后触发一个事件：

    1. nano installed:
    2.   pkg.installed:
    3.     – name: nano
    4.     – fire_event: True

    或者你可以将True替换为自定义事件字符串，该字符串将附加到触发的事件：

    1. nano installed:
    2.   pkg.installed:
    3.     – name: nano
    4.     – fire_event: nano/installed

    触发一个自定义事件

    你也可以直接在命令行指定一个自定义事件tag和事件数据直接触发一个事件。在你的其中一个salt minions运行如下命令：

    1. salt-call event.send /my/test/event ‘{"data": "my event test"}’

    输出类似如下：

    1. /my/test/event  {
    2.     "_stamp": "2016-02-05T18:24:47.001310",
    3.     "cmd": "_minion_event",
    4.     "data": {
    5.         "__pub_fun": "event.send",
    6.         "__pub_jid": "20160205182446924651",
    7.         "__pub_pid": 1933,
    8.         "__pub_tgt": "salt-call",
    9.         "data": "my event test"
    10.     },
    11.     "id": "minion1",
    12.     "tag": "/my/test/event"
    13. }

    SaltStack事件驱动(1) – 监视事件

    salt的内部组件之间的通信是通过发送和监听事件实现的。在salt中，几乎所有的变动都会产生事件，如：

  • salt minion连接salt master
  • 密钥被接受或拒绝
  • 发送作业
  • 从minion返回作业结果
  • 在线心跳（默认情况下已关闭）

    • 甚至是salt命令行接口使用事件系统都会产生事件。当一个命令发送到salt master后，salt CLI仅仅需要监视事件总线来获取从目标minion返回的作业结果。

    监视事件

    salt提供了一个runner来在salt master上实时显示事件。

    1. salt-run state.event pretty=True

    如果你使用的是demo环境，你的事件总线可能是安静的，所以尝试打开另一个终端，发送一条salt ‘*’ test.ping命令或者重启salt-minion服务。
    下面是几条在salt master上获取到的事件：

    1. salt/job/20150923203228234305/new   {
    2.     "_stamp": "2016-12-01T08:11:28.235712",
    3.     "arg": [],
    4.     "fun": "test.ping",
    5.     "jid": "20161201081128234305",
    6.     "minions": [
    7.         "minion2"
    8.     ],
    9.     "tgt": "*",
    10.     "tgt_type": "glob",
    11.     "user": "sudo_vagrant"
    12. }
    1. salt/job/20161201081128234305/ret/minion2   {
    2.     "_stamp": "2016-12-01T08:11:28.291789",
    3.     "cmd": "_return",
    4.     "fun": "test.ping",
    5.     "fun_args": [],
    6.     "id": "minion2",
    7.     "jid": "20161201081128234305",
    8.     "retcode": 0,
    9.     "return": true,
    10.     "success": true
    11. }
    1. salt/auth   {
    2.     "_stamp": "2016-12-01T08:11:02.998305",
    3.     "act": "pend",
    4.     "id": "minion1",
    5.     "pub": "—–BEGIN PUBLIC KEY—–…n—–END PUBLIC KEY—–n",
    6.     "result": true
    7. }

    事件格式

    事件由两个主要部分组成：标识事件的tag和事件的详细信息。

    事件标记

    所有的salt事件的前缀是salt/，加上基于事件类型的额外级别(level)。例如，作业事件前缀为salt/job/。每个事件部分使用/分隔提供简单的命名空间。这个标识符称为事件标记(event tag)，通常包含具体的详细信息，如作业ID或minion ID。
    除了事件标记外，每个事件还包括特定的事件数据。

    事件数据

    每一个事件包括一个timestamp和该特定事件唯一的键和值。