Salt 是一个配置管理系统，能够维护预定义状态的远程节点（比如，确保指定的报被安装，指定的服务在运行）一个分布式远程执行系统，用来在远程节点（可以是单个节点，也可以是任意规则挑选出来的节点）上执行命令和查询数据 开发其的目的是为远程执行提供最好的解决方案，并使远程执行变得更好，更快，更简单 Saltstack（中国用户组 www.saltstack.cn ）基于 python 开发，c/s 架构，支持多平台，比 puppet 轻量，在远程执行命令时非常快捷，配置和使用比 puppet 容易，能实现 puppet 几乎所有的功能。



一、安装与简介



1.1 环境准备

准备两台安装好 epel 源的 Linux 系统，这里我们系统使用的是 centos7，如果没有的话，请进行安装

yum install -y epel-release

像批量管理工具都是 C/S 架构的，以下是用2台设备的演示步骤：

1）服务器 192.168.44.250 上安装 salt-master

yum install salt-master -y

2）客户端 192.168.44.132 上安装 salt-minion

yum install salt-minion -y



1.2 优势分析

1）salt 有 master 端和 minion 端，执行的信息比较稳定，不容易丢失信息，或者出现失联主机的情况；

2）有封装好的 http-api，我们可以直接启动 salt-api 就可以通过 http 协议进行调用。不需要自己进行第二次的封装。



1.3 秘钥认证

Master 与 Minion 认证 minion 在第一次启动时，会在 /etc/salt/pki/minion/（该路径在 /etc/salt/minion 里面设置）下自动生成 minion.pem（private key）和 minion.pub（public key），然后将 minion.pub 发送给master。

[root@V2 ~]# ll /etc/salt/pki/minion/
total 12
-rw-r--r-- 1 root root  451 Jun 29 16:24 minion_master.pub
-r-------- 1 root root 1675 Jun 29 16:24 minion.pem
-rw-r--r-- 1 root root  451 Jun 29 16:24 minion.pub

master 在接收到 minion 的 public key 后，通过 salt-key 命令 accept minion public key，这样在 master 的 /etc/salt/pki/master/minions 下的将会存放以 minion id 命名的 public key，然后 master 就能对 minion 发送指令了。

[root@V1 ~]# ll /etc/salt/pki/master/minions
total 4
-rw-r--r-- 1 root root 451 Jun 29 16:50 client-zyy

 



二、具体配置



2.1 master服务端

saltstack 的配置文件属于 YAML 格式，所以配置的时候一定注意语法

  • 每个配置行前需要有空格
  • 每个 ‘：’ 两边需要有空格
  • 数组中间加空格
  • 还有注释掉的参数不能在 # 后边加空格不然报错

配置文件 vim /etc/salt/master，进行如下编辑

1）配置监听 master地址

[root@V1 ~]# cat /etc/salt/master |grep -v ^$ |grep -v ^# |grep "interface"
interface : 192.168.44.250

2）添加自动验证

[root@V1 ~]# cat /etc/salt/master |grep -v ^$ |grep -v ^# |grep "auto_accept"
auto_accept : True

salt-master 详细配置可参照 ​​salt-master配置文件详解​​ 。



2.2 minion客户端

配置文件 vim /etc/salt/minion，进行如下编辑

1、添加master地址：master: 192.168.44.132

[root@V2 ~]# cat /etc/salt/minion |grep -v ^$ |grep -v ^# |grep "master"
master : 192.168.44.132
master_port : 4506

2、添加客户端的id，用以在服务端区分客户端机器

[root@V2 ~]# cat /etc/salt/minion |grep -v ^$ |grep -v ^# |grep "client-zyy"
id : client-zyy

 



2.3 启动服务

服务端

systemctl start salt-master

客户端

systemctl start salt-minion

 



2.4 日志文件

服务端

/var/log/salt/master

客户端

/var/log/salt/minion

 



2.5 监听端口

分别服务端和客户端查看默认监听端口 4506

[root@V1 ~]# netstat -antlp|grep 4506
tcp 0 0 xxx.xxx.xxx.xxx:4506 0.0.0.0:* LISTEN 13458/python
tcp 0 0 xxx.xxx.xxx.xxx:4506 xxx.xxx.xxx.xxx:36196 ESTABLISHED 13458/python
tcp 0 0 xxx.xxx.xxx.xxx:56328 xxx.xxx.xxx.xxx:4506 TIME_WAIT -

说明服务已正常运行。

 



2.6 确认连接

在服务端查看客户端是否已经连接成功

[root@V1 ~]# salt-key -L
Accepted Keys:
Denied Keys:
Unaccepted Keys:
Rejected Keys:

可以看到没有可用的客户端，于是我们应该在客户端上进行查看 salt-minion 端口是否启动，在这里我们看到是没有启动成功的，

[root@V2 ~]# systemctl status salt-minion
● salt-minion.service - The Salt Minion
Loaded: loaded (/usr/lib/systemd/system/salt-minion.service; disabled; vendor preset: disabled)
Active: active (running) since Fri 2018-06-29 16:27:31 CST; 3s ago
Main PID: 900 (salt-minion)
Tasks: 3
Memory: 25.2M
CGroup: /system.slice/salt-minion.service

├─900 /usr/bin/python /usr/bin/salt-minion

└─903 /usr/bin/python /usr/bin/salt-minion

Jun 29 16:27:31 V2 salt-minion[900]: [ERROR ] Error parsing configuration file: /etc/salt/minion - expected...tart>'
Jun 29 16:27:31 V2 salt-minion[900]: in "<string>", line 52, column 1:
Jun 29 16:27:31 V2 salt-minion[900]: master_port: 4506
Jun 29 16:27:31 V2 salt-minion[900]: ^
Jun 29 16:27:31 V2 salt-minion[900]: [ERROR ] Error parsing configuration file: /etc/salt/minion - expected...tart>'
Jun 29 16:27:31 V2 salt-minion[900]: in "<string>", line 52, column 1:
Jun 29 16:27:31 V2 salt-minion[900]: master_port: 4506
Jun 29 16:27:31 V2 salt-minion[900]: ^
Jun 29 16:27:32 V2 salt-minion[900]: [ERROR ] DNS lookup of 'salt' failed.
Jun 29 16:27:32 V2 salt-minion[900]: [ERROR ] Master hostname: 'salt' not found. Retrying in 30 seconds
Hint: Some lines were ellipsized, use -l to show in full.

从日志中可以看出是因为 minion 客户端没有解析 salt 主机名，于是我们在 /etc/hosts 里面添加如下

[root@V2 ~]# cat /etc/hosts
::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.44.250 salt

然后重新启动minion

[root@V2 ~]# systemctl restart salt-minion

再次在 master 服务端验证有无客户端的证书：salt-key -L

[root@V1 ~]# salt-key -L
Accepted Keys:
client-zyy
Denied Keys:
Unaccepted Keys:
Rejected Keys:

以上，基本环节已经完成，服务端已可以执行客户端的一些命令，示例如下：

[root@V1 ~]# salt '*' test.ping
client-zyy:
True

或者查看主机名命令

[root@V1 ~]# salt '*' cmd.run 'hostname'
client-zyy:
           V2



2.7 小示例

使用 ansible 安装 minion，之后用 saltstack。

saltstack的安装与常见模块的使用_数据



三、模块介绍



3.1 Runner 模块

runner 是个啥呢，runner 的写法和 execution module 的写法差不多。

不同的是，execution module 需要同步到 minions 上，然后在 minions 上面执行，

而 runner 则在 master 上直接用 salt-run 这个命令就可以调用了，而不需要同步到 minions 上面。

既然，runner 和 execution module 执行场景不同，那么显然他们操作的对象也不一样。

一个 exection module 同步到一个 minion 上之后，干好这一台机器的活就 OK 了。

而 runner 在 master 执行，它干的活，更加具有全局性，它可以使用 master 上面的一切资源，可以通过

salt 命令去间接的获取 minions 上的资源。

runner 这东西就如同 "ls /home | grep lixc" ，"ls /home" 可以理解为 master 对 minions 的一系列操作，然后返回的结果通过管道交 "grep " 。而 runner 干的活恰恰就是管道后面的活，对返回的结果做二次处理。

当然也可以用 runner 去执行一系列的任务，下面我们来试着自定义一个 runner。

1）查看 master 中配置文件的 runner 目录

[root@V1 ~]# grep '#runner_dirs' /etc/salt/master 
#runner_dirs: []

先建立一个 runners 的存放文件夹，runner 的目录可以有多个，以列表的形式存在。我们这里把目录放在 /srv/salt/_runners，如下：

[root@V1 ~]# grep '^runner_dirs' /etc/salt/master
runner_dirs: ['/srv/salt/_runners']

来看一下代码：

[root@V1 /]# cat /srv/salt/_runners/lsdir.py   
#!/usr/bin/env python
import salt.client
import re 

def lsdir(directory):
   match = re.findall(r'^(/)',directory)

   if not match:
       directory = "/%s" % directory
   client = salt.client.LocalClient(__opts__['conf_file'])
   ret  = client.cmd('*', 'cmd.run',['/bin/ls /home'],timeout=1)

   for key,value in ret.items():
       value_list = value.split('\n')
       print "\033[31m%s\033[0m" % key
       for value in value_list:
           print "\033[32m%s\033[0m" % value

执行一下，我们会得到 minions 下 /home 路径下的内容

[root@V1 /]# salt-run lsdir.lsdir home      
client-zyy
jenkins
memcached
test
web-
None

这时候我们会发现，其实实现的功能就是 salt '*' cmd.run 'ls /home'，只是我们以自定义的形式展现了出来

[root@V1 /]# salt '*' cmd.run 'ls /home'
 client-zyy:
    jenkins
    memcached
    test
    web-
    None

这样之后，我们把 runner 模块基本功能跑通了，runner 肯定不止这么点点用处了，到时候就得根据需求去用了。

 



3.2 Module 模块

模块是个啥呢？其实就是个文件。

salt模块其实分为两类

一类模块，叫 execution modules（执行模块），这一类模块是在命令行上面执行的，来个内置执行模块的链接地址：​​FULL LIST OF BUILTIN EXECUTION MODULES​​；

还有一类模块，叫 state modules（状态模块），这一类模块是在 state 里面使用的，也来个内置 state模块的链接：​​所有内置的STATE模块列表​​

先说 execution modules 执行模块是怎么写的吧。

执行模块，默认的路径在 /srv/salt/_modules 下

[root@V1 ~]# grep "#module_dirs" /etc/salt/master 
#module_dirs: <no default>
[root@V1 ~]# grep "^module_dirs" /etc/salt/master  
module_dirs : ['/srv/salt/_modules']

__salt__ 是个字典，是个啥字典呢，这个玩意，是属于 salt 全局的一个字典，只要我们定义的模块被minion 加载后，就可以用 __salt__ 了。

注意：这个 __salt__ 字典，不是在我们模块里面自己定义的，而是 salt 全局的，我们写模块的时候直接拿来用就 OK 了

OK，知道 __salt__ 是个啥之后，那个这东西里面都装了些什么玩意呢？

其实，__salt__ 这个字典里面装的 minion 上面所有的 modules 。__salt__ 的 key 是一个个的模块名称，value 则是模块里面的一个个函数。

下面咱们看个例子，看看内建模块是怎么调用的。

我们先自定义一个命名为 foo.py 的模块，很简单，传一个参数进去，然后返回一段话

[root@V1 /]# cat /srv/salt/_modules/foo.py 
#!/usr/bin/env python

def foo(name):
    return "I am {0}".format(name)

接着再自定义一个 命名为 zhou.py 的模块，目的是通过 __salt__ 调用我们上面定义的那个 foo 模块中的 foo 函数

[root@V1 /]# cat /srv/salt/_modules/zhou.py   
#!/usr/bin/env python

def zhou(name):
  return __salt__['foo.foo'](name)

然后我们同步一下模块

[root@V1 /]# salt '*' saltutil.sync_modules    
client-zyy:
    - modules.foo
    - modules.zhou

最后我们可以运行得到结果

[root@V1 /]# salt '*' zhou.zhou zyy
client-zyy:
    I am zyy

从上面的演示过程中，我们可以看出怎样调用 __salt__ 里面的模块函数，且它的使用格式如下

__salt__['模块.函数']('函数参数')

那么我们自定义的模块，怎样使用 grains，pillar，以及编写文档，还有自定义输出格式呢？请继续往下看

[root@V1 ~]# cat /srv/salt/_modules/zyy.py
#!/usr/bin/env python
__outputter__ = {
                'zyy': 'json'
                }
  '''指定输出格式,__outputter__这个东西也是个字典，
  这个字典会绑定salt中的一个方法，
  当你以 "函数名:输出格式" 这种形式加入__outputter__这个字典后，
  salt就会帮你把你指定的函数，按照指定的格式打印返回值。'''

def zyy(args):
    '''
    A function just one example
    CLI Example:
        salt '*' lisisi.lisisi args
    把这个函数的用法加到sys.doc里面的
    '''
    grain = __grains__['chengge']
    # 通过salt默认的一个字典__grains__，你想去哪个grain的时候，使用 __grains__['Id']

    pillar = __pillar__['group']
    # pillar 和 grains 一个样，__pillar__['Id']

    result = __salt__['cmd.run'](args)
    # __salt__['模块.函数']('函数参数')

    result = "{0},{1},{2}".format(grain,pillar,result)
    return  result

在实际中，我们不应该在模块中保留注释，所以我们会在去掉注释之后

[root@V1 ~]# cat /srv/salt/_modules/zyy.py 
#!/usr/bin/env python

__outputter__ = {
                'zyy' : 'json'
                }

def zyy(args):
    '''
    A function just one example
    CLI Example:
        salt '*' zyy.zyy args
    '''
    result = __salt__['cmd.run'](args)
    result = "{0}".format(result)
    return  result

然后同步一下模块到 minion 端

[root@V1 ~]# salt '*' saltutil.sync_modules
client-zyy:
    - modules.zyy

首先通过查看一下doc，看看这个函数是咋用的？

[root@V1 ~]# salt '*' -d zyy.zyy            
'zyy.zyy:'

    A function just one example
    CLI Example:
        salt '*' zyy.zyy args
    

[root@V1 ~]#

现在我们就可以执行了，传个命令运行如下

[root@V1 ~]# salt '*' zyy.zyy 'ls /tmp' 
{
    "client-zyy": "Aegis-<Guid(5A2C30A2-A87D-490A-9281-6765EDAD7CBA)>\ngitaly-ruby064629261\nhsperfdata_root\nspring.log\nspring.log.1\nspring.log.2\nspring.log.3\nspring.log.4\nspring.log.5\nspring.log.6\nspring.log.7\nsystemd-private-ad4933dd5312402ebb22b63c1e18717e-mariadb.service-efkPrn\nsystemd-private-ad4933dd5312402ebb22b63c1e18717e-ntpd.service-ETSUmn\ntomcat-docbase.2235036041880545551.3336\ntomcat-docbase.232260128623980968.3336\ntomcat-docbase.4534970583944051382.2236\ntomcat-docbase.4539933346299648069.3336\ntomcat-docbase.5766346230451110185.9002\ntomcat-docbase.7852222648457097619.3336\ntomcat-docbase.938898103132580800.3335\ntomcat.1044739914805588690.3335\ntomcat.1700777959358680247.3336\ntomcat.3118119981664415691.3336\ntomcat.3182192429944317071.3336\ntomcat.3596014754434510879.9002\ntomcat.7288634415309080614.2236\ntomcat.8453255276092695862.3336"
}

关于执行模块，官方文档中还有这么个功能，__virtual__， 这东西叫虚拟模块，具体可参看 ​​saltstack（七）modules(一)​​ 了解一下。

我们有三种方法可以同步模块

salt '*' state.highstate

salt '*' saltutil.sync_all

salt '*' saltutil.sync_modules

 



3.3 Grins 模块

grains 其实是一些静态 data，对，是数据。这个数据是个啥结构呢？是 key: value 的结构

这些数据是属于谁的？属于 minion 的，也就是说 grains 是 minion 私有的数据，和别人不搭嘎的

当 minion 启动的时候，这些数据会被加载到内存里面，然后 grains 就保持不变了，即使你添加或者修改 grains，数据也不会改变，除非你重启 minion。

当然万事总留一线，凡事总有个例外嘛，我们在 master 上面定义或者更新 grains，执行同步后，可以修改 grains，就可以不重启 minion 而达到改变 grains 的目的。

其实还有一种方法来更新 grains 的，在master上执行 salt '*' state.highstate 或者在 minion 上执行，

salt-call state.highstate 也可以更新 grains 。详细这里不赘述，具体可参考  ​​saltstack（四）grains（一）​​​和 ​​saltstack（五）grains（二）​​。

总的来说，grains 主要负责采集客户端一些基本信息, 这个也完全可以自定义，可以在客户端自定义，然后自动汇报上来；也可以从服务器端定义然后推下去，采集完后，再汇报上来。



1）打印所有 items 值

[root@V1 ~]# salt '*' grains.items
client-zyy:
    ----------
    SSDs:
    biosreleasedate:
        04/01/2014
    biosversion:
        rel-1.7.5-0-ge51488c-20140602_164612-nilsson.home.kraxel.org
    cpu_flags:
        - fpu
        - vme
        - de
        - pse
        - tsc
    ··· ···
    cpu_model:
        Intel(R) Xeon(R) CPU E5-2682 v4 @ 2.50GHz
    cpuarch:
        x86_64
    ··· ···
    id:
        client-zyy
    init:
        systemd
    ip4_interfaces:
        ----------
        docker0:
            - 192.168.0.1
        eth0:
            - xxx.xxx.xxx.xxx
        eth1:
            - xxx.xxx.xxx.xxx
        lo:
            - 127.0.0.1
        veth62589b9:
        veth6d70e12:
        veth8a157ff:
        veth911df84:
        vethaba1fd6:
        vethcd2bebc:
        vethed9f167:
    ip6_interfaces:
        ----------
        docker0:
        eth0:
        eth1:
        lo:
        veth62589b9:
        veth6d70e12:
        veth8a157ff:
        veth911df84:
        vethaba1fd6:
        vethcd2bebc:
        vethed9f167:



2）列出所有 items

[root@V1 ~]# salt '*' grains.ls
client-zyy:
    - SSDs
    - biosreleasedate
    - biosversion
    - cpu_flags
    - cpu_model
    - cpuarch
    - domain
    - fqdn
    - fqdn_ip4
    - fqdn_ip6
    - gpus
    - host
    - hwaddr_interfaces
    - id
    - init
    - ip4_interfaces
    - ip6_interfaces
    - ip_interfaces
    - ipv4
    - ipv6
    - kernel
    - kernelrelease
    ··· ···



3）查看单个 item 值

[root@V1 ~]# salt '*' grains.item shell
client-zyy:
    ----------
    shell:
        /bin/sh
[root@V1 ~]# salt '*' grains.item ipv4
client-zyy:
    ----------
    ipv4:
        - xxx.xxx.xxx.xxx
        - xxx.xxx.xxx.xxx
        - 127.0.0.1
        - 192.168.0.1



4）自定义 grains 数据



a. 在 minion 端实现

修改配置文件 /etc/salt/minion 中打开 default_include: minion.d/.conf

[root@V2 ~]# grep "^default_include" /etc/salt/minion   
default_include: minion.d/*.conf

在 /etc/salt/minion.d/ 目录中添加需要增加的 items，文件类型与配置项 .conf 对应

[root@V2 ~]# cat /etc/salt/minion.d/tomcat.conf
grains:             #开头需声明是grains
  role: 
    - tomcat
    - db
  max_con: 123

然后重启 minion，在 master 可以查看到如下（本文实验均只有一个 minion）

[root@V1 ~]# salt '*' grains.item  max_con  role
client-zyy:
    ----------
    max_con:
        123
    role:
        - tomcat
        - db

 



b. 在 master 端实现

在 /srv/salt/ 创建 _grains 目录,一般是 py 文件，编写 grains 文件，需要返回一个字典。

[root@V1 /]# cat /srv/salt/_grains/tomcat.py 
#!/usr/bin/env python

def tomcat_version():
        grains = {}
        grains['tomcat'] = '7.0.64'
        return grains

同步到 minion 端

[root@V1 /]# salt '*' saltutil.sync_modules
client-zyy:
[root@V1 /]# 
[root@V1 /]# salt '*' saltutil.sync_all
client-zyy:
    ----------
    beacons:
    grains:
        - grains.tomcat
    modules:
    output:
    renderers:
    returners:
    sdb:
    states:
    utils:

于是我们可以在 master 端查看到自定义的 grains 信息

[root@V1 /]# salt '*' grains.item tomcat
client-zyy:
    ----------
    tomcat:
        7.0.64

 



3.4 Pillar模块



1）pillar是什么？

pillar 是 salt 非常重要的一个组件，它用于给特定的 minion 定义任何你需要的数据， 这些数据可以被salt 的其他组件使用。pillar 在解析完成 后，是一个嵌套的 dict 结构；最上层的 key 是 minion ID，其 value 是该 minion 所拥有的 Pillar 数据；每一个 value 也都是 key/value。这里可以看出 Pillar 的一个特点，Pillar 数据是与特定 minion 关联的，也就是说每一个 minion 都只能看到自己的数据， 所以 Pillar 可以用来传递敏感数据 。



2）Pillar用在哪些地方？

a. 敏感数据
例如 ssh key，加密证书等，由于Pillar使用独立的加密 session，可以确保这些敏感数据不被其他minion看到。

b. 变量
可以在 Pillar 中处理平台差异性，比如针对不同的操作系统设置软件包的名字，然后在 State 中引用。

c. 其他任何数据
可以在 Pillar 中添加任何需要用到的数据。比如定义用户和UID的对应关系，mnion 的角色等。

d. 用在 Targetting 中
Pillar 可以用来选择 minion，使用 -I 选项。



3）怎样定义 Pillar 数据？

a. master 配置文件中定义

默认情况下，master 配置文件中的所有数据都添加到 Pillar 中，且对所有 minion 可用。如果要禁用这一默认值，可以在 master 配置文件中添加如下数据，重启服务后生效：

[root@V1 ~]# grep 'pillar_opts' /etc/salt/master  
# The pillar_opts option adds the master configuration file data to a dict in
#pillar_opts: False

b. 使用 SLS 文件定义 Pillar

Pillar 使用与 State 相似的 SLS 文件。Pillar 文件放在 master 配置文件中 pillar_roots 定义的目录下。示例如下，重启服务后生效：

[root@V1 ~]# egrep 'pillar_roots|base|/srv/pillar' /etc/salt/master 
pillar_roots:
  base:
    - /srv/salt/_pillar

c. 定义入口文件和数据

[root@V1 /]# cat /srv/salt/_pillar/top.sls 
base:
  '*':
    - data
[root@V1 /]# cat /srv/salt/_pillar/data.sls 
appname: website
flow:
  maxconn: 30000
  maxmen: 8G



4）如何知道 minion 拥有哪些 Pillar 数据？

在 master 上修改 Pillar 文件后，需要用以下命令刷新 minion 上的数据

[root@V1 ~]# salt '*' saltutil.refresh_pillar 
client-zyy:
    True

使用执行模块 pillar。pillar 模块有两个 funtion：pillar.data 和 pillar.raw。示例如下

[root@V1 ~]# salt '*' pillar.data            
client-zyy:
    ----------

如果定义好的 pillar 不生效，建议重启 master 端并且刷新一下试试。

[root@V1 ~]# salt '*' saltutil.refresh_pillar
client-zyy:
    True
[root@V1 ~]# salt '*' pillar.data            
client-zyy:
    ----------
    appname:
        website
    flow:
        ----------
        maxconn:
            30000
        maxmen:
            8G



5）Pillar中数据如何使用？

完成 pillar 配置后，我们可以在 state 和模板文件中引用，模板格式变量为 {{ pillar变量 }}

{{ pillar['appname'] }}           # 代表值 website
{{ pillar['flow']['maxconn'] }}   # 代表值 30000

python API格式

pillar['appname']
pillar['flow']['maxconn']



a. 操作目标主机

使用 -I，大写 i
选项表示使用 Pillar 来匹配 minion

[root@V1 ~]# salt -I 'appname:website' test.ping
client-zyy:
    True



b. 结合grains处理数据差异性

首先结合 grainx 的 id 信息来区分不同 id 的 maxcpu 和 maxmen；

修改上面的 data.sls ,语法为 jinja2 ,​​查看jinja2中文文档​​

[root@V1 /]# cat /srv/salt/_pillar/data.sls 
appname : website
ip : {{ grains['ipv4'][0] }}
flow:
  maxconn : 30000

刷新 pillar 数据，查看主机的 pillar 数据，看看是否有差异

[root@V1 _pillar]# salt \* saltutil.refresh_pillar
client-zyy:
    True
[root@V1 _pillar]# 
[root@V1 _pillar]# salt \* pillar.data ip         
client-zyy:
    ----------
    ip:
        xxx.xxx.xxx.xxx

 



3.5 cmd模块

[root@PaulV1 /]# salt '*' cmd.run 'df -h'
client-zyy:
    Filesystem      Size  Used Avail Use% Mounted on
    /dev/vda1        99G   41G   53G  44% /
    devtmpfs        7.8G     0  7.8G   0% /dev
    tmpfs           7.8G   16K  7.8G   1% /dev/shm
    tmpfs           7.8G  1.8M  7.8G   1% /run
    tmpfs           7.8G     0  7.8G   0% /sys/fs/cgroup
    /dev/vdb1        99G   27G   67G  29% /var
    tmpfs           1.6G     0  1.6G   0% /run/user/0

 



3.6 ping模块

[root@V1 /]# salt '*' test.ping -t 5            # 判断 5s 内有无响应
client-zyy:
    True

 



3.7 cp 模块

cp 模块是小型文件服务器操作的主页。 cp 模块由 Salt 状态系统 salt-cp 使用，可用于分发 Salt 文件服务器提供的文件。

详细可参照 ​​Salt文件服务器与salt-cp以及cp模块​​

 



3.8 cron模块

salt '*' cron.raw_cron root     （查看定时任务）
salt '*' cron.set_job root '*' '*' '*' '*' 1 /export/scripts/rm_log.sh 
salt '*' cron.rm_job root /export/scripts/rm_log.sh   (写全没效果)



3.9 dnsutil模块

salt '*' dnsutil.hosts_append /etc/hosts 127.0.0.1 zzz.com
salt '*' dnsutil.hosts_remove /etc/hosts zzz.com



3.10 file模块

salt '*' file.chown /etc/passwd root root
salt '*' file.copy /path/to/src /path/to/dst
salt '*' file.file_exists /etc/hosts
salt '*' file.directory_exists /etc/
salt '*' file.get_mod /etc/passwd
salt '*' file.set_mod /etc/passwd 0644
salt '*' file.mkdir /tmp/test
salt '*' file.sed /export/servers/nginx/conf/nginx.conf 'debug' 'warn'
salt '*' file.append /tmp/test.txt "welcome xiang"
salt '*' file.remove /tmp/1.txt



3.11 network模块

salt '*' network.dig www.qq.com
salt '*' network.ping www.qq.com
salt '*' network.ip_addrs



3.12 pkg包管理模块

# 管理yum， apt-get等
salt '*' pkg.install php
salt '*' pkg.remove php
salt '*' pkg.upgrade    （升级所有的软件包）



3.13 service模块

salt '*' service.enable nginx
salt '*' service.disable nginx
salt '*' service.restart nginx

 

 



参考资料

1. ​​elasticsearch报错expected <block end>, but found BlockMappingStart解决方法​​

2. ​​salt-master配置文件详解​​

3. ​​saltstack（十一）runners​​

4. ​​saltstack（七）modules(一)​​

5. ​​saltstack（四）grains（一）​​

6. ​​saltstack（五）grains（二）​​

7. ​​salt实战系列-grains和pillar学习 作者：撸大师​​

8. ​​saltstack管理八之常用执行模块​​

9. ​​SALT文件服务器​​

10. ​​Salt文件服务器与salt-cp以及cp模块​​