Saltstack自动化运维详解（数据系统 jinja模板 job管理）

文章目录

1. saltstack 的数据系统
- 1.1 SaltStack组件之Grains
- - 1.grains使用方法
  - - 信息查询
    - 查询某个key值
    - 用Grains来匹配minion
  - 2.自定义grains
  - - 方法一:在minion端
    - 方法二:在minion端
  - 3. 匹配运用
  - - target匹配
    - top.sls文件使用
- 1.2 SaltStack组件之Pillar
- - 1. 自定义pillar项
  - 2. 数据匹配
2. jinja模板
- 2.1介绍
- 2.2 jinja的使用
- 2.3 高可用安装配置示例
3. job管理
- 3.1 把job存储到数据库
- 3.2 Job管理

1. saltstack 的数据系统

saltstack有两大数据系统-grains和pillar

1.1 SaltStack组件之Grains

Grains是SaltStack的一个组件，其存放着minion启动时收集到的信息。当salt-minion启动时会把收集到的数据静态存放在Grains当中，只有当minion重启时才会进行数据的更新。由于grains是静态数据，因此不推荐经常去修改它。
Grains是SaltStack组件中非常重要的组件之一，因为我们在做配置部署的过程中会经常使用它，Grains是SaltStack记录minion的一些静态信息的组件。可简单理解为Grains记录着每台minion的一些常用属性，比如CPU、内存、磁盘、网络信息等。我们可以通过grains.items查看某台minion的所有Grains信息。
Grains应用场景：

信息查询
在命令行下进行目标匹配
在top file中进行目标匹配
在模板中进行目标匹配

1.grains使用方法

信息查询

salt server2 grains.ls只查询grains的key项
salt server3 grains.item fqdn查询域名
salt server3 grains.item ipv4查询IP
salt server3 grains.item ipv6

查询某个key值

用Grains来匹配minion

2.自定义grains

方法一:在minion端

在minion端vim /etc/salt/minion

systemctl restart salt-minion重启服务
在master端进行查询 salt server3 grains.item roles
server2的设置方法如上，将server2的roles设置为httpd

方法二:在minion端

vim /etc/salt/grains创建grains文件

在master端

salt server3 saltutil.sync_grains同步数据

salt server3 grains.item roles查看数据

master端

mkdir /srv/salt/_grains创建目录
vim /srv/salt/_grains/my_grain.py编写py文件

def my_grain():grains = {}grains['salt'] = 'stack123'grains['hello'] = 'world'return grains

salt '*' saltutil.sync_grains
salt server2 grains.item salt查看数据
salt server2 grains.item hello

注意：如果在.py文件中设置了 grains['roles] = 'XXXX',重新查看minion的role，发现并没有生效，因为minion端的更改优先级更高

3. 匹配运用

target匹配

salt -G roles:httpd cmd.run date -G通过grains
salt -G roles:nginx cmd.run hostname
salt -G salt:stack123 cmd.run hostname
salt -G hello:world cmd.run hostname

top.sls文件使用

vim /srv/salt/top.sls

base:'roles:httpd':- match: grain- httpd'roles:nginx':- match: grain- nginx

salt '*' state.highstate全局推

1.2 SaltStack组件之Pillar

Pillar也是SaltStack组件中非常重要的组件之一，是数据管理中心，经常配置states在大规模的配置管理工作中使用它。Pillar在SaltStack中主要的作用就是存储和定义配置管理中需要的一些数据，比如软件版本号、用户名密码等信息，而且可以指定某一个minion才可以看到对应的信息,它的定义存储格式与Grains类似，都是YAML格式。
Pillar的特点：

可以给指定的minion定义它需要的数据
只有指定的人才能看到定义的数据
在master配置文件里设置

在Master配置文件中有一段Pillar settings选项专门定义Pillar相关的一些参数：
vim /etc/salt/master
默认Base环境下Pillar的工作目录在/srv/pillar目录下。若你想定义多个环境不同的Pillar工作目录，只需要修改此处配置文件即可。

1. 自定义pillar项

mkdir /srv/pillar创建pillar目录
mkdir /srv/pillar/web自定义目录web
vim /srv/pillar/web/init.sls

{% if grains['fqdn'] == 'server2' %}
package: httpd
{% if grains['fqdn'] == 'server3' %}
package: nginx
{% endif %}

vim /srv/pillar/top.sls

base:'*':- web

salt '*' saltutil.refresh_pillar刷新pillar数据
salt '*' pillar.items查询pillar数据
salt '*' pillar.item package查询pillar数据

2. 数据匹配

命令行中匹配
salt -I package:nginx cmd.run hostname
state系统中使用
vim /srv/salt/httpd/init.sls

web:pkg.installed:- pkgs:- {{ pillar['package'] }}file.managed:- source: salt://httpd/files/httpd.conf- name: /etc/httpd/conf/httpd.confservice.running:- name: httpd- enable: True- reload: True- watch:- file: web

2. jinja模板

2.1介绍

Jinja2的应用场景：针对不同的操作系统安装软件，针对不同的cpu数量、内存等动态生成软件的配置文件，都需要Jinja2以及Grains和pillar的辅助，
Jinja2是一个强大的python模板引擎，他的设计思想来源于Django的模板引擎，并扩展了其语法和一系列强大的功能。其中最显著的一个是增加了沙箱执行功能和可选的自动转义功能，这对大多应用的安全性来说是非常重要的。
Jinja模板两种分隔符: {% … %} 和 {{ … }}，前者用于执行诸如 for 循环
或赋值的语句，后者把表达式的结果打印到模板上。

2.2 jinja的使用

控制条件
vim /srv/salt/test.sls

/mnt/testfile:file.append:{% if grains['fqdn'] == 'server2' %}- text: server2{% elif grains['fqdn'] == 'server3' %}- text: server3{% endif %}

salt '*' state.sls test执行命令，发minion端已经完成

2. 在普通文件中的使用
vim /srv/salt/httpd/httpd.conf

vim /srv/salt/httpd/init.sls

web:pkg.installed:- pkgs:- httpdfile.managed:- source: salt://httpd/files/httpd.conf- name: /etc/httpd/conf/httpd.conf- template: jinja- context:port: 80service.running:- name: httpd- enable: True- reload: True- watch:- file: web

想要加上端口号的话

vim httpd.conf

Listen {{ bind }}:{{ port }}

vim init.sls

- template: jinja
- context:port: 80bind: 192.168.43.2

或者

...
- template: jinja
- context:port: 80bind: { grains['ipv4'][-1] }

直接引用pillar/grains变量
vim /srv/salt/httpd/init.sls

...
- template: jinja
- context:port: {{ pillar['PORT'] }}bind: { grains['ipv4'][-1] }

vim /srv/pillar/web/init.sls

{% if grains['fqdn'] == 'server2' %}
package: httpd
PORT: 80
{% elif grains['fqdn'] == 'server3' %}
package: nginx
{% endif %}

引用pillar变量
vim /srv/salt/httpd/init.sls

...
- template: jinja
- context:port: {{ pillar['PORT'] }}bind: {{ pillar['BIND'] }}

vim /srv/pillar/web/init.sls

{% if grains['fqdn'] == 'server2' %}
package: httpd
PORT: 80
BIND: 192.168.43.2
{% elif grains['fqdn'] == 'server3' %}
package: nginx
{% endif %}

直接引用pillar变量
vim httpd.conf

Listen {{ grains['ipv4'][-1] }}:{{ pillar['PORT'] }}

引入其他文件中的变量,使用jinja模板的Import方式
vim /srv/salt/lib.sls

{%  set port = 80 %}

vim /srv/salt/httpd/files/httpd.conf

{% from 'lib.sls' import port %} ##在apache配置文件中导入模板文件,将其写在第一行

注意： lib.sls文件的优先级大于pillar，最后生效

2.3 高可用安装配置示例

vim /srv/salt/keepalived建立目录
vim /srv/salt/keepalived/files建立文件目录
vim /srv/salt/keepalived/install.sls安装。先写安装文件，

kp-install:pkg.installed:- name: keepalived

salt server2 state.sls keepalived.install先进行安装，然后传送配置文件到files/

[root@server2 ~]# cd /etc/keepalived/
[root@server2 keepalived]# ls
keepalived.conf
[root@server2 keepalived]# scp keepalived.conf server1:/srv/salt/keepalived/files
keepalived.conf                                     100% 1037   152.3KB/s   00:00

vim /srv/salt/keepalived/files/keepalived.conf配置keepalived文件

[root@server1 files]# cat keepalived.conf
! Configuration File for keepalivedglobal_defs {notification_email {root@localhost}notification_email_from keepalived@localhostsmtp_server 127.0.0.1smtp_connect_timeout 30router_id LVS_DEVELvrrp_skip_check_adv_addrvrrp_garp_interval 0vrrp_gna_interval 0
}vrrp_instance VI_1 {state {{ STATE }}interface ens33virtual_router_id {{ VRID }}priority {{ PRI }}advert_int 1authentication {auth_type PASSauth_pass 1111}virtual_ipaddress {{{ VIP }}}
}

vim /srv/salt/keepalived/init.sls

kp-install:pkg.installed:- name: keepalivedfile.managed:- source: salt://keepalived/files/keepalived.conf- name: /etc/keepalived/keepalived.conf- template: jinja- context:STATE: {{ pillar['state'] }}VRID: {{ pillar['vrid'] }}PRI: {{ pillar['pri'] }}VIP: {{ pillar['vip'] }}service.running:- name: keepalived- enable: True- reload: True- watch:- file:kp-install

mkdir /srv/pillar/kp创建kp目录

vim /srv/pillar/kp/init.sls

{% if grains['fqdn'] == 'server2' %}
state: MASTER
pri: 100
{% elif grains['fqdn'] == 'server3' %}
state: BACKUP
pri: 50
{% endif %}vrid: 60
vip: 192.168.43.100

vim /srv/pillar/top.sls

base:'*':- web- kp

salt '*' state.sls keepalived执行命令

在server2中-master

server3中 backup

断掉server2中的httpd服务后，server3就会补上

3. job管理

master在下发指令消息时，会附带上产生的jid，minion在接收到指令开始执行时，会在本地的cachedir(默认是/var/cache/salt/minion)下的proc目录产生已该jid命名的文件，用于在执行过程中master查看当前任务的执行情况，指令执行完毕将结果传送给master后，删除该临时文件
master将minion的执行结果存放在本地/var/cache/salt/master/jobs目录，默认缓存24小时(可通过修改master配置文件keepjobs选项调整)
vim /etc/salt/master

keep_jobs: 24

3.1 把job存储到数据库

配置数据库

server1中
yum install mariadb-server安装数据库
systemctl start mariadb

MariaDB [(none)]> grant all on salt.* to salt@'*' identified by 'salt';
Query OK, 0 rows affected (0.00 sec)MariaDB [(none)]> grant all on salt.* to salt@'localhost' identified by 'salt';

vim /mnt/add.sql建立数据库表

CREATE DATABASE  `salt`DEFAULT CHARACTER SET utf8DEFAULT COLLATE utf8_general_ci;USE `salt`;--
-- Table structure for table `jids`
--DROP TABLE IF EXISTS `jids`;
CREATE TABLE `jids` (`jid` varchar(255) NOT NULL,`load` mediumtext NOT NULL,UNIQUE KEY `jid` (`jid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- CREATE INDEX jid ON jids(jid) USING BTREE;--
-- Table structure for table `salt_returns`
--DROP TABLE IF EXISTS `salt_returns`;
CREATE TABLE `salt_returns` (`fun` varchar(50) NOT NULL,`jid` varchar(255) NOT NULL,`return` mediumtext NOT NULL,`id` varchar(255) NOT NULL,`success` varchar(10) NOT NULL,`full_ret` mediumtext NOT NULL,`alter_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,KEY `id` (`id`),KEY `jid` (`jid`),KEY `fun` (`fun`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;--
-- Table structure for table `salt_events`
--DROP TABLE IF EXISTS `salt_events`;
CREATE TABLE `salt_events` (
`id` BIGINT NOT NULL AUTO_INCREMENT,
`tag` varchar(255) NOT NULL,
`data` mediumtext NOT NULL,
`alter_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
`master_id` varchar(255) NOT NULL,
PRIMARY KEY (`id`),
KEY `tag` (`tag`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

mysql -p < add.sql 导入数据库

把job存储到数据库

在server1（master）中
yum install -y MySQL-python.x86_64 使master可以访问数据库
vim /etc/salt/master 修改master端配置
在server1中 vim /etc/salt/master

1253 master_job_cache: mysql
1254 mysql.host: 'localhost'
1255 mysql.user: 'salt'
1256 mysql.pass: 'salt'
1257 mysql.db: 'salt'
1258 mysql.port: 3306

systemctl restart salt-master重启salt-master服务：

测试

还有一种方法，数据库配置在minion端，配置方法同上。
yum install -y MySQL-python.x86_64 使minion可以访问数据库
vim /etc/salt/minion 修改minion端配置

return mysql ##返回数据到数据库
mysql.host: 'localhost'
mysql.user: 'salt'
mysql.pass: 'salt'
mysql.db: 'salt'

systemctl restart salt-minion重启salt-minion服务：

3.2 Job管理

salt-run jobs.active 查看所有minion当前正在运行的jobs（在所有minions上运行saltutil.running）

salt-run jobs.list_jobs 列出当前master jobs cache中所有job

salt-run jobs.lookup_jid <jid> 从master jobs cache中查询指定jid的运行结果