saltstack高效运维

 

salt介绍

saltstack是由thomas Hatch于2011年创建的一个开源项目，设计初衷是为了实现一个快速的远程执行系统。

salt强大吗

系统管理员日常会进行大量的重复性操作，例如安装软件，修改配置文件，创建用户，批量执行命令等等。如果主机数量庞大，单靠人工维护实在让人难以忍受。

　　早期运维人员会根据自己的生产环境来写特定脚本完成大量重复性工作，这些脚本复杂且难以维护。系统管理员面临的问题主要是1、系统配置管理，2、远程执行命令，因此诞生了很多开源软件，系统维护方面有fabric、puppet、chef、ansible、saltstack等，这些软件擅长维护系统状态或方便的对大量主机进行批量的命令执行。

　　salt灵活性强大，可以进行大规模部署，也能进行小规模的系统部署。salt的设计架构适用于任意数量的服务器，从少量本地网络系统到跨越数个数据中心，拓扑架构都是c/s模型，配置简单。

　　不管是几台、几百台、几千台服务器，都可以使用salt在一个中心节点上进行管控，灵活定位任意服务器子集来运行命令。　

　　Salt是python编写的，支持用户通过python自定义功能模块，也提供了大量的python API接口，用户可以根据需要进行简单快速的扩展。

saltstack的运行方式

  • Local  本地运行，交付管理
  • Master/Minion   <<<   常用方式
  • Salt SSH   不需要客户端

salt部署基本架构

在安装salt之前，先理解salt架构中各个角色，主要区分是salt-master和salt-minion，顾名思义master是中心控制系统，minion是被管理的客户端。

salt架构中的一种就是master > minion。

在远程执行系统中，salt用python通过函数调用完成任务。

运行salt依赖包

  1. python
  2. zeromq
  3. pyzmp
  4. pycrypto
  5. msgpack-python
  6. yaml
  7. jinja2

解决依赖包最简单的办法就是用安装包管理器，yum工具

服务器环境准备

服务器环境 centos7(master) centos7(master)

ip地址

 192.168.178.131 192.168.178.132

身份

 master slave

软件包

 salt-master salt-minion

修改虚拟机ip地址为静态地址，并且确保可上网

  1. TYPE="Ethernet"
  2. PROXY_METHOD="none"
  3. BROWSER_ONLY="no"
  4. BOOTPROTO="static"
  5. DEFROUTE="yes"
  6. IPV4_FAILURE_FATAL="no"
  7. IPV6INIT="yes"
  8. IPV6_AUTOCONF="yes"
  9. IPV6_DEFROUTE="yes"
  10. IPV6_FAILURE_FATAL="no"
  11. IPV6_ADDR_GEN_MODE="stable-privacy"
  12. NAME="ens33"
  13. UUID="7d4f9ede-810f-4976-a01b-250b845c99cc"
  14. DEVICE="ens33"
  15. ONBOOT="yes"
  16. IPADDR=192.168.11.131
  17. NETMASK=255.255.255.0
  18. GATEWAY=192.168.11.1
  19. DNS1=119.29.29.29

master网卡配置

  1. TYPE="Ethernet"
  2. PROXY_METHOD="none"
  3. BROWSER_ONLY="no"
  4. BOOTPROTO="static"
  5. DEFROUTE="yes"
  6. IPV4_FAILURE_FATAL="no"
  7. IPV6INIT="yes"
  8. IPV6_AUTOCONF="yes"
  9. IPV6_DEFROUTE="yes"
  10. IPV6_FAILURE_FATAL="no"
  11. IPV6_ADDR_GEN_MODE="stable-privacy"
  12. NAME="ens33"
  13. UUID="f9fc5929-8594-466e-a041-34caee8c1e32"
  14. DEVICE="ens33"
  15. ONBOOT="yes"
  16. IPADDR=192.168.11.132
  17. NETMASK=255.255.255.0
  18. GATEWAY=192.168.11.1
  19. DNS1=119.29.29.29

slave网卡配置

  1. # Generated by NetworkManager
  2. nameserver 119.29.29.29

dns配置文件

  1. 127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
  2. ::         localhost localhost.localdomain localhost6 localhost6.localdomain6
  3. 192.168.11.132  slave
  4. 192.168.11.131  master

/etc/hosts

关闭服务器安全策略

  1. 关闭firewalld
  2. systemctl disable firewalld
  3. systemctl stop firewalld
  4.  
  5. 关闭iptables
  6. iptables -F
  7.  
  8. 关闭selinux

关闭安全策略

安装saltstack

salt软件包需要epel源的支持，那么下载

EPEL的全称叫 Extra Packages for Enterprise Linux 。EPEL是由 Fedora 社区打造，为 RHEL 及衍生发行版如 CentOS、Scientific Linux 等提供高质量软件包的项目。装上了 EPEL之后，就相当于添加了一个第三方源。

  1. wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
  1. wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
    yum clean all #清空缓存
    yum makecache #生成yum缓存

安装好epel源就可以开始安装salt了

  1. 查看salt包
    yum list salt
  2.  
  3. 安装salt-master
  4. yum install salt-master -y
  1. 安装salt-minion
  2. yum install salt-minion -y

salt端口

安装好salt之后开始配置，salt-master默认监听两个端口：

  1.    publish_port 提供远程命令发送功能
  2.    ret_port     提供认证，文件服务，结果收集等功能
  3. 确保客户端可以通信服务器的此2个端口，保证防火墙允许端口通过。因此在测试环境直接关闭防火墙。

配置文件

  1. salt-master的配置文件是/etc/salt/master
  2. salt-minion的配置文件是/etc/salt/minion
  3. 配置文件中包含了大量可调整的参数，这些参数控制master和minion各个方面

配置salt-master

  1. # salt运行的用户，影响到salt的执行权限
  2. user: root
  3.  
  4. #s alt的运行线程，开的线程越多一般处理的速度越快，但一般不要超过CPU的个数
  5. worker_threads: 
  6.  
  7. # master的管理端口
  8. publish_port : 
  9.  
  10. # master跟minion的通讯端口，用于文件服务，认证，接受返回结果等
  11. ret_port : 
  12.  
  13. # 如果这个master运行的salt-syndic连接到了一个更高层级的master,那么这个参数需要配置成连接到的这个高层级master的监听端口
  14. syndic_master_port : 
  15.  
  16. # 指定pid文件位置
  17. pidfile: /var/run/salt-master.pid

常用配置解析

超哥的salt-master文件

  1. [root@master ~]# grep -v ^# /etc/salt/master|grep -v ^$
  2. interface: 0.0.0.0  #绑定到本地的0.0.0.0地址
  3. publish_port: 4505　　#管理端口，命令发送
  4. user: root　　　　　　#运行salt进程的用户
  5. worker_threads: 5　　#salt运行线程数，线程越多处理速度越快，不要超过cpu个数
  6. ret_port: 4506　　#执行结果返回端口
  7. pidfile: /var/run/salt-master.pid #pid文件位置
  8. log_file: /var/log/salt/master　　#日志文件地址
  9.  
  10. #自动接收minion的key
    auto_accept: False
  1. # minion的识别ID，可以是IP，域名，或是可以通过DNS解析的字符串
  2. id: slave
  3.  
  4. # salt运行的用户权限
  5. user: root
  6.  
  7. # master的识别ID，可以是IP，域名，或是可以通过DNS解析的字符串
  8. master : master
  9.  
  10. # master通信端口
  11. master_port: 
  12.  
  13. # 备份模式，minion是本地备份，当进行文件管理时的文件备份模式
  14. backup_mode: minion
  15.  
  16. # 执行salt-call时候的输出方式
  17. output: nested
  18.  
  19. # minion等待master接受认证的时间
  20. acceptance_wait_time: 
  21.  
  22. # 失败重连次数，0表示无限次，非零会不断尝试到设置值后停止尝试
  23. acceptance_wait_time_max: 
  24.  
  25. # 重新认证延迟时间，可以避免因为master的key改变导致minion需要重新认证的syn风暴
  26. random_reauth_delay: 
  27.  
  28. # 日志文件位置
  29. log_file: /var/logs/salt_minion.log

salt-minion常用配置

超哥的satl-minion文件

  1. [root@slave ~]# grep -v ^# /etc/salt/minion|grep -v ^$
  2. master: master
  3. master_port:
  4. user: root
  5. id: slave
  6. acceptance_wait_time:
  7. log_file: /var/log/salt/minion

启动salt-master和salt-minion

  1. systemctl start salt-minion
  2. systemctl start salt-master
  3.  
  4. #检查salt状态
    systemctl status salt-minion
    systemctl status salt-master

在master上接收minion秘钥

在minion启动后连接master会请求master为其签发证书，等待证书签发完成后，master可以信任minion，并且minion和master之间的通信是加密的。

在salt-master执行

salt-key命令用于管理mionion秘钥

  1. [root@master ~]# salt-key -L
  2. Accepted Keys:
  3. Denied Keys:
  4. Unaccepted Keys:
  5. slave　　　　#此时已经出现slave
  6. Rejected Keys:

此时slave已经出现在unaccepted keys中，说明minion已经和master联系，并且master已经获取了minion的公钥，等待下一步指令。

检查master和minion的秘钥匹配

在master上执行

  1. [root@master ~]# salt-key -f slave
  2. Unaccepted Keys:
  3. slave:  0a:b9::b5:9a::b8::a1::a5:6a::ce::ea

然后可以在minion上获取minion的秘钥

  1. [root@slave ~]# salt-call --local key.finger
  2. local:
  3.     0a:b9::b5:9a::b8::a1::a5:6a::ce::ea

因此可确认秘钥匹配，在master上接收秘钥

  1. [root@master ~]# salt-key -a slave
  2. The following keys are going to be accepted:
  3. Unaccepted Keys:
  4. slave
  5. Proceed? [n/Y] y
  6. Key for minion slave accepted.

确认接收秘钥后，检验minion秘钥是否被接收

  1. [root@master ~]# salt-key -L
  2. Accepted Keys:
  3. slave
  4. Denied Keys:
  5. Unaccepted Keys:
  6. Rejected Keys:

秘钥接收完成后，就可以执行第一条salt啦

salt-key

只有Master接受了Minion Key后，才能进行管理。具体的认证命令为salt-key常用的有如下命令。

  1. [root@linux-node1 ~]# salt-key -L
  2. Accepted Keys：  #已经接受的key
  3. Denied Keys：    #拒绝的key
  4. Unaccepted Keys：#未加入的key
  5. Rejected Keys：#吊销的key
  6.  
  7. #常用参数
  8. -L  #查看KEY状态
  9. -A  #允许所有
  10. -D  #删除所有
  11. -a  #认证指定的key
  12. -d  #删除指定的key
  13. -r  #注销掉指定key（该状态为未被认证）
  14.  
  15. #在master端/etc/salt/master配置
  16. auto_accept: True   #如果对Minion信任,可以配置master自动接受请求

salt-key的使用

  1. #列出当前所有的key
  2. [root@salt0-master ~]# salt-key
  3. Accepted Keys:
  4. salt1-minion.example.com
  5. salt2-minion.example.com
  6. salt3-minion.example.com
  7. salt4-minion.example.com
  8. Denied Keys:
  9. Unaccepted Keys:
  10. Rejected Keys:
  11.  
  12. #添加指定minion的key
  13. [root@salt0-master ~]# salt-key  -a salt1-minion.example.com -y
  14. #添加所有minion的key
  15. [root@salt0-master ~]# salt-key  -A  -y
  16.  
  17. #删除指定的key
  18. [root@salt0-master ~]# salt-key -d salt1-minion.example.com -y
  19. #删除所有的key
  20. [root@salt0-master ~]# salt-key -D -y

日常命令参数

首先知道master和minion都安装了什么文件，然后才知道怎么操作

master端

  1. rpm -ql salt-master
  1. /etc/salt/master      # salt master主配置文件
  2. /usr/bin/salt           #salt master 核心操作命令
  3. /usr/bin/salt-cp       #salt 文件传输命令
  4. /usr/bin/salt-key    #salt证书管理
  5. /usr/bin/salt-master    #salt master 服务命令
  6. /usr/bin/salt-run          #salt master runner命令

slave端

  1. [root@slave  ~]$rpm -ql salt-minion
  1. /etc/salt/minion     #minion配置文件
  2. /usr/bin/salt-call    #拉取命令
  3. /usr/bin/salt-minion   #minion服务命令
  4. /usr/lib/systemd/system/salt-minion.service   #minion启动脚本

第一条salt命令

  1. [root@master ~]# salt '*' test.ping
  2. slave:
  3.     True
  4.  
  5. # salt 是一个命令 
    # * 表示目标主机, 在这里代表所有目标主机 
    # test.ping是salt远程执行的一个模块下面的方法。

这是条很简单的探测minion主机存活命令，也是远程执行命令，我们通过master发送消息给"*"所有的minion，并且告诉他们运行salt内置的命令（也是python模块中的一个函数），返回true表示slave机器监控存活。

test模块实际上还有许多其他的函数

  1. [root@master 192.168.199.155 ~]$salt '*' sys.list_functions test
  2. slave:
  3.     - test.arg
  4.     - test.arg_repr
  5.     - test.arg_type
  6.     - test.assertion
  7.     - test.attr_call
  8.     - test.collatz
  9.     - test.conf_test
  10.     - test.cross_test
  11.     - test.echo
  12.     - test.exception
  13.     - test.fib
  14.     - test.get_opts
  15.     - test.kwarg
  16.     - test.module_report
  17.     - test.not_loaded
  18.     - test.opts_pkg
  19.     - test.outputter
  20.     - test.ping
  21.     - test.provider
  22.     - test.providers
  23.     - test.rand_sleep
  24.     - test.rand_str
  25.     - test.retcode
  26.     - test.sleep
  27.     - test.stack
  28.     - test.try_
  29.     - test.tty
  30.     - test.version
  31.     - test.versions_information
  32.     - test.versions_report

test其他函数

测试下test.echo

  1. [root@master 192.168.199.155 ~]$salt '*' test.echo 'chaoge nb666'
  2. slave:
  3.     chaoge nb666

test.fib生成斐波那契数列

菲波那切数列定义是第0项是0，第1项是1，数列从第3项开始，每一项等于前两项之和。

  1. [root@master 192.168.199.155 ~]$salt '*' test.fib
  2. slave:
  3.     |_
  4.       -
  5.       -
  6.       -
  7.       -
  8.       -
  9.       -
  10.       -
  11.       -
  12.       -
  13.       -
  14.     - 1.09672546387e-05

小结

此前在机器上安装了salt minion和salt master，进行了最简单的连接，然后master接受了minion的秘钥，运行了第一条test.ping命令

salt命令组成结构

在命令行输入的命令都是 　　　　执行模块

等到命令写入到文件中，             就叫做状态模块

  1. salt --help #即可查看salt帮助

[root@master 192.168.199.155 ~]$salt --help
Usage: salt [options] '<target>' <function> [arguments]

salt命令 参数 目标 salt模块的函数 远程执行的参数

完整的五部分命令

  1. #--summary参数显示salt命令的概要
    [root@master 192.168.199.155 ~]$salt --summary '*' cmd.run 'hostname'
  2. slave:
  3.     slave
  4.  
  5. -------------------------------------------
  6. Summary
  7. -------------------------------------------
  8. # of Minions Targeted:
  9. # of Minions Returned:
  10. # of Minions Did Not Return:
  11. -------------------------------------------

列出所有salt的sys模块

  1. #与系统交互的sys模块
    [root@master 192.168.11.72 ~]$salt 'slave' sys.list_modules

远程执行命令模块

cmd是超级模块，所有shell命令都能执行

  1. [root@master 192.168.11.72 ~]$salt 'slave' cmd.run 'ps -ef|grep python'
  2. slave:
  3.     root                 : ?        :: /usr/bin/python -Es /usr/sbin/tuned -l -P
  4.     root                : ?        :: /usr/bin/python /usr/bin/salt-minion
  5.     root             : ?        :: /usr/bin/python /usr/bin/salt-minion
  6.     root                : ?        :: /usr/bin/python /usr/bin/salt-minion
  7.     root             : ?        :: /bin/sh -c ps -ef|grep python
  8.     root             : ?        :: grep python

远程安装nginx

  1. #在minion上安装nginx
  2. [root@master 192.168.11.72 ~]$salt 'slave' pkg.install "nginx"
  3. #卸载minion上的nginx
  4. [root@master 192.168.11.72 ~]$salt 'slave' pkg.remove "nginx"
  5. #检查pkg包的版本
  6. [root@master 192.168.11.72 ~]$salt 'slave' pkg.version "nginx"

远程管理服务模块

管理服务是系统管理员的重要任务，通过salt管理minion服务会很简单，使用service模块

  1. [root@master 192.168.11.72 ~]$salt 'slave' service.start "nginx"
  2. slave:
  3.     True
  4. [root@master 192.168.11.72 ~]$salt 'slave' service.status "nginx"
  5. slave:
  6.     True
  7. [root@master 192.168.11.72 ~]$salt 'slave' service.stop "nginx"
  8. slave:
  9.     True

与标准的Linux命令一样，salt的命令一样用法

--out控制salt命令结果输出的格式

JSON

  1. [root@master 192.168.199.155 ~]$salt --out=json '*' cmd.run_all 'hostname'
  2. {
  3.     "slave": {
  4.         "pid": ,
  5.         "retcode": ,
  6.         "stderr": "",
  7.         "stdout": "slave"
  8.     }
  9. }

YAML

  1. [root@master 192.168.199.155 ~]$salt --out=yaml '*' cmd.run_all 'hostname'
  2. slave:
  3.   pid:
  4.   retcode:
  5.   stderr: ''
  6.   stdout: slave

YAML讲解

  1. 在学习saltstack过程中，第一要点就是States编写技巧，简称SLS文件。这个文件遵循YAML语法。初学者看这玩意很容易懵逼，来，超哥拯救你学习YAML语法
  2. json xml yaml 数据序列化格式
  3. yaml容易被解析，应用于配置文件
  4.  
  5. salt的配置文件是yaml配置文件，不能用tab
  6. saltstack,k8s,ansible都用的yaml格式配置文件
  7.  
  8. 语法规则
  9.     大小写敏感
  10.     使用缩进表示层级关系
  11.     缩进时禁止tab键，只能空格
  12.     缩进的空格数不重要，相同层级的元素左侧对其即可
  13.     # 表示注释行
  14. yaml支持的数据结构
  15.     对象： 键值对，也称作映射 mapping 哈希hashes 字典 dict    冒号表示 key: value   key冒号后必须有
  16.     数组： 一组按次序排列的值，又称为序列sequence 列表list     短横线  - list1
  17.     纯量： 单个不可再分的值
  18.  
  19. 对象：键值对
  20. yaml
  21.     first_key:
  22.       second_key:second_value
  23.  
  24. python
  25.     {
  26.         'first_key':{
  27.             'second_key':'second_value',
  28.         }
  29.     }
  1. YAML是YAML Ain't Markup Language的首字母缩写，YAML的语法简单，
    结构体通过空格展示
    项目使用 '-' 代表
    键值对通过 ':' 分割
  1. YAML语法遵循固定的缩进风格，表示数据层级结构关系，saltstack需要每个缩进级别由2个空格组成，禁止用tabs！！！
  1. Python中的字典是简单的键值对，go语言中称作哈希表map
    字典的key通过冒号分割
  2.  
  3. key在YAML中表现形式是一个冒号结果的字符串
    my_key: my_value
    转化到python语法中，上述命令为
    {'my_key':'my_value'}
  4.  
  5. value还可以通过缩进和key关联，四个空格！！
    my_key:
        my_value 
    转化为python语法同样的
    {'my_key':'my_value'}
  6.  
  7. YAML语法中字典是可以嵌套的
    one_dict_key:
        two_dict_key:value_dict
    转化为python语法

{
　　'one_dict_key':{
　　　　'two_dict_key':'value_dict'
　　}
}

  1. 短横杠
  2. YAML语法表示列表，使用一个横杠加一个空格
  3. 多个项使用同样的缩进级别作为同一个列表的部分
  4. - list_value_one
  5. - list_value_two
  6. - list_value_three
    列表可以作为一个键值对的value，例如一次性要安装多个软件
    my_dict:
      - l1
      - l2
      - l3
    转化为python代码理解就是

{
　　'my_dict':['l1','l2',;l3]
}

目标定位字符串

　　之前的salt命令我们都是使用 salt '*'控制所有minion，并且我们只有一个“slave”，但是生产环境的服务器很可能是成千上百的minion，因此需要灵活地定位所需的服务器并且执行远程命令。

  1. .全局匹配
  2. [root@master 192.168.11.72 ~]$salt '*' test.ping
  3. slave:
  4.     True
  1. Linux通配符
  2. *               代表任意字符，或空字符串
  3. ?               代表一个字符，不可以为空
  4. [a-z] [-]     代表任何一个小写字母
  5.  
  6. [root@master 192.168.11.72 ~]$salt 'slav?' test.ping
  7. slave:
  8.     True
  9.  
  10. [root@master 192.168.11.72 ~]$salt '[a-z]lave' test.ping
  11. slave:
  12.     True            
    salt海支持python的re正则表达式

state模块定义主机状态

之前执行的远程命令，都是一个过程式的，类似一段shell或者python脚本执行，执行一次触发一次相同的功能。

那么大量的minion上运行远程命令就必须使用salt提供的“状态管理”了，状态是对minion的一种描述和定义，运维不需要关心部署是如何完成的，只需要描述minion需要达到什么状态。

接下来通过state模块部署nginx

master端

  1. vim /etc/salt/master 
    #打开注释，写入以下，必须严格遵循语法，空格
  2. file_roots:
  3.   base:
  4.     - /srv/salt/base
  5.  dev:
  6.    - /srv/salt/dev
  7.  test:
  8.    - /srv/salt/test
  9.  prod:
  10.    - / srv/salt/prod

#此步骤在master和minion都需要执行，都需要文件夹，和nginx.sls文件
[root@master  ~]$mkdir -p /srv/salt/{base,dev,test,prod}

[root@slave   ~]$mkdir -p /srv/salt/{base,dev,test,prod}

  1. #这个nginx.sls状态文件，在master和minion上都得有
    [root@master /srv/salt/base]$cat nginx.sls
  2. nginx-install:
  3.   pkg.installed:
  4.     - name: nginx
  5.  
  6. nginx-service:
  7.   service.running:
  8.     - name: nginx
  9.     - enable: True
  1. 解释下nginx.sls描述文件
    sls配置文件都遵循YAML语言描述
  2. 第一条命令使用了pkg.install安装命令，相对于运行了yum install，而此时state模块会判断nginx是否安装了，如果没有安装就进行安装，安装了就什么都不做。
  3. 状态描述都会遵循这个原则，只有检测到真实状态和所需状态不一就会执行此功能，这种性质叫做幂等性。

此时用state模块部署nginx软件，通过我们编写的nginx.sls描述性配置文件，命令行调用state模块的sls函数。

  1. #启动命令，此时slave已经安装且存活了nginx，进行状态管理
  2. [root@master  /srv/salt/base]$salt 'slave' state.sls nginx

可以去slave测试关闭nginx，删除nginx，重新执行命令，一样可以安装启动nginx

通过master检查slave的nginx状态

  1. [root@master 192.168.199.155 /srv/salt/base]$salt 'slave' cmd.run 'ps -ef|grep nginx'
  2. slave:
  3.     root                Sep14 ?        :: nginx: master process /usr/sbin/nginx
  4.     nginx            Sep14 ?        :: nginx: worker process
  5.     root             : ?        :: /bin/sh -c ps -ef|grep nginx
  6.     root             : ?        :: /bin/sh -c ps -ef|grep nginx

Salt采集静态信息之Grains

如果你入职了，你的老板让你收集公司300台服务器的相关硬件信息，你是一台台登录呢？还是选择用salt收集呢？又或者用python的salt-api写脚本呢

  1. Grains 是saltstack组件中非常重要之一，在配置部署时候回经常使用，Grains记录minion的静态信息，比如常用属性，CPU、内存、磁盘、网络信息等。
  2. Minions的Grains信息是Minion启动时采集汇报给Master的
    Grains是以 key  value形式存储的数据库，可以看做Host的元数据（metadata）
    Grains保存着收集到的客户端的详细信息
    如果slave机器数据变化，grains就过期了
  3. 在生产环境中需要自定义Grains，可以通过
  4. Minion配置文件
  5. Grains相关模块定义
  6. Python脚本定义
  7.  
  8. salt 'slave' sys.doc grains#查看grains的命令用法

Grains

  1. Grains人为是描述minion本身固有的静态属性数据，列出主机所有Grains数据

[root@master 192.168.11.72 ~]$salt 'slave' grains.items
slave:
----------
SSDs:
biosreleasedate:
05/19/2017
biosversion:
6.00　　

信息过长，已经省略

salt 'slave' grains.ls  #列出所有grains方法

检索某些数据

  1. [root@master 192.168.11.72 ~]$salt 'slave' grains.item os id host
  2. slave:
  3.     ----------
  4.     host:
  5.         slave
  6.     id:
  7.         slave
  8.     os:
  9.         CentOS

利用Grains静态信息定位主机

超哥以前公司有100+的redhat操作系统，80+的centos，在不知道salt之前很是懵逼。。

除了系统的不同，还有不同的系统版本，redhat6.x centos6.x..

  1. 两种写法：
    salt '*' grains.item key1 key2 key3
    salt '*' -G
  2.  
  3. #定位Cenots的机器
    [root@master 192.168.11.72 ~]$salt -G 'os:CentOS' test.ping
  4. slave:
  5.     True
    #定位操作系统系统是7系列的机器

[root@master 192.168.11.72 ~]$salt -G 'osrelease:7*' test.ping
slave:
True

#找出ip地址

salt '*' grains.item fqdn_ip4

因此用grains.items列出所有的数据匹配主机，以及根据单一信息定位数据，Grains还可以自定义来满足不同的需求。

自定义设置Grains数据

  1. #设置数据
    [root@master 192.168.11.72 ~]$salt 'slave' grains.setval cpu_num
  2. slave:
  3.     ----------
  4.     cpu_num:
  5.         8
    #查询数据
  6. [root@master 192.168.11.72 ~]$salt 'slave' grains.item cpu_num
  7. slave:
  8.     ----------
  9.     cpu_num:
  10.

在master端设置Grains静态数据，原理会将此数据添加到minion服务器的配置文件的/etc/salt/grains

  1. [root@slave 192.168.11.71 ~]$cat /etc/salt/grains
  2. cpu_num:

对于复杂的数据结构，可以添加灵活的JSON语法

  1. [root@master 192.168.11.72 ~]$salt 'slave' grains.setval cpu_info '["Intel","Xeon","10"]'
  2. slave:
  3.     ----------
  4.     cpu_info:
  5.         - Intel
  6.         - Xeon
  7.         -
  8. [root@master 192.168.11.72 ~]$salt 'slave' grains.item cpu_info
  9. slave:
  10.     ----------
  11.     cpu_info:
  12.         - Intel
  13.         - Xeon
  14.         -

此时可以检查minion服务器上的grains文件

  1. [root@slave 192.168.11.71 ~]$cat /etc/salt/grains
  2. cpu_info:
  3. - Intel
  4. - Xeon
  5. - ''
  6. cpu_num:

因此Grains数据写入配置文件后，重启salt-minion服务，数据也不会丢失

想要删除可以通过grains.delval命令删除，或者去minion的配置文件删除配置一样完成操作（或者删除文件）

  1. .方法一，清空值
  2. [root@master 192.168.11.72 ~]$salt 'slave' grains.delval cpu_info
  3. slave:
  4.     None
  5. [root@master 192.168.11.72 ~]$salt 'slave' grains.delval cpu_num
  6. slave:
  7.     None
  8.  
  9. 2.方法二 删除minion的grains配置文件，重启服务

[root@slave 192.168.11.71 ~]$rm -rf /etc/salt/grains
[root@slave 192.168.11.71 ~]$!sys
systemctl restart salt-minion

  1. 检查结果删除成功

数据管理中心之Pillar组件

Pillar也是saltstack组件中非常重要的组件之一，称作数据管理中心，经常配合states在大规模的配置管理中使用。

Pillar是动态的，存储在master端，提供和给minion端

Pillar在SaltStack中主要的作用是存储和定义配置管理中需要的一些数据，比如软件版本号，用户账号密码等，保证敏感数据不被其他minion看到

存储格式与Grains类似，都是YAML格式

在master配置文件中有一段Pillar settings选项专门定义Pillar的参数

  1. cat /etc/salt/master  
    #此配置代表pillar的工作根目录，在/srv/pillar下，然后可以新建sls文件
  2. #pillar_roots:
  3. #  base:
  4. #    - /srv/pillar

默认pillar的工作目录在/srv/pillar目录下，执行如下代码

  1. mkdir -p /srv/pillar
  2. #指定环境，标记，引用packages.sls和services.sls
  3. vim /srv/pillar/top.sls
  4. base:
  5.   '*':
  6.       - packages
  7.       - services
  8. vim /srv/pillar/packages.sls
  9. nginx:
  10.     packages-name: nginx
  11.     version: 1.12.
  12.  
  13. vim /srv/pillar/packages.sls
  14. nginx:
  15.     port:
  16.     user: root

检查我们设置的pillar值

  1. [root@master 192.168.199.155 /srv/pillar]$salt '*' pillar.item nginx
  2. slave:
  3.     ----------
  4.     nginx:
  5.         ----------
  6.         packages-name:
  7.             nginx
  8.         port:
  9.  
  10.         user:
  11.             root
  12.         version:
  13.             1.12.

Pillar与Grains对比

  1. pillar与Grains对比
  2.  
  3. 类型     数据采集方式   应用场景                   定义位置
  4. Grains   静态         minion启动时收集  数据查询  目标选择  配置管理   minion
  5. Pillar   动态         master进行自定义  目标选择  配置管理  敏感数据   master

Python API调用SaltStack

SaltStack本身提供salt(usr/bin/salt)来交互管理，但是去服务器上敲命令肯定不是一个长远之计，这时候python就体现了nb的功能。

Python API就是给Python提供的API使用，需要在SaltStack master上运行

实例代码

  1. [root@master  ~]$python
  2. Python 2.7. (default, Jul  , ::)
  3. [GCC 4.8.  (Red Hat 4.8.-)] on linux2
  4. Type "help", "copyright", "credits" or "license" for more information.
  5. >>> import salt.client
  6. >>> local = salt.client.LocalClient()  #<salt.client.LocalClient object at 0x7f886dbdd850>
  7. >>> local.cmd('*','cmd.run',['hostname'])#向所有minion发送命令
  8. {'slave': 'slave'}

因此python API就是提供了向saltstack发送命令的入口。

通过API获取saltstack的配置文件

获取master配置文件

  1. >>> import salt.config #导入salt配置模块
  2. >>> m_opts=salt.config.client_config('/etc/salt/master') #读取salt配置文件，得到一个字典数据

获取minion配置文件

  1. Python 2.7. (default, Jul  , ::)
  2. [GCC 4.8.  (Red Hat 4.8.-)] on linux2
  3. Type "help", "copyright", "credits" or "license" for more information.
  4. >>> import salt.client
  5. >>> salt.config.minion_config('/etc/salt/minion') #读取minion配置文件，得到字典数据，通过字典方法可以查看信息

Python API介绍

  1. /usr/bin/salt默认使用的接口是LocalClient，该接口只能在salt master上使用
  1. [root@master  ~]$python
  2. Python 2.7.5 (default, Jul 13 2018, 13:06:57)
  3. [GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
  4. Type "help", "copyright", "credits" or "license" for more information.
  5. >>> import salt.client
  6. >>> local = salt.client.LocalClient()  #<salt.client.LocalClient object at 0x7f886dbdd850>
  7. >>> local.cmd('*','cmd.run',['hostname'])#向所有minion发送命令
  8. {'slave': 'slave'}

逐条返回结果，local.cmd_iter()

  1. >>> ret=local.cmd_iter('*','test.ping')
  2. >>> ret
  3. <generator object cmd_iter at 0x7f886d455c80>
  4. >>> for i in ret:
  5. ...     print i
  6. ...
  7. {'slave': {'retcode': , 'ret': True}}

菲波那切数列

  1. >>> local.cmd('*','test.fib',[])
  2. {'slave': [[, , , , , , ], 2.1457672119140625e-06]}

检查minion服务器信息

  1. >>> local.cmd('*','cmd.run',['hostname'])
  2. {'slave': 'slave'}
  3. >>> local.cmd('*','cmd.run',['ifconfig'])
  4. >>> local.cmd('*','cmd.run',['crontab -l'])
  5. >>> local.cmd('*','cmd.run',['df -h'])

启停minion的服务，如nginx

  1. >>> local.cmd('*','service.stop',['nginx'])
  2. {'slave': True}
  3. >>> local.cmd('*','service.status',['nginx'])
  4. {'slave': False}
  5. >>> local.cmd('*','service.start',['nginx'])
  6. {'slave': True}
 

saltstack高效运维的更多相关文章

  1. 17，saltstack高效运维

      salt介绍 saltstack是由thomas Hatch于2011年创建的一个开源项目,设计初衷是为了实现一个快速的远程执行系统. salt强大吗 系统管理员日常会进行大量的重复性操作,例如安 ...

  2. 七天学会SALTSTACK自动化运维　(3)

    七天学会SALTSTACK自动化运维 (3) 导读 SLS TOP.SLS MINION选择器 SLS文件的编译 总结 参考链接 导读 SLS SLS (aka SaLt State file) 是 ...

  3. 七天学会SALTSTACK自动化运维 （2）

    七天学会SALTSTACK自动化运维 (2) 导读 Grains Pillar 总结 参考链接 导读 上一篇主要介绍了安装和基本的使用方法,但是我认为如果理解了相关概念的话,使用会更加顺手,因为毕竟每 ...

  4. saltstack自动化运维系列11基于etcd的saltstack的自动化扩容

    saltstack自动化运维系列11基于etcd的saltstack的自动化扩容 自动化运维-基于etcd加saltstack的自动化扩容# tar -xf etcd-v2.2.1-linux-amd ...

  5. saltstack自动化运维系列⑩SaltStack二次开发初探

    saltstack自动化运维系列⑩SaltStack二次开发初探 1.当salt运行在公网或者网络环境较差的条件下,需要配置timeout时间vim /etc/salt/master timeout: ...

  6. saltstack自动化运维系列⑧SaltStack实践配置管理安装nginx-1.10.3

    saltstack自动化运维系列⑧SaltStack实践配置管理安装nginx-1.10.3 安装nginx-1.10.3.tar.gz # mkdir -p /srv/salt/prod/pkg / ...

  7. saltstack自动化运维系列⑦SaltStack实践配置管理安装zabbix

    saltstack自动化运维系列⑥SaltStack实践配置管理安装zabbix 1.添加管理zabbix的sls文件# vim /srv/salt/base/init/zabbix_agent.sl ...

  8. saltstack自动化运维系列⑥SaltStack实践安装配置HAproxy的Keepalived

    saltstack自动化运维系列⑥SaltStack实践安装配置HAproxy的Keepalived 安装配置Keepalived 1.编写功能模块 #创建keepalived目录# mkdir -p ...

  9. saltstack自动化运维系列⑥SaltStack实践安装配置HAproxy

    saltstack自动化运维系列⑥SaltStack实践安装配置HAproxy 下载haproxy1.6.2.tar.gz下载地址:http://www.haproxy.org/download/1. ...

随机推荐

  1. 加sogou 和wps

    刚装完系统,装常用工具: sogoupinyin / wps linux ==========sogoupinyin=========================1.sogou linux 下载d ...

  2. Qt信号槽第5个参数

    1.Qt::AutoConnection: 默认值,使用这个值则连接类型会在信号发送时决定.如果接收者和发送者在同一个线程,则自动使用Qt::DirectConnection类型.如果接收者和发送者不 ...

  3. C# 批量新增的两种方法。

    public class Test { private static readonly string strConnection = ""; public static void ...

  4. Java问题解决："错误：编码GBK 的不可映射字符"

    参考资料:http://blog.csdn.net/l1028386804/article/details/46583279 场景: 在使用javac编译java文件时出现以下错误: 解决方法: 使用 ...

  5. canvas 模拟时钟

    <meta charset="utf-8"> <canvas width="1000" height="1000" id= ...

  6. Map.putAll方法

    import Java.util.HashMap; public class Map_putAllTest { public static void main(String[] args){    / ...

  7. python常用技巧

    1,关于tab键与4个空格: 由于不同平台间,tab键值设置有所区别,据相关介绍,官方在缩进方面推荐使用4个空格.方便起见,可设置tab自动转换为4个空格. 1.1在pycharm中:    通过fi ...

  8. MySQL 存储过程返回多个值

    MySQL  存储过程返回多个值   在本教程中,您将学习如何编写/开发返回多个值的存储过程. MySQL存储函数只返回一个值.要开发返回多个值的存储过程,需要使用带有INOUT或OUT参数的存储过程 ...

  9. 如何增加亚马逊listing多个类目节点

    流量是电商销售的必要因素,可以说,任何成功的电商平台都离不开流量.亚马逊listing优化做得好,不仅能提高产品的曝光率,还能提升转换率,而好的类目可以吸引大的流量.帮你快速爬升. 首先我们来了解一下 ...

  10. vue 简单实现父组件向子组件传值，简单来说就是子组件肆意妄为的调用父组件里后台返回的值

    首先在于父子组件传值的方法很多,本人在这里只是简单描述一下一个组件里面引用了子组件,那么子组件如何才能获取父组件中后台返回的值呢? 首先调用组件相信大家都应该明白了(不明白的自己撸撸文档), < ...