您的位置:新葡亰496net > 服务器网络 > 新葡亰496net火速入门教程,赶快入门SaltStack

新葡亰496net火速入门教程,赶快入门SaltStack

发布时间:2019-06-18 08:50编辑:服务器网络浏览(194)

    Saltstack 快速入门教程,Saltstack入门教程

    目录

    • saltstack简介
    • 安装saltstack
    • grains&pillar
    • 管理对象Target
    • 配置管理States
    • 自定义module
    导读 SaltStack是基于Python开发的一套C/S架构配置管理工具(功能不仅仅是配置管理,如使用salt-cloud配置AWS EC2实例),它的底层使用ZeroMQ消息队列pub/sub方式通信,使用SSL证书签发的方式进行认证管理。号称世界上最快的消息队列ZeroMQ使得SaltStack能快速在成千上万台机器上进行各种操作。

    简述

    saltstack

    • saltstack是一个新的基础平台管理工具,只需要花费数分钟即可运行起来,可以支撑管理上万台服务器的规模,数秒钟即可完成数据传递。
    • saltstack是使用python语言开发的,同时也支持restAPI方便二次开发以及和它平台集成,同时官方也发布了一个Web管理界面halite。

    优点:

    • 首先,他速度快,基于消息队列 线程,跑完多台设备,都是毫秒级别的
    • 其次,非常灵活,源码是python,方便理解和自定义模块(python 语言相对于其他的perl、ruby等还是很好理解的)
    • 命令简单,功能强大

    saltstack运行方式

    • Local
    • Master/Minion
    • Salt SSH

    本文使用Master/Minion运行方式。

    saltstack三大功能

    • 远程执行
    • 配置管理
    • 云管理

    saltstack数据系统

    • Grains (静态数据)
    • pillar (动态数据)

    saltstack配置管理

    • SLS(YAML、Jinja)
    • Highstate
    • States Module

    自动化工具比较

    Puppet也许是四款工具中最深入人心的。就可用操作、模块和用户界面而言,它是最全面的。Puppet呈现了数据中心协调的全貌,几乎涵盖每一个运行系统,为各大操作系统提供了深入的工具。初始设置比较简单,只需要在需要加以管理的每个系统上安装主服务器和客户端代理软件。命令行接口(CLI)简单直观,允许通过puppet命令下载和安装模块。然后,需要对配置文件进行更改,好让模块适合所需的任务;应接到指令的客户端与主服务器联系时,会更改配置文件,或者客户端通过立即触发更改配置文件的推送(push)来进行更改。

    Ansible关注的重点是力求精简和快速,而且不需要在节点上安装代理软件。因此,Ansible通过SSH执行所有功能。需要管理的节点被添加到Ansible配置环境,SSH授权密钥被附加到每个节点上,这与运行Ansible的用户有关。一旦完成了这步,Ansible主服务器可以通过SSH与节点进行通信,执行所有必要的任务。Ansible可以使用Paramiko(基于SSH2协议的Python实现)或标准SSH用于通信,不过还有一种加速模式,允许更快速、更大规模的通信。

    Salt类似Ansible,因为它也是基于CLI的工具,采用了推送方法实现客户端通信。它可以通过Git或通过程序包管理系统安装到主服务器和客户端上。客户端会向主服务器提出请求,请求在主服务器上得到接受后,就可以控制该客户端了。Salt可以通过普通的SSH与客户端进行通信,但如果使用名为minion的客户端代理软件,可以大大增强可扩展性。此外,Salt含有一个异步文件服务器,可以为客户端加快文件服务速度,这完全是Salt注重高扩展性的一个体现。与Ansible一样,你可以直接通过CLI,向客户端发出命令,比如启动服务或安装程序包;你也可以使用名为state的YAML配置文件,处理比较复杂的任务。还有“pillar”,这些是放在集中地方的数据集,YAML配置文件可以在运行期间访问它们。

    总结:个人观点puppet最大缺点就是默认情况下Agent每隔30分钟向master同步状态,master主动推送功能比较薄弱(2.7版本),ansible基于SSH服务执行,如果服务器过多不建议使用,他是使用轮训的方式。Salt基于消息队列。性能相当好,适合大量生产环境。

    Saltstack 快速入门教程

    saltstack简介

    新葡亰496net 1

    实现环境

    准备三台机器,这三台机器都关闭 selinux,清空防火墙规则。

    • saltstack ==> 172.16.0.19 (服务端)
    • client1 ==> 172.16.0.20 (客户端)
    • client2 ==> 172.16.0.21 (客户端)

    查看版本和内核

    [root@saltstack ~]# cat /etc/RedHat-release
    CentOS Linux release 7.3.1611 (Core) 
    [root@saltstack ~]# uname -rm
    3.10.0-514.6.1.el7.x86_64 x86_64
    

    分别设置 hostname,设置完毕xshell注销重新连接一下

    [root@saltstack ~]# hostnamectl set-hostname saltstack
    [root@client1 ~]# hostnamectl set-hostname client1
    [root@client2 ~]# hostnamectl set-hostname client2
    

    编辑 hosts 文件
    每台都设置,若机器太多,可以通过搭建 DNS,则不用在每台机器上设置这个

    [root@saltstack ~]# vi /etc/hosts
    添加下面内容
    172.16.0.19 saltstack
    172.16.0.20 client1
    172.16.0.21 client2
    

    SaltStack简介与特性

    SaltStack 是一种基于 C/S 架构的服务器基础架构集中化管理平台,管理端称为 Master,客户端称为 Minion。SaltStack 具备配置管理、远程执行、监控等功能,一般可以理解为是简化版的 Puppet 和加强版的 Func。SaltStack 本身是基于 Python 语言开发实现,结合了轻量级的消息队列软件 ZeroMQ 与 Python 第三方模块(Pyzmq、PyCrypto、Pyjinjia2、python-msgpack 和 PyYAML 等)构建。

    通过部署 SaltStack 环境,运维人员可以在成千上万台服务器上做到批量执行命令,根据不同的业务特性进行配置集中化管理、分发文件、采集系统数据及软件包的安装与管理等。

    1.介绍

    Saltstack 比 Puppet 出来晚几年,是基于Python 开发的,也是基于 C/S 架构,服务端 master 和客户端 minions ;Saltstack 和 Puppet 很像,可以说 Saltstatck 整合了 Puppet 和 Chef 的功能,更加强大,更适合大规模批量管理服务器,并且它比 Puppet 更容易配置。 三大功能: 远程命令执行,配置管理(服务,文件,cron,用户,组),云管理。

    什么是saltstack?

    Saltstack开源项目始于2011年,使用Python开发的一套C/S架构的运维工具,由Master和Minion组成,通过ZeroMQ进行通信。
    项目地址: https://github.com/saltstack/salt
    官网地址: http://www.saltstack.com
    官方文档: http://docs.saltstack.com OR http://docs.saltstack.cn
    开发语言: Python
    运行模式: C/S

    而且采用RSA Key方式确认身份,传输采用AES加密,这使得它的安全性得到了保障。SaltStack经常被描述为Func加强版 Puppet精简版。

    开始安装

    分别为三台机器添加阿里云epel源

    [root@saltstack ~]# mv /etc/yum.repos.d/epel.repo /etc/yum.repos.d/epel.repo.backup
    [root@saltstack ~]# mv /etc/yum.repos.d/epel-testing.repo /etc/yum.repos.d/epel-testing.repo.backup
    [root@saltstack ~]# wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
    

    服务端安装

    [root@saltstack ~]# yum -y install salt-master salt-minion
    

    客户端安装

    [root@client1 ~]# yum -y install salt-minion
    

    客户端安装

    [root@client2 ~]# yum -y install salt-minion
    

    SaltStack 具有以下特性:

    1、部署简单、方便;

    2、支持大部分UNIX/Linux及Windows环境;

    3、主从集中化管理;

    4、配置简单、功能强大、扩展性强;

    5、主控端(master)和被控端(minion)基于证书认证,安全可靠。

    6、支持API及自定义模块,可通过Python轻松扩展。

    2.准备工作

    准备两台机器,这两台机器都关闭 selinux,清空 iptables 规则并保存。 master:192.168.1.160 slaver:192.168.1.161

    更新软件源

    [[email protected] ~]# wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
    [[email protected] ~]# yum makecache fast
    Loaded plugins: fastestmirror
    HuaDongBD                                                                                                                                            | 2.9 kB  00:00:00     
    base                                                                                                                                                 | 3.6 kB  00:00:00     
    extras                                                                                                                                               | 3.4 kB  00:00:00     
    os                                                                                                                                                   | 3.6 kB  00:00:00     
    updates                                                                                                                                              | 3.4 kB  00:00:00     
    updates/7/x86_64/primary_db                                                                                                                          | 7.8 MB  00:00:07     
    Loading mirror speeds from cached hostfile
     * base: mirrors.aliyun.com
     * extras: mirrors.aliyun.com
     * updates: mirrors.aliyun.com
    Metadata Cache Created
    [[email protected] ~]#
    

    基本术语

    说明
    master 控制中心,salt命令运行和资源状态管理端
    minions 需要管理的客户端机器,会主动连接master端,并从master端得到资源状态信息,同步资源管理信息
    states 配置管理的指令集
    grains minion端的静态变量
    pillar minion端的动态变量
    highstate 给minion永久添加状态,从sls配置文件读取
    salt schedule 自动保持客户端配置

    为什么选择SaltStack?

    配置master

    服务端和客户端都要配置

    [root@saltstack ~]# vi /etc/salt/minion  16
    以下两种方式都可以,选择其中一种即可
    # master改为服务端的主机名
    master: saltstack    
    # master改为服务端的IP
    master: 172.16.0.19
    

    分别修改三台机器minion文件中的的id为自己的主机名

    [root@client1 ~]# vi /etc/salt/minion  78
    id: client1
    [root@client2 ~]# vi /etc/salt/minion  78
    id: client2
    

    启动saltstack服务
    服务端

    [root@saltstack ~]# systemctl enable salt-master
    [root@saltstack ~]# systemctl enable salt-minion
    [root@saltstack ~]# systemctl start salt-master
    [root@saltstack ~]# systemctl start salt-minion
    

    客户端

    [root@client1 ~]# systemctl enable salt-minion
    [root@client1 ~]# systemctl start salt-minion
    

    SaltStack 的工作原理

    SaltStack 采用 C/S 结构来对云环境内的服务器操作管理及配置管理。为了更好的理解它的工作方式及管理模型,将通过图形方式对其原理进行阐述。

    SaltStack 客户端(Minion)在启动时,会自动生成一套密钥,包含私钥和公钥。之后将公钥发送给服务器端,服务器端验证并接受公钥,以此来建立可靠且加密的通信连接。同时通过消息队列 ZeroMQ 在客户端与服务端之间建立消息发布连接。具体通信原理图,如图 1 所示,命令执行如图 2 所示:

    新葡亰496net 2

    专业术语说明:

    Minion 是 SaltStack 需要管理的客户端安装组件,会主动去连接 Master 端,并从 Master 端得到资源状态信息,同步资源管理信息。

    Master 作为控制中心运行在主机服务器上,负责 Salt 命令运行和资源状态的管理。

    ZeroMQ 是一款开源的消息队列软件,用于在 Minion 端与 Master 端建立系统通信桥梁。

    Daemon 是运行于每一个成员内的守护进程,承担着发布消息及通信端口监听的功能。

    新葡亰496net 3

    原理图说明:

    Minion 是 SaltStack 需要管理的客户端安装组件,会主动去连接 Master 端,并从 Master 端得到资源状态信息,同步资源管理信息。

    Master 作为控制中心运行在主机服务器上,负责 Salt 命令运行和资源状态的管理。

    Master 上执行某条指令通过队列下发到各个 Minions 去执行,并返回结果。

    3. 安装

    在SaltsStack架构中服务端叫作Master,客户端叫作Minion,都是以守护进程的模式运行,一直监听配置文件中定义的ret_port(saltstack客户端与服务端通信的端口,负责接收客户端发送过来的结果,默认4506端口)和publish_port(saltstack的消息发布系统,默认4505端口)的端口。当Minion运行时会自动连接到配置文件中定义的Master地址ret_port端口进行连接认证。

    • Master:控制中心,salt命令运行和资源状态管理
    • Minion : 需要管理的客户端机器,会主动去连接Mater端,并从Master端得到资源状态信息,同步资源管理信息
    • States:配置管理的指令集
    • Modules:在命令行中和配置文件中使用的指令模块,可以在命令行中运行
    • Grains:minion端的变量,静态的
    • Pillar:minion端的变量,动态的比较私密的变量,可以通过配置文件实现同步minions定义
    • highstate:为minion端下发永久添加状态,从sls配置文件读取.即同步状态配置
    • salt_schedule:会自动保持客户端配置

    安装saltstack

    目前市场上主流的开源自动化配置管理工具有puppet、chef、ansible、saltstack等等。到底选择那个比较好?可以从以下几方面考虑:

    配置认证

    服务端操作

    [root@saltstack ~]# salt-key -a client1
    The following keys are going to be accepted:
    Unaccepted Keys:
    client1
    Proceed? [n/Y] y     
    Key for minion client1 accepted.
    
    [root@saltstack ~]# salt-key -a client2
    The following keys are going to be accepted:
    Unaccepted Keys:
    client2
    Proceed? [n/Y] y
    Key for minion client2 accepted.
    [root@saltstack ~]# salt-key -a saltstack
    The following keys are going to be accepted:
    Unaccepted Keys:
    saltstack
    Proceed? [n/Y] y
    Key for minion saltstack accepted.
    
    [root@saltstack ~]# salt-key 
    Accepted Keys:
    client1
    client2
    saltstack
    Denied Keys:
    Unaccepted Keys:
    Rejected Keys:
    

    说明:-a :accept ,-A:accept-all,-d:delete,-D:delete-all。可以使用 salt-key 命令查看到已经签名的客户端。此时我们在客户端的 /etc/salt/pki/minion 目录下面会多出一个minion_master.pub 文件。

    测试验证
    示例1: salt '*' test.ping //检测通讯是否正常,也可以指定其中一个 'client1'

    [root@saltstack ~]# salt '*' test.ping
    saltstack:
        True
    client2:
        True
    client1:
        True
    [root@saltstack ~]# salt 'client1' test.ping
    client1:
        True
    

    示例2: salt '*' cmd.run 'df -h' //远程执行命令

    [root@saltstack ~]# salt '*' cmd.run 'df -hT'
    client2:
        Filesystem     Type      Size  Used Avail Use% Mounted on
        /dev/sda2      xfs        17G   13G  4.2G  76% /
        devtmpfs       devtmpfs   97M     0   97M   0% /dev
        tmpfs          tmpfs     111M   12K  111M   1% /dev/shm
        tmpfs          tmpfs     111M  8.8M  102M   8% /run
        tmpfs          tmpfs     111M     0  111M   0% /sys/fs/cgroup
        /dev/sda1      xfs       297M  202M   96M  68% /boot
        tmpfs          tmpfs      23M     0   23M   0% /run/user/0
    saltstack:
        Filesystem     Type      Size  Used Avail Use% Mounted on
        /dev/sda2      xfs        17G  6.8G   11G  40% /
        devtmpfs       devtmpfs  475M     0  475M   0% /dev
        tmpfs          tmpfs     489M   16K  489M   1% /dev/shm
        tmpfs          tmpfs     489M   14M  476M   3% /run
        tmpfs          tmpfs     489M     0  489M   0% /sys/fs/cgroup
        /dev/sda1      xfs       297M  202M   96M  68% /boot
        tmpfs          tmpfs      98M     0   98M   0% /run/user/0
        tmpfs          tmpfs      98M     0   98M   0% /run/user/994
    client1:
        Filesystem     Type      Size  Used Avail Use% Mounted on
        /dev/sda2      xfs        17G   13G  4.1G  77% /
        devtmpfs       devtmpfs   97M     0   97M   0% /dev
        tmpfs          tmpfs     111M   12K  111M   1% /dev/shm
        tmpfs          tmpfs     111M   13M   98M  12% /run
        tmpfs          tmpfs     111M     0  111M   0% /sys/fs/cgroup
        /dev/sda1      xfs       297M  202M   96M  68% /boot
        tmpfs          tmpfs      23M     0   23M   0% /run/user/0
    

    说明: 这里的 * 必须是在 master 上已经被接受过的客户端,可以通过 salt-key 查到,通常是我们已经设定的 id 值。关于这部分内容,它支持通配、列表以及正则。 比如两台客户端 client1、client2, 那我们可以写成 salt 'client*' salt 'client[2]' salt -L 'client1,client2' salt -E 'client(1|2)' 等形式,使用列表,即多个机器用逗号分隔,而且需要加-L,使用正则必须要带-E选项。 它还支持 grains 和 pillar,分别加 -G 和 -I 选项。

    [root@saltstack ~]# salt -E 'client(1|2)' cmd.run 'ls'
    client1:
        anaconda-ks.cfg
        initial-setup-ks.cfg
        one-click-install-lnmp.sh
    client2:
        anaconda-ks.cfg
        initial-setup-ks.cfg
        one-click-install-lnmp.sh
    [root@saltstack ~]# salt -L 'client1,client2' cmd.run 'ls'
    client1:
        anaconda-ks.cfg
        initial-setup-ks.cfg
        one-click-install-lnmp.sh
    client2:
        anaconda-ks.cfg
        initial-setup-ks.cfg
        one-click-install-lnmp.sh
    [root@saltstack ~]# salt 'client[2]' cmd.run 'ls'
    client2:
        anaconda-ks.cfg
        initial-setup-ks.cfg
        one-click-install-lnmp.sh
    [root@saltstack ~]# salt 'client*' cmd.run 'ls'
    client2:
        anaconda-ks.cfg
        initial-setup-ks.cfg
        one-click-install-lnmp.sh
    client1:
        anaconda-ks.cfg
        initial-setup-ks.cfg
        one-click-install-lnmp.sh
    

    SaltStack 的架构设计

    为了让大家更好的理解 SaltStack 集中化管理方面的优势,因此,根据项目的实际情况绘制了部署架构图,并在文中对架构图进行了详细说明。如图 3 所示:

    新葡亰496net 4

    说明:

    SaltStack 的所有被管理客户端节点(如图 3 所示 DB 和 Web),都是通过密钥进行加密通信,使用端口为 4506。客户端与服务器端的内容传输,是通过消息队列完成,使用端口为 4505。Master 可以发送任何指令让 Minion 执行,salt 有很多可执行模块,比如说 CMD 模块,在安装 minion 的时候已经自带了,它们通常位于你的 python 库中,locate salt | grep /usr/ 可以看到 salt 自带的所有东西。

    为了更好的理解架构用意,以下将展示主要的命令发布过程:

    SaltStack 的 Master 与 Minion 之间通过 ZeroMq 进行消息传递,使用了 ZeroMq 的发布订阅模式,连接方式包括 TCP 和 IPC。

    Salt 命令,将 cmd.run ls 命令从 salt.client.LocalClient.cmd_cli 发布到 Master,获取一个 Jodid,根据 jobid 获取命令执行结果。

    Master 接收到命令后,将要执行的命令发送给客户端 minion。

    Minion 从消息总线上接收到要处理的命令,交给 minion._handle_aes 处理。

    Minion._handle_aes 发起一个本地线程调用 cmdmod 执行 ls 命令。线程执行完 ls 后,调用 Minion._return_pub 方法,将执行结果通过消息总线返回给 master。

    Master 接收到客户端返回的结果,调用 master.handle_aes 方法将结果写的文件中。

    Salt.client.LocalClient.cmd_cli 通过轮询获取 Job 执行结果,将结果输出到终端。

    3.1 服务端安装

    yum install -y epel-release

    yum install -y salt-master salt-minion

    [[email protected] ~]# yum install -y epel-release
    [[email protected] ~]# yum install -y salt-master salt-minion
    

    安装

    Installs the latest release. Updating installs the latest release even if it is a new major version.

    1.1、Run the following command to import the SaltStack repository key:

    wget -O - https://repo.saltstack.com/apt/ubuntu/16.04/amd64/latest/SALTSTACK-GPG-KEY.pub | sudo apt-key add -
    

    1.2、Save the following file to /etc/apt/sources.list.d/saltstack.list:

    deb http://repo.saltstack.com/apt/ubuntu/16.04/amd64/latest xenial main
    

    1.3、Install

    > sudo apt-get update
    > sudo apt-get install salt-master
    > sudo apt-get install salt-minion
    > sudo apt-get install salt-ssh
    > sudo apt-get install salt-syndic
    > sudo apt-get install salt-cloud
    > sudo apt-get install salt-api
    

    1.4、show version

    > salt --version
    salt 2016.3.3 (Boron)
    

    语言的选择(puppet/chef vs ansible/saltstack)

    grains 和 pillar

    1、grains
    grains 是在 minion(客户端)启动时收集到的一些信息,比如操作系统类型、网卡ip等。
    使用命令:

    [root@saltstack ~]# salt 'client1' grains.ls      // 列出所有的 grains 项目名字
    [root@saltstack ~]# salt 'client1' grains.items    // 列出所有的 grains 项目名以及值
    

    grains的信息并不是动态的,并不会时时变更,它只是在 minion 启动时收集到的。grains 也可以做配置管理

    自定义 grains的方法有两种(客户端自定义配置和服务端写脚本定义):
    1.客户端配置(缺点:每台都得去配置,机器多了配置起来不方便)

    [root@client1 ~]# vi /etc/salt/grains     // 添加如下,注意冒号后有空格
    role: nginx
    env: test
    myname: primum est
    

    或者

    [root@client2 ~]# vi /etc/salt/minion  12
    去掉这行内容的注释
    default_include: minion.d/*.conf
    
    [root@client2 ~]# cd /etc/salt/minion.d/
    [root@client2 minion.d]# vi custom_grains.conf            // 添加下面内容
    grains:
      role:  
        nginx
      env:  
        test
      myname:  
        primum est
    

    重启minion服务

    [root@client1 ~]# systemctl restart salt-minion
    [root@client2 ~]# systemctl restart salt-minion
    

    服务端获取 grains

    [root@saltstack ~]# salt 'client*' grains.item role env myname        // 列出多个
    client1:
        ----------
        env:
            test
        myname:
            primum est
        role:
            nginx
    client2:
        ----------
        env:
            test
        myname:
            primum est
        role:
            nginx
    
    [root@saltstack ~]# salt 'client*' grains.get myname        // 列出单个
    client1:
        primum est
    client2:
        primum est
    
    [root@saltstack ~]# salt 'client*' grains.item myname
    client2:
        ----------
        myname:
            primum est
    client1:
        ----------
        myname:
            primum est
    

    grains 在远程执行命令时很方便。我们可以按照 grains 的一些指标来操作。比如把所有的 web 服务器的 grains 的 role 设置为 nginx,那这样我们就可以批量对 nginx 的服务器进行操作了:

    [root@saltstack ~]# salt -G role:nginx cmd.run 'hostname'
    client2:
        client2
    client1:
        client1
    [root@saltstack ~]# salt -G os:CentOs cmd.run 'hostname'
    client2:
        client2
    client1:
        client1
    

    2.服务端写Python脚本

    [root@saltstack ~]# mkdir /srv/salt/_grains
    [root@saltstack ~]# cd /srv/salt/_grains/
    [root@saltstack _grains]# vi mytest.py        // 添加下面内容
    #!/usr/bin/env python
    # _*_ coding:utf-8 _*_
    
    import os
    
    def my_test():
        grains = {}
        grains['say'] = 'hello world'
        return grains
    
    def my_test1():
        grains = {}
        with os.popen('free -m') as f:
            grains['mem_usage'] = f.read()
        return grains
    

    同步到客户端

    [root@saltstack _grains]# salt 'client*' saltutil.sync_all
    

    新葡亰496net 5

     

    客户端验证脚本是否同步过去

    [root@client1 ~]# ll /var/cache/salt/minion/extmods/grains/
    总用量 8
    -rw------- 1 root root 266 4月  27 11:13 mytest.py
    -rw------- 1 root root 613 4月  27 11:13 mytest.pyc
    

    服务端刷新模块

    [root@saltstack _grains]# salt 'client*' sys.reload_modules 
    client1:
        True
    client2:
        True
    

    服务端查看客户端自定义的两个监控项

    [root@saltstack _grains]# salt 'client*' grains.item say
    client1:
        ----------
        say:
            hello world
    client2:
        ----------
        say:
            hello world
    [root@saltstack _grains]# salt 'client*' grains.item mem_usage
    client2:
        ----------
        mem_usage:
                          total        used        free      shared  buff/cache   available
            Mem:            220         103          31           4          85          78
            Swap:          2046         176        1870
    client1:
        ----------
        mem_usage:
                          total        used        free      shared  buff/cache   available
            Mem:            220         106          30           2          83          76
            Swap:          2046         178        1868
    

    可以看到服务端写自定义监控项的脚本,可以一键同步到所有客户端上,快捷方便。

    2、pillar
    pillar 和 grains 不一样,是在 master 上定义的,并且是针对 minion 定义的一些信息。像一些比较重要的数据(密码)可以存在 pillar 里,还可以定义变量等。
    首先我们查看master端pillars组件是否在开启状态
    查看/etc/salt/master pillar_ops: True 就代表pillars在开启状态,否则我们手动修改。
    新的版本默认已经开启,继续下面内容。

    查看指定minion的 pillar 值:

    [root@saltstack ~]# salt 'client1' pillar.items
    client1:
        ----------
    

    服务端自定义配置 pillar

    [root@saltstack ~]# vi /etc/salt/master  529    // 找到如下内容,去掉#号
    pillar_roots:
      base:
        - /srv/pillar
    [root@saltstack ~]#  mkdir /srv/pillar
    [root@saltstack ~]# vi /srv/pillar/test.sls    // 自定义配置文件,内容如下
    conf: /etc/mum.conf
    myname: primum est
    [root@saltstack ~]# vi /srv/pillar/top.sls    // 总入口文件,内容如下
    base:
      'client1':
        - test
    

    重启master

    [root@saltstack ~]# systemctl restart salt-master
    

    注意:当更改完 pillar 配置文件后,我们可以通过刷新 pillar 配置来获取新的 pillar 状态:

    [root@saltstack ~]# salt '*' saltutil.refresh_pillar
    client1:
        True
    saltstack:
        True
    client2:
        True
    

    验证:

    [root@saltstack ~]# salt 'client1' pillar.items
    client1:
        ----------
        conf:
            /etc/mum.conf
        myname:
            primum est
    
    [root@saltstack ~]# salt 'client1' pillar.item myname
    client1:
        ----------
        myname:
            primum est
    
    [root@saltstack ~]# salt 'client1' pillar.item conf
    client1:
        ----------
        conf:
            /etc/mum.conf
    

    pillar 同样可以用来作为 salt 的匹配对象。比如:

    [root@saltstack ~]# salt -I 'conf:/etc/mum.conf' test.ping
    client1:
        True
    [root@saltstack ~]# salt -I 'conf:/etc/mum.conf' cmd.run 'w'
    client1:
         17:19:45 up  7:45,  1 user,  load average: 0.05, 0.03, 0.05
        USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
        root     pts/1    172.16.0.1       11:14   25.00s  0.68s  0.68s -bash
    

    另外一种定义pillar的方式,也适用于state
    首先编辑/srv/pillar/目录下的top.sls 文件

    [root@saltstack ~]# vi /srv/pillar/top.sls           // 内容如下
    base:
      'client1':
        - test
        - apache
    

    第一行代表这是我们的入口文件
    第二行代表我们要匹配的用户,‘client1’代表client1客户端,“*”代表所有用户
    第三丶四行代表匹配到的用户可以看到的数据的配置文件的名字

    这里我们可以直接写一个名字叫做apache的文件进行配置,也可以写一个包含init.sls的目录进行配置。这里采用包含init.sls文件的目录的形式的配置方法。

    [root@saltstack ~]# cd /srv/pillar/
    [root@saltstack pillar]# mkdir apache
    [root@saltstack pillar]# cd apache/
    [root@saltstack apache]# vim init.sls              // 添加如下内容
    system-type:
      {% if grains.os == 'CentOS' %}
        name: Centos-Linux
      {% else %}
        name: unknown
      {% endif %}
    
    apache-name:
      {% if grains.os_family == 'RedHat' %}
        apache: httpd
      {% elif grains.os_family == 'Arch' %}
        apache: apache
      {% elif grains.os_family == 'Debian' %}
        apache: apache2
      {% endif %}
    

    {% if grains.os == 'CentOS' %} 类似于django的模板语言(我们可以采用python脚本定义grains的数据,但是pillar没有。我们可以在pillar的sls脚本当中调用grains的变量,pillar和grains具有同样的功能可以被其他组件调用。)

    服务端查看自定义的pillar信息

    [root@saltstack apache]# salt 'client1' pillar.item apache-name
    client1:
        ----------
        apache-name:
            ----------
            apache:
                httpd
    [root@saltstack apache]# salt 'client1' pillar.item system-type
    client1:
        ----------
        system-type:
            ----------
            name:
                Centos-Linux
    

     

    SaltStack 的安装与配置

    对 SaltStack 有了一个初步的了解之后,通过实际案例操作进一步了解 SaltStack。

    一、安装Salt

    Salt需要epel源支持,所有安装前需要先安装epel源包。

    1、salt-master

    # yum -y install salt-master

    2、salt-minion

    # yum -y install salt-minion

    二、配置Salt

    1、master(/etc/salt/master)

    # salt运行的用户,影响到salt的执行权限

    user: root

    #salt的运行线程,开的线程越多一般处理的速度越快,但一般不要超过CPU的个数

    worker_threads: 10

    # master的管理端口

    publish_port : 4505

    # master跟minion的通讯端口,用于文件服务,认证,接受返回结果等

    ret_port : 4506

    # 如果这个master运行的salt-syndic连接到了一个更高层级的master,那么这个参数需要配置成连接到的这个高层级master的监听端口

    syndic_master_port : 4506

    # 指定pid文件位置

    pidfile: /var/run/salt-master.pid

    # saltstack 可以控制的文件系统的开始位置

    root_dir: /

    # 日志文件地址

    log_file: /var/log/salt_master.log

    # 分组设置

    nodegroups:

    group_all: '*'

    # salt state执行时候的根目录

    file_roots:

        base:

            - /etc/salt/

    # 设置pillar 的根目录

    pillar_roots:

        base:

            - /etc/pillar

    2、配置minion(/etc/salt/minion)

    master: mail  #这块的mail指的是在/etc/hosts文件中所定义的主机名

    id: node1

    3、启动salt

    service salt-master start

    service salt-minion start

    # saltstack 是使用python2的语言编写,对python3的兼容性不好,请使用python2的环境

    4、认证命令介绍

    salt-key #证书管理    

    # salt-key –L       #查看所有minion-key    

    # salt-key –a      #接受某个minion-key    

    # salt-key –A      #接受所有minion-key

    # salt-key –d       #删除某个minion-key

    # salt-key –D       #删除所有minion-key

    新葡亰496net 6

    新葡亰496net 7

    新葡亰496net 8

    5、salt命令介绍

    命令格式:salt [options] [arguments]

    例:salt * cmd.run 'uptime'

    新葡亰496net 9

    3.2 客户端安装

    [[email protected] ~]# yum install -y epel-release
    [[email protected] ~]# yum install -y salt-minion
    

    基本的配置

    文件 /etc/salt/master

    interface: 192.168.199.86
    

    文件 /etc/salt/minion

    master: 192.168.199.86
    id: qianlnk # minion的识别ID,可以是IP,域名,或是可以通过DNS解析的字符串
    

    Puppet、Chef基于Ruby开发,ansible、saltstack基于python开发的

    配置管理安装Apache

    下面进行的演示是远程通过 yum 方式安装 Apache。步骤如下:
    修改配置文件

    [root@saltstack ~]# vi /etc/salt/master  406    // 打开如下内容的注释
    file_roots:
      base:
        - /srv/salt/
    

    注意:环境: base、dev(开发环境)、test(测试环境)、prod(生产环境)。

    [root@saltstack ~]# mkdir /srv/salt
    [root@saltstack ~]# vi /srv/salt/top.sls        
    base:
      'client1':
        - apache
    

    注意:若换成 '*',则表示在所有的客户端执行 apache 模块。

    [root@saltstack ~]# vi /srv/salt/apache.sls            
    apache-service:
      pkg.installed:
        - names:                // 如果只有一个服务,那么就可以写成 –name: httpd 不用再换一行
          - httpd
          - httpd-devel
      service.running:
        - name: httpd
        - enable: True
    

    注意:apache-service 是自定义的 id 名。pkg.installed 为包安装函数,下面是要安装的包的名字。service.running 也是一个函数,来保证指定的服务启动,enable 表示开机启动。

    重启服务

    [root@saltstack ~]# systemctl restart salt-master
    

    执行命令

    [root@saltstack ~]# salt 'client1' state.highstate          // 执行时间比较长,因为要安装httpd
    

    新葡亰496net 10

     

    如上图所示,说明 Apache 远程安装已成功。

     

    SaltStack minion匹配方式

    1、 Glob(salt默认的target类型,使用shell的通配符来指定一个或多个Minion ID)

    # salt * test.ping 或 salt ‘*’ test.ping

    2、pcre兼容正则表达式

    # salt –E ‘^[m|M]in.[e|o|u]n$’ test.ping

    3、Subnet(通过指定一个IPv4地址或一个CIDR的IPv4子网)

    # salt –S 192.168.0.42 test.ping

    # salt –s 192.168.0.0/16 test.ping

    4、Grains(salt可以通过操作系统、CPU架构及自定义信息等机器特征进行target Minion)

    # salt –G ‘os:Ubuntu’ test.ping

    # Salt –G ‘os_family:Debian’ test.ping

    5、pillar(salt支持通过pillar数据进行匹配)

    # Salt –I ‘my_val:my_val’ test.ping

    6、混合(compound)

    # Salt –C ‘web* or G@os:Arch’ test.ping

    7、节点组(Nodegroup)

    节点组需要事先定义,配置方法如下:

    # vim /etc/salt/master

    nodegroups:

    node: 'L@node1,node2’

    # salt -N node test.ping

    4.配置

    配置

    master:
    https://docs.saltstack.com/en/latest/ref/configuration/master.html
    http://arlen.blog.51cto.com/7175583/1423997

    minion:
    https://docs.saltstack.com/en/latest/ref/configuration/minion.html
    http://arlen.blog.51cto.com/7175583/1424008

    运维开发语言热衷于python(后期可做二次开发),排除Puppet、Chef

    文件目录管理

    1、文件管理
    服务端配置
    编辑/srv/salt/目录下的top.sls 文件

    [root@saltstack ~]# vi /srv/salt/top.sls     // 修改为如下
    base:
      'client1':
        - filetest
    

    新建 filetest.sls 文件

    [root@saltstack ~]# vi /srv/salt/filetest.sls        
    file-test:
      file.managed:
        - name: /tmp/filetest.txt
        - source: salt://test/123/1.txt
        - user: root
        - group: root
        - mode: 644
    

    注意:第一行的 file-test 为自定的名字,表示该配置段的名字,可以在别的配置段中引用它;source指定文件从哪里拷贝,这里的 test 目录相当于是 /srv/salt/test 目录;name指定远程客户端要生成的文件。

    新建所要测试的源文件

    [root@saltstack ~]# mkdir -p /srv/salt/test/123
    [root@saltstack ~]# vim /srv/salt/test/123/1.txt
    saltstack ....
    this is a test ....
    

    执行命令:

    [root@saltstack ~]# salt 'client1' state.highstate
    

    新葡亰496net 11

     

    客户端验证

    [root@client1 ~]# ll /tmp/filetest.txt 
    -rw-r--r-- 1 root root 34 4月  26 10:58 /tmp/filetest.txt
    [root@client1 ~]# cat /tmp/filetest.txt 
    saltstack ....
    this is a test ...
    

    2、目录管理
    服务端配置
    接着编辑/srv/salt/目录下的top.sls 文件

    [root@saltstack ~]# vi /srv/salt/top.sls     // 修改为如下
    base:
      'client1':
        - filedir
    

    新建 filedir.sls 文件

    [root@saltstack ~]# vi /srv/salt/filedir.sls
    file-dir:
      file.recurse:
        - name: /tmp/testdir
        - source: salt://test1/234
        - user: root
        - file_mode: 644
        - dir_mode: 755
        - mkdir: True
        - clean: True
    

    注意:clean: True 源删除文件或目录,目标也会跟着删除,否则不会删除。可以默认设置为 False。

    新建所要测试的源目录

    [root@saltstack ~]# mkdir -p /srv/salt/test1/234/
    [root@saltstack ~]# vi /srv/salt/test1/234/2.txt
    filedir..........test
    and add delete select alter
    

    执行命令:

    [root@saltstack ~]# salt 'client1' state.highstate
    

    新葡亰496net 12

     

    客户端验证

    [root@client1 ~]# ll /tmp/testdir/
    总用量 4
    -rw-r--r-- 1 root root 50 4月  26 11:11 2.txt
    

    测试增删功能

    [root@saltstack ~]# mkdir /srv/salt/test1/234/mydir
    [root@saltstack ~]# touch /srv/salt/test1/234/mydir/111.txt
    [root@saltstack ~]# touch /srv/salt/test1/234/testdir.add
    [root@saltstack ~]# rm -rf /srv/salt/test1/234/2.txt
    

    执行命令:

    [root@saltstack ~]# salt 'client1' state.highstate
    

    新葡亰496net 13

     

    客户端验证

    [root@client1 ~]# tree /tmp/testdir/
    /tmp/testdir/
    |-- mydir
    |   `-- 111.txt
    `-- testdir.add
    
    1 directory, 2 files
    

    注意:由上图可知,成功在客户端 /tmp/testdir/ 目录下创建了 mydir 目录以及 testdir.add 文件,并删除 2.txt 文件。这里值得注意的是要成功创建 mydir 目录,前提是 mydir 目录下要有文件,如这里的111.txt 文件,如若没有,客户端是不会创建 mydir 目录的。

     

    SaltStack常用模块

    1、status模块(查看系统信息)

    新葡亰496net 14

    新葡亰496net 15

    # salt "*" status.diskstats    #查看磁盘信息

    # salt "*" status.meminfo      #查看内存信息

    # salt "*" status.w            #w命令返回信息

    2、查看所有module列表

    新葡亰496net 16

    3、查看指定module的所有function方法

    新葡亰496net 17

    4、查看指定module用法

    新葡亰496net 18

    5、具体模块的使用(例子)

    新葡亰496net 19

    同时到指定机器查看

    新葡亰496net 20

    cmd.run模块的使用

    新葡亰496net 21

    新葡亰496net 22

    4.1 Salt minion配置

    用vi/vim打开/etc/salt/minion,找到配置选项master所在行,一般在第16行。修改内容,去掉#,冒号后有一个空格,将salt更改为master。

    示例操作如下:

    [[email protected] ~]# vi /etc/salt/minion

    [[email protected] ~]# vi /etc/salt/minion

    # Set the location of the salt master server. If the master server cannot be
    # resolved, then the minion will fail to start.
    master: master
    

    如果找不到master对应的行,可以直接在文件尾部添加一行master: mastermaster: 192.168.1.160

    也可以使用sed命令直接修改配置文件

    [[email protected] ~]# sed -i 's/#master: salt/master: 192.168.1.160/g' /etc/salt/minion
    

    启动

    sudo service salt-master start
    sudo service salt-minion start
    

    速度的选择 (ansible vs saltstack)

    远程执行

    前面提到远程执行命令 test.ping,cmd.run,点前面的是模块,点后面的是函数;这样总归是不太规范化,下面详细介绍怎么远程执行命令和脚本。
    1、远程执行命令
    服务端配置
    接着编辑/srv/salt/目录下的top.sls 文件

    [root@saltstack ~]# vi /srv/salt/top.sls     // 修改为如下
    base:
      'client1':
        - cmdtest
    

    新建 cmdtest.sls 文件

    [root@saltstack ~]# vi /srv/salt/cmdtest.sls
    cmd-test:
      cmd.run:
        - onlyif: test -f /tmp/filetest.txt
        - names:
          - touch /tmp/cmdtest.txt
          - mkdir /tmp/cmdtest
        - user: root
    

    注意:条件 onlyif 表示若 /tmp/filetest.txt 文件存在,则执行后面的命令;可以使用 unless,两者正好相反。

    执行命令:

    [root@saltstack ~]# salt 'client1' state.highstate
    

    新葡亰496net 23

     

    客户端验证

    [root@client1 ~]# ll /tmp/
    总用量 156
    drwxr-xr-x  2 root  root      6 4月  26 11:45 cmdtest
    -rw-r--r--  1 root  root      0 4月  26 11:45 cmdtest.txt
    -rw-r--r--  1 root  root     34 4月  26 10:58 filetest.txt
    drwxr-xr-x  3 root  root     38 4月  26 11:14 testdir
    

    2、远程执行脚本
    服务端配置
    接着编辑/srv/salt/目录下的top.sls 文件

    [root@saltstack ~]# vi /srv/salt/top.sls    // 修改为如下
    base:
      'client1':
        - shelltest
    

    新建 shelltest.sls 文件

    [root@saltstack ~]# vi /srv/salt/shelltest.sls
    shell-test:
      cmd.script:
        - source: salt://test/1.sh
        - user: root
    

    新建 1.sh 脚本文件

    [root@saltstack ~]# vi /srv/salt/test/1.sh
    #!/bin/sh
    touch /tmp/shelltest.txt
    if [ -d /tmp/shelltest ]
    then
        rm -rf /tmp/shelltest
    else
        mkdir /tmp/shelltest
    fi
    

    执行命令:

    [root@saltstack ~]# salt 'client1' state.highstate
    

    新葡亰496net 24

     

    客户端验证

    [root@client1 ~]# ll /tmp/
    drwxr-xr-x  2 root  root      6 4月  26 12:08 shelltest
    -rw-r--r--  1 root  root      0 4月  26 12:08 shelltest.txt
    

    通过上面的例子,我们实现了远程执行脚本;如果我们想一键远程安装 LAMP 或者 LNMP,那么只需把本例中的 1.sh 脚本替换成 一键安装的脚本就行。

    管理任务计划
    1、建立 cron
    服务端配置
    编辑/srv/salt/目录下的top.sls 文件

    [root@saltstack ~]# vi /srv/salt/top.sls     // 修改为如下
    #base:
    #  'client1':
    #    - apache
    #base:
    #  'client1':
    #    - filetest
    #base:
    #  'client1':
    #    - filedir
    #base:
    #  'client1':
    #    - cmdtest
    #base:
    #  'client1':
    #    - shelltest
    #base:
    #  'client1':
    #    - shelltest
    base:
      'client1':
        - crontest
    

    编辑 crontest.sls 文件

    [root@saltstack ~]# vim /srv/salt/crontest.sls
    cron-test:
      cron.present:
        - name: /bin/touch /tmp/111.txt
        - user: root
        - minute: '*'
        - hour: 20
        - daymonth: 1-10
        - month: '3,5'
        - dayweek: '*'
    

    注意,*需要用单引号引起来。当然我们还可以使用 file.managed 模块来管理 cron,因为系统的 cron都是以配置文件的形式存在的。

    执行命令:

    [root@saltstack ~]# salt 'client1' state.highstate
    

    新葡亰496net 25

     

    客户端验证

    [root@client1 ~]# crontab -l
    # Lines below here are managed by Salt, do not edit
    # SALT_CRON_IDENTIFIER:/bin/touch /tmp/111.txt
    * 20 1-10 3,5 * /bin/touch /tmp/111.txt
    

    2、删除 cron
    服务端配置
    我们只需修改 crontest.sls 文件

    [root@saltstack ~]# vim /srv/salt/crontest.sls
    cron.present    改为    cron.absent
    

    注意:两者不能共存,要想删除一个 cron,那之前的 present 就得替换掉或者删除掉。

    执行命令:

    [root@saltstack ~]# salt 'client1' state.highstate
    

    新葡亰496net 26

     

    客户端验证

    [root@client1 ~]# crontab -l        // 可查看到该任务计划已删除
    # Lines below here are managed by Salt, do not edit
    

     

    Grains

    Static bits of information that a minion collects about the system when the minion first starts.

    The grains interface is made available to Salt modules and components so that the right salt minion commands are automatically available on the right systems.

    以上是官方的解释,大致意思是说grains是minion第一次启动的时候采集的静态数据,可以用在salt的模块和其他组件中。例如,当os_family的Grain数据为Centos时,则会使用yum工具组件来进行软件包管理。Grains会在Minion进程启动时加载,并缓存在内存中。这样salt-minion进程就无须每次操作都重新检索系统来获取Grain,极大的提高了Minion的性能。

    1、我们这里简单做一个输出测试,可以看到minion节点的一些信息如下:

    新葡亰496net 27

    查看具体每一项信息

    新葡亰496net 28

    2、应用场景:

    grains的特性–每次启动汇报、静态决定了它没有pillar灵活,要知道pillar是随时可变的,只要在master端修改了那一般都会立刻生效的。所以grains更适合做一些静态的属性值的采集,例如设备的角色(role),磁盘个数(disk_num),操作系统版本等诸如此类非常固定的属性。简单总结起来grains的用途如下:

    (1),grains可以在state系统应用中,用户配置管理模块。

    (2),grains可以在target中使用,用来匹配minion,比如os,用-G。

    (3),grains可以用于信息查询,grains保存着收集到的客户端的信息。

    那么我们就可以得到一个大致的判断,如果你想定义的属性值是经常变化的,那请采用pillar,如果是很固定、不易变的那请用grains。

    3、grains优先级

    grains可以保持在minion端、通过master端下发等多个方式来分发。但不同的方法有不同的优先级的(由低到高):

    (1). /etc/salt/grains

    (2) /etc/salt/minion

    (3)./srv/salt/_grains/  master端_grains目录下

    优先级顺序依次为存在在minion端/etc/salt/minion配置文件中的同名grains会覆盖/etc/salt/grains文件中的值,而通过master端_grains目录下grains文件下发的值可以会覆盖minion端的所有同名值。比较拗口,总之记得,通过master下发的grains优先级是最高的可,/etc/salt/minion次之,/etc/salt/grains最低(core grains不大懂,就不讨论了,这个比/etc/salt/grains还低)。

    4、grains的下发

    grains的下发大致可以分为两个思路:

    (1)自定义的(_grains)可以通过state.highstate、saltutil.sync_grains、saltutil.sync_all 等方法批量下发,切记所有在_grains目录下的所有自定义grains值都会下发到minion,这是血的教训。

    (2)固定存放在minion端配置文件中,如grains、minion文件中,可以通过file manager的方法去批量下发/etc/salt/grains等配置文件实现grains的批量下发,当然了也通过别的方式把这个文件批量下发下去,都是ok的。

    对比:

    (1)通过state.highstate 下发的grains好处是无须重启minion即可生效,但通过下发/etc/salt/grains文件下发的grains值则必须重启minion端服务才可以生效。

    (2)自定义的_grains每次在highstate调用的时候就会自动下发、刷新,而/etc/salt/grains文件的则不会。

    5.启动服务

    (1)服务端

    [[email protected] ~]# salt-master start
    

    在后端运行

    [[email protected] ~]# salt-master start &
    [3] 35438
    [[email protected] ~]#
    

    (2)客户端

    [[email protected] ~]# salt-minion start &
    [ERROR   ] The Salt Master has cached the public key for this node, this salt minion will wait for 10 seconds before attempting to re-authenticate
    [ERROR   ] The Salt Master has cached the public key for this node, this salt minion will wait for 10 seconds before attempting to re-authenticate
    
    [[email protected] ~]# salt-minion start &
    [ERROR   ] The Salt Master has cached the public key for this node, this salt minion will wait for 10 seconds before attempting to re-authenticate
    [ERROR   ] The Salt Master has cached the public key for this node, this salt minion will wait for 10 seconds before attempting to re-authenticate
    
    [[email protected] ~]# salt-minion start
    [ERROR   ] The Salt Master has cached the public key for this node, this salt minion will wait for 10 seconds before attempting to re-authenticate
    [ERROR   ] The Salt Master has cached the public key for this node, this salt minion will wait for 10 seconds before attempting to re-authenticate
    

    minion在第一次启动时,会在/etc/salt/pki/minion/(该路径在/etc/salt/minion里面设置)下自动生成minion.pem(private key)和 minion.pub(public key),然后将 minion.pub发送给master。master在接收到minion的public key后,通过salt-key命令accept minion public key,这样在master的/etc/salt/pki/master/minions下的将会存放以minion id命名的 public key,然后master就能对minion发送指令了。

    master接受minion的key

    > sudo salt-key -L                
    Accepted Keys:
    Denied Keys:
    Unaccepted Keys:
    qianlnk
    Rejected Keys:
    
    > sudo salt-key -a qianlnk
    The following keys are going to be accepted:
    Unaccepted Keys:
    qianlnk
    Proceed? [n/Y] y
    Key for minion qianlnk accepted.
    
    > sudo salt-key -L        
    Accepted Keys:
    qianlnk
    Denied Keys:
    Unaccepted Keys:
    Rejected Keys:
    

    ansible基于ssh协议传输数据,SaltStack使用消息队列zeroMQ传输数据。从网上数据来看,SaltStack比ansible快大约40倍。

    一键搭建rsync服务

    rsync服务端搭建配置文件介绍

    [root@saltstack rsync]# cat rsync_server.sls 
    rsync:    ##ID  这个ID必须是唯一的名字
      user.present:    ##user模块中present应用
        - fullname: rsync  ##用户名字
        - createhome: False  ##不创建家目录
        - shell: /sbin/nologin  ##禁止登录
        - empty_password: True  ##不需要密码
    rsyncd.conf: ##ID
      file.managed:  ##file模块
        - name: /etc/rsyncd.conf  ##客户端文件存放路径
        - source: salt://rsync/rsyncd.conf   ##服务端文件路径
        - user: root    ##属主
        - group: root  ##属组
        - mode: 644 ##权限
    backup:
      file.directory: ##file模块
        - name: /backup ##创建目录名
        - user: rsync
        - group: rsync
        - mode: 755
        - makedirs: True  ##如果没有自动创建
    rsync.password:  
      file.managed:
        - name: /etc/rsync.password
        - source: salt://rsync/rsyncd.password
        - user: root
        - group: root
        - mode: 600
    daemon:
      cmd.run:  ##使用cmd.run模块
        - name: rsync --daemon
    Boot from open:
      cmd.run:
        - name: echo "/usr/bin/rsync --daemon" >>/etc/rc.local
    

    开始部署
    服务端配置
    编辑/srv/salt/目录下的top.sls 文件

    [root@saltstack ~]# vi /srv/salt/top.sls        // 修改为下面内容
     base:
      'client1':
        - rsync.rsync_server
      'client2':
        - rsync.rsync_client
    

    创建rsync服务端搭建配置文件

    [root@saltstack ~]# mkdir /srv/salt/rsync
    [root@saltstack ~]# cd /srv/salt/rsync/
    [root@saltstack rsync]# vi rsync_server.sls                // 添加下面内容
    rsync:   
      user.present:    
        - fullname: rsync  
        - createhome: False  
        - shell: /sbin/nologin  
        - empty_password: True  
    rsyncd.conf: ##ID
      file.managed:  
        - name: /etc/rsyncd.conf  
        - source: salt://rsync/rsyncd.conf   
        - user: root    
        - group: root  
        - mode: 644 
    backup:
      file.directory: 
        - name: /backup 
        - user: rsync
        - group: rsync
        - mode: 755
        - makedirs: True  
    rsync.password:  
      file.managed:
        - name: /etc/rsync.password
        - source: salt://rsync/rsyncd.password
        - user: root
        - group: root
        - mode: 600
    daemon:
      cmd.run:  
        - name: rsync --daemon
    Boot from open:
      cmd.run:
        - name: echo "/usr/bin/rsync --daemon" >>/etc/rc.local
    

    创建rsync客户端搭建配置文件

    [root@saltstack rsync]# vi rsync_client.sls              // 添加下面内容 
    rsync.passwd:
      file.managed:
        - name: /etc/rsync.password
        - source: salt://rsync/rsync.password
        - user: root
        - group: root
        - mode: 600
    backup:
      file.directory:
        - name: /backup
        - user: root
        - group: root
        - mode: 755
        - makedirs: True
    

    创建rsync服务配置文件(这里是rsync服务的配置文件,上面的是salt安装rsync服务应用的搭建配置文件)

    [root@saltstack rsync]# vi rsyncd.conf           // rsync配置文件
    uid =rsync     
    gid =rsync     
    use chroot=no
    max chonnections =200
    timeout = 300
    pid file =/var/run/rsyncd.pid
    lock file = /var/run/rsync.lock
    log file = /var/log/rsyncd.log
    ignore errors
    read only = false
    list = false
    hosts allow = 172.16.0.0/24
    hosts deny = 0.0.0.0/32
    auth users = rsync_backup
    secrets file = /etc/rsync.password
    [backup]                
    path = /backup 
    
    [root@saltstack rsync]# vi rsyncd.password            // 服务端密码文件
    rsync_backup:123456
    
    [root@saltstack rsync]# vi rsync.password             // 客户端密码文件
    123456
    
    [root@saltstack rsync]# ll
    总用量 20
    -rw-r--r-- 1 root root 274 4月  26 15:17 rsync_client.sls
    -rw-r--r-- 1 root root 376 4月  26 15:11 rsyncd.conf
    -rw-r--r-- 1 root root  20 4月  26 15:15 rsyncd.password
    -rw-r--r-- 1 root root   7 4月  26 15:15 rsync.password
    -rw-r--r-- 1 root root 723 4月  26 15:16 rsync_server.sls
    

    验证rsync服务是否安装成功
    rsync服务端查看服务是否启动

    [root@client1 ~]# ll /etc/rsync.password 
    -rw------- 1 root root 20 4月  26 15:24 /etc/rsync.password
    [root@client1 ~]# cat /etc/rsync.password 
    rsync_backup:123456
    [root@client1 ~]# ps -ef|grep rsync
    root      12636      1  0 15:24 ?        00:00:00 rsync --daemon
    root      12710   2400  0 15:25 pts/0    00:00:00 grep --color=auto rsync
    

    好极了,我们在rsync客户端推送一个文件到服务端是否成功

    [root@client2 ~]# cd /backup/
    [root@client2 backup]# echo 'this msg from new install rsync client used by test' > test.txt
    [root@client2 backup]# ls test.txt 
    test.txt
    [root@client2 backup]# rsync -avz /backup/  rsync_backup@172.16.0.20::backup --password-file=/etc/rsync.password
    sending incremental file list
    ./
    test.txt
    
    sent 132 bytes  received 30 bytes  324.00 bytes/sec
    total size is 52  speedup is 0.32
    

    貌似推送成功了,快去rsync服务端看下吧

    [root@client1 ~]# cd /backup/
    [root@client1 backup]# ll
    总用量 4
    -rw-r--r-- 1 rsync rsync 52 4月  26 15:46 test.txt
    [root@client1 backup]# cat test.txt 
    this msg from new install rsync client used by test
    

    好的,顺利装完,出去抽支烟和活动下颈椎吧。

     

    Pillar

    在大多数场景中,Pillar的表现行为和Grain一致,但有个很大的区别是:Pillar在Master上进行定义,存在于一个集中化的路径。Pillar数据是与特定minion关联的,也就是说每一个minion都只能看到自己的数据,所以Pillar可以用来传递敏感数据(在Salt的设计中,Pillar使用独立的加密session,也是为了保证敏感数据的安全性)。

    Pillar可以用在那些地方:

    1、敏感数据

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

    2、变量

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

    3、其他任何数据

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

    4、用在Targetting中

    Pillar可以用来选择minion,使用-I选项。

    定义Pillar:

    master配置文件中定义:

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

    pillar_opts: False

    使用SLS文件定义Pillar

    Pillar使用与State相似的SLS文件。Pillar文件放在master配置文件中pillar_roots定义的目录下。示例如下:

    pillar_roots:

        base:

            - /srv/pillar

    下面这段代码定义了base环境下的Pillar文件保存在/srv/pillar/目录下。与State相似,Pillar也有top file,也使用相同的匹配方式将数据应用到minion上。示例如下:

    # cat /srv/pillar/top.sls:

    base:

        '*':

            - packages

    # cat /srv/pillar/packages.sls:

    {% if grains['os'] == 'RedHat' %}

    apache: httpd

    git: git

    {% elif grains['os'] == 'Debian' %}

    apache: apache2

    git: git-core

    {% endif %}

    base环境中所有的minion都具有packages中定义的数据。Pillar采用与file server相同的文件映射方式,在本例中,packages映射到文件/srv/pillar/packages.sls。注意key与value要用冒号加空格分隔,没有空格的话将解析失败。

    如何知道minion拥有那些Pillar数据?

    在Master上修改pillar文件后,需要用以下命令刷新minion上的数据:

    新葡亰496net 29

    使用Pillar获取自定义数据:

    新葡亰496net 30

    6.配置认证

    (1)在服务端上操作 新打开一个nb0终端

    [[email protected] ~]# salt-key -a nb0
    The following keys are going to be accepted:
    Unaccepted Keys:
    nb0
    Proceed? [n/Y] y
    Key for minion nb0 accepted.
    [[email protected] ~]#
    
    [[email protected] ~]# salt-key -a nb1
    The following keys are going to be accepted:
    Unaccepted Keys:
    nb1
    Proceed? [n/Y]y
    Key for minion nb1 accepted.
    [[email protected] ~]#
    
    [[email protected] ~]# salt-key -a nb2
    The following keys are going to be accepted:
    Unaccepted Keys:
    nb2
    Proceed? [n/Y] y
    Key for minion nb2 accepted.
    You have mail in /var/spool/mail/root
    [[email protected] ~]#
    
    [[email protected] ~]# salt-key
    Accepted Keys:
    nb0
    nb1
    nb2
    Denied Keys:
    Unaccepted Keys:
    Rejected Keys:
    [[email protected] ~]# 
    

    注意: 在==大规模部署Minion==的时候可以设置自动接受指定等待认证的 key

    在修改/etc/salt/master前,先备份一下

    [[email protected] ~]# cp /etc/salt/master /etc/salt/master.bak
    

    通过vi打开/etc/salt/master

    [[email protected] ~]# vi /etc/salt/master
    

    找到#auto_accept: False一行,修改False为True

    # Enable auto_accept, this setting will automatically accept all incoming
    # public keys from the minions. Note that this is insecure.
    #auto_accept: False
    

    或者通过sed命令修改

    [[email protected] ~]# sed -i 's/#auto_accept: False/auto_accept: True/g' /etc/salt/master
    

    ctrl c停止salt-master,然后再启动

    [[email protected] ~]# salt-master start 
    ^C[WARNING ] Stopping the Salt Master
    [WARNING ] Stopping the Salt Master
    
    Exiting on Ctrl-c
    [WARNING ] Stopping the Salt Master
    
    Exiting on Ctrl-c
    
    Exiting on Ctrl-c
    [[email protected] ~]# salt-master start
    

    (2)测试验证

    [[email protected] ~]# salt '*' test.ping
    nb2:
        True
    nb1:
        True
    nb0:
        True
    [[email protected] ~]#
    

    这里的 * 必须是在 master 上已经被接受过的客户端,可以通过 salt-key 查到

    远程执行命令

    [[email protected] ~]# salt '*' cmd.run   'df -h'
    nb0:
        Filesystem           Size  Used Avail Use% Mounted on
        /dev/mapper/cl-root   48G   26G   22G  55% /
        devtmpfs             3.9G     0  3.9G   0% /dev
        tmpfs                3.9G   16K  3.9G   1% /dev/shm
        tmpfs                3.9G  402M  3.5G  11% /run
        tmpfs                3.9G     0  3.9G   0% /sys/fs/cgroup
        /dev/sda1           1014M  139M  876M  14% /boot
        /dev/mapper/cl-home   24G   33M   24G   1% /home
        tmpfs                781M     0  781M   0% /run/user/0
        /dev/loop0           7.8G  7.8G     0 100% /var/ftp/iso-home
    nb1:
        Filesystem           Size  Used Avail Use% Mounted on
        /dev/mapper/cl-root   48G  4.3G   44G   9% /
        devtmpfs             3.9G     0  3.9G   0% /dev
        tmpfs                3.9G   12K  3.9G   1% /dev/shm
        tmpfs                3.9G  377M  3.5G  10% /run
        tmpfs                3.9G     0  3.9G   0% /sys/fs/cgroup
        /dev/sda1           1014M  139M  876M  14% /boot
        /dev/mapper/cl-home   24G   33M   24G   1% /home
        tmpfs                781M     0  781M   0% /run/user/0
    nb2:
        Filesystem           Size  Used Avail Use% Mounted on
        /dev/mapper/cl-root   48G  4.9G   43G  11% /
        devtmpfs             3.9G     0  3.9G   0% /dev
        tmpfs                3.9G   12K  3.9G   1% /dev/shm
        tmpfs                3.9G  401M  3.5G  11% /run
        tmpfs                3.9G     0  3.9G   0% /sys/fs/cgroup
        /dev/sda1           1014M  139M  876M  14% /boot
        /dev/mapper/cl-home   24G   33M   24G   1% /home
        tmpfs                781M     0  781M   0% /run/user/0
    [[email protected] ~]# 
    

    首先我们要知道在安装SaltStack的时候Master 跟Minion端都分别安装了哪些文件,这样有利于我 们去了解SaltStack日后的一些日常操作。大家可以 通过以下命令查看SaltStack安装部署的时候分别安 装了哪些命令(yum安装方式)。

    [[email protected] ~]# rpm -ql salt-master
    /etc/salt/master            #salt master 配置文件
    /usr/bin/salt               #salt master  核心操作命令
    /usr/bin/salt-cp            #salt  文件传输命令
    /usr/bin/salt-key           #salt  证书管理命令
    /usr/bin/salt-master        #salt master  服务命令
    /usr/bin/salt-run           #salt master runner 命令
    /usr/bin/salt-unity
    /usr/lib/systemd/system/salt-master.service
    /usr/share/man/man1/salt-cp.1.gz
    /usr/share/man/man1/salt-key.1.gz
    /usr/share/man/man1/salt-master.1.gz
    /usr/share/man/man1/salt-run.1.gz
    /usr/share/man/man1/salt-unity.1.gz
    /usr/share/man/man7/salt.7.gz
    [[email protected] ~]#
    
    [[email protected] ~]# salt --version
    salt 2015.5.10 (Lithium)
    [[email protected] ~]#
    

    测试

    > sudo salt "qianlnk" test.ping
    qianlnk:
      True
    
    > sudo salt "qianlnk" cmd.run 'uptime'
    qianlnk:
      13:34:25 up 14 days, 2:37, 1 user, load average: 0.04, 0.18, 0.16
    

    对比ansible,Saltstack缺点是需要安装客户端。为了速度建议选择SaltStack

    Saltstack 常用命令

    1、拷贝文件到客户端

    [root@saltstack ~]# salt 'client2' cp.get_file salt://apache.sls /tmp/cp.txt
    client2:
        /tmp/cp.txt
    

    客户端查看

    [root@client2 ~]# ll /tmp
    总用量 4
    -rw-r--r-- 1 root root 151 4月  26 14:04 cp.txt
    

    2、拷贝目录到客户端

    [root@saltstack ~]# salt 'client2' cp.get_dir salt://test /tmp
    client2:
        - /tmp/test/1.sh
        - /tmp/test/123/1.txt
    

    客户端查看

    root@client2 ~]# ll /tmp/
    总用量 4
    -rw-r--r-- 1 root root 151 4月  26 14:04 cp.txt
    drwxr-xr-x 3 root root  29 4月  26 14:14 test
    

    3、显示存活的客户端

    [root@saltstack ~]# salt-run manage.up
    - client1
    - client2
    - saltstack
    

    4、命令下执行服务端的脚本

    [root@saltstack ~]# vim /srv/salt/test/shell.sh
    #! /bin/sh
    echo "salt server do run shell script on client" > /tmp/shell.txt
    
    [root@saltstack ~]# salt 'client2' cmd.script salt://test/shell.sh
    

    新葡亰496net 31

     

    客户端查看

    [root@client2 ~]# ll /tmp/
    -rw-r--r-- 1 root root  42 4月  26 14:20 shell.txt
    [root@client2 ~]# cat /tmp/shell.txt 
    salt server do run shell script on client
    

    本文永久更新链接地址:http://www.linuxidc.com/Linux/2017-10/147566.htm

    新葡亰496net 32

    State

    简述:SLS(代表SaLt State文件)是Salt State系统的核心。SLS描述了系统的目标状态,由格式简单的数据构成。这经常被称作配置管理

    top.sls是配置管理的入口文件,一切都是从这里开始,在master 主机上,默认存放在/srv/salt/目录.

    top.sls 默认从 base 标签开始解析执行,下一级是操作的目标,可以通过正则,grain模块,或分组名,来进行匹配,再下一级是要执行的state文件,不包换扩展名。

    创建/srv/salt/top.sls

    新葡亰496net 33

    state实战

    新葡亰496net 34

    新葡亰496net 35

    新葡亰496net 36

    7管理对象

    如果我们要维护好一个庞大的配置管理系统,那么首先得维护好我们的管理对象,在SaltStack系 统中我们的管理对象叫作Target,在Master上我们可以采用不同Target去管理不同的Minion。这些 Target都是通过去管理和匹配Minion的ID来做的一些集合。

    [[email protected] ~]# rpm -ql salt-minion
    /etc/salt/minion                #salt minion 配置文件
    /usr/bin/salt-call              #salt call 拉取命令
    /usr/bin/salt-minion            #salt minion  服务命令
    /usr/lib/systemd/system/salt-minion.service
    /usr/share/man/man1/salt-call.1.gz
    /usr/share/man/man1/salt-minion.1.gz
    You have mail in /var/spool/mail/root
    [[email protected] ~]# 
    

    (1)正则匹配

    在操作与管理Minion时可以通过正则表达式来 匹配Minion ID的方式去管理它们。 比如我们想要 对匹配到’nb*’字符串的Minion进行操作,查看各节点的IP

    [[email protected] ~]# salt 'nb*' network.ip_addrs
    nb0:
        - 192.168.1.160
    nb1:
        - 192.168.1.161
    nb2:
        - 192.168.1.162
    [[email protected] ~]# 
    

    (2)列表匹配

    -L, –list 列表匹配

    [[email protected] ~]# salt -L nb1,nb2 test.ping
    nb2:
        True
    nb1:
        True
    [[email protected] ~]# 
    

    (3)Grians匹配

    [[email protected] ~]# salt -G 'os:CentOS' test.ping
    nb0:
        True
    nb1:
        True
    nb2:
        True
    You have mail in /var/spool/mail/root
    [[email protected] ~]#
    

    其中os:CentOS,这里的对象是一组键值对, 这里用到了Minion的Grains的键值对。在后面介绍 Grains的时候会详细讲解,这里只需要知道可以通 过键值对的方式去匹配Minion ID。

    -G, –grain grains 匹配

    (4)组匹配

    首先在master配置文件中定义组

    [[email protected] ~]# vi /etc/salt/master
    
    #####         Node Groups           #####
    ##########################################
    # Node groups allow for logical groupings of minion nodes. A group consists of a group
    # name and a compound target.
    #nodegroups:
    #  group1: '[email protected],bar.domain.com,baz.domain.com and bl*.domain.com'
    #  group2: '[email protected]:Debian and foo.domain.com'
    

    [email protected] 和[email protected] 分别表示minion和grain信息 [email protected]开通的是指定的以逗号分隔的多个minionId

    Letter

    Match Type

    Example

    Alt Delimiter?

    G

    Grains glob

    [email protected]:Ubuntu

    Yes

    E

    PCRE Minion ID

    `[email protected]d .(dev

    qa

    P

    Grains PCRE

    [email protected]:(RedHat

    Fedora

    L

    List of minions

    [email protected],minion3.domain.com or bl*.domain.com

    No

    I

    Pillar glob

    [email protected]:foobar

    Yes

    J

    Pillar PCRE

    `[email protected]:^(foo

    bar)$`

    S

    Subnet/IP address

    [email protected]/24 or [email protected]

    No

    R

    Range cluster

    [email protected]%foo.bar

    No

    Matchers can be joined using boolean and, or, and not operators.

    修改group1:group1: '[email protected],nb2'

    -N, –nodegroup 组匹配

    (5)CIDR匹配 192.168.1.0/24是一个指定的CIDR网段,这里 CIDR匹配的IP地址是Minion连接Matser 4505端口 的来源地址。

    [[email protected] ~]# salt -S '192.168.1.0/24' test.ping
    nb0:
        True
    nb2:
        True
    nb1:
        True
    [[email protected] ~]# 
    

    使用帮助

    sys.doc 类似于linux的man命令,可以显示minion模块的详细使用说明。如:

    sudo salt ‘qianlnk’ sys.doc test
    

    查看minion qianlnk上test模块的更多信息。

    SaltStack github地址:https://github.com/saltstack/salt

    8.管理对象属性

    Grains是SaltStack组件中非常重要的组件之 一,因为我们在做配置部署的过程中会经常使用 它,Grains是SaltStack记录Minion的一些静态信息 的组件,我们可以简单地理解为Grains里面记录着 每台Minion的一些常用属性,比如CPU、内存、磁 盘、网络信息等,我们可以通过grains.items查看某 台Minion的所有Grains信息,Minions的Grains信息 是Minions启动的时候采集汇报给Master的,在实际 应用环境中我们需要根据自己的业务需求去自定义 一些Grains

    grains&pillar

    SaltStack官网文档地址:https://docs.saltstack.com

    8.1通过Minion配置文件定义Grains

    先介绍下比较简单的Grains自定义方法,就是通过Minion配置文件定义

    Minions的Grains信息是在Minions服务启动的时候汇报给Matser的,所以我们需要修改好Minion配置文 件后重启Minion服务。在Minion的/etc/salt/minion配置文件中默认有一些注释行。这里就是在Minion上 的minion配置文件中如何定义Grains信息例子。下面只需根据自动的需求按照以下格式去填写相应的 键值对就行,大家注意格式就行,SaltStack的配置文件的默认格式都是YAML格式:

    # Custom static grains for this minion can be specified here and used in SLS
    # files just like all other grains. This example sets 4 custom grains, with
    # the 'roles' grain having two values that can be matched against.
    #grains:
    #  roles:
    #    - webserver
    #    - memcache
    #  deployment: datacenter4
    #  cabinet: 13
    #  cab_u: 14-15
    

    为了统一管理Minion的Grains信息,需要把这 些注释复制到minion.d/grains文件中

    自定义 grains,客户端上配置

    [[email protected] ~]# vi /etc/salt/minion
    
    # Custom static grains for this minion can be specified here and used in SLS
    # files just like all other grains. This example sets 4 custom grains, with
    # the 'roles' grain having two values that can be matched against.
    grains:
      roles:
        - nginx
      env:
        - test
      myname:
        - hadron
    #  deployment: datacenter4
    #  cabinet: 13
    #  cab_u: 14-15
    

    重启salt-minion

    [[email protected] ~]# ps -aux|grep salt-minion
    root      38792  0.0  0.1 231928 15388 pts/0    S    02:32   0:00 /usr/bin/python /usr/bin/salt-minion restart
    root      38795  0.5  0.3 547648 28872 pts/0    Sl   02:32   0:00 /usr/bin/python /usr/bin/salt-minion restart
    root      43928  0.3  0.1 231928 15384 pts/0    S    02:34   0:00 /usr/bin/python /usr/bin/salt-minion restart
    root      43933  1.8  0.3 547648 28784 pts/0    Sl   02:34   0:00 /usr/bin/python /usr/bin/salt-minion restart
    root      45693  0.0  0.0 112648   960 pts/0    S    02:34   0:00 grep --color=auto salt-minion
    root      50604  0.0  0.1 231928 15384 pts/0    S    Aug17   0:00 /usr/bin/python /usr/bin/salt-minion start
    root      50607  0.0  0.3 760916 29024 pts/0    Sl   Aug17   0:48 /usr/bin/python /usr/bin/salt-minion start
    root      92074  0.0  0.1 231928 15388 pts/0    S    01:58   0:00 /usr/bin/python /usr/bin/salt-minion restart
    root      92077  0.0  0.3 547916 26832 pts/0    Sl   01:58   0:01 /usr/bin/python /usr/bin/salt-minion restart
    [[email protected] ~]# kill 38792 43928 45693 50604
    -bash: kill: (45693) - No such process
    [[email protected] ~]# ps -aux|grep salt-minion
    root      43933  1.2  0.3 547648 28784 pts/0    Sl   02:34   0:00 /usr/bin/python /usr/bin/salt-minion restart
    root      46529  0.0  0.0 112648   956 pts/0    S    02:35   0:00 grep --color=auto salt-minion
    root      92074  0.0  0.1 231928 15388 pts/0    S    01:58   0:00 /usr/bin/python /usr/bin/salt-minion restart
    root      92077  0.0  0.3 547916 26832 pts/0    Sl   01:58   0:02 /usr/bin/python /usr/bin/salt-minion restart
    [1]   Terminated              salt-minion start
    [3]-  Terminated              salt-minion restart
    [4]   Terminated              salt-minion restart
    [[email protected] ~]# kill 92077 92074 43933
    -bash: kill: (43933) - No such process
    [[email protected] ~]# ps -aux|grep salt-minion
    root      48215  0.0  0.0 112648   960 pts/0    S    02:36   0:00 grep --color=auto salt-minion
    [2]   Terminated              salt-minion restart
    [[email protected] ~]# salt-minion restart &
    [1] 49052
    [[email protected] ~]# 
    

    服务端获取 grains

    [[email protected] ~]# salt 'nb1' grains.item role env myname
    nb1:
        ----------
        env:
            - test
        myname:
            - hadron
        role:
            - nginx
    [[email protected] ~]# 
    [[email protected] ~]# salt 'nb1' grains.item role
    nb1:
        ----------
        role:
            - nginx
    [[email protected] ~]#
    

    注意:grains 在远程执行命令时很方便。我们可以按照 grains 的一些指标来操作。比如把所有的 web 服务器的 grains 的 role 设置为 nginx,那这样我们就可以批量对 nginx 的服务器进行操作了:

    [[email protected] ~]# salt -G role:nginx cmd.run 'hostname'
    nb1:
        nb1
    [[email protected] ~]# 
    
    [[email protected] ~]# salt -G os:CentOS cmd.run 'hostname'
    nb1:
        nb1
    nb0:
        nb0
    nb2:
        nb2
    [[email protected] ~]#
    

    什么是grains?

    Grains是服务器的一系列粒子信息,也就是服务器的一系列物理,软件环境信息。在执行salt的sls时候可以根据Grains信息的不同对服务器进行匹配分组,例如可以根据系统是centos服务器跟系统是redhat环境的安装不同的软件包。

    SaltStack架构

    8.2 pillar

    pillar 和 grains 不一样,是在 master 上定义的,并且是针对 minion 定义的一些信息。像一些比较重要的数据(密码)可以存在 pillar 里,还可以定义变量等。

    (1)服务端自定义配置 pillar

    [[email protected] ~]# vim /etc/salt/master
    

    找到如下内容,

    #pillar_roots:
    #  base:
    #    - /srv/pillar
    #
    

    去掉#号,修改为

    pillar_roots:
      base:
        - /srv/pillar
    
    [[email protected] ~]# mkdir /srv/pillar
    

    自定义配置文件,内容如下

    [[email protected] ~]# vim /srv/pillar/test.sls
    [[email protected] ~]# cat /srv/pillar/test.sls
    conf: /etc/test123.conf
    myname: hadron
    [[email protected] ~]# 
    

    总入口文件,内容如下

    [[email protected] ~]# vim /srv/pillar/top.sls
    [[email protected] ~]# cat /srv/pillar/top.sls
    base:
      'nb1':
        - test
    [[email protected] ~]#
    

    重启master

    [[email protected] ~]# ps -aux|grep salt-master
    root      29178  0.0  0.3 313076 26816 pts/3    S    Aug17   0:00 /usr/bin/python /usr/bin/salt-master start
    root      29242  0.5  0.4 407192 32856 pts/3    Sl   Aug17   1:24 /usr/bin/python /usr/bin/salt-master start
    root      29243  0.0  0.2 395004 22692 pts/3    Sl   Aug17   0:00 /usr/bin/python /usr/bin/salt-master start
    root      29244  0.0  0.3 395004 24292 pts/3    Sl   Aug17   0:00 /usr/bin/python /usr/bin/salt-master start
    root      29245  0.0  0.2 313076 22016 pts/3    S    Aug17   0:00 /usr/bin/python /usr/bin/salt-master start
    root      29250  0.0  0.3 1204752 28560 pts/3   Sl   Aug17   0:01 /usr/bin/python /usr/bin/salt-master start
    root      29251  0.0  0.3 1205064 28624 pts/3   Sl   Aug17   0:01 /usr/bin/python /usr/bin/salt-master start
    root      29252  0.0  0.3 1205068 28596 pts/3   Sl   Aug17   0:01 /usr/bin/python /usr/bin/salt-master start
    root      29255  0.0  0.3 1205068 28648 pts/3   Sl   Aug17   0:01 /usr/bin/python /usr/bin/salt-master start
    root      29258  0.0  0.3 1205072 28584 pts/3   Sl   Aug17   0:01 /usr/bin/python /usr/bin/salt-master start
    root      29261  0.0  0.2 689932 22668 pts/3    Sl   Aug17   0:00 /usr/bin/python /usr/bin/salt-master start
    root      93354  0.0  0.0 112652   960 pts/2    S    03:07   0:00 grep --color=auto salt-master
    [[email protected] ~]# kill 29178 29242 29243 29244 29245 29250 29251 29252 29255 29258 29261
    

    在单独终端启动

    [[email protected] ~]# salt-master start
    

    注意:当更改完 pillar 配置文件后,我们可以通过刷新 pillar 配置来获取新的 pillar 状态

    [[email protected] ~]# salt '*' saltutil.refresh_pillar
    nb1:
        True
    nb0:
        True
    nb2:
        True
    [[email protected] ~]# 
    

    验证

    [[email protected] ~]# salt 'nb1' pillar.items
    nb1:
        ----------
        conf:
            /etc/test123.conf
        myname:
            hadron
    [[email protected] ~]# salt 'nb1' pillar.item conf
    nb1:
        ----------
        conf:
            /etc/test123.conf
    [[email protected] ~]# salt 'nb1' pillar.item myname
    nb1:
        ----------
        myname:
            hadron
    [[email protected] ~]# 
    

    pillar 同样可以用来作为 salt 的匹配对象

    [[email protected] ~]# salt -I 'conf:/etc/test123.conf' test.ping
    nb1:
        True
    [[email protected] ~]# salt -I 'conf:/etc/test123.conf' cmd.run 'w'
    nb1:
         03:17:08 up 67 days, 14:25,  1 user,  load average: 0.02, 0.12, 0.24
        USER     TTY      FROM             [email protected]   IDLE   JCPU   PCPU WHAT
        root     pts/0    hadron           Mon21   24:44   2.38s  0.16s -bash
    [[email protected] ~]#
    

    查看grains的功能

    sudo salt ‘qianlnk’ sys.list_functions grains
    qianlnk: 
      - grains.append 
      - grains.delval 
      - grains.fetch 
      - grains.filter_by 
      - grains.get 
      - grains.get_or_set_hash 
      - grains.has_value 
      - grains.item 
      - grains.items 
      - grains.ls 
      - grains.remove 
      - grains.set 
      - grains.setval 
      - grains.setvals 
    

    在SaltsStack架构中服务端叫作Master,客户端叫作Minion,都是以守护进程的模式运行,一直监听配置文件中定义的ret_port(saltstack客户端与服务端通信的端口,负责接收客户端发送过来的结果,默认4506端口)和publish_port(saltstack的消息发布系统,默认4505端口)的端口。当Minion运行时会自动连接到配置文件中定义的Master地址ret_port端口进行连接认证。

    9. 配置管理安装Apache

    下面进行的演示是远程通过 yum 方式安装 Apache。步骤如下:

    (1)配置

    [[email protected] ~]# vim /etc/salt/master
    

    找到如下内容

    # file_roots:
    #   base:
    #     - /srv/salt/
    

    去掉#注释

    file_roots:
      base:
        - /srv/salt
    
    [[email protected] ~]# mkdir /srv/salt
    [[email protected] ~]# vim /srv/salt/top.sls
    [[email protected] ~]# cat /srv/salt/top.sls
    base:
      'nb1':
        - apache
    [[email protected] ~]#
    
    [[email protected] ~]# vim /srv/salt/apache.sls
    [[email protected] ~]# cat /srv/salt/apache.sls
    apache-service:
      pkg.installed:
        - names:
          - httpd
          - httpd-devel
      service.running:
        - name: httpd
        - enable: True
    [[email protected] ~]#
    

    注意:apache-service 是自定义的 id 名。pkg.installed 为包安装函数,下面是要安装的包的名字。service.running 也是一个函数,来保证指定的服务启动,enable 表示开机启动。

    (2)重启服务

    [[email protected] ~]# salt-master start 
    ^C[WARNING ] Stopping the Salt Master
    [WARNING ] Stopping the Salt Master
    [WARNING ] Stopping the Salt Master
    
    Exiting on Ctrl-c
    
    Exiting on Ctrl-c
    
    Exiting on Ctrl-c
    You have mail in /var/spool/mail/root
    [[email protected] ~]# salt-master start
    
    [[email protected] ~]# salt 'nb1' state.highstate
    nb1:
    ----------
              ID: apache-service
        Function: pkg.installed
            Name: httpd
          Result: True
         Comment: Package httpd is already installed.
         Started: 03:38:36.137884
        Duration: 1250.258 ms
         Changes:   
    ----------
              ID: apache-service
        Function: pkg.installed
            Name: httpd-devel
          Result: True
         Comment: The following packages were installed/updated: httpd-devel
         Started: 03:38:37.388313
        Duration: 33668.276 ms
         Changes:   
                  ----------
                  apr-devel:
                      ----------
                      new:
                          1.4.8-3.el7
                      old:
                  apr-util-devel:
                      ----------
                      new:
                          1.5.2-6.el7
                      old:
                  cyrus-sasl:
                      ----------
                      new:
                          2.1.26-20.el7_2
                      old:
                  cyrus-sasl-devel:
                      ----------
                      new:
                          2.1.26-20.el7_2
                      old:
                  httpd:
                      ----------
                      new:
                          2.4.6-45.el7.centos.4
                      old:
                          2.4.6-45.el7.centos
                  httpd-devel:
                      ----------
                      new:
                          2.4.6-45.el7.centos.4
                      old:
                  httpd-tools:
                      ----------
                      new:
                          2.4.6-45.el7.centos.4
                      old:
                          2.4.6-45.el7.centos
                  openldap-devel:
                      ----------
                      new:
                          2.4.40-13.el7
                      old:
    ----------
              ID: apache-service
        Function: service.running
            Name: httpd
          Result: True
         Comment: Service httpd has been enabled, and is running
         Started: 03:39:11.080192
        Duration: 6685.669 ms
         Changes:   
                  ----------
                  httpd:
                      True
    
    Summary
    ------------
    Succeeded: 3 (changed=2)
    Failed:    0
    ------------
    Total states run:     3
    [[email protected] ~]# 
    

    说明 Apache 远程安装已成功。

    [[email protected] ~]# systemctl status httpd.service
    ● httpd.service - The Apache HTTP Server
       Loaded: loaded (/usr/lib/systemd/system/httpd.service; enabled; vendor preset: disabled)
       Active: active (running) since Fri 2017-08-18 03:39:17 EDT; 2min 10s ago
         Docs: man:httpd(8)
               man:apachectl(8)
     Main PID: 11613 (httpd)
       Status: "Total requests: 0; Current requests/sec: 0; Current traffic:   0 B/sec"
       CGroup: /system.slice/httpd.service
               ├─11613 /usr/sbin/httpd -DFOREGROUND
               ├─11715 /usr/sbin/httpd -DFOREGROUND
               ├─11716 /usr/sbin/httpd -DFOREGROUND
               ├─11717 /usr/sbin/httpd -DFOREGROUND
               ├─11718 /usr/sbin/httpd -DFOREGROUND
               └─11719 /usr/sbin/httpd -DFOREGROUND
    
    Aug 18 03:39:16 nb1 systemd[1]: Starting The Apache HTTP Server...
    Aug 18 03:39:16 nb1 httpd[11613]: AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 192.168.1.161. Set the 'ServerN...his message
    Aug 18 03:39:17 nb1 systemd[1]: Started The Apache HTTP Server.
    Hint: Some lines were ellipsized, use -l to show in full.
    [[email protected] ~]# 
    

    查看grains信息

    sudo salt ‘qianlnk’ grains.items
    

    新葡亰496net 37

    10.states文件

    salt states的核心是sls文件,该文件使用YAML语法定义了一些k/v的数据。

    sls文件存放根路径在master配置文件中定义,默认为/srv/salt,该目录在操作系统上不存在,需要手动创建。

    在salt中可以通过salt://代替根路径,例如你可以通过salt://top.sls访问/srv/salt/top.sls。

    在states中top文件也由master配置文件定义,默认为top.sls,该文件为states的入口文件。 一个简单的sls文件如下:

    apache:
     pkg.installed
     service.running
       - require:
         - pkg: apache
    

    说明:此SLS数据确保叫做”apache”的软件包(package)已经安装,并且”apache”服务(service)正在运行中。

    • 第一行,被称为ID说明(ID Declaration)。ID说明表明可以操控的名字。
    • 第二行和第四行是State说明(State Declaration),它们分别使用了pkg和service states。pkg state通过系统的包管理其管理关键包,service state管理系统服务(daemon)。 在pkg及service列下边是运行的方法。方法定义包和服务应该怎么做。此处是软件包应该被安装,服务应该处于运行中。
    • 第六行使用require。本方法称为”必须指令”(Requisite Statement),表明只有当apache软件包安装成功时,apache服务才启动起来

    salt-master是通过写sls配置管理minion上重复指令的,服务状态等等。

    salt states的核心是sls文件,该文件使用YAML语法定义了一些k/v的数据。sls文件存放根路径在master配置文件中定义,默认为/srv/salt,该目录在操作系统上不存在,需要手动创建。

    [[email protected] ~]# mkdir -p /srv/salt/base
    

    怎么使用grains?

    1. Master:控制中心,salt命令运行和资源状态管理
    2. Minion : 需要管理的客户端机器,会主动去连接Mater端,并从Master端得到资源状态
    3. 信息,同步资源管理信息
    4. States:配置管理的指令集
    5. Modules:在命令行中和配置文件中使用的指令模块,可以在命令行中运行
    6. Grains:minion端的变量,静态的
    7. Pillar:minion端的变量,动态的比较私密的变量,可以通过配置文件实现同步minions定义
    8. highstate:为minion端下发永久添加状态,从sls配置文件读取.即同步状态配置
    9. salt_schedule:会自动保持客户端配置

    11.文件目录管理

    命令行中使用

    对操作系统是Ubuntu的服务器执行test.ping 
    ➜ salt sudo salt -G "os:Ubuntu" test.ping 
    dk1: 
      True 
    dk2: 
      True 
    
    显示cpu架构是x86_64的服务器的cpu个数 
    ➜ salt sudo salt -G 'cpuarch:x86_64' grains.item num_cpus 
    dk2: 
      ---------- 
      num_cpus: 
      4 
    dk1: 
      ---------- 
      num_cpus: 
      4 
    

    SaltStack安装配置

    11.1文件管理

    (1)服务端配置

    [[email protected] ~]# vim /srv/salt/top.sls
    [[email protected] ~]# cat /srv/salt/top.sls
    base:
      'nb1':
        - apache
      'nb2':
        - filetest
    [[email protected] ~]# 
    

    新建 filetest.sls 文件

    [[email protected] ~]# vim /srv/salt/filetest.sls
    [[email protected] ~]# cat /srv/salt/filetest.sls
    file-test:
      file.managed:
        - name: /tmp/filetest.txt
        - source: salt://test/123/1.txt
        - user: root
        - group: root
        - mode: 644
    [[email protected] ~]# 
    

    注意:第一行的 file-test 为自定的名字,表示该配置段的名字,可以在别的配置段中引用它;source指定文件从哪里拷贝,这里的 test 目录相当于是 /srv/salt/test 目录;name指定远程客户端要生成的文件。

    新建所要测试的源文件

    [[email protected] ~]# mkdir -p /srv/salt/test/123/
    [[email protected] ~]# echo "file test" > /srv/salt/test/123/1.txt
    [[email protected] ~]#
    

    执行命令:

    [[email protected] ~]# salt 'nb2' state.highstate
    nb2:
    ----------
              ID: file-test
        Function: file.managed
            Name: /tmp/filetest.txt
          Result: True
         Comment: File /tmp/filetest.txt updated
         Started: 03:59:13.664379
        Duration: 505.159 ms
         Changes:   
                  ----------
                  diff:
                      New file
                  mode:
                      0644
    
    Summary
    ------------
    Succeeded: 1 (changed=1)
    Failed:    0
    ------------
    Total states run:     1
    [[email protected] ~]# 
    

    (2)客户端验证

    [[email protected] ~]# cat /tmp/filetest.txt 
    file test
    [[email protected] ~]# 
    

    sls中使用

    #在top.sls中使用 
    
    'os:Ubuntu': 
      - match: grain 
      - webserver 
    
    在top.sls入口中对系统是Ubuntu的服务器执行webserver.sls里定义的状态信息。 
    

    默认以CentOS6为例,采用yum安装,还有其它安装方式,如pip、源码、salt-bootstrap

    11.2目录管理

    (1)接着编辑之前的 top.sls 文件

    修改为如下

    [[email protected] ~]# vim /srv/salt/top.sls
    [[email protected] ~]# cat /srv/salt/top.sls
    base:
      'nb1':
        - apache
      'nb2':
        - filedir
    [[email protected] ~]#
    

    (2)新建 filedir.sls 文件

    [[email protected] ~]# vim /srv/salt/filedir.sls
    [[email protected] ~]# cat /srv/salt/filedir.sls
    file-dir:
      file.recurse:
        - name: /tmp/testdir
        - source: salt://test/123
        - user: root
        - file_mode: 644
        - dir_mode: 755
        - mkdir: True
        - clean: True
    [[email protected] ~]#
    

    clean: True 源删除文件或目录,目标也会跟着删除,否则不会删除。可以默认设置为 False

    (3)新建所要测试的源目录

    /srv/salt/test/123已经存在,且有一个文件

    [[email protected] ~]# ls /srv/salt/test/123
    1.txt
    [[email protected] ~]# cat /srv/salt/test/123/1.txt 
    file test
    

    (4)执行命令

    [[email protected] ~]# salt 'nb2' state.highstate
    nb2:
    ----------
              ID: file-dir
        Function: file.recurse
            Name: /tmp/testdir
          Result: True
         Comment: Recursively updated /tmp/testdir
         Started: 01:38:38.129930
        Duration: 392.34 ms
         Changes:   
                  ----------
                  /tmp/testdir/1.txt:
                      ----------
                      diff:
                          New file
                      mode:
                          0644
    
    Summary
    ------------
    Succeeded: 1 (changed=1)
    Failed:    0
    ------------
    Total states run:     1
    [[email protected] ~]#
    

    (5)客户端验证

    [[email protected] ~]# ls /tmp
    filetest.txt                     Jetty_0_0_0_0_16010_master____.6nvknp        Jetty_localhost_40934_datanode____.k20t6j
    hadoop-root-journalnode.pid      Jetty_0_0_0_0_16030_regionserver____.45q9os  Jetty_nb2_50070_hdfs____xjgcrn
    hadoop-unjar4050493136279788948  Jetty_0_0_0_0_8042_node____19tj0x            systemd-private-bd8f0cf7c19147208fb1f2948ed5483f-vmtoolsd.service-LQvsNz
    hsperfdata_root                  Jetty_0_0_0_0_8480_journal____.8g4awa        testdir
    [[email protected] ~]# ls /tmp/testdir/
    1.txt
    [[email protected] ~]# 
    

    (6)测试增删功能

    在服务端新建newDir目录以及文件a,删除1.txt 文件

    [[email protected] ~]# cd /srv/salt/test/123
    [[email protected] 123]# mkdir newDir
    [[email protected] 123]# echo "Hello" > newDir/a
    [[email protected] 123]# rm -rf 1.txt
    

    (7)再次执行命令

    [[email protected] ~]# salt 'nb2' state.highstate
    nb2:
    ----------
              ID: file-dir
        Function: file.recurse
            Name: /tmp/testdir
          Result: True
         Comment: Recursively updated /tmp/testdir
         Started: 01:45:59.688250
        Duration: 442.358 ms
         Changes:   
                  ----------
                  /tmp/testdir/newDir:
                      ----------
                      /tmp/testdir/newDir:
                          New Dir
                  /tmp/testdir/newDir/a:
                      ----------
                      diff:
                          New file
                      mode:
                          0644
                  removed:
                      - /tmp/testdir/1.txt
    
    Summary
    ------------
    Succeeded: 1 (changed=1)
    Failed:    0
    ------------
    Total states run:     1
    [[email protected] ~]#
    

    (8)再次验证

    [[email protected] ~]# ls /tmp/testdir/
    newDir
    [[email protected] ~]# ls /tmp/testdir/newDir/
    a
    [[email protected] ~]#
    

    注意的是要成功创建newDir目录,前提是newDir目录下要有文件;如若没有,客户端是不会创建newDir目录的。

    自定义grains

    存在形式:

    1、core grains 
    2、在/etc/salt/grains 中自定义 
    3、在/etc/salt/minion 中自定义 
    4、在_grains目录中自定义grains,同步到minions 
    
    • core grains是系统设定的grains,如果自定义的grains的名称跟core grains中的一样则会将之覆盖掉。
    • 在minion端的/etc/salt/grains中定义:
    root@17ca9e9efc8a:/etc/salt# cat grains  
    roles: 
      - zookeeper 
      - kafka 
    

    注意!该目录下不存在grains文件的话自己创建,定义grains后需要重启salt-minion。

    测试:

    sudo salt -G “roles:kafka”  test.ping
    cn2: 
      True
    
    • 在/etc/salt/minion中定义,类似在/etc/salt/grains中定义。
    • 在master端,_grains目录中定义:
    ➜  cd /srv/salt 
    ➜  mkdir _grains 
    ➜  cd _grains  
    ➜  vi my_grain.py 
    #添加内容 
    ➜  cat my_grain.py  
    def my_grains(): 
    grains = {'roles' : ['phpserver','webserver']} 
    return grains 
    
    ➜  sudo salt -E "dk*" saltutil.sync_grains     #刷新minion的grains 
    dk2: 
      - grains.my_grain 
    dk1: 
      - grains.my_grain 
    ➜  sudo salt -E "dk*" grains.item roles 
    dk2: 
      ---------- 
      roles: 
      - phpserver 
      - webserver 
    dk1: 
      ---------- 
      roles: 
      - phpserver 
      - webserver 
    
    ➜ sudo salt -G "roles:webserver" test.ping 
    dk2: 
      True 
    dk1: 
      True 
    

    EPEL源配置

    12.远程执行

    前面提到远程执行命令 test.ping,cmd.run,点前面的是模块,点后面的是函数;这样总归是不太规范化,下面详细介绍怎么远程执行命令和脚本。

    什么是pillar?

    跟grains的结构是一样的,也是字典格式,数据通过key/value的格式进行存储。使用独立的session加密。Pillar是数据中心, 其在Saltstack中主要的作用就是存储和定义配置管理中需要的一些数据,比如软件版本号、用户名密码等信息。

    rpm -ivh https://mirrors.tuna.tsinghua.edu.cn/epel/epel-release-latest-6.noarch.rpm
    

    12.1远程执行命令

    (1)接着编辑之前的 top.sls 文件

    [[email protected] ~]# vim /srv/salt/top.sls
    [[email protected] ~]# cat /srv/salt/top.sls
    base:
      'nb1':
        - cmdtest
      'nb2':
        - filedir
    [[email protected] ~]# 
    

    (2)新建 cmdtest.sls 文件

    [[email protected] ~]# vim /srv/salt/cmdtest.sls
    [[email protected] ~]# cat /srv/salt/cmdtest.sls
    cmd-test:  
      cmd.run:
        - onlyif: test -f /tmp/1.txt
        - names:
          - touch /tmp/cmdtest.txt
          - mkdir /tmp/cmdtest
        - user: root
    [[email protected] ~]# 
    

    条件 onlyif 表示若 /tmp/1.txt文件存在,则执行后面的命令;可以使用 unless,两者正好相反。

    [[email protected] ~]# echo "hello" > /tmp/1.txt
    [[email protected] ~]# cat /tmp/1.txt 
    hello
    [[email protected] ~]#
    

    (3)执行命令

    [[email protected] ~]# salt 'nb1' state.highstate
    nb1:
    ----------
              ID: cmd-test
        Function: cmd.run
            Name: touch /tmp/cmdtest.txt
          Result: True
         Comment: Command "touch /tmp/cmdtest.txt" run
         Started: 02:23:07.347360
        Duration: 565.866 ms
         Changes:   
                  ----------
                  pid:
                      7209
                  retcode:
                      0
                  stderr:
                  stdout:
    ----------
              ID: cmd-test
        Function: cmd.run
            Name: mkdir /tmp/cmdtest
          Result: True
         Comment: Command "mkdir /tmp/cmdtest" run
         Started: 02:23:07.913505
        Duration: 208.682 ms
         Changes:   
                  ----------
                  pid:
                      7245
                  retcode:
                      0
                  stderr:
                  stdout:
    
    Summary
    ------------
    Succeeded: 2 (changed=2)
    Failed:    0
    ------------
    Total states run:     2
    [[email protected] ~]#
    

    (4)验证

    [[email protected] ~]# ll /tmp|grep cmd
    drwxr-xr-x 2 root root   6 Aug 21 02:23 cmdtest
    -rw-r--r-- 1 root root   0 Aug 21 02:23 cmdtest.txt
    [[email protected] ~]# 
    

    查看grains的功能

    ➜ ~ sudo salt "cn1" sys.list_functions pillar 
    cn1: 
      - pillar.data 
      - pillar.ext 
      - pillar.fetch 
      - pillar.file_exists 
      - pillar.get 
      - pillar.item 
      - pillar.items 
      - pillar.keys 
      - pillar.ls 
      - pillar.obfuscate 
      - pillar.raw 
    

    Pillar数据跟特定的Minion关联,可以用来传递Minion自己的信息。管理员也可以自定义自己的pillar来管理minion。

    安装、配置管理端(master)

    12.2 远程执行脚本

    (1)接着编辑之前的 top.sls 文件

    [[email protected] ~]# vim /srv/salt/top.sls
    [[email protected] ~]# cat /srv/salt/top.sls
    base:
      'nb1':
        - cmdtest
      'nb2':
        - shelltest
    [[email protected] ~]# 
    

    (2)新建 shelltest.sls 文件

    [[email protected] ~]# vim /srv/salt/shelltest.sls
    [[email protected] ~]# cat /srv/salt/shelltest.sls
    shell-test:
      cmd.script:
        - source: salt://test/1.sh
        - user: root
    [[email protected] ~]# 
    

    (3)新建 1.sh 脚本文件

    [[email protected] ~]# vim /srv/salt/test/1.sh
    [[email protected] ~]# cat /srv/salt/test/1.sh
    #!/bin/bash
    touch /tmp/shelltest.txt
    if [ -d /tmp/shelltest ]
    then
        rm -rf /tmp/shelltest
    else
        mkdir /tmp/shelltest
    fi
    [[email protected] ~]#
    

    (4)执行命令

    [[email protected] ~]# salt 'nb2' state.highstate
    nb2:
    ----------
              ID: shell-test
        Function: cmd.script
          Result: True
         Comment: Command 'shell-test' run
         Started: 02:35:33.341722
        Duration: 585.072 ms
         Changes:   
                  ----------
                  pid:
                      48228
                  retcode:
                      0
                  stderr:
                  stdout:
    
    Summary
    ------------
    Succeeded: 1 (changed=1)
    Failed:    0
    ------------
    Total states run:     1
    [[email protected] ~]# 
    

    (5)客户端验证

    [[email protected] ~]# ll /tmp|grep shell
    drwxr-xr-x 2 root root   6 Aug 21 02:35 shelltest
    -rw-r--r-- 1 root root   0 Aug 21 02:35 shelltest.txt
    [[email protected] ~]# 
    

    通过上面的例子,我们实现了远程执行脚本;如果我们想一键远程安装 LAMP 或者 LNMP,那么只需把本例中的 1.sh 脚本替换成 一键安装的脚本就行。

    自定义pillar

    在master的sls文件中定义,master配置需要指定pillar的目录。

    pillar_roots: 
      base: 
      - /srv/pillar 
    
    ➜ pillar git:(master) ✗ pwd
    /srv/pillar
    
    ➜ pillar git:(master) ✗ cat top.sls 
    base:
      '*':
      - data
      - git
    
    ➜ pillar git:(master) ✗ cat data/init.sls
    roles: webserver
    ➜ pillar git:(master) ✗ cat git.sls
    {% if grains[‘os’] == ‘CentOs’ %}
    git: git
    {% elif grains[‘os’] == ‘Debian’ %}
    git: git-core
    {% endif %}
    

    默认情况下,master配置文件中的所有数据都会添加到pillar中,且对所有的minion可用。如果要禁止这一个默认值,可以设置master文件中的选项:
    pillar_opts: False

    pillar跟sls一样有自己的top.sls文件作为入口来组织其他的pillar。base中 “×”制定所有minion拥有pillar:mongodb、zookeeper、kafka、supervisor, 然后是各个minion组有自己的init.sls。kafka.sls中定义kafka对应的一些信息。

    修改完pillar文件后需要用以下的命令刷新以下minion的信息:

    ➜ pillar git:(master) ✗ sudo salt 'cn1' saltutil.refresh_pillar 
    cn1: 
      True 
    
    yum -y install salt-master
    service salt-master start
    

    13.管理任务计划

    使用pillar

    Target:

    #salt使用 -l 选项来使用pillar
    ➜ pillar git:(master) ✗ sudo salt -l ”roles:webserver” test.ping
    

    sls文件中使用:

    #如根据系统环境安装git
    ➜ salt git:(master) ✗ cat git_env.sls
    git:
      pkg.installed:
        - name: {{pillar[‘git’]}}
    
    #或者:
    git:
      pkg.installed:
        - name: {{ salt[‘pillar.get’](‘git’, ‘git’) }}
    

    注:需要iptables开启master端4505、4506端口

    13.1 建立 cron

    (1)编辑 top.sls 文件

    [[email protected] ~]# vim /srv/salt/top.sls
    [[email protected] ~]# cat /srv/salt/top.sls
    base:
      'nb1':
        - crontest
      'nb2':
        - shelltest
    [[email protected] ~]#
    

    (2)编辑 crontest.sls 文件

    [[email protected] ~]# vim /srv/salt/crontest.sls
    [[email protected] ~]# cat /srv/salt/crontest.sls
    cron-test:
      cron.present:
        - name: /bin/touch /tmp/111.txt
        - user: root
        - minute: '*'
        - hour: 20
        - daymonth: 1-10
        - month: '3,5'
        - dayweek: '*'
    [[email protected] ~]#
    

    注意,*需要用单引号引起来。当然我们还可以使用 file.managed 模块来管理 cron,因为系统的 cron都是以配置文件的形式存在的。

    (3)执行命令

    [[email protected] ~]# salt 'nb1' state.highstate
    nb1:
    ----------
              ID: cron-test
        Function: cron.present
            Name: /bin/touch /tmp/111.txt
          Result: True
         Comment: Cron /bin/touch /tmp/111.txt added to root's crontab
         Started: 02:47:51.454886
        Duration: 1478.963 ms
         Changes:   
                  ----------
                  root:
                      /bin/touch /tmp/111.txt
    
    Summary
    ------------
    Succeeded: 1 (changed=1)
    Failed:    0
    ------------
    Total states run:     1
    [[email protected] ~]# 
    

    (4)客户端验证

    [[email protected] ~]# crontab -l
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.160
    # Lines below here are managed by Salt, do not edit
    # SALT_CRON_IDENTIFIER:/bin/touch /tmp/111.txt
    * 20 1-10 3,5 * /bin/touch /tmp/111.txt
    [[email protected] ~]# 
    

    管理对象Target

    在saltstack系统中,我们的管理对象叫作Target。在Master上我们可以采用不同的Target去管理不同的Minion。这些Target可以是主机名、系统信息、定义的分组、甚至是自定义绑定的对象。

    安装被管理端

    13.2 删除 cron

    (1)修改 crontest.sls 文件 把 cron.present: 改成 cron.absent: 注意:两者不能共存,要想删除一个 cron,那之前的 present 就得替换掉或者删除掉。

    [[email protected] ~]# vim /srv/salt/crontest.sls
    [[email protected] ~]# cat /srv/salt/crontest.sls
    cron-test:
      cron.absent:
        - name: /bin/touch /tmp/111.txt
        - user: root
        - minute: '*'
        - hour: 20
        - daymonth: 1-10
        - month: '3,5'
        - dayweek: '*'
    [ro
    [email protected] ~]#
    

    (2)执行命令

    [[email protected] ~]# salt 'nb1' state.highstate
    nb1:
    ----------
              ID: cron-test
        Function: cron.absent
            Name: /bin/touch /tmp/111.txt
          Result: True
         Comment: Cron /bin/touch /tmp/111.txt removed from root's crontab
         Started: 02:56:03.583557
        Duration: 29.663 ms
         Changes:   
                  ----------
                  root:
                      /bin/touch /tmp/111.txt
    
    Summary
    ------------
    Succeeded: 1 (changed=1)
    Failed:    0
    ------------
    Total states run:     1
    [[email protected] ~]# 
    

    (3)客户端验证

    [[email protected] ~]# crontab -l
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.81
    00      03      *       *       *       ntpdate 192.168.1.160
    # Lines below here are managed by Salt, do not edit
    [[email protected] ~]#
    

    有哪些匹配?

    所有操作目标参数:
    
    Target Options: 
    -E, --pcre                   正则匹配 
    -L, --list                   列表匹配 
    -G, --grain                  grains 匹配 
    --grain-pcre                 grains 加正则匹配 
    -N, --nodegroup              组匹配 
    -R, --range                  范围匹配 
    -C, --compound               综合匹配( 指定多个匹配) 
    -I, --pillar                 pillar 值匹配 
    -S, --ipcidr                 minions网段地址匹配 
    
    yum -y install salt-minion
    sed -i 's@#manster:.*@manster: master_ipaddress@' /etc/salt/minion  #master_ipaddress为管理端IP
    echo 10.252.137.141 > /etc/salt/minion_id #个人习惯使用IP,默认主机名
    service salt-minion start
    

    14.Saltstack 常用命令

    各种匹配的详细说明

    • minion ID
    sudo salt ‘cn1’ test.ping
    
    • 通配符(*)
    sudo salt ‘cn1’ test.ping
    # 匹配所有的minion 
    sudo salt '*' test.ping 
    
    # 匹配ID开头为cn的minion 
    sudo salt 'cn*' test.ping 
    
    # 匹配cn1、cn2、cn3、cn4、cn5 
    sudo salt 'cn[1-5]' test.ping 
    
    # 匹配web-x, web-y, web-z 
    sudo salt 'web-[x-z]' test.ping 
    
    • 正则表达式
    # 如: 匹配ID为assassin-production,assassin-sandbox 
    sudo salt -E 'assassin-[production|sandbox]' test.ping 
    
    # 在state中也可以这么用 
    base: 
      'assassin-[production|sandbox]' 
        - match: pcre 
        - webserver 
    
    • 列表匹配
    # 对一些有特殊要求的minion可以手动指定ID作为Target 
    sudo salt -L 'cn1, cn2, cn23' test.ping 
    
    • grains匹配
    # 如 测试所有操作系统为ubuntu的为minion 
    sudo salt -G 'os:Ubuntu' test.ping 
    
    # 查看CPU架构是x86_64的minion的cpu个数 
    sudo salt -G 'cpuarch:x86_64' grains.item numcpus 
    
    
    # 在top.sls中使用 
    'node_type:web' 
      - match: grain 
      - webserver 
    'node_type:mysql' 
      - match: grain 
      - database 
    
    • pillar匹配
      # pillar匹配跟grains差不多, 不过将grains对象换成pillar 
    sudo salt -I 'somekey:specialvalue' test.ping 
    
    • 组匹配
    # 节点分组需要先在top.sls或者master配置文件中定义好。
    nodegroups: 
     group1: 'L@foo.domain.com,bar.domain.com,baz.domain.com or bl*.domain.com' 
     group2: 'G@os:Debian and foo.domain.com' 
     group3: 'G@os:Debian and N@group1' 
     group4: 
     - 'G@foo:bar' 
     - 'or' 
     - 'G@foo:baz' 
    
    sudo salt -N group1 test.ping 
    
    # 在top.sls中: 
    base: 
      group1: 
      - match: nodegroup 
      - webserver 
    
    • CIDR匹配
    # 指定192.168.1.0/24网段内的minion 
    sudo salt -S '192.168.1.0/24' test.ping 
    
    • 复合匹配
    salt -C 'G@os:Ubuntu or L@cn1,cn2' test.ping
    

    最后,有时候匹配到的minion会很多,如果直接全部执行master可能会挂机。
    所以我们可以分批执行:

    # 一次10个minion执行 
    sudo salt '*' -b 10 test.ping 
    
    # 一次25%执行 
    sudo salt -G 'os:Ubuntu' --batch-size 25% test.ping 
    

    Master与Minion认证

    14.1拷贝文件到客户端

    [[email protected] ~]# salt 'nb1' cp.get_file salt://apache.sls /tmp/cp.txt
    nb1:
        /tmp/cp.txt
    [[email protected] ~]#
    
    [[email protected] ~]# cat /tmp/cp.txt 
    apache-service:
      pkg.installed:
        - names:
          - httpd
          - httpd-devel
      service.running:
        - name: httpd
        - enable: True
    [[email protected] ~]# 
    

    针对管理对象Target的操作,Module

    • 查看所有的module列表
    sudo salt "cn1" sys.list_modules  
    cn1: 
      - aliases 
      - alternatives 
      - archive 
      - artifactory 
    ... 
    
    • 查看指定module的所有function
    ➜ pillar git:(master) ✗ sudo salt "cn1" sys.list_functions cmd 
    cn1: 
      - cmd.exec_code 
      - cmd.exec_code_all 
      - cmd.has_exec 
      - cmd.powershell 
      - cmd.retcode 
      - cmd.run 
      - cmd.run_all 
      - cmd.run_bg 
      - cmd.run_chroot 
      - cmd.run_stderr 
      - cmd.run_stdout 
      - cmd.script 
      …
    
    • 查看指定module用法
    ➜ pillar git:(master) ✗ sudo salt "cn1" sys.doc cmd 
    cmd.exec_code: 
    
      Pass in two strings, the first naming the executable language, aka - 
      python2, python3, ruby, perl, lua, etc. the second string containing 
      the code you wish to execute. The stdout will be returned. 
    
      CLI Example: 
    
      salt '*' cmd.exec_code ruby 'puts "cheese"' 
    

    minion在第一次启动时,会在/etc/salt/pki/minion/(该路径在/etc/salt/minion里面设置)下自动生成minion.pem(private key)和 minion.pub(public key),然后将 minion.pub发送给master。master在接收到minion的public key后,通过salt-key命令accept minion public key,这样在master的/etc/salt/pki/master/minions下的将会存放以minion id命名的 public key,然后master就能对minion发送指令了。
    认证命令如下:

    14.2 拷贝目录到客户端

    [[email protected] ~]# salt 'nb1' cp.get_dir salt://test /tmp
    nb1:
        - /tmp/test/1.sh
        - /tmp/test/123/newDir/a
    [[email protected] ~]# 
    
    [[email protected] ~]# ll /tmp/test/
    total 4
    drwxr-xr-x 3 root root  20 Aug 21 03:02 123
    -rw-r--r-- 1 root root 126 Aug 21 03:02 1.sh
    [[email protected] ~]#
    

    配置管理States

    salt states是salt模块的扩展。主系统使用的状态系统叫SLS系统,SLS代表Saltstack State。States是Saltstack中的配置语言,在日常进行配置管理时需要编写大量的States文件。比如我们需要安装一个包,然后管理一个配置文件,最后保证某个服务正常运行。这里就需要我们编写一些states sls文件去描述和实现我们想要的功能。

    [root@10.252.137.14 ~]# salt-key -L    #查看当前证书签证情况
    Accepted Keys:
    Unaccepted Keys:
    10.252.137.141
    Rejected Keys:
    [root@10.252.137.14 ~]# salt-key -A -y   #同意签证所有没有接受的签证情况
    The following keys are going to be accepted:
    Unaccepted Keys:
    10.252.137.141
    Key for minion 10.252.137.141 accepted.
    [root@10.252.137.14 ~]# salt-key -L
    Accepted Keys:
    10.252.137.141
    Unaccepted Keys:
    Rejected Keys:
    

    14.3 显示存活的客户端

    [[email protected] ~]# salt-run manage.up
    - nb0
    - nb1
    - nb2
    [[email protected] ~]# 
    

    查看state modules的详细使用

    # 1、查看所有states列表
    sudo salt ‘cn1’ sys.list_state_modules
    
    # 2、 查看指定state的所有function
    sudo salt ‘cn1’ sys.list_state_functions cmd
    
    # 3、查看指定states的用法
    sudo salt ‘cn1’ sys.state_doc cmd
    
    # 4、查看指定state指定function的用法
    sudo salt ‘cn1’ sys.state_doc cmd.run
    

    SaltStack远程执行

    14.4 命令下执行服务端的脚本

    [[email protected] ~]# vim /srv/salt/test/shell.sh
    [[email protected] ~]# cat /srv/salt/test/shell.sh
    #! /bin/bash
    echo "hadron.cn" > /tmp/shell.txt
    [[email protected] ~]# 
    
    [[email protected] ~]# salt 'nb2' cmd.script salt://test/shell.sh
    nb2:
        ----------
        pid:
            86257
        retcode:
            0
        stderr:
        stdout:
    [[email protected] ~]# 
    
    [[email protected] ~]# cat /tmp/shell.txt 
    hadron.cn
    [[email protected] ~]# 
    

    Salt state树

    # 在/etc/salt/master中配置file_roots
    file_roots: 
      base: 
      - /srv/salt 
    
    [root@10.252.137.14 ~]# salt '*' test.ping
    10.252.137.141:
    True
    [root@10.252.137.14 ~]# salt '*' cmd.run 'ls -al'
    10.252.137.141:
    total 40
    drwx------  4 root root 4096 Sep  7 15:01 .
    drwxr-xr-x 22 root root 4096 Sep  3 22:10 ..
    -rw-------  1 root root  501 Sep  7 14:49 .bash_history
    -rw-r--r--  1 root root 3106 Feb 20  2014 .bashrc
    drwx------  2 root root 4096 Jan 30  2015 .cache
    drwxr-xr-x  2 root root 4096 Apr 22 13:57 .pip
    -rw-r--r--  1 root root  140 Feb 20  2014 .profile
    -rw-r--r--  1 root root   64 Apr 22 13:57 .pydistutils.cfg
    -rw-------  1 root root 4256 Sep  7 15:01 .viminfo
    

    15.问题

     [[email protected] ~]# salt-master start
    [ERROR   ] An extra return was detected from minion nb1, please verify the minion, this could be a replay attack
    [ERROR   ] An extra return was detected from minion nb1, please verify the minion, this could be a replay attack
    

    执行一次命令,返回两个值

     [[email protected] ~]# salt '*' cmd.run   'df -h'
    nb1:
        Filesystem           Size  Used Avail Use% Mounted on
        /dev/mapper/cl-root   48G  4.3G   44G   9% /
        devtmpfs             3.9G     0  3.9G   0% /dev
        tmpfs                3.9G   24K  3.9G   1% /dev/shm
        tmpfs                3.9G  385M  3.5G  10% /run
        tmpfs                3.9G     0  3.9G   0% /sys/fs/cgroup
        /dev/sda1           1014M  139M  876M  14% /boot
        /dev/mapper/cl-home   24G   33M   24G   1% /home
        tmpfs                781M     0  781M   0% /run/user/0
    nb1:
        Filesystem           Size  Used Avail Use% Mounted on
        /dev/mapper/cl-root   48G  4.3G   44G   9% /
        devtmpfs             3.9G     0  3.9G   0% /dev
        tmpfs                3.9G   24K  3.9G   1% /dev/shm
        tmpfs                3.9G  385M  3.5G  10% /run
        tmpfs                3.9G     0  3.9G   0% /sys/fs/cgroup
        /dev/sda1           1014M  139M  876M  14% /boot
        /dev/mapper/cl-home   24G   33M   24G   1% /home
        tmpfs                781M     0  781M   0% /run/user/0
    nb0:
        Filesystem           Size  Used Avail Use% Mounted on
        /dev/mapper/cl-root   48G   27G   22G  55% /
        devtmpfs             3.9G     0  3.9G   0% /dev
        tmpfs                3.9G   16K  3.9G   1% /dev/shm
        tmpfs                3.9G  394M  3.5G  11% /run
        tmpfs                3.9G     0  3.9G   0% /sys/fs/cgroup
        /dev/sda1           1014M  139M  876M  14% /boot
        /dev/mapper/cl-home   24G   33M   24G   1% /home
        tmpfs                781M     0  781M   0% /run/user/0
        /dev/loop0           7.8G  7.8G     0 100% /var/ftp/iso-home
    [[email protected] ~]#
    

    问题产生的原因在node2节点上重复启动

     [[email protected] ~]# salt-minion start
    ^C[WARNING ] Stopping the Salt Minion
    [WARNING ] Exiting on Ctrl-c
    [[email protected] ~]# 
    

    新葡亰496net火速入门教程,赶快入门SaltStack。ctrl c终止第二次的salt-minion启动即可。

    Salt state的top文件

    top.sls是state系统的入口文件,它在大规模配置管理工作中负责指定哪些设备调用哪些states.sls文件。top.sls是salt state默认的sls文件,在未做特别制定的时候salt state会默认调用top.sls来执行。如:

    sudo salt ‘cn1’ state.hightate
    

    top.sls需要手动创建,位置则是salt state树定义的目录/srv/salt下。

    salt执行命令的格式如下:

    调试Salt

    # 开启debug日志
    salt-minion -l debug
    
    # 设置超时
    salt ‘*’ state.highstate -t 60
    
    salt ''  [arguments]
    

    简单的例子

    cat top.sls
    base:                       # 匹配状态树的base目录配置
      ‘*’:                        # 匹配minion
        - webserver         # 表示执行base目录下的webserver.sls状态文件或者webserver/init.sls文件
    
    cat webserver.sls
    apache:                   # ID声明,跟yum install apache指定的名称一样
      pkg:                      # 状态声明,说明要做什么状态操作,pkg使用系统本地的软件包管理工具
        - installed           # 函数声明,说明该sls文件指定的执行操作函数
      service:                #管理系统守护进程
        - running
        - require:
          - pkg: apache
    
    # 更新所有minion的状态
    sudo salt “*” state.highstate
    
    注:这样就可以在所有的minion中安装apache了。
    
    当然也可以不要top.sls,直接指定sls文件来执行
    sudo salt ‘cn1’ state.sls webserver
    
    或者使用apply function,apply会根据后面的参数来决定调用state.highstate还是state.sls
    sudo salt ‘cn1’ state.apply webserver
    

    target:执行salt命令的目标,可以使用正则表达式

    简单的扩展

    添加配置文件和用户
    部署apache这样的服务还需要添加其他的内容,比如apache的配置文件,运行apache服务的用户和组。

    # 目录结构:
    ls /srv/salt/apache
    init.sls
    http.conf
    
    cat init.sls
    apache:                   
     pkg:                     
        - installed          
      service:               
        - running
        - watch:
          - pkg: apache
          - file: /etc/httpd/conf/httpd.conf
          - user: apache
      user.present:
        - did: 87
        - gid: 87
        - home: /var/www/html
        - shell: /bin/nologin
        - require:
          - group: apache
    group.present:
      - gid: 87
      - require:
        - pkg: apache
    /etc/httpd/conf/httpd.conf
      file.managed:
        - source: salt://apache/httpd.conf
        - user: root
        - group: root
        - mode: 644
    

    function:方法,由module提供

    自定义module

    根据官网的说法,自定义module应该存放在/srv/salt/_modules/目录下。同步到minion的方法有三种:

    state.apply
    saltutil.sync_modules
    saltutil.sync_all
    

    例子:

    #encoding = utf8
    
    def test():
        return 'this is a test'
    
    def get_target():
        return __grains__['target']
    
    def get_domain(service):
        dom = __pillar__[service]['domain']
        return dom
    
    def deploy(service,version):
        target = get_target()
        domain = get_domain(service)
        cmd = "gover -s " service " -t " target " -v " str(version) " -d "  domain
        return __salt__['cmd.run'](cmd)
    

    arguments:function的参数

    target可以是以下内容:

    1. 正则表达式

      salt -E 'Minion*' test.ping #主机名以Minion开通

    2. 列表匹配

      salt -L Minion,Minion1 test.ping

    3. Grians匹配

      salt -G 'os:CentOS' test.ping

    os:CentOS(默认存在)是Grains的键值对,数据以yaml保存在minion上,可在minion端直接编辑/etc/salt/grains,yaml格式。或者在master端执行salt '*' grains.setval key "{'sub-key': 'val', 'sub-key2': 'val2'}" ,具体文档(命令salt * sys.doc grains查看文档)

    1. 组匹配

      salt -N groups test.ping

    如,在master新建/etc/salt/master.d/nodegroups.conf ,yaml格式

    1. 复合匹配

      salt -C 'G@os:CentOS or L@Minion' test.ping

    2. Pillar值匹配

      salt -I 'key:value' test.ping

    /etc/salt/master设置pillar_roots,数据以yaml保存在Master上

    1. CIDR匹配

      salt -S '10.252.137.0/24' test.ping

    10.252.137.0/24是一个指定的CIDR网段

    function是module提供的方法

    通过下面命令可以查看所有的function:
    salt '10.252.137.141' sys.doc cmd

    function可以接受参数:

    salt '10.252.137.141' cmd.run 'uname -a'
    

    并且支持关键字参数:

    在所有minion上切换到/目录以salt用户运行uname -a命令。
    salt '10.252.137.141' cmd.run 'uname -a' cwd=/ user=salt
    

    SaltStack配置管理

    states文件

    salt states的核心是sls文件,该文件使用YAML语法定义了一些k/v的数据。

    sls文件存放根路径在master配置文件中定义,默认为/srv/salt,该目录在操作系统上不存在,需要手动创建。

    在salt中可以通过salt://代替根路径,例如你可以通过salt://top.sls访问/srv/salt/top.sls。

    在states中top文件也由master配置文件定义,默认为top.sls,该文件为states的入口文件。

    一个简单的sls文件如下:

    apache:
     pkg.installed
     service.running
       - require:
         - pkg: apache
    

    说明:此SLS数据确保叫做"apache"的软件包(package)已经安装,并且"apache"服务(service)正在运行中。

    • 第一行,被称为ID说明(ID Declaration)。ID说明表明可以操控的名字。
    • 第二行和第四行是State说明(State Declaration),它们分别使用了pkg和service states。pkg state通过系统的包管理其管理关键包,service state管理系统服务(daemon)。 在pkg及service列下边是运行的方法。方法定义包和服务应该怎么做。此处是软件包应该被安装,服务应该处于运行中。
    • 第六行使用require。本方法称为”必须指令”(Requisite Statement),表明只有当apache软件包安装成功时,apache服务才启动起来。

    state和方法可以通过点连起来,上面sls文件和下面文件意思相同。

    apache:
     pkg.installed
     service.running
       - require:
         - pkg: apache
    

    将上面sls保存为init.sls并放置在sal://apache目录下,结果如下:

    /srv/salt
    ├── apache
    │   └── init.sls
    └── top.sls
    

    top.sls如何定义呢?

    master配置文件中定义了三种环境,每种环境都可以定义多个目录,但是要避免冲突,分别如下:

    # file_roots:
    #   base:
    #     - /srv/salt/
    #   dev:
    #     - /srv/salt/dev/services
    #     - /srv/salt/dev/states
    #   prod:
    #     - /srv/salt/prod/services
    #     - /srv/salt/prod/states
    

    top.sls可以这样定义:

    base:
      '*':
       - apache
    

    说明:

    第一行,声明使用base环境

    第二行,定义target,这里是匹配所有

    第三行,声明使用哪些states目录,salt会寻找每个目录下的init.sls文件。

    运行states

    一旦创建完states并修改完top.sls之后,你可以在master上执行下面命令:

    [root@10.252.137.14 ~]# salt '*' state.highstate
    sk2:
    ----------
    State: - pkg
    Name:      httpd
    Function:  installed
    Result:    True
    Comment:   The following packages were installed/updated: httpd.
    Changes:
    ----------
    httpd:
    ----------
    new:
    2.2.15-29.el6.centos
    old:
    ----------
    State: - service
    Name:      httpd
    Function:  running
    Result:    True
    Comment:   Service httpd has been enabled, and is running
    Changes:
    ----------
    httpd:
    True
    Summary
    ------------
    Succeeded: 2
    Failed:    0
    ------------
    Total:     2
    

    上面命令会触发所有minion从master下载top.sls文件以及其中定一个的states,然后编译、执行。执行完之后,minion会将执行结果的摘要信息汇报给master。

    新葡亰496net 38

    本文由新葡亰496net发布于服务器网络,转载请注明出处:新葡亰496net火速入门教程,赶快入门SaltStack

    关键词: