分类：运维自动化

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和该特定事件唯一的键和值。

    SaltStack配置管理(6) – 管理文件

    在系统上获取正确的文件通常比安装正确的软件更有挑战性。salt有一个内置的文件服务器可以用来分发文件和目录到受控系统。

    SALT://

    你对放置在srv/salt目录的salt state文件应该熟悉了，不过你可能不知道的是，你放置在此目录中的任何其他文件和文件夹也可用于你的Salt minion。你可以在salt state文件中使用salt://引用srv/salt目录里的文件。

    FILE.MANAGED

    这个salt state函数允许你通过指定salt master上的源文件来管理本地文件。

    1. deploy the http.conf file:
    2.   file.managed:
    3.     – name: /etc/http/conf/http.conf
    4.     – source: salt://apache/http.conf

    由于源路径以salt://开始，我们可以推断出salt master源文件实际路径为/srv/salt/apache/http.conf。
    每一次应用这个salt state，salt会确保本地的文件与minion中的文件一致。这有助于确保应用程序在不同系统上配置相同。
    例如，如果你需要分发包含自定义设置限制下载速度的lftp全局配置文件，我们可以使用file.managed来实现：

    1. install network packages:
    2.   pkg.installed:
    3.     – pkgs:
    4.       – rsync
    5.       – lftp
    6.       – curl
    7.  
    8. copy lftp config file:
    9.   file.managed:
    10.     – name: /etc/lftp.conf
    11.     – source: salt://_tmpl_lftp.conf

    另一个选项，由于我们的配置文件只更改一行，所以我们可以使用file.append来简单地插入新的一行：

    1. install network packages:
    2.   pkg.installed:
    3.     – pkgs:
    4.       – rsync
    5.       – lftp
    6.       – curl
    7.  
    8. update lftp conf:
    9.   file.append:
    10.     – name: /etc/lftp.conf
    11.     – text: set net:limit-rate 100000:500000

    FILE.RECURSE

    这个salt state函数复制整个目录。

    1. copy some files to the web server:
    2.   file.recurse:
    3.     – name: /var/www
    4.     – source: salt://apache/www

    SaltStack配置管理(5) – JINJA

    salt引入了Jinja2模板引擎，可用于salt state文件，salt pillar文件和其它由salt管理的文件。
    salt允许你使用Jinja访问minion配置值，grains和salt pillar数据，和调用salt执行模块。这些是除了Jinja提供的标准控制结构和Python数据类型之外的功能。

    条件语句

    Jinja最常用的功能是在salt pillar文件中插入控制声明语句。
    由于许多发行版本有不同的包名称，你可以使用os grain来设置平台特定的路径，软件包名称和其它值。
    例如：

    1. {% if grains[‘os_family’] == ‘RedHat’ %}
    2. apache: httpd
    3. git: git
    4. {% elif grains[‘os_family’] == ‘Debian’ %}
    5. apache: apache2
    6. git: git-core
    7. {% endif %}

    如你所见，salt grains跟salt pillar的数据字典都是字典。这个示例检查salt grain值来设置操作系统特定的salt pillar键值。
    保存上面的代码到saltstack/pillar/common.sls文件，然后运行如下命令来刷新和列出每一个minions的salt pillar值：

    1. salt ‘*’ saltutil.refresh_pillar
    2. salt ‘*’ pillar.items

    设置这些值后，当应用如下salt state:

    1. install apache:
    2.   pkg.installed:
    3.     – name: {{ pillar[‘apache’] }}

    httpd软件包安装在RedHat，apache2安装在Debian系统。

    循环语句

    在salt state中创建多个用户和目录使用循环语句会很方便。

    1. {% for usr in [‘moe’,’larry’,’curly’] %}
    2. {{ usr }}:
    3.   user.present
    4. {% endfor %}
    1. {% for DIR in [‘/dir1′,’/dir2′,’/dir3’] %}
    2. {{ DIR }}:
    3.   file.directory:
    4.     – user: root
    5.     – group: root
    6.     – mode: 774
    7. {% endfor %}

    一般来说，你应该努力保持你的salt state足够简单。如果你发现你必须编写复杂的Jinja才能实现功能，你应该考虑把一个任务分割为多个salt state文件，或者编写一个自定义的salt执行模块。

    使用salt获取数据

    你可以在Jinja中调用salt执行函数来实时获取数据。

    1. {{ salt.cmd.run(‘whoami’) }}

    SaltStack配置管理(4) – 使用require声明salt state执行顺序

    执行顺序

    配置管理最重要的（和复杂的）方面之一是确保每个任务在正确的时间执行。
    默认情况下，salt state文件中的每个ID是按在文件中出现的顺序来执行。此外，在Top文件中，每个salt state文件是在列表的顺序来应用。例如下图中的ID是按salt state文件中在Top文件出现的次序来执行的。
    运维自动化
    通过组织Top文件中Salt state出现的顺序，可以在不显式定义依赖性的情况下控制执行顺序。

    require

    require可以显性地指定salt state中ID的依赖。如果你添加一个声明指示id1依赖id4，那么就首先应用id4。
    运维自动化
    你可以使用state.show_sls执行函数来查看salt state的执行顺序。例如：

    1. salt ‘minion1’ state.show_sls sls1[,sls2,…]

    查看examples.sls文件中salt state的执行顺序，使用如下命令：

    1. salt ‘minion1’ state.show_sls examples

    更多声明顺序方法

    还有几个其它用来控制执行顺序的声明。你可以在这里找到https://docs.saltstack.com/en/latest/ref/states/requisites.html

    SaltStack配置管理(3) – INCLUDE

    为了保持你的salt state模块化和可重用，每一个配置任务应该只在salt state树描述一次。如果你需要在多个地方使用同样的配置任务，你可以使用include指令。
    include的使用很简单。在你的state文件的顶部（任何ID的外部），使用如下格式添加include:

    1. include:
    2.   – sls1
    3.   – sls2

    其中sls1和sls2是你想include的sls文件名称。注意不需要添加.sls后缀。
    如果你想include的state文件在salt state树的子目录，可以使用小圆点(.)作为目录分隔符：

    1. include:
    2.   – dir.sls1

    include的state文件是插入到当前state文件的顶部，并且会首先处理。

    示例

    还记得之前下面的示例吗?

    1. sync directory using lftp:
    2.   cmd.run:
    3.     – name: lftp -c "open -u {{ pillar[‘ftpusername’] }},{{ pillar[‘ftppassword’] }}
    4.            -p 22 sftp://example.com;mirror -c -R /local /remote"

    这个salt state依赖lftp命令，所以最好是创建另一个salt state来确保lftp已经安装。然后我们可以使用include来连接它们。
    srv/salt/lftp.sls:

    1. install lftp:
    2.   pkg.installed:
    3.     – name: lftp

    srv/salt/dir-sync.sls:

    1. include:
    2.   – lftp
    3.  
    4. sync directory using lftp:
    5.   cmd.run:
    6.     – name: lftp -c "open -u {{ pillar[‘ftpusername’] }},{{ pillar[‘ftppassword’] }}
    7.            -p 22 sftp://example.com;mirror -c -R /local /remote"

    SaltStack配置管理(2) – PILLAR

    salt pillar是salt state实现可重用的重要组件，所以我们来快速创建一个salt state来看pillar如何使用的。

    salt pillar top文件

    salt pillar使用Top文件来匹配应用到salt minions的salt pillar数据。这个Top文件与用来匹配应用到salt minions的salt state的Top文件类似。
    跟salt state函数一样，我们通过示例来学习salt pillar。创建salt-vagrant-demo-master/saltstack/pillar目录，然后在此目录下创建top.sls文件，添加如下内容：

    1. base:
    2.   ‘*’:
    3.     – default

    下一步创建default.sls文件，添加如下行：

    1. editor: vim

    当salt pillar数据刷新后，每个Salt minion与top.sls文件中列出的目标匹配。当salt minion匹配后，它接收在该目标下面的列表中定义的所有Salt pillar SLS文件。
    因为*通配符匹配所有salt minions，每一个salt minion接收到一个键为editor，值为vim的pillar数据。

    刷新salt pillar

    我们打算用我们刚才配置的salt pillar，所以我们需要在所有minions刷新salt pillar数据：

    1. salt ‘*’ saltutil.refresh_pillar

    salt state中使用salt pillar

    salt pillar数据可以使用在salt state中，所以我们可以更新上一篇文章中的salt state示例来使用salt pillar字典：

    1. vim installed:
    2.   pkg.installed:
    3.     – name: {{ pillar[‘editor’] }}

    salt pillar数据是安全的，你可以用它设置密码。例如，你可以添加如下密码的salt pillar:

    1. ftpusername: me
    2. ftppassword: oxfm4@8t5gglu^h^&

    然后在salt state中引用：

    1. sync directory using lftp:
    2.   cmd.run:
    3.     – name: lftp -c "open -u {{ pillar[‘ftpusername’] }},{{ pillar[‘ftppassword’] }}
    4.            -p 22 sftp://example.com;mirror -c -R /local /remote"

    命令行下设置salt pillar

    为了测试或临时使用，你可以在命令行下设置salt pillar的值。这些值会覆盖salt pillar文件中设置的值。

    1. salt ‘*’ state.apply ftpsync pillar='{"ftpusername": "test", "ftppassword": "0ydyfww3giq8"}’

    SaltStack配置管理(1) – 函数

    salt state函数

    salt state函数就是指在salt state中所做的实际工作，是saltstack配置管理最重要的东西。
    函数用来安装和配置应用，创建用户，分发文件和关于你配置你系统的所有其它事情。
    在我们调用函数之前，我们来看一下salt state函数的语法。

    语法

    salt state使用YAML来描述系统状态，YAML是描述结构化数据(类似JSON，但更人性化)的简单语言。
    下面的图表显示salt state的声明格式：
    运维自动化
    salt state第一行声明是是一个ID。
    ID下面是你调用一个或多个salt state函数的地方。

  • ID和函数的行以冒号结尾。每个函数调用在ID的下行缩进两个空格。参数以列表形式传递给函数。函数的下面每行一个参数，先缩进两个空格，然后一个连字符，再一个空格，之后就是参数名称和值了。
  • 如果参数只有一个值，那么参数名称和值在同一行，以冒号和一个空格分隔。如果参数值是一个列表，那么列表在下一行开始，缩进两个空格。

    • 函数示例

    最好学习salt state函数的方法是学习一个示例。我们再次使用之前搭建的demo环境来学习这个示例http://devops.webres.wang/2016/11/saltstack-demo-environment/。
    打开终端，切换到salt-vagrant-demo-master目录，执行vagrant up命令。
    当环境启动后，创建一个名称为salt-vagrant-demo-master/saltstack/salt/examples.sls的文件，以便你能运行这么示例。

    安装软件包

    把下面的代码复制到刚才创建的examples.sls文件：

    1. install vim:
    2.   pkg.installed:
    3.     – name: vim

    ssh到salt master服务器：

    1. vagrant ssh master

    用如下命令应用examples.sls state:

    1. sudo salt ‘minion1’ state.apply examples

    运维自动化

    创建目录

    下面是创建目录的示例。

    1. create my_new_directory:
    2.  file.directory:
    3.    – name: /opt/my_new_directory
    4.    – user: root
    5.    – group: root
    6.    – mode: 755

    运行服务

    下面的state用来确保一个服务正在运行在salt minion:

    1. Make sure the mysql service is running:
    2.   service.running:
    3.     – name: mysql

    每一个state声明以一个state ID来区分。state ID必须是唯一的，它们能包含空格和数字。
    你可以在一个state ID下添加多个salt state函数：

    1. Install mysql and make sure the mysql service is running:
    2.   pkg.installed:
    3.     – name: mysql
    4.   service.running:
    5.     – name: mysql

    开始启动服务

    当你调用一个函数时，确保你把函数的参数全部看一遍，因为通常你仅需传递额外的参数就可以完成许多事件。通过传递enable: True到service.running函数，saltstack就会确保服务开机启动。

    1. Make sure the mysql service is running and enable it to start at boot:
    2.   service.running:
    3.     – name: mysql
    4.     – enable: True

    下载GIT仓库

    每个函数都有一个name参数。如果你没有设置，那么salt就使用state的ID。在这个示例中，name参数为https://github.com/saltstack/salt.git:

    1. https://github.com/saltstack/salt-bootstrap:
    2.   git.latest:
    3.     – rev: develop
    4.     – target: /tmp/salt

    使用ID作为name参数值的确省了敲打一些字符，不过还是推荐都设置一个name，如下：

    1. Clone the SaltStack bootstrap script repo:
    2.   pkg.installed:
    3.     – name: git # make sure git is installed first!
    4.   git.latest:
    5.     – name: https://github.com/saltstack/salt-bootstrap
    6.     – rev: develop
    7.     – target: /tmp/salt

    这样能让你的state更明了，更容易维护。

    添加用户

    1. user account for pete:
    2.   user.present:
    3.     – name: pete
    4.     – shell: /bin/bash
    5.     – home: /home/pete
    6.     – groups:
    7.       – sudo

    参数groups的值是一个列表，所以放到下一行，缩进两个空格再加一个短破折号。

    添加条目到hosts文件

    1. myserver in hosts file:
    2.   host.present:
    3.     – name: myserver
    4.     – ip: 192.168.0.42

    平台规范化的一个很好的例子。即使每个平台配置的hosts方式有所不同，salt state仍然能正确地在各个系统配置hosts（不需要关心salt实现的细节）。

    调用执行函数

    service.restart和其它执行函数可以在salt state调用。

    1. restart vsftpd:
    2.   module.run:
    3.     – name: service.restart
    4.     – m_name: vsftpd  # m_name gets passed to the execution module as "name"

    salt执行和salt state函数的区别

    你可能好奇为什么不使用service state函数而使用service执行函数，为什么salt state和salt执行函数看起来类似有很多重叠的地方。
    如果你比较salt执行函数与salt state函数的名称，如service.restart和service.running，你可能会注意到重要的区别。salt state函数设计用来只在必要的时候应用配置，没有必要时不做任何更改。salt执行函数在每次调用时都执行。
    当你调用service.running state函数时，函数首先先查看服务是否已经运行，如果没有就启动，否则不做任何事情。当你调用service.restart执行函数时，始终会重启服务。

    test=True

    在目标系统应用一个salt state会发生许多更改。salt state函数提供了一个机制来测试显示在运行期间将会做怎样的变更。

    1. sudo salt ‘minion1’ state.apply examples test=True