Saltstack 的学习总结
一 、Saltstack的简介
SaltStack采用 C/S模式，server端就是salt的master，client端就是minion，minion与master之间通过ZeroMQ消息队列通信。minion上线后先与master端联系，把自己的pub key发过去，这时master端通过salt-key-L命令就会看到minion的key，接受该minion-key后，也就是master与minion已经互信。master可以发送任何指令让minion执行了，salt有很多可执行模块，比如说cmd模块，在安装minion的时候已经自带了，它们通常位于你的python库中，locate salt | grep/apps/ns1/python/bin/salt 可以看到salt自带的所有东西。这些模块是python写成的文件，里面会有好多函数，如cmd.run，当我们执行/apps/ns1/python/bin/salt'*' cmd.run 'uptime'的时候，master下发任务匹配到的minion上去，minion执行模块函数，并返回结果。master监听4505和4506端口，4505对应的是ZMQ的PUBsystem，用来发送消息，4506对应的是REPsystem是来接受消息的。
具体步骤如下
1. Saltstack的Master与Minion之间通过ZeroMq进行消息传递，使用了ZeroMq的发布-订阅模式，连接方式包括tcp，ipc
2. salt命令，将cmd.runls命令从salt.client.LocalClient.cmd_cli发布到master，获取一个Jodid，根据jobid获取命令执行结果。
3. master接收到命令后，将要执行的命令发送给客户端minion。
4. minion从消息总线上接收到要处理的命令，交给minion._handle_aes处理
5. minion._handle_aes发起一个本地线程调用cmdmod执行ls命令。线程执行完ls后，调用minion._return_pub方法，将执行结果通过消息总线返回给master
6. master接收到客户端返回的结果，调用master._handle_aes方法，将结果写的文件中
7. salt.client.LocalClient.cmd_cli通过轮询获取Job执行结果，将结果输出到终端。
二、saltstack 的安装
（略）
三、Salt常用命令（远程执行命令）
1、salt该命令执行salt的执行模块，通常在master端运行，也是我们最常用到的命令
salt [options]'<target>'<function>[arguments]
如: /apps/ns1/python/bin/salt '*' test.ping
2、salt-run 该命令执行runner(salt带的或者自定义的，runner以后会讲)，通常在master端执行，比如经常用到的manage
/apps/ns1/python/bin/salt-run [options] [runner.func]
/apps/ns1/python/bin/salt-run manage.status ##查看所有minion状态
/apps/ns1/python/bin/salt-run manage.down ##查看所有没在线minion
/apps/ns1/python/bin/salt-run manged.up ##查看所有在线minion
3、salt-key 密钥管理，通常在master端执行
/apps/ns1/python/bin/salt-key [options]
/apps/ns1/python/bin/salt-key -L ##查看所有minion-key
/apps/ns1/python/bin/salt-key -a<key-name> ##接受某个minion-key
/apps/ns1/python/bin/salt-key -d<key-name> ##删除某个minion-key
/apps/ns1/python/bin/salt-key -A ##接受所有的minion-key
/apps/ns1/python/bin/salt-key -D ##删除所有的minion-key
4、salt-call 该命令通常在minion上执行，minion自己执行可执行模块，不是通过master下发job
salt-call [options] <function> [arguments]
salt-call test.ping ##自己执行test.ping命令
salt-call cmd.run 'ifconfig' ##自己执行cmd.run函数
5、salt-cp 分发文件到minion上,不支持目录分发，通常在master运行
salt-cp [options] '<target>' SOURCEDEST
salt-cp '*' testfile.html /tmp
salt-cp 'test*' index.html /tmp/a.html
6、salt-master master运行命令
salt-master [options]
salt-master ##前台运行master
salt-master -d ##后台运行master
salt-master -l debug ##前台debug输出
7、 salt-minion minion运行命令
salt-minion [options]
salt-minion ##前台运行
salt-minion -d ##后台运行
salt-minion -l debug ##前台debug输出
四、saltstack 的常用模块以及API
简介
Saltstack 提供了十分丰富的功能模块，涉及操作系统的基础信息、常用工具支持等。可以参看更多模块的相关信息：
https://docs.saltstack.com/en/latest/ref/modules/all/index.html
可以通过/apps/ns1/python/bin/salt ‘*’ sys.list_modules 参看当前版本系统支持的相关模块。
以下是运行/apps/ns1/python/bin/salt ‘*’ sys.list_modules命令后的部分截图
接下来是saltstack的十大常用模块以及对应API的介绍
Saltstack –API的简介
API的原理是调用master client 模块，创建LocalClient对象，在调用cmd()方法来实现。
示例:通过API实现test.ping
Importsalt.client
client= salt.client.LoaclClient()
ret= client.cmd(‘*’,’test.ping’)
printret
运行后的结果如下：
Archive 模块
1） 功能：实现系统层面的压缩包调用，支持gunzip、gzip、rar、tar、unrar、unzip等
2） 示例
利用gunzip 对/apps/file/soucrefile.txt.gz 解压
/apps/ns1/python/bin/salt ‘*’ archive.gunzip /apps/file/soucrefile.txt.gz
利用gzip 对/apps/file/soucrefile.txt 解压
/apps/ns1/python/bin/salt ‘*’ archive.gzip /apps/file/soucrefile.txt
3） API 调用示例:利用gunzip 对/apps/file/soucrefile.txt.gz 解压
Import salt.client
client = salt.client.LocalClient()
ret = client.cmd(‘*’,’archive.gzip’,[‘/apps/file/soucrefile.txt.gz’])
cmd 模块
1） 功能：实现远程的命令行调用执行（默认具备root操作权限）
2） 示例：
获取所有被控主机的内存使用情况
/apps/ns1/python/bin/salt ‘*’ cmd.run “free -m”
3）API 调用示例: 获取所有被控主机的内存使用情况
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
Import salt.client
Client = salt.client.LocalClient()
Ret = Client.cmd(‘*’,’cmd.run’,[‘free –m’])
cp模块
1） 实现远程文件、目录的复制，以及下载url 文件操作等
2） 示例
将指定被控主机的/etc/hosts 文件复制到被控制主机本地的file 目录下（/apps/file）
/apps/ns1/python/bin/salt ‘*’ cp.cache_local_file /etc/hosts
将主服务器file_roots指定位置下的目录复制到被控主机
/apps/ns1/python/bin/salt ‘*’ cp.get_dir salt://path/to/dir/ /minion/dest
下载URL内容到被控主机指定位置
/apps/ns1/python/bin/salt ‘*’ cp.get_url http://www.slashdot.org /tmp/index.html
3） API调用示例：下载URL内容到被控主机指定位置
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
Import salt.client
Client = salt.client.LocalClient()
Ret = Client.cmd(‘*’,’cp.get_url’,[‘http://www.slashdot.org’,’ /tmp/index.html’])
cron模块
1） 功能：控主机的crontab操作
2） 示例：
查看指定被控主机、root用户的crontab清单
/apps/ns1/python/bin/salt ‘*’ cron.row_cron root
为指定的被控主机、root用户添加/usr/local/weekly任务作业
/apps/ns1/python/bin/salt ‘*’ cron.set_job root ‘*’ ‘*’ ‘*’‘*’ 1 /usr/local/weekly
删除指定的被控主机、root用户crontab的/usr/local/weekly任务作业
/apps/ns1/python/bin/salt ‘*’ cron.rm_job root/usr/local/weekly
3） API调用：删除指定的被控主机、root用户crontab的/usr/local/weekly任务作业
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
Import salt.client
Client = salt.client.LocalClient()
Ret = Client.cmd(‘*’,’cron.rm_job’,[‘root’,’/usr/local/weekly’])
dnsutil模块
1） 功能：实现被控主机通用DNS相关操作
2） 示例：
添加指定被控主机hosts的主机配置项
/apps/ns1/python/bin/salt ‘*’ dnsutil.hosts_append/etc/hosts 127.0.01 ad1.yuk.com ,d2.yuk.com
删除指定被控主机hosts的主机配置项
/apps/ns1/python/bin/salt ‘*’ dnsutil.hosts_remove/etc/hosts ad1.yuk.com
3） API 调用：删除指定被控主机hosts的主机配置项
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
Import salt.client
Client = salt.client.LoaclClient()
Ret = Client.cmd(‘*’,’dnsutil.hosts_remove’,[‘/etc/hosts’,’ad1.yuk.com’])
file模块
1） 功能：被控主机文件常见操作，包括文件读写、权限、查找、校验等
2） 示例：
校验所有被控主机/etc/fstab文件的md5是否为6254e84e2f6ffa54e0c8d9cb230f5505，一致则返回True
/apps/ns1/python/bin/salt ‘*’ ilechenk_hash
/etc/fstab d5=6254e84e2f6ffa54e0c8d9cb230f5505
复制本地所有被控主机本地 /path/to/src 文件到本地的/path/to/dat文件
/apps/ns1/python/bin/salt ‘*’ file.copy /path/to/src /path/to/dat
获取所有被控主机/etc/passwd 的stats 信息
/apps/ns1/python/bin/salt ‘*’ ile.stats /etc/passwd
获取所有被控主机/etc/passwd的权限mode,如755，644
/apps/ns1/python/bin/salt ‘*’ file.get_mode /etc/passwd
修改所有被控主机/etc/passwd的权限mode为0644
/apps/ns1/python/bin/salt ‘*’ file.set_mode /etc/passwd0644
在所有被控主机创建/opt/test目录
/apps/ns1/python/bin/salt ‘*’ file.mkdir /opt/test
给所有被控主机的/tmp/test/testc.onf 文件追加内容”maxclient 100”
/apps/ns1/python/bin/salt ‘*’ file.append/tmp/test/testc.onf ”maxclient 100”
删除所有被控主机的/tmp/foo文件
/apps/ns1/python/bin/salt ‘*’ file.remove /tmp/foo
3）API调用：删除所有被控主机的/tmp/foo文件
#!_INSX/python/bin/python
Import salt.client
Client = salt.client.LocalClient()
Ret = Client.cmd(‘*’,’file.remove’,[‘/tmp/foo’])
Iptables模块
1） 功能：被控主机iptables支持
2） 示例：
在所有被控端主机追加（append）、插入（insert）iptables规则，其中INPUT为输入链
Salt ‘*’ iptables.append filter INPUT rule = ‘-m state –stateRELATED,ESTABLISHED –J ACCEPT’
保存所有被控端主机规则到本地硬盘（/etc/sysconfig/iptales）
/apps/ns1/python/bin/salt ‘*’ iptables.save etc/sysconfig/iptales
3）API调用：在所有被控端主机追加（append）iptables规则，其中INPUT为输入链
#!_INSX/python/bin/python
Import salt.client
Client = salt.client.LocalClient()
Ret = Client.cmd(‘*’,’iptables.append’,[‘filter’,’INPUT’, ‘rule= \’-m state ELATED,ESTABLISHED –J ACCEPT\’’])
Network模块
1） 功能：返回被控主机网络信息
2） 示例：
获取所有被控主机的MAC地址
/apps/ns1/python/bin/salt ‘*’ network.hwaddrs eth0
获取所有被控主机的网卡配置信息
/apps/ns1/python/bin/salt ‘*’ network.interfaces
获取所有被控主机的IP地址配置信息
/apps/ns1/python/bin/salt ‘*’ network.ip_addrs
获取指定被控主机的子网信息
/apps/ns1/python/bin/salt ‘*’ network.subnets
3） API调用：获取指定被控主机的子网信息
#!_INSX/python/bin/python
Import salt.client
Client =salt.client.LocalClient()
Ret = Client.cmd(‘*’,’network.subnets’)
Pkg包管理模块
1） 功能：被控主机程序包管理，如yum、apt-get等
2） 示例：
为所有被控主机安装php环境
/apps/ns1/python/bin/salt ‘*’ pkg.install php
卸载所有被控主机的php环境
/apps/ns1/python/bin/salt ‘*’ pkg.remove php
升级所有被控主机的软件包
/apps/ns1/python/bin/salt ‘*’ pkg.upgrade
3）API 调用：卸载所有被控主机的php环境
#!_INSX/python/bin/python
Import salt.client
Client =salt.client.LocalClient()
Ret = Client.cmd(‘*’,’pkg.remove’,[‘php’])
Service服务模块
1） 功能：被控主机程序包服务管理
2） 示例：
开启（enable）、禁用（disables）nginx开机自启动服务
/apps/ns1/python/bin/salt ‘*’ service.enable nginx
/apps/ns1/python/bin/salt ‘*’ service.disable nginx
针对nginx服务的reload、restart、start、stop、status操作
/apps/ns1/python/bin/salt ‘*’ service.reload nginx
/apps/ns1/python/bin/salt ‘*’ service.restart nginx
/apps/ns1/python/bin/salt ‘*’ service.start nginx
/apps/ns1/python/bin/salt ‘*’ service.stop nginx
/apps/ns1/python/bin/salt ‘*’ service.status nginx
3） API调用：针对niginx服务的reload操作
#!_INSX/python/bin/python
Import salt.client
Client = salt.client.LocalClient()
Ret = Client.cmd(‘*’,’service.reload’,[‘nginx’])
Grains组件
Grains是Saltstack最重要的组件之一，grians的作用是收集被控主机的基本信息，这些信息通常都是一些静态类型的数据，包括被控主机的CPU、内核、操作系统、虚拟化等信息。
Grains常用操作命令
示例1：匹配内版本为2.6.32-358.14.1e16.x86_64的主机
/apps/ns1/python/bin/salt–G ‘kernelrelease:2.6.32-358.14.1e16.x86_64’ cmd.run ‘uname –a’
示例2：获取所有主机的grains项信息
/apps/ns1/python/bin/salt ‘*’ grains.ls
示例3：获取被控主机单项数据
/apps/ns1/python/bin/salt ‘*’ grains.itemos
定义Grains数据
定义grains数据有两种，其中一种为在被控主机定制配置文件，这种比较方便，但有局限性；另一种是通过主控端扩展模块API来实现，用Python编程动态定义。
被控端主机定制grains数据
通过手动更新被控主机的grains文件、让master进行采集
1） 在每台被控主机上新建/etc/salt/minion.d/hostinfo.conf文件
Grains:
Roles:
---webserver
2） 重启salt-minion服务
(1) Cp/apps/ns1/utils
(2) ./salt-minion restart
通过主控端master扩展API来实现
首先，需要明确master上的bash目录，可以到/etc/salt/master配置文件的file_roots处查看，默认为/srv/salt
1） 新建一个_grains目录
Install –d /apps/ns1/srv/salt/_grains
2） 在_grains目录下新建一个py文件（例如）
[/srv/salt/_grains/sysprocesss.py]
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
import os
import sys
import commands
def Grains_openfile():
"""
:return: os max open file ofgrains value
"""
grains = {}
# init default value
_open_file = 65536
try:
getulimit =commands.getstatusoutput('source /etc/profile;ulimit -n')
except Exception as e:
pass
if getulimit[0] == 0:
_open_file = int(getulimit[1])
grains['max_open_file'] = _open_file
print grains
return grains
3） 新建文件之后，需要分发到所有Minion上
/apps/ns1/python/bin/salt ‘*’ saltutil.sync_all
4） 刷新模块
/apps/ns1/python/bin/salt ‘*’ sys.reload_modules
5） 收集数据
/apps/ns1/python/bin/salt ‘*’ grains.item max_open_file
6） 运行结果
Pillar组件
Pillar简介
Pliiar也是Saltstack最重要的组件之一，其主要作用是定义与被控主机相关的任何数据，定义好的的数据可以被其他组件使用，如模板、state、API等，在pillar定义的数据与不同业务特性的被控主机相关联，这样不同被控主机只能看到自己匹配的数据，因此pillar安全性很高，适用于一些比较敏感的数据，这是区别于grains的最关键的一点。
Pillar的定义
主配置文件定义
Saltstack默认将主控端配置文件中的所有数据都定义到pillar中，而且对所有被控主机开放。可以通过修改/etc/salt/master配置中的pillar_opts:True 或False来定义是否开启或者禁用这项功能。
运行：/apps/ns1/python/bin/salt‘*’ pillar.data 命令来查看效果
SLS文件定义
Pillar 支持在sls文件中定义数据，格式必须符合YAML规范，与SaltStack的组件十分相似。两者文件的配置格式、入口文件top.sls都是一致的。
1） 定义pillar 的主要目录
修改主配置文件/etc/salt/master的参数，定义pillar的主目录，格式如下：
Pillar_roots:
Base:
---/srv/pillar
同时创建pillar目录，执行命令
Install -d /apps/ns1/srv/pillar
2） 定义入口文件top.sls
入口文件的作用一般是定义pillar的数据覆盖别控主机的有效域范围，‘*’代表任意主机，其中包括一个data.sls文件，具体内容如下：
[/srv/pillar/top.sls]
Base:
‘*’:
— data
[/srv/pillar/data.sls]
Appname: website
Flow:
Maxconn: 30000
Maxmem: 6G
3） 校验pillar
（1） 刷新被控制主机的pillar 信息，执行如下命令。
/apps/ns1/python/bin/salt '*' saltutil.refresh_pillar
（2） 查看定义的data.sls数据，执行如下命令。
/apps/ns1/python/bin/salt '*' pillar.data appname flow
（3） 运行结果：
Pillar的使用
完成pilllar配置后，接下来简单介绍使用方法。可以在state、模板文件中引用，模板格式为“{{ pillar 变量}}”，例如：
{{pillar[‘appname’] }} （一级字典）
{{pillar[‘flow][‘maxconn’] }}（二级字典）或者{{ salt[‘pillar.get’] (‘flow’:’maxconn’,{}) }}
Python API格式如下：
Pillar[‘flow’][‘maxconn’]
Pillar.get(‘flow:appname’, {})
操作目标主机
通过 –I 选项来使用Pillar 来配置被控主机
/apps/ns1/python/bin/salt-I 'appname:website' test.ping
结合grains处理数据的差异性
首先通过结合grains的id信息来区分不同id的maxcpu的值，其次进行引用观察匹配的信息。我还是延伸‘pillar的定义’的例子将data.sls 修改成如下形式，其中，“if … else …endif”为jinja2的模块语法，jinja2语法可参考：http://jinja.pocoo.org/docs/2.10/templates/
[/srv/salt/data.sls]
Appname: website
Flow:
Maxconn: 3000
Maxmem: 6G
{% if grains[‘id’] == ‘172.30.154.60’ %}
Maxcpu: 8
{% else %}
Maxcpu: 4
{% endif %}
编写好data.sls文件后。执行以下步骤：
（1） 刷新被控制主机的pillar 信息，执行如下命令。
/apps/ns1/python/bin/salt '*' saltutil.refresh_pillar
（2） 查看定义的data.sls数据，执行如下命令。
/apps/ns1/python/bin/salt '*' pillar.data appname flow
（3） 运行结果：
State介绍
State是Saltstack最核心的功能，通过预先定制好的sls（salt state file）文件对被控主机进行状态管理，支持包括程序包（pkg）、文件（file）、网络配置（network）、系统服务（service）、系统用户（user）等。更多状态对象见 :
https://docs.saltstack.com/en/latest/ref/states/all/index.html
state的定义
state的定义是通过sls文件进行描述的。支持YAML语法，定义的规则如下：
$ID:
$State:
—$state: states
其中：
$ID，定义state的名称，通常采用与描述的对象保存一致的方法，如apache、nginx等。
$State，管理对象的类型，，看参考：
https://docs.saltstack.com/en/latest/ref/states/all/index.html
$state: states，定制对象的状态
如下例子：
Apache:
Pkg:
—installed
Service:
—running
—require:
—pkg: apache
注意：第6行是关键字require,它确保了apache服务只有在成功安装软件包后才会启动
State的使用
State的入口文件和pillar一样，文件名称都是top.sls,但是state要求文件必须存放在saltstack base目录下，默认为/srv/salt。State描述配置.sls支持jinja模块、grains以及pillar引用等。在state的逻辑层次定义完成后，再通过 salt ‘*’ state.highstate 执行生效。
定义pillar
[/srv/pillar/top.sls]
Base:
“*”:
—apache
在top.sls中引用二级配置有两种方式：一是直接引用，二是创建apache目录，在引用目录中的init.sls文件。
先执行如下命令：
Install -d /srv/pillar/apache 或者mkdir/srv/pillar/apache
[/srv/pillar/apache/init.sls]
Pkgs：
{% if grains[‘os_family’]== ‘Debian’ %}
Apache: apache2
{% elif grains[‘os_family’] == ‘RedHat’ %}
Apache: httpd
{% elif grains[‘os_family’] == ‘Arch’ %}
Apache: apache
{% endif %}
编写好init.sls文件后。执行以下步骤：
（1） 刷新被控制主机的pillar 信息，执行如下命令。
/apps/ns1/python/bin/salt '*' saltutil.refresh_pillar
（2） 查看定义的data.sls数据，执行如下命令。
/apps/ns1/python/bin/salt '*' pillar.data pkgs
定义state
[/srv/salt/top.sls]
Base:
‘*”:
—apache
[/srv/salt/apache/init.sls]
Apache:
Pkg:
—installed
—name: {{ pillar[‘pkgs’][‘apache’] }}
Sevice:
—name: {{ pillar[‘pkgs’][‘apache’] }}
—require:
—pkg: {{pillar[‘pkgs’][apache’] }}
执行state
/apps/ns1/python/bin/salt'*' state.highstate
Saltstack事件系统与反应系统（event and reacter system）
简介
Master和Minion是基于ZMQ通信的。它们通信的消息队列就是一些事件。反应系统就是基于事件系统的。一条消息其实就是一个事件，事件通常是一个字典数据，这个字典数据通常包含tag,这个tag是用来区分用途过滤消息的。
事件系统(event system)
捕捉事件（list event）
事件代码
官方网给的事件捕捉程序eventlisten 可见：
https://github.com/saltstack/salt/blob/develop/tests/eventlisten.py
打开网址，复制下载，不要直接wget
运行程序
Master: python eventlisten.py ##捕捉master端的event直接运行即可
Minion: python eventlisten.py -n minion <minion-id> ##捕捉minion端的需要额外参数，minion-id是该Minion的id
发送事件（fire event）
Matert 发给minion
salt '*'event.fire "{'data': 'some message'}""tag" ##前面必须是字符串包住的字典，后面是tag,如果你的minion在监听event，你会看到这条event的
Minion发给minion
salt-call event.fire_master 'some message''tag' ##前面数据类型没有要求，后面是tag,去master那看看收到了没有
Minion发给自己
salt-call event.fire "{'data': 'some message'}"'tag'##前面必须是字符串包住的字典，后面是tag
用code来捕捉，并发送event
捕捉事件
Master:
# python2.6
>>> import salt.utils.event
>>> event = salt.utils.event.SaltEvent('master', '/var/run/salt/master')
##master表明是在master端监听，/var/run/salt/master是你master的sock_dir
>>> data = event.get_event()
>>> print(data) ##查看内容
>>> data = event.get_event(wait=10, tag='auth') ##wait是指timeout时间，默认5s,用tag来过滤事件，可省略
>>> print(data)
>>> for data inevent.iter_events(tag='auth'): ##用迭代器一直查看事件
>>> print(data)
Minion:
#python2.6
>>> import salt.utils.event
>>> event = salt.utils.event.SaltEvent('minion', '/var/run/salt/minion',id='minion_id')
##minion代表是在minion端监听，/var/run/salt/minion是minion端的sock_dir,minion_id是该Minion的id
>>> data = event.get_event()
>>> print(data)
>>> for data inevent.iter_events(tag='auth'): ##用迭代器一直查看事件
>>> print(data)
发送事件:
Master:
>>> import salt.utils.event
>>> event = salt.utils.event.SaltEvent('master', '/var/run/salt/minion')
>>> event.fire_event({'hello': 'world'}, 'hello')
反应系统(reacter system)
反应系统是基于事件系统的，它的作用是当master收到来自minion的特殊事件后就触发某些动作，比如minion上线后发送一个init事件，master收到后，对其应用init的状态文件，minion没有反应系统，事情就是这样的。
配置reactor
修改master配置文件或者在/etc/salt/master.d/中建立reactor.conf,内容
reactor:
- 'testtag': ##接收到的tag
- /srv/reactor/start.sls
- /srv/reactor/monitor.sls
- 'test1*tag': ##接收到的tag，支持通配符
- /srv/reactor/other.sls
建立reactor响应sls文件
[/srv/reacter/start.sls]
{% if data['id'] == 'mysql1' %}
delete_file:
cmd.cmd.run:
- tgt: 'G@os:CentOS'
- expr_form: compound
- arg:
- rm -rf /tmp/*
{% endif %}
[/srv/reactor/other.sls]:
{% if data['data']['state'] == 'refresh' %}
overstate_run:
runner.state.over
{% endif %}
下面来解释一下这两个文件，reacter的sls文件是支持jinja的，所以第一行是通过jinja来判断，reacter的sls支持两个变量data和tag, data是接受事件的那个字典，tag就是事件的tag，所以第一行的判断就很好理解了，第二行是id，可以随意起，第三行是要运行的执行模块或者runner，如果是执行模块，以cmd.开始，如果是runner则以runner.开始，可执行模块执行需要target，所以- tat:后面跟的就是可执行模块的target,- expr_form指的target的匹配方式，- arg是只执行模块函数的参数，runner一般不需要这些。所以第一个示例相当于执行了salt -C 'G@mysql1'cmd.run 'rm -rf /tmp/*' 第二个相当于执行了 salt-run state.over
Returners
默认所有minion返回的值都会发送到master端，我们可以看到，returner就是让Minion把返回的值发给其它地方，如redis,MySQL,或者一个文本下面我们来自定义一个returner：
1.建立自定义returner
mkdir -p /srv/salt/_returners;
vim mysql.py ##就用官方给的例子吧，修改其中mysql的Host,user和pass
内容见https://github.com/saltstack/salt/blob/develop/salt/returners/mysql.py
2.建立需要的数据库
见https://github.com/saltstack/salt/blob/develop/salt/returners/mysql.py注释里的见表语句
3.授权其他主机用户可写该表
>grant all on salt.* to 'user_in_returner'@'%'identified by 'passwd_in_returner';
4.同步
salt '*' saltutil.sync_all ##同步到minion上去
5.测试
salt '*' test.ping --return mysql ##数据返回到mysql上去，打开mysql查看
扩展salt
扩展salt简述
通过自定义各个模块来扩展salt，常见自定义模块有:
可执行模块 Execution Modules
如我们常用的cmd.run ,test.ping这样的可执行模块
Grains
扩展grains，grains是一些静态信息，可能好多我们需要的没有，我们可以通过编写grains模块自定义grains
状态模块 State Module
如我们常用的pkg.install,file.managed
Returners
我们可以自定义returner，将返回的数据发送到其他存储，只要符合固定的格式就行了
Runner
Runner是在master端快速执行的模块，自定义很方便
自定义可执行模块
所有可执行module见https://github.com/saltstack/salt/tree/develop/salt/modules，或http://docs.saltstack.com/ref/modules/all/index.html?highlight=full%20list%20builtin
建立自定义模块目录,通常所有自定义模块放在该目录下
mkdir /srv/salt/_modules
编写模块
vim test.py
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
'''
support for yum of RedHat family!
'''
def __virtual__():
'''
Only RedHat family os can use it.
'''
if __grains__.get('os_family', 'unkown') == 'RedHat':
return 'yum'
else:
return False
def install(rpm):
cmd = 'yum -y install {0}'.format(rpm)
ret = __salt__['cmd.run'](cmd)
return ret
说明：__virtual__函数通常用来匹配是否满足该模块的环境，如果满足return出来的字符串作为该模块的名字而不是文件名，如果return的是False代表的此模块无效，不能使用。在自定义模块中可以中__grains__是一个包含了minion 所有grains的字典，__pillar__是包含了所有Pillar的grains字典,__salt__是所有可执行函数对象的字典，通常最常使用的就是这三个变量了。再往下面是定义了函数install,在salt中一般不用’%s’ %var这种格式化形式，而是使用字符串的format方法，具体使用见百度。下面就是通过__salt__执行了cmd.run这个函数来运行yum命令，很简单吧，最后把结果返回回去。
测试
salt '*' yum.install ftp ##查看返回值
自定义grains
自定义的grains也是由Python写成的，通常放在/srv/salt/_grains下，grains需要返回一个字典，__salt__,__grains__,__pillar__也是可以在grains中使用的。前面已经介绍过写简单自定义grains了，复杂就就参照https://github.com/saltstack/salt/blob/develop/salt/grains/core.py官方这个吧
自定义returner
前面已经看过官方的mysql的returner了，今天来说说自定义returner需要注意的，来个例子吧。/srv/salt/_returners/file.py内容
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
def __virtual__():
return 'file'
def returner(ret):
'''
Return information to/tmp/returns.txt.
'''
# open a file
result_file = '/tmp/returns.txt'
f = open(result_file, 'a+')
f.write(str(ret))
f.close()
程序编好后分别执行以下命令
salt '*' saltutil.sync_all ##同步模块
salt '*' test.ping --return file ##测试
cat /tmp/returns.txt ##在minion上查看
{'jid': '20131227153001246117', 'return': True, 'retcode': 0, 'success': True,'fun': 'test.ping', 'id': 'test1'}
说明：通过这个简单的例子我们了解返回的值是个字典，字典包括的项就是上面我们看到的，以后写其它returner时，也就是把这个字典的值写到不同的地方而已。这个returner的意思就是把返回的值写到各个minion的/tmp/returns.txt中。
应用实例
saltstack 远程触发文件备份、回滚
创建模块方法文件
mkdir /srv/salt/_modules
默认没有此文件，自己生成一个
下面的py文件自己定义，下面是我写的两个方法：
#!_INSX/python/bin/python
# -*- coding:UTF-8 -*-
import sys, string, shutil
import os, tarfile
import datetime, time
tn = datetime.datetime.today()
time_now = tn.strftime("%Y-%m-%d")
data_bak = '/data/databak'
data_tmp = '/data/databak/tmp/%s' % time_now
com_f = "%s/%s"% (data_bak, time_now)
if not os.path.exists(com_f):
os.makedirs(com_f)
def CpFile():
id = sys.argv[1]
dir = sys.argv[2] # 传入两个变量，任务自动生成的id与要替换的文件
filename = '%s/%s.tar' % (com_f, id)
mode = 'w:tar'
os.chdir(data_bak)
w_file = open("/tmp/tmp.list", 'w')
w_file.write(id + " " + dir) # 记录每次备份的id与相对应的备份目录或文件的路径
w_file.close()
file = tarfile.open(filename, mode)
file.add('/tmp/tmp.list')
file.add(dir)
file.close()
return 'ok' # 测试过程，就先让返回ok吧，之后再做判断
def RollBack():
id = sys.argv[1] # 想要回滚到的版本id
if not os.path.exists(data_tmp):
os.makedirs(data_tmp)
filename = '%s/%s.tar' % (com_f, id)
tar = tarfile.open("%s" % filename)
for b in tar:
tar.extract(b, path="%s" % data_tmp)
tar.close()
for line in open('%s/tmp/tmp.list' % data_tmp):
id = line.split(" ")[:1][0]
dir = line.split(" ")[1:][0] # 读取备份时的路径
backup_dir = '%s/%s' % (data_tmp, dir)
os.system('\cp -rp %s %s' % (backup_dir, dir))
return 'ok'
测试
master上同步方法脚本到节点
salt '*' saltutil.sync_all
然后先测试备份方法
salt ‘*’ cp_bakfile.CpFile 1234 /tmp/test #id + 路径上节点服务器上查看，存在
把/tmp/test下内容删除，测试回滚操作
salt '*' cp_bakfile.RollBack 1234
参考
[1] 刘天斯. Python自动化运维：技术与最佳实践[M].北京.机械工业出版社.2014.11 169-186
[2] http://outofmemory.cn/saltstack/salt
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
