安装： salt \'*‘ state.high ’{“vim”: {“pkg”: [“installed”]}}\' salt \'*\' state.single pkg.installed name=vim 卸载： salt \'*‘ state.high ’{“vim”: {“pkg”: [“removed”]}}\' salt \'*\' state.single pkg.removed name=vim 升级： salt \'*‘ state.high ’{“vim”: {“pkg”: [“latest”]}}\' salt \'*\' state.single pkg.latest name=vim
##minion端版本最好一致！，不然会收不到版本差异的minion数据
Master端安装：
SaltStack@Master: rpm -vih http://mirrors.zju.edu.cn/epel/6/i386/epel-release-6-8.noarch.rpm
SaltStack@Master: yum install salt-master -y
SaltStack@Master: service salt-master start
Minon端安装：
SaltStack@Minion: rpm -vih http://mirrors.zju.edu.cn/epel/6/i386/epel-release-6-8.noarch.rpm
SaltStack@Minion: yum install salt-minion -y
SaltStack@Minion: sed -i \'s/#master: salt/master: IPADDRESS/g\' /etc/salt/minion #IPADDRESS
SaltStack@Minion: service salt-minion start
测试被控主机的连通性
salt \'*\' test.ping
远程命令执行测试
salt \'*\' cmd.run \'uptime\'
根据被控主机的grains信息进行匹配过滤
salt -G \'os:Windows\' test.ping
显示被控主机的操作系统类型
salt \'*\' grains.item os
远程代码执行测试
salt \'*\' cmd.exec_code python \'import sys; print sys.version\'
列出当前版本支持的模块
salt \'*\' sys.list_modules
##如果编写了
salt \'*\' cp.list_master 查看自定义的调用cp 模块是否生效
#文件下发，只支持文件。不支持目录
salt-cp "minion1" /root/docker.sh e:/
------------------------------------------------------------------------------------------------
基本操作命令
#正则匹配
salt -E \'min*\' test.ping
#列表匹配
salt -L minion1,minion2 test.ping
###Grians Minion的Grains的键值对
salt -G \'os:windows\' test.ping
#组匹配
需要在配置文件中定义
nodegroups:
groups: \'L@Minon,Minion1
salt -N groups test.ping
#复合匹配
SaltStack@Master: salt -C \'G@os:MacOS or L@Minion1\' test.ping
Minion:
True
Minion1:
True
#指定IP网段匹配
salt -S \'192.168.23.0/24\' test.ping
pillar值匹配
key:value是Pillar系统中定义的一组键值对，
SaltStack@Master: salt -I \'key:value\' test.ping
Target参数
也就是正则匹配
# Grains是SaltStack组件中非常重要的组件之一，记录的是一些minion静态信息，常用属性等,如CPU,内存,网络等等
查看静态信息
salt \'minion1\' grains.items
查看grains相关模块
salt \'minion1\' sys.list_functions grains
查看granis帮助文档
salt \'minion1\' sys.doc grains
查看自定义的granis 角色(可以自定制--在minion文件中增加grains )
salt \'minion2\' grains.item roles
##自定义的granis
salt \'minion5\' grains.item roles Webserve
##Pillar也是saltstack组件中非常重要的组件之一,是数据管理中心,主要是存储和定义配置管理数据, 软件版本号,密码
#默认工作目录在master配置文件有写,/srv/pillar
cat /srv/pillar/top.sls
base ： # 指定环境
\'*\': #Target
- packages # 引用 packages.sls 或者 packages/init.sls
- services # 引用 services.sls 或者 services/init.
#查看pillar相关的模块
salt \'minion1\' sys.list_functions pillar
#查看module列表
salt \'minion1\' sys.list_modules
#查看指定module的function方法
salt \'minion1\' sys.list_functions user
#查看指定module的详细方法--很强大
salt \'minion1\' sys.doc user.info
#查看minion所支持的所有states列表
salt \'minion1\' sys.list_state_modules
#查看指定minion的states function方法
salt \'minion1\' sys.list_state_functions
#查看states详细用法
salt \'minion1\' sys.state_doc file.copy
#刷新自定义的states文件
salt \'*\' saltutil.refresh_pillar
#编写states.sls （top.sls是states系统的入口文件）
- source: salt://test/123/1.txt # 源路径 salt:// == /srv/salt
#查看return 列表
salt \'minion1\' sys.list_returners
###Return是在Master端触发任务，然后Minion接受处理任务后直接与Return存储服务器建立连接，
然后把数据Return存到存储服务器。关于这点大家一定要记住，因为这个过程都是Minion端操作存储
服务器，所以要确保Minion端的配置跟依赖包是正确的。
因此是minion直接操作redis服务器,
所以需要在minion端安装redis 客户端,修改minion的配置文件
redis.db: \'0\' #redis 数据库
redis.host: \'vps.shencan.net\' #redis 主机 (ip 地址和域名都行)
redis.port: 6379 #redis 端口
[JOB管理]
在salt 里面执行任何一个操作都会在master上产生一个jjd号,
Minion端会在cache目录下
的proc目录创建一个以jid为名称的文件，这个文件
里面的内容就是此次操作的记录，当操作处理完成
后该文件会自动删除。而Master端会记录每次操作
的详细信息，这个记录都是存到在Master端cache
目录下jobs下
##查看job管理的一些用法
salt-run -d | grep jobs
jobs.active: 查看当前正在运行的jobs
jobs.list_job: 指定jjd查看jobs详细信息
jobs.list_jobs: 查看所有jobs信息
jobs.lookup_jid: 指定 jid 查询 jobs 结果
jobs.print_job: 指定 jid 查询 jobs 详细
----示例:
#查看所有minion当前正在运行的jobs（在所有minions上运行saltutil.running）
## salt-run jobs.active
#
#
#从master jobs cache中查询指定jid的运行结果
#salt-run jobs.lookup_jid <jid>
#列出当前master jobs cache中所有job
# salt-run jobs.list_jobs
#查看salt自带的module来管理job
salt \'minion1\' sys.doc saltutil | grep job
salt \'*\' saltutil.find_cached_job <job id> 查看job cache信息
alt \'*\' saltutil.find_job <job id> 查看job信息
saltutil.kill_job 杀掉job(发送sigterm 9 信号)
saltutil.signal_job 发送指定信号
saltutil.term_job: 删除job(发送sigterm 15 信号)
#检查salt minion 是否存活
salt-run manage.status
示例:
[root@linux-node1 salt]# salt \'minion5\' cmd.run \'sleep 500\'
^C
[root@linux-node1 salt]# salt \'minion5\' saltutil.find_job 20170421102314172550
minion5:
----------
arg:
- sleep 500
fun:
cmd.run
jid:
20170421102314172550
pid:
20182
ret:
tgt:
minion5
tgt_type:
glob
user:
root
接下来测试kill掉这个job
[root@linux-node1 salt]# salt \'minion5\' saltutil.kill_job 20170421102614208854
minion5:
Signal 9 sent to job 20170421102614208854 at pid 20234
示例2：
#top是入口
[root@linux-node1 states]# cat top.sls
base:
\'minion1\':
- init.cpfile
\'minion5\':
- one
[root@linux-node1 states]# cat one.sls
/root/foo.conf: #这个目录是minion的目录！并不是你master的目录！！注意空格
file.managed:
- source: salt://conf/nginx.conf
- user: root
- group: root
- mode: 777
[root@linux-node1 states]# salt \'minion5\' state.sls one 执行
[Event]
vent是SaltStack里面的对每个事件的一个记录，它相比job更加底层，Event能记录更加详细的
SaltStack事件，比如Minion服务启动后请求Master签发证书或者证书校验的过程，都能通过Event事
件来查看整个过程。Event也为扩展SaltStack提供了更加友好的接口。目前官方已经列出一些Event事
件，包括认证，Minion连接Master，key认证，job等
#查看event事件
salt-run state.event pretty=True
[Reactor]
Reactor是基于Event的每个事件来做相应的操作（states）。我们可以理解
Reactor系统是一直监听着Event，然后触发一些States操作
[Renderer]
Renderer默认是YAML+jinja
【YAML】
YAML的语法很简单，
结构通过空格来展示，项目使用“-”来代表，
键值对使用“：”分割
规则一: 缩进
SaltStack需要每个缩进级别由两个空格组成
规则二: 冒号
字典的key在YAML中的表现形式是一个以冒号结尾的字符串
my_key: my_value
另一种选择:
value可以通过缩进与key联接
my_key:
my_value
规则三: 短横杠
要表示列表项，使用一个短横杠加一个空格
多个项使用同样的缩进级别作为同一列表的一部分
- list_value_one
- list_value_two
- list_value_three
列表可以作为一个键值对的value，比如我们一次性安装多个软件包
my_dictionary:
- list_value_one
- list_value_two
- list_value_three
最后再强调一下冒号后面都有一个空格（表示路径的除外）！！！！！！！！！！！！
【Jinja】
jinjia是基于python的模板引擎
Salt默认使用yaml_jinja渲染器。yaml_jinja的流程是先用jinja2模板引擎处理SLS，然后再调用YAML解析器。所以
在开始解析YAML之前，你可以使用jinja干一些你想干的事情。
[jinja]基本使用
三个步骤:
1）File状态使用template参数-template: jinja。
2）模板文件里面变量使用{{名称}}，比如 {{PORT}}
3）File状态模块要指定变量列表：
- defaults:
PORT: 8080
Jinja变量使用Grains
{{ grains[\'fqdn_ip4\'] }}
Jinja变量使用执行模块:
{{ salt[\'network.hw_addr\'](\'eth0\') }}
Jinja变量使用Pillar：
{{ pillar[\'apache\'][\'PORT\'] }}
[jinjia]逻辑关系
{% if grains[\'os\'] == \'RedHat\' %}
apache: httpd
{% elif grains[\'os\'] == \'Debian\' %}
apache: apache2
{% endif % }
salt \'*\' state.highstate test=True #模拟运行
实例操作:zabbix-agentd安装
/srv/salt/base/init
[root@node1 init]# vim zabbix_agent.sls
zabbix_agent: #id
pkg.installed: #安装包
- name: zabbix22-agent #安装zabbix22-agent
file.managed: #文件模块
- name: /etc/zabbix_agentd.conf # 所管理的配置文件 ，那个名称的意思应该是相对应file上面的插件而言
- source: salt://init/files/zabbix_agentd.conf #salt分发minion端文件
- user: root #用户
- group: root #用户组
- mode: 644 #权限
service.running: #服务模块
- name: zabbix-agentd #服务名
- enable: True #开机启动
- restart: True #文件修改重启
- watch: #重启服 务
- file: zabbix_agent #重启zabbix_agent内服务
#salt \'minion[5-6]\' state.sls init/zabbix_agent state.sls默认的运行环境是base环境，但是它并不读取top.sls
#state.highstate: 这个是全局的所有环境，以及所有状态都生效。它会读取每一个环境的top.sls，并且对所有sls都生效
r
自定义grains
自定义的grains并不是直接放在minion上，而是放在master配置文件中定义的file_roots下的_grains目录中。执行state.highstate，saltutil.sync_grains，saltutil.sync_all时，会将_grains中的文件分发到客户端上。
假定file_roots为/srv/salt/base，增加自定义grain的操作如下：
# mkdir /srv/salt/base/_grains/
##minion启动时，会执行grains包所带的模块及自定义grains模块中的函数，返回的结果就是grains。
grains模块中的函数必须返回一个dict，其中key是grains的名字，value是值。
如果自定义module 那就需要在/srv/salt/base/_modules/ 下编写
SaltStack@Master: salt ‘ * ’ state.highstate Minion01 ：
SaltStack@Master: salt \* pillar.get master:environment #
SaltStack@Master: salt \* state.sls cpis1 saltenv=stage #制定运行state运行环境
道Salt本身的操作实际上在底 层都是以一个消息来传输并解析执行的
实际上API要做的也就是模拟一个消息并发送到该发送的地方
Python API实际上就是提供了一个程序的接口，让大家可以很容易地通过这个接口来给SaltStack发送消息
Python API实际上就是提供了一个向SaltStack发送命令的入口
API：
获取master配置信息
# 导入 saltstack 的配置模块
import salt.config
# 读取 saltstack 的配置 文件 (/ etc/salt/master) 并赋值给 master_opts
master_opts = salt.config.client_config(\'/etc/salt/master\')
# 查看 master_opts 的属性
>>> dir(master_opts)
[\' — class — \', \' — cmp — \', \' — contains — \', \' — delattr — \', \'
# 查看 master_opts 的类型
>>> type(master_opts)
<type \'dict\'>
# 以字典形式打印
>>> print dict(master_opts)
获取minion配置信息
# 导入 salt 客户端
>>> import salt.client
# 获取客户端配置 , 并赋值给 minion_opts
>>> minion_opts = salt.config.minion_config(\'/etc/salt/minion\')
# 查看 minion_opts 的属性
>>> dir(minion_opts)
[\' — class — \', \' — cmp — \', \' — contains — \', \' — delattr — \', \'
# 查看 minion_opts 类型
>>> type(minion_opts)
<type \'dict\'>
# 查看 minion_opts 的 key
>>> minion_opts.keys()
[\'cython_enable\', \'mysql.user\', \'sls_list\', \'log_level\', \'acceptance_wait_time\', \'recon_default\',
#key 太多 , 省略若干行
\'rejected_retry\', \'state_events\', \'mysql.host\', \'pki_dir\', \'win_repo_cachefile\', \'ipc_mode\', \'keysize\', \'log_file\']
>>> print minion_opts[\'user\']
salt.client来执行模块
>>> import salt.client
>>> local=salt.client.LocalClient()
>>> local.cmd(\'minion5\',\'cmd.run\',[\'whoami\'])
{\'minion5\': \'root\'}
>>> local.cmd(\'minion5\',\'cmd.run\',[\'ifconfig\'])
# 导入 saltstack 的配置模块
import salt.config
# 读取 saltstack 的配置 文件 (/ etc/salt/master) 并赋值给 master_opts
master_opts = salt.config.client_config(\'/etc/salt/master\')
# 查看 master_opts 的属性
>>> dir(master_opts)
[\' — class — \', \' — cmp — \', \' — contains — \', \' — delattr — \', \'
# 查看 master_opts 的类型
>>> type(master_opts)
<type \'dict\'>
# 以字典形式打印
>>> print dict(master_opts)
{\'cython_enable\': False, \'reactor\': [],
\'interface\': \'127.0.0.1\', \'jinja_lstrip_blocks\': False}
# 查看 minion_opts 的 key
>>> minion_opts.keys()
>>> print minion_opts[\'user\']
#我们已经可以获取到minion中的配置信息了
minion端可以用来直接在minions上执行命令或者也可以用来写returnner的时候获取minion的grain信息等
import salt.client caller = salt.client.Caller() caller.sminion.functions[\'cmd.run\'](\'ls -l\')
获取grains的信息
import salt.client caller = salt.client.Caller() caller.sminion.functions[\'grains.items\'] #grains.items代表获取全部的grains信息 caller.sminion.functions[\'grains.item\'](\'os\') #想要特定的grains信息用grains.item然后在后面指
1.localClient
这个接口只能在salt master本机调用
cmd(tgt, fun, arg=(), timeout=None, expr_form=\'glob\', ret=\'\', jid=\'\', kwarg=None, **kwargs)
##示例:local.cmd(\'*\', [\'grains.items\',\'sys.doc\',\'cmd.run\',],[[],[],[\'uptime\'],])
支持一次执行多个模块命令，一次对多个模块进行调用时，需要arg和fun都是一个列表，而且两者的顺序要一一对应
·tgt：即为target，执行该命令的目标机器、字符串或列表。
·fun：字符串或列表，执行的模块
arg：列表或者一个由列表组成的列表，对应模块的参数。
·timeout：Minion返回的超时时间。
·expr_from：匹配模式，可选项：glob、pcre、list、grain、grain_pcre、pillar、pillar_pcre、noegroup、range、compound，前面已经具体介绍过。
·ret：使用的returner，一个或者多个returner（多个用逗号隔开）。
·kwarg：方法的字典形式参数。
·kwargs：可选的参数。
#异步执行
cmd_async(tgt, fun, arg=(), expr_form=\'glob\', ret=\'\', jid=\'\', kwarg=None, **kwargs)
参数与cmd参数基本类似,差异在于该函数执行后立即返回该任务的jid,任务会在后台执行，后续可以通过jid来获取任务信息
#批量执行
cmd_batch(tgt, fun, arg=(), expr_form=\'glob\', ret=\'\', kwarg=None, batch=\'10%\', **kwargs)
示例
eturns = local.cmd_batch(\'*\', \'state.highstate\', bat=\'10%\')
>>> for return in returns:
... print return
#逐个返回结果
cmd_iter(tgt, fun, arg=(), timeout=None, expr_form=\'glob\', ret=\'\', kwarg=None, **kwargs)
示例:
>>ret = local.cmd_iter(\'*\', \'test.ping\')
>> for i in ret:
... print i
#逐次返回结果，如果没有结果继续等待
cmd_iter_no_block(tgt, fun, arg=(), timeout=None, expr_form=\'glob\', ret=\'\', kwarg=None, **kwargs)
跟cmd_iter的区别在于，当没有minion返回结果时，返回值依然有值，不过是空值
示例:
>>> ret = local.cmd_iter_no_block(\'*\', \'test.ping\')
>>> for i in ret:
... print i
随机执行--没什么用
cmd_subset(tgt, fun, arg=(), expr_form=\'glob\', ret=\'\', kwarg=None, sub=3, cli=False, progress=False, **kwargs)
sub为一次执行命令的客户端数量
随机在部分Minion上执行命令
执行命令
run_job(tgt, fun, arg=(), expr_form=\'glob\', ret=\'\', timeout=None, jid=\'\', kwarg=None, **kwargs)
异步向Minion发送一个命令，此函数在上面的函数中基本都有用到：
Salt Caller
Salt Caller的功能是在Minion端通过API调用SaltStack，salt-call（/usr/bin/salt-call）后端调用的就是这个接口。
caller.cmd(\'test.ping\') # 为了保持与其他 client 的一致性 , 在 *Beryllium*
caller.function(\'test.ping\') # 早期版本不支持 caller.cmd
RunnerClient
RunnerClient的功能是在Master端通过Python调
用runner（调用此接口的系统用户需与运行Master
的用户一致）。salt-run后端调用的是这个接口。
>>> import salt.config
>>> opts = salt.config.master_config(\'/etc/salt/master\')
>>> runner = salt.runner.RunnerClient(opts)
>>> runner.cmd(\'jobs.list_jobs\', [])
通过external_auth异步执行如下所示：
>>> import salt.config
>>> opts = salt.config.master_config(\'/etc/salt/master\')
>>> runner = salt.runner.RunnerClient(opts)
>>> runner.cmd_async({
\'fun\': \'jobs.list_jobs\',
\'username\': \'saltdev\',
\'password\': \'saltdev\',
\'eauth\': \'pam\',
})
WheelClient
为SaltStack wheel模块提供的程序接口（调用
此接口的系统用户需与运行Master的用户一致）
>>> opts = salt.config.master_config(\'/etc/salt/master\')
>>> wheel = salt.wheel.Wheel(opts)
>>> wheel.call_func(\'key.list_all\')
{\'local\': [\'master.pem\', \'master.pub\'],
\'minions\': [\'minion1\', \'minion2\', \'minion3\'],
\'minions_pre\': [],
\'minions_rejected\': []}
saltstack API使用
1).# 环境准备 , 建议对 salt-api 使用 HTTPS, 生成签名证书 ; 这里我们通过
yum install gcc make python-devel libffi-devel
pip install PyOpenSSL
2).生成证书
#这里需要注意.因为salt-call是minion端的命令，所以你需要在minion端生成这个证书。然后在传输到master端 在master端上装minion也行
salt-call tls.create_self_signed_cert
local:
Created Private Key: "/etc/pki/tls/certs/localhost.key." Created Certificate: "/etc/pki/tls/certs/localhost.crt."
#在master端安装api
yum install -y salt-api
3）.配置用户权限
cat /etc/salt/master.d/eauth.conf
external_auth:
pam: # 认证模式，这里 pam 用 Linux 本身的用户认证模式，
saltapi: # 用户名
- . # 用户权限
- \'@wheel\'
- \'@runner\'
# 添加用户
useradd -M -s /sbin/nologin saltapi
echo "spassword" | passwd saltapi --stdin
由于API可以被远程调用，所以这里会牵涉限
制的问题，接近常用的方式就是引入认证，
SaltStack支持多种认证，这里我们借助于系统自带
的认证：PAM。
4）.配置salt-api
# cat /etc/salt/master.d/api.conf
rest_cherrypy:
port: 8000
ssl_crt: /etc/pki/tls/certs/localhost.crt # 使用前面生成的证书
ssl_key: /etc/pki/tls/certs/localhost.key
5）.启动服务
/etc/init.d/salt-api restart
Stopping salt-api daemon: [FAILED]
Starting salt-api daemon: [ OK ]
# netstat -lnp | grep 8000
tcp 0 0 0.0.0.0:8000 0.0.0.0: LISTEN
27818/python2.6
6）.测试
[root@linux-node1 ~]# curl -X POST -k https://192.168.29.72:8000/login -d username=\'saltapi\' -d password=\'spassword\' -d eauth=\'pam\' | python -mjson.tool
##其中 token 后边的串为认证成功后获取的token串，之后可以不用再次输入密码，直接使用本Token即可
通过Restful API实现日常操作
1）运行远程模块。
2）查询指定job。
3）运行runner
模板方法:
curl -k https://10.0.2.118:8000/ \
-H "Accept: application/json" \ # 返回信息格式 , 默认 json,
-H "X-Auth-Token: eb74373815d94624d3dd05016432a1b385fa43e9" \ #
-d client=\'local\' \ # 调用的底层 salt 模块
-d tgt=\'*\' \ #target, 如果不使用默认匹配模式 (glob), 添加
-d fun=\'test.ping\' \ # 执行函数
| python -mjson.tool #Json 格式化输出
1.远程执行模块
curl -k https://192.168.29.72:8000/ -H "Accept: application/json" -H "X-Auth-Token: 0e827785dccd22163d025a71c0045771a06beff8" -d client=\'local\' -d tgt=\'*\' -d fun=\'test.ping\'| python -mjson.tool
2.查询制定job
通过jid来获取任务详细信息
curl -k https://192.168.29.72:8000/jobs -H "X-Auth-Token: 0e827785dccd22163d025a71c0045771a06beff8" -d client=\'local\' -d tgt=\'*\' -d fun=\'test.ping\'| python -mjson.tool
return": [
{
"20150503173832332733": {
"Arguments": [], # 任务参数
"Function": "test.ping", # 任务调用行数
"StartTime": "2015, May 03 17:38:32.332733",
"Target": "*", # 任务对象
"Target-type": "glob", # 匹配类型
"User": "root" # 执行用户
}
获取jid后,即可获得该任务详细信息
curl -k https://192.168.29.72:8000/jobs/20170503160855059500 -H "X-Auth-Token: 0e827785dccd22163d025a71c0045771a06beff8" | python -mjson.tool
3.运行runner
curl -k https://192.168.29.72:8000/jobs/ -H "X-Auth-Token: 0e827785dccd22163d025a71c0045771a06beff8" -d client="runner" -d fun="manage.status" | python -mjson.tool
Salt SSH
通过SaltSSH的执行速度会远远低于ZeroMQ支持的标准的Salt通信方式。
yum install -y salt-ssh
Salt SSH，控制服务器就需要这些。SaltStack使用Rosters来管理这些数据。
默认情况下Roster文件本地路径为：/etc/salt/roster。
Roster系统编译了一个内部数据结构，称为Targets
<SaltID>: # 目标 ID
host: # 远程主机的 IP 地址或者主机名
user: # 可以登录的用户
passwd: # 可以登录用户的密码
# 可选参数
port: # SSH 端口
sudo: # 是否运行 sudo, 设置 True 或者 False
priv: # SSH 私钥的路径 , 默认是 salt-ssh.rsa
timeout: # 连接 SSH 时的超时时间
thin_dir: # 目标系统 Salt 的存储路径，默认是 /tmp/salt-<hash>
1.Salt SSH Target
相对于C/S模式，salt-ssh在Target中还有一定的
局限性，目前支持如下匹配模式：
-E--pcre正则匹配
-L--list列表匹配
-G--grain grains匹配--grain-pcre grains加正则匹
配
-N--nodegroup组匹配
-R--range范围匹配
2.命令执行
默认情况下salt-ssh可以直接在远程系统上运行
Salt执行模块。通过salt-ssh也可以直接执行原始
shell命令：
[root@saltstack-node1 ~]# salt-ssh \'*\' -r \'ifconfig\'
该命令基本等同于salt‘*’cmd.run‘ifconfig’执行
其他模块时也类似，如salt-ssh‘*’disk.usage。
3.状态管理
salt-ssh命令可以直接使用Salt状态管理系统。
使用时将salt命令直接替换为salt-ssh即可：
[root@saltstack-node1 ~]# salt-ssh \'*\' state.sls salt.init_repo
上面的命令基本等同于"salt\'*\'state.sls salt.init_repo
排错方法
停掉SaltStack的Minion服务：
[root@localhost ~]# service salt-minion stop
Stopping salt-minion daemon:
以debug形式启动Minion服务：
[root@localhost ~]# salt-minion -l debug
自定义grains模块后需要
1)同步grains模块
salt \'*\' saltutil.sync_all
2)刷新模块(让minion编译模块)
salt \'*\' sys.reload_modules
自定义pillar信息
我们需要在Master配置文件中定义ext_pillar接口脚本存放路径，以及引用这个ext_pillar：！！！！！！！！！！！！
extension_modules: /srv/salt/modules/
ext_pillar:
- salt: []
这里ext_pillar接口的脚本就叫做salt.py，脚本的路径是在/srv/salt/modules/pillar/目录下，也就是extension_modules定义的pillar目录下
扩展modules模块##当写完模块后，需要salt \'*\' saltutil.sync_modules 把自定义模块同步到minion端，
/srv/salt/_modules/test.py
def foo():
return __salt__[\'cmd.run\'](\'df\')
所有的模块都包含在__salt__字典里面，我试试执行cmd.run "df",看看结果：
或者可以这样使用传参的方式
def foo(w):
cmd = \'{0}\'.format(w)
return __salt__[\'cmd.run\'](cmd)
##__grains__ 和 __pillar__ 保存了grains和pillar的数据，我们可以在module或者扩展pillar中这样来读取
EVENT事件用法:
SaltStack reactor系统可以根据 你这台新部署的机器来请求签售证书开始 到自动给他部署
SaltStack reactor系统先会扑捉 签证的这一个过程(因为有一个新的event) 然后自动给他签证(这个地方你可以根据id 来判定是否要给它签证) 然后自动扑捉master检测minion启动服务这一个event 然后自动给minion 推送states(可以在设计states的时候 根据角色来include一些states) 甚至你还可以扑捉 删除key的event 然后调用一些脚本去做其他事情 你懂的。。
今天只要是个大家讲解了 reactor系统的一个流程 原理 ，只要熟悉这个东西之后 才能结合自己的业务 把它应用到你们业务之中去。 下面我就简单 做个demo吧
建议大家先在配置reactor系统之前 玩玩这个命令 (了解一下events)
salt-run state.event pretty=True
然后你就会看到整个过程
接来下来咱们使用这个reactor
修改master配置文件.
##自定义grains是在msater发生脚步然后在minion端执行的操作