SaltStack技术入门与实践

第1章 SaltStack入门


1.2.1 SaltStack软件依赖
SaltStack有两种消息系统，一种是REAT，一种是ZeroMQ，默认使用ZeroMQ.
软件依赖列表如下:
●Python版本大于2.6或版本小于3.0:对Python版本要求
●msgpack-python:SaltStack消息交换库
●YAML:SaltStack配置解析定义语法
●Jinja2: SaltStack states配置模板
●MarkupSafe: Python unicode转换库
●apache-libcloud: SaltStack对云架构编排库
●Requests: HTTP Python库
●ZeroMQ: SaltStack消息系统
●pyzmq: ZeroMQ Python库
●PyCrypto: Python密码库
●M2Crypto: Openssl Python包装库


1.2.2 yum方式安装（采用EPEL源）
Master端安装：
SaltStack@Master: rpm -vih rpm -vih http://mirrors.zju.edu.cn/epel/6/i386/epel-release-6-8.noarch.rpm
SaltStack@Master: yum install salt-master -y
SaltStack@Master: service salt-master start


Minion端安装：
SaltStack@Minion: rpm -ivh rpm -vih http://mirrors.zju.edu.cn/epel/6/i386/epel-release-6-8.noarch.rpm 
SaltStack@Minion: yum install salt-minion -y
SaltStack@Minion: sed -i 's/#master: salt/master: IPADDRESS/g'  /etc/salt/minion   
   #IPADDRESS 为Master服务器地址
SaltStack@Minion: service salt-minion start


1.2.5 salt-bootstrap安装
salt-bootstrap主要用于解决多平台一键部署SaltStack环境。核心工程机就是维护一个庞大的bash脚本。


Master端安装：
SaltStack@Master: curl -L https://bootstrap.saltstack.com -o install_salt.sh
SaltStack@Master: sh install_salt.sh -M -N                    #只安装最新版的Master


Minion端安装：
SaltStack@Minion: echo "IPADDRESS  salt"  >> /etc/hosts    #IPADDRESS为Master服务器地址
SaltStack@Minion: curl -L https://bootstrap.saltstack.com -o install_salt.sh
SaltStack@Minion: sh install_salt.sh -i Minion       #只安装最新版Minion并且指定Minion id


1.3 开始SaltStack之旅


1.3.1 证书管理
对Minion进行签售证书：
SaltStack@Master:  salt-key -L               #查看当前证书签售情况
SaltStack@Master:  salt-key -A -y          #同意签证有没有接受的签证请求




#查看更多证书管理命令
SaltStack@Master:  salt-key -h




SaltStack@Master:  salt 'Minion'  test.ping


1.3.2 日常命令参数


1.Master端
SaltStack@Master: rpm -ql salt-master
/etc/rc.d/init.d/salt-master                #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


2.Minion端
SaltStack@Minion: rpm -ql salt-minion
/etc/rc.d/init.d/salt-minion              #salt minion服务启动脚本
/etc/salt/minion                              #salt minion配置文件
/usr/bin/salt-call                             #salt call拉取命令
/usr/bin/salt-minion                       #salt minion服务命令


SaltStack@Minion:  salt-call -h




1.4 熟悉SaltStack配置文件
SaltStack的配置文件分为Master(/etc/salt/master)和Minion(/etc/salt/minion)


1.4.1 Master配置文件
●max_open_files: 可以根据Master将Minion数量进行适当的调整
●timeout: 可以根据Master和Minion的网络状况适当调整
●auto_accept和autosign_file: 在大规模部署Minion的时候可以设置自动签证
●master_tops和所有以external开头的参数：这些参数是SaltStack与外部系统进行整合的相关配置参数


-----------------------------------------------------------------------------------------------------------
第2章  SaltStack组件


2.1 从管理对象说起


SaltStack系统中的管理对象叫做Target, 在Master上我们可以采用不同的Target去管理不同的Minion,这些Target都是通过去管理和匹配Minion的ID来做一些集合！


1.正则匹配


#想要匹配到'Min*'字符串的Minion进行操作
SaltStack@Master:  salt  -E 'Min*'   test.ping


2.列表匹配
SaltStack@Master:  salt  -L  Minion,Minion1 test.ping


Minion和Minion1通过列表的方式去指定Minion ID,可直接使用。


3.Grians匹配
SaltStack@Master:  salt  -G  'os:MacOS'  test.ping


其中os:MacOS,这里的对象是一组键值对。


4.组匹配
SaltStack@Master:  salt  -N  groups test.ping
groups是我们在master配置文件中定义的组名称


5.复合匹配
SaltStack@Master: salt -C 'G@os:MacOS or L@Minion1'  test.ping


os:MacOs or L@Minion1是一个复合组合，支持使用and和or关联多个条件


6.Pillar值匹配
SaltStack@Master:  salt  -I  'key:value'  test.ping


key:value是Pillar系统中定义的一组键值对，跟Grains的键值对类似。


7.CIDR匹配
SaltStack@Master:  salt  -S  '192.168.1.0/24'   test.ping


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


2.2  管理对象属性
Grains是SaltStack记录Minion的一些静态信息的组件，简单理解为Grains里面记录着每台Minion的一些常用属性，例如CPU、内存、磁盘、网络信息等。
可以通过grains.items查看某台Minion的所有Grains信息。Minion的Grains信息是Minions启动时采集汇报给Master的。


关于自定义Grains的常用方法有以下几种：
●通过Minion配置文件定义
●通过Grains相关模块定义
●通过Python脚本定义


Grains相关命令用法：
SaltStack@Master: salt  'Minion'  sys.list_functions  grains
Minion:
       - grains.append
       - grains.delval
       - grains.filter_by
       - grains.get
       - grains.get_or_set_hash
       - grains.has_value
       - grains.items
       - grains.ls
       - grains.remove
       - grains.setval
       - grains.setvals




#查看详细用法
salt 'Minion'  sys.doc grains


2.2.1  通过Minion配置文件定义Grains
SaltStack的配置文件的默认格式都是YAML格式
为了统一管理Minion的Grains信息，需要把SaltStack的配置文件中定义grains的部分复制到minion.d/grains文件中：
SaltStack@Minion:  cat  /etc/minion.d/grains
grains:
    roles:
        - webserver
        - memcache
    deployment: datacenter4
    cabinet: 13
    cab_u: 14-15
    
然后/etc/init.d/salt-minion restart命令重启Minion服务，之后可以去Master上查看定义的Grains信息是否生效：
SaltStack@Master:  salt 'Minion'  grains.item roles
SaltStack@Master:  salt 'Minion'  grains.item deployment


2.2.2 通过Grains模块定义Grains
SaltStack@Master: salt  'Minion'  grains.append saltbook 'verycool'
#设置grains信息
   Minion:
         ---------------
         saltbook:
               -  verycool
SaltStack@Master: salt  'Minion'   grains.item saltbook             #查看grains信息
    Minion:
         ---------------
         saltbook:
               -  verycool


可以使用grains.setvals同时设置多个Grains信息：
SaltStack@Master:  salt 'Minion'  grains.setvals  "{'salt': 'good','book': 'cool'}"
Minion:
         ---------------
         book:
              cool
         salt:
              good
SaltStack@Master: salt 'Minion'  grains.item salt
Minion:
        ---------------
        salt:
              good






上面设置的内容会被写入到Minion端的/etc/salt/grains文件中
更多用法可通过sys.doc grains命令查询（salt 'Minion' sys.doc grains）


2.3 数据管理中心
Pillar是数据管理中心。Pillar在SaltStack中主要的作用是存储和定义配置管理中需要的一些数据，比如软件版本号，用户名密码等信息
它的存储定义格式也是YAML格式。
在Master配置文件中有一段Pillar settings选项专门定义Pillar相关的一些参数：
#pillar_roots:
#   base:
#      -  /srv/pillar


默认Base环境下Pillar工作目录在/srv/pillar目录下。
【使用默认的配置】
首先去pillar工作目录新建top.sls文件然后引用两个sls文件：
SaltStack@Master:  cat  /srv/pillar/top.sls
base:                             #指定环境
     '*':                            #Target
          - packages          #引用package.sls或者packages/init.sls
          - services            #引用services.sls或者services/init.sls
SaltStack@Master:  cat /srv/pillar/packages.sls
zabbix:
     package-name: zabbix
     version:  2.2.4
SaltStack@Master:  cat /srv/pillar/services.sls
zabbix:
     port: 10050
     user: admin


#查看关于pillar相关的一些模块用法
SaltStack@Master:  salt  'Minion'  sys.list_functions pillar
Minion: 
     - pillar.data
     - pillar.ext
     - pillar.get
     - pillar.item
     - pillar.items
     - pillar.raw


详细用法和例子可通过命令salt 'Minion'  sys.doc pillar查看。


#查看刚刚定义的pillar:
SaltStack@Master:  salt 'Minion'  pillar.item zabbix


2.4 针对管理对象操作
Module用于管理对象操作，也是SaltStack通过Push方式进行管理的入口：例如执行命令、查看安装包情况、查看服务运行情况。


1.查看所有module列表
查看Minion支持的所有module列表的命令如下：
SaltStack@Master: salt 'Minion' sys.list_modules


2.查看指定module的所有function
查看cmd module的所有function的命令如下：
SaltStack@Master:  salt 'Minion' sys.list_functions cmd


3.查看指定module用法
查看cmd module的详细用法与例子的命令：
SaltStack@Master:  salt 'Minion'  sys.doc  cmd


SaltStack默认也支持一次执行多个Module，Module之间通过逗号隔开，默认传参之间也用逗号隔开，也支持指定传参分隔符号--args-separator=@即可
SaltStacke@Master: salt  'Minion'  test.echo,cmd.run,service.status,saltbook,hostname,salt-master


2.5配置管理从这里开始
States是SaltStack中的配置语言，在日常进行配置管理时需要编写大量的States文件！


1.查看所有states列表
要查看Minion支持的所有states列表，命令如下：
SaltStack@Master:  salt  'Minion'  sys.list_state_modules


2.查看指定states的所有function
查看file.states的所有function,命令如下：
SaltStack@Master: salt  'Minion'  sys.list_state_functions file


3.查看指定states用法
查看file.states的详细用法：
SaltStack@Master: salt  'Minion' sys.state_doc file


4.查看指定states指定function用法
查看file.managed states的详细用法和例子：
SaltStack@Master:  salt 'Minion'  sys.state_doc file.managed


5.从一个简单的例子去了解states
使用states的流程：
●编写top.sls文件（非必须）
●编写states.sls文件


top.sls是states系统的入口文件，它在大规模配置管理工作中负责指定哪些设备调用哪些states.sls文件。


例如：要简单的对某台机器进行配置管理，可直接使用state.sls命令指定states.sls文件即可，具体操作如下：
先在states的工作目录（base环境默认在/srv/salt）下新建一个one.sls.states文件：
SaltStack@Master:  cat  /srv/salt/one.sls
/tmp/foo.conf:                              #id
    file.mangled:                             #file states的mangled functions
          - source: salt://foo.conf       #文件来源(salt://代表states的工作目录)
          - user: root                          #文件属主
          - group: root                       #文件属组
          - mode: 644                        #文件权限
          - backup:minion                 #备份原文件


这个states.sls文件的功能就是实现对Minion的/tmp/foo.conf文件进行统一管理。
【部署】
可以在states的工作目录下新建一个foo.conf文件，然后对Minion进行配置部署：
SaltStack@Master: echo "SaltStack Books" > /src/salt/foo.conf
SaltStack@Master: salt 'Minion'  state.sls one




使用top.sls入口文件同时对多台机器进行一个简单的配置管理，操作如下：
首先在states的工作目录下新建top.sls文件：
SaltStack@Master:   cat   /src/salt/top.sls
base:                          #base环境
       '*':                       #Target(代表所有Target)
           - one               #引用one.sls或者one/init.sls states文件
       'Minion':              #Target(代表匹配Minion)
           - tow               #引用tow.sls或者tow/init.sls states文件
       'Minion1':            #Target(代表匹配Minion1)
           - three             #引用three.sls或者three/init.sls states文件
           
然后我们新建三个states文件：one.sls、tow.sls、three.sls，并使用state.highstate命令同时对Minion和Minion1两台机器进行配置管理。


2.6执行结果处理
Return组件是SaltStack系统对执行Minion返回后的数据进行存储或者返回给其他程序。它支持多种存储方式，比如用MySQL,MongoDB,Redis,Memcache等
通过Return可以对SaltStack的每次操作进行记录，对以后日志审计提供了数据来源。
官方支持30多种Return数据存储与接口！


1.查看所有Return列表
SaltStack@Master:  salt  'Minion'  sys.list_returners


2.Return流程
Return是在Master端触发任务，然后Minion接受处理任务后直接与Return存储服务器建立连接，然后把数据Return存到存储服务器。


3.使用Redis作为Return存储方式
需要修改的配置信息：
●Minion配置文件
●在Minion上安装Redis Python Client


(1)在Minion配置文件中定义Redis存储服务器信息
redis.db: '0'                                     #redis数据库
redis.host:  'vps.shencan.net'           #redis主机（ip地址和域名都行）
redis.port:  6379                              #redis端口


(2)安装依赖包
SaltStack@Minion: python -c  'import redis; print redis.VERSION'
如果能显示出版本号，说明当前Python版本下的Redis Client已经安装好！




2.7 Job管理
在SaltStack里面执行任何一个操作都会在Master上产生一个jid号。Minion端会在cache目录下的proc目录创建一个以jid为名称的文件，这个文件里面的内容就是
此次操作的记录，当操作处理完成后该文件会自动删除。而Master端会记录每次操作的详细信息，这个记录都是存到在Master端cache目录下的jobs下。


1.通过salt-run来管理job
查看salt-run对job管理的一些用法：
SaltStack@Master:  salt-run -d |grep jobs


[root@SaltStack-Master salt]# salt-run -d|grep jobs
/usr/lib64/python2.6/site-packages/Crypto/Util/randpool.py:40: RandomPool_DeprecationWarning: This application uses RandomPool, which is BROKEN in older releases.  See http://www.pycrypto.org/randpool-broken
  RandomPool_DeprecationWarning)
'jobs.active:'
    Return a report on all actively running jobs from a job id centric
        salt-run jobs.active
'jobs.last_run:'
    List all detectable jobs and associated functions
        salt-run jobs.last_run
        salt-run jobs.last_run target=nodename
        salt-run jobs.last_run function='cmd.run'
        salt-run jobs.last_run metadata="{'foo': 'bar'}"
'jobs.list_job:'
        salt-run jobs.list_job 20130916125524463507
'jobs.list_jobs:'
    List all detectable jobs and associated functions
        Search for jobs where the start time of the job is greater than
        Search for jobs where the start time of the job is less than
        salt-run jobs.list_jobs
        salt-run jobs.list_jobs search_function='test.*' search_target='localhost' search_metadata='{"bar": "foo"}'
        salt-run jobs.list_jobs start_time='2015, Mar 16 19:00' end_time='2015, Mar 18 22:00'
'jobs.list_jobs_filter:'
    List all detectable jobs and associated functions
        salt-run jobs.list_jobs_filter 50
        salt-run jobs.list_jobs_filter 100 filter_find_job=False
'jobs.lookup_jid:'
        salt-run jobs.lookup_jid 20130916125524463507
        salt-run jobs.lookup_jid 20130916125524463507 outputter=highstate
'jobs.print_job:'
        salt-run jobs.print_job 20130916125524463507
        


关于每个参数的解释可以通过命令来查看：
salt-run -d jobs


可以通过salt-run job管理来查看job的信息。
查看某个job的运行结果：
SaltStack@Master:  salt-run jobs.lookup_jid  20150503205732787057


查看这个job的详细记录：
SaltStack@Master:  salt-run jobs.list_job   20150503205732787057




2.通过SaltStack Module来管理job
salt-run对job管理功能比较局限，目前salt-run不支持kill某个job.


#查看相关Module的用法
SaltStack@Master: salt \*  sys.doc saltutil | grep job


[root@SaltStack-Master salt]# salt \*  sys.doc saltutil | grep job
saltutil.find_cached_job:         #查询job cache信息
    Return the data for a specific cached job id
        salt '*' saltutil.find_cached_job <job id>
saltutil.find_job:                     #查询job信息
    Return the data for a specific job id
        salt '*' saltutil.find_job <job id>
saltutil.kill_job:                      #杀掉job(发送SIGTERM 9信号方式)
    Sends a kill signal (SIGKILL 9) to the named salt job's process
        salt '*' saltutil.kill_job <job id>
        salt '*' saltutil.runner jobs.list_jobs
saltutil.signal_job:                 #发送指定信号
    Sends a signal to the named salt job's process
        salt '*' saltutil.signal_job <job id> 15
saltutil.term_job:                   #删掉job（发送SIGTERM 15信号方式）
    Sends a termination signal (SIGTERM 15) to the named salt job's process
        salt '*' saltutil.term_job <job id>


使用Module来管理job
SaltStack@Master: salt 'Minion'  saltutil.find_job  20150503205732787057


直接杀掉这个job
SaltStack@Master: salt 'Minion'  saltutil.kill_job   20150503205732787057


2.8 EVENT和Reactor系统
EVENT是SaltStack里面对每一个事件的一个记录，它相对job更加底层，Event能记录更加详细的SaltStack事件。
例如：Minion服务启动后请求Master签发证书或者证书校验的过程，都能通过Event事件来查看整个过程。
Event也为扩展SaltStack提供了更加友好的接口。


1.查看Event事件
SaltStack@Master:  salt-run state.event pretty=True


2.在Master上配置Reactor
Reactor是基于Event的每个事件来做相应的操作。可以理解为Reactor系统是一直监听着Event，然后触发一些States操作。
当大规模新机器上线时，都希望Minion第一次起来时就能完成所有的配置，这就能通过Reactor实现。


●在Master配置文件里面添加如下内容：
reactor:
     -  'salt/auth':                                    #监听证书认证event
          -  /srv/reactor/Minion.sls            #执行states sls文件
     -  'salt/minion/Minion/start':            #监听Minion start event
          - /srv/reactor/auto.sls                 #执行states sls文件
          
●配置states文件
SaltStack@Master:  cat /srv/reactor/Minion.sls
{% if 'act' in data  and data['act']  ==  'pend'  and data['id'].startswith('Min')   %}
key_accept:
       wheel.key.accept:
            - match:  {{  data['id']  }}
{%  endif  %}


上述文件主要是取event里面的数据，然后根据Minion的ID进行证书签发。


初始的auto.sls文件
SaltStack@Master:  cat  /srv/reactor/auto.sls
run_state:
    local.state.sls
       - tgt:  {{  data['id']  }}
       - arg: 
             - shencan
run_init:
    local.cmd.run:
      - tgt:  {{   data['id']  }}
      -arg:
             - echo initsok  >>/tmp/cpis
 
上述文件运行了两个Module,一个是states.sls进行，一个是cmd.run.
run_state是针对Minion运行state.sls shencan
run_init: 是针对Minion运行cmd.run 'echo initok >> /tmp/cpis'


2.9 Renderer组件
默认SaltStack的Renderers是YAML+Jinja，可以通过查看Master配置文件得知当前的Renderer.
三种应用范围比较广的Renderer ： YAML、Jinja、py


使用Python语言去定义state文件：
SaltStack@Master:  cat  /srv/salt/test.sls
#!py                                                           #指定renderer，这里为Python
def run():
    example={}
    example['/tmp/test']  = {
                  'file.managed': [
                  {'source': 'salt://test'},
                  {'mode': '644'},
                  {'user': 'root'},
                  {'template':'jinja'},
                  {'group':'root'},
                  {'context':{
                   'a': __grains__['os'],
                   'b': __pillar__['a'],
                  },
                  },
                  ],
                  }
    return example


state.sls文件的用途就是使用Jinja模板去同步/tmp/test文件。
通过Python定义一个run函数，函数返回一个dict。


使用Python编写的state就是使用YAML编写的state.
在state里面调用Pillar Grains,使用python编写时可直接使用__grains__  __pillar__这两个Python方法进行引用。
使用YAML编写的state里面引入Jinja来调取grains['key'] pillar['key']


2.10 其他组件


2.10.1 Mine
Mine是SaltStack收集Minion数据存储到Master的一个组件，功能和Grains类似！
Mine可以指定任何Minion模块去采集数据。
Master只能存储Minion收集上来的最近一段的数据，Mine的主要应用场景是配合前端负载均衡动态获取Mine汇报信息，来动态生成配置文件！


Mine支持两种配置方式：(1)通过在Minion配置文件中定义;(2)通过模块的方式去下发Mine采集任务。


#查看Mine模块的更多用法
sys.doc mine


2.10.2 Peer
Peer组件是SaltStack中Minion向Master发布任务的一个组件，使用Peer可以直接在Minion上向Master发布一些任务。
【配置Peer】
peer:
      Minion:
          -  test.ping
peer_run:
     Minion:
          -  manage.up


Peer是控制Minion执行模块的，peer_run是控制Minion执行runner的。
下面通过在Minion上向Master发布任务：
●执行test.ping
SaltStack@Minion: salt-call publish.publish 'Minion' test.ping
●其他任务
SaltStack@Minion: salt-call publish.publish 'Minion' test.echo saltstack
●调用runner
SaltStack@Minion: salt-call publish.runner manage.up
SaltStack@Minion: salt-call publish.runner manage.down
-----------------------------------------------------------------------------------------------
第3章 SaltStack实践案例


使用SaltStack进行生产环境配置管理，主要包括以下功能和服务：
●系统初始化
●Haproxy服务
●Keepalived服务
●Nginx服务
●PHP(FastCGI)服务
●Memcached服务


3.1环境规划