automation►salt►salt state module

salt state module

salt通过state模块定义主机状态

  1. salt状态的概念

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    远程执行模块的执行是过程式的,类似于shell脚本或者python脚本,每次执行都会触发一次相同的功能

    在大量的minion上运行远程命令非常重要,但对于minion的环境控制,使用状态进行管理更为合适.
    状态是对minion的一种描述和定义,管理人员可以不关心具体部署任务是如何完成的,只需要描述minion需要达到什么状态,底层由salt的状态模块来完成功能
    例如: 在minion上部署apache
    [root@saltserver ~]# salt '*' pkg.install "httpd"
    192.168.13.187:
        ----------
        httpd:
            ----------
            new:
                2.2.15-60.el6.centos.4
            old:
    pkg.install 类似于 直接在系统上执行 "yum install httpd"

  2. salt状态的编写

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    * 创建state存放目录
    [root@saltserver ~]# mkdir -p /srv/salt/

    * 创建apache.sls文件(state文件)
    [root@saltserver ~]# vim /srv/salt/apache.sls
    install_httpd:
      pkg.installed:
        - name: httpd

    * 执行命令
    [root@saltserver ~]# salt '*' state.sls apache
    192.168.13.187:
    ----------
              ID: install_httpd
        Function: pkg.installed
            Name: httpd
          Result: True
         Comment: The following packages were installed/updated: httpd
         Started: 10:01:50.639510
        Duration: 28720.413 ms
         Changes:   
                  ----------
                  httpd:
                      ----------
                      new:
                          2.2.15-60.el6.centos.4
                      old:

    Summary for 192.168.13.187
    ------------
    Succeeded: 1 (changed=1)
    Failed:    0
    ------------
    Total states run:     1
    Total run time:  28.720 s

    综上,state模块部署apache时,我们用了一个描述性配置文件,命令行调用了state模块的SLS函数,从返回结果上看是成功部署了httpd
    再次执行,查看状态:
    [root@saltserver ~]# salt '*' state.sls apache
    192.168.13.187:
    ----------
              ID: install_httpd
        Function: pkg.installed
            Name: httpd
          Result: True
         Comment: Package httpd is already installed
         Started: 10:03:52.341712
        Duration: 805.446 ms
         Changes:   

    Summary for 192.168.13.187
    ------------
    Succeeded: 1
    Failed:    0
    ------------
    Total states run:     1
    Total run time: 805.446 ms

    综上,执行模块和状态模块之间的主要区别: 执行模块是过程式的,而状态模块是描述性的
    当你连续几次调用同一个执行模块时,实际上将执行相同的逻辑和指令;状态模块恰恰相反,状态模块设计为描述性的,它们只是执行必要的工作,在目标minion上创建根据描述文件指定的状态

    当我们通过pkg.install命令时,实际上只运行了yum install命令,而state模块时会首先判断httpd软件是否安装,如果没安装就进行安装,如果安装了,就什么都不做

  3. 状态配置文件各要素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    例如:
    [root@saltserver ~]# cat /srv/salt/apache.sls
    install_httpd:
      pkg.installed:
        - name: httpd

    SLS配置文件使用YAML语言描述.salt默认的SLS文件的renderer是YAML renderer. YAML renderer的工作是将YAML数据格式的结构编译成python数据结构给salt使用.
    只需要三个简单规则即可使用YAML语法描述SLS文件:
    规则一: 缩进
    YAML使用一个固定的缩进风格来表示数据层次结构关系.缩进由两个空格组成,禁止使用Tab键
    规则二: 冒号
    字典的keys在YAML中表现形式是一个以冒号结尾的字符串;values的表现形式是冒号下面的每一行用一个空格隔开
    例如: my_key: my_value 对应python {'my_key': 'my_value'}
    字典可以被嵌套:
    例如:
    first_dict_key:
      second_dict_key: second_dict_value
    对应于python:
    {
      'first_dict_key': {
          'second_dict_key': 'second_dict_value'
      }
    }
    规则三: 短横杠
    用一个短横杠加一个空格来表示列表项,多个列表项使用同样的缩进级别作为同一列表的一部分
    例如:
    my_dictionary:
      - list_value_1
      - list_value_2
      - list_value_3
    对应python为:
    {
      'my_dictionary':[
          'list_value_1',
          'list_value_2',
          'list_value_3'
      ]
    }

  4. 常用的状态模块

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    //获取所有可执行模块
    [root@saltserver ~]# salt '*' sys.list_modules

    //获取所有状态模块
    [root@saltserver ~]# salt '*' sys.list_state_modules

    //获取状态模块中的所有函数
    [root@saltserver ~]# salt '*' sys.list_state_functions pkg

    * file模块
    1.file.managed下发文件
    /etc/foo.conf:
      file.managed:
        - source:
          - salt://foo.conf
        - user: foo
        - group: users
        - mode: 644
    2.file.directory建立目录
    /etc/stuff/substuf:
      file.directory:
        - user: fred
        - group: users
        - mode: 755
        - makedirs: True
    3.file.symlink建立软连接
    /etc/grub.conf:
      file.symlink:
        - target: /boot/grub/grub.conf
    4.file.recurse下发整个目录
    /opt/code/flask:
      file.recurse:
        - source: salt://code/flask
        - include_empty: True

    * pkg模块
    1.pkg.install软件安装
    mypkgs:
      pkg.installed:
        - pkgs:
          - foo
          - bar: 1.2.3-4
    2.pkg.installed安装指定版本
    mypkgs:
      pkg.installed:
        - pkgs:
          - foo
          - bar: '>=1.2.3-4'
    3.pkg.installed指定安装的rpm来源
    mypkgs:
      pkg.installed:
        - sources:
          - foo: salt://rpms/foo.rpm
          - bar: http://somesite.com/bar.rpm
          - baz: ftp://someothersite.com/baz.rpm
          - qux: /minion/path/to/qux.rpm
    4.pkg.installed指定安装最新版本的软件
    pkg.latest:
      mypkgs:
        pkg.latest:
          - pkgs:
            - foo
            - bar

    * service模块
    1.启动服务(redis为例)
    redis:
      service.running:
        - enable: True
        - reload: True
        - watch:
          - pkg: redis

    * cron模块
    1. 每五分钟执行一次任务
    date > /tmp/crontest:
      cron.present:
        - user: root
        - minute: '*/5'

    * user模块
    1.user.present建立用户
    user.present:
      - fullname: Fred Jones
      - shell: /bin/zsh
      - home: /home/fred
      - uid: 4000
      - gid: 4000
      - groups:
        - wheel
        - storage
        - games

    * sysctl模块
    vm.swappiness:
      sysctl.present:
        - value: 20

    * pip模块
    django:
      pip.installed:
        - name: django >=1.6,<=1.7
        - require:
          - pkg: python-pip

  5. 使用requisites对状态进行排序控制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    通过state模块可以定义minion的状态,但是如果一个主机涉及多个状态,并且状态之间有相互关联,需要在执行顺序上有先后之分,就必须引入requisites来进行控制
    例一:
    install_httpd:
      pkg_installed:
        - name: httpd
    httpd_running:
      service.running:
        - name: httpd
        - enable: True
        - require:
          - pkg: install_httpd

    综上,定义了两个状态:安装httpd和启动httpd,很明显有先后顺序,先安装httpd,然后启动httpd.我们通过require指定httpd启动时必须在install_httpd安装完成后才可以执行

    例二:
    install_httpd:
      pkg_installed:
        - name: httpd
    httpd_running:
      service.running:
        - name: httpd
        - enable: True
        - require:
          - pkg: install_httpd
        - watch:
          - file: httpd_conf
    httpd_conf:
      file.managed:
        - name: /etc/httpd/conf/httpd.conf
        - source: salt://httpd.conf
        - user: root
        - group: root
        - mode: 600

    综上,首先必须安装httpd,然后去报httpd启动,最后对比需要下发的httpd.conf和minion上已有的是否相同,如果不同就下发文件,下发文件后要触发httpd进程的重载以加载新的配置