saltstack官网最新文档

saltstack_3">saltstack架构设计

saltstack 高可用方案：Salt官网是有

• HA
• Rebalance
  • minion配置里写多个master地址
• failover（syndic）

架构

• 操作系统：CentOS7.6
• salt版本：3000.3

多master

https://www.cnblogs.com/renolei/p/4725455.html

minion配置里写多个地址

cat minion | grep -vE "^#|^$"
master:- saltstack.online.net- 2.2.2.2- 3.3.3.3

架构解析

Master01是leader节点, Master02和Master03是follower节点;leader上的配置, state文件, return等文件变动都会完全同步到其他follower节点上;Master01绑定DNS, Minion上的配置是:master:- saltstack.online.net- 2.2.2.2- 3.3.3.3
一台Minion启动是会使用multi-master模块建立每个Master的TCP链接, Zero-MQ通信机制配置Minion自动拉取时, 随机选取Master节点, 达到Rebalance目的;当leader节点Master宕机, 只需要切换DNS, 更新Minion-cnf配置即可, 达到半自动HA目的;一般情况下minion节点配置每天同步一次master配置, 因此完全有主动时间处理master节点宕机问题 -

注意事项

1.2个master并不会共享Minion keys，一个master删除了一个key不会影响另一个
2.不会自动同步File_roots,所以需要手动去维护，如果用git就没问题了
3.不会自动同步Pillar_Roots，所以需要手工去维护，也可以用git
4.Master的配置文件也是独立的

saltstacksyndic_54">saltstack之syndic的配置

https://www.cnblogs.com/kaishirenshi/p/9420790.html

saltstack_60">saltstack升级

当升级Salt的时候，master(s)应该首先升级。masters向后兼容，minions运行版本比masters版本新是不能保证运行正常的。只要可能，新masters向后兼容旧minions的特性就会被保留下来。一般来说，唯一例外的情况是有安全漏洞的情况下。

salt的管控方式

salt 命令的使用
Usage: salt [options] ‘’ [arguments]

1. 调用saltstack提供的模块
2. 写sls状态文件

组管理

1、官方文档

https://docs.saltstack.com/en/latest/topics/targeting/nodegroups.html

2、分组的方式

https://segmentfault.com/a/1190000000506668

文档 4.4 Compound matchers 和 4.3. Node groups 知道，对目标服务器分组有以下七种方式，这七种方式的标示符分别为：

1. G – 针对 Grains 做单个匹配，例如：G@os:Ubuntu
2. E – 针对 minion 针对正则表达式做匹配，例如：E@web\d+.(dev|qa|prod).loc
3. P – 针对 Grains 做正则表达式匹配，例如：P@os(RedHat|Fedora|CentOS)
4. L – 针对 minion 做列表匹配，例如：L@minion1.example.com,minion3.domain.com or bl*.domain.com
5. I – 针对 Pillar 做单个匹配，例如：I@pdata:foobar
6. S – 针对子网或是 IP 做匹配，例如：S@192.168.1.0/24 or S@192.168.1.100
7. R – 针对客户端范围做匹配，例如：R@%foo.bar

saltstack_89">调用saltstack提供的模块

帮助信息

1 查看用salt的所有模块
salt l-k8s1.ops.bj4.daling.com sys.list_modules2 查看模块提供的操作方法 
salt l-k8s1.ops.bj4 sys.list_functions user3 查看方法的使用
salt l-k8s1.ops.bj4  user.add

写sls状态模块

通过使用state组件提供模块

帮助信息

1 查看用salt的所有模块
salt l-k8s1.ops.bj4 sys.list_state_modules2 查看模块提供的操作方法 
salt l-k8s1.ops.bj4 sys.list_state_functions user3 查看方法的使用
salt l-k8s1.ops.bj4 sys.state_doc user.absent

遵循yaml语法

1. 同级别代码要有相同缩进：建议4个空格
2. key: value 冒号后必须要有一个空格
3. 一个键对应多个值时,每个值单独占一行,每个值需要一个有一个 - 横线

key:- value1- value2- value3

状态文件大体格式 *.sls

任务名称:模块名称:参数参数参数模块名称:参数参数参数

定位保存状态文件

saltstack有环境的概念
状态文件的环境 本质就是一个目录，saltstack默认只识别base环境

定位保存状态文件环境

• 环境
  • 生产
  • 测试
• 环境A
  • …
• 环境B
  • …

修改master状态文件的相关配置

默认配置

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

修改配置如下（为了测试功能，使用默认base环境）

file_roots:base:- /srv/salt/

创建目录，并重启master

mkdir -p /srv/salt/files
systemctl restart salt-master.service

编写测试sls

写一个创建用户的状态文件 /srv/salt/user.sls

create hadoop user:user.present:- name: hadoop- shell: /sbin/nologin

如何执行状态文件

方式一：state.sls 文件名称

所有的配置不能tab出来

salt l-k8s1.ops.bj4 state.sls user

方式二：state.highstate 执行的就是top.sls里面的操作

不需要指定文件名称，但是必须存在一个入口文件top.sls
定义minion与状态文件间的关系
创建位置为 环境的根目录

cat /srv/salt/top.sls

base: #环境'*':  #目标minion (以命令执行时的主机为准)- user  ##不用加后缀

定义资源的依赖关系

第一个

unless cmd.run模块的参数
只有unless后的命令执行失败,name参数对应的命令才执行

installed dhcp:cmd.run:- name: yum install -y dhcp- unless: rpm -q dhcp

第二个

require 我依赖谁
require_in 我被谁依赖
httpd.sls

install httpd:pkg.installed:- name: httpd
copy config file:file.managed:- source: salt://files/httpd.conf- name: /etc/httpd/conf/httpd.conf- require: - pkg: install httpd
start httpd deamon:service.running:- name: httpd- enable: True- require:- pkg: install httpd- file: copy config file

第三个

使用场景：检测配置文件变化，自动加载配置文件
watch 我关注谁
watch_in 我被谁关注

httpd.sls

copy config file:file.managed:- source: salt://files/httpd.conf- name: /etc/httpd/conf/httpd.confstart httpd deamon:service.running:- name: httpd- enable: True- require:- file: copy config file- watch:- file: copy config file

saltstack_264">部署saltstack

https://www.cnblogs.com/xintiao-/p/10380656.html

Salt的master和minion包是分开的。机器只需要安装相应的包即可运行。通常情况下，会有一个master和多个minions。

从updates-testing安装

yum --enablerepo=updates-testing install salt-master
yum --enablerepo=updates-testing install salt-minion

salt master

yum install salt-master salt-minion salt-ssh salt-syndic salt-cloud salt-api -y

rpm --import https://repo.saltstack.com/yum/redhat/7/x86_64/latest/SALTSTACK-GPG-KEY.pub
yum install https://repo.saltstack.com/yum/redhat/salt-repo-latest.el7.noarch.rpm
yum install salt-master
pip install salt

配置

http://docs.saltstack.cn/ref/configuration/master.html

安装后操作 启动

## 方式一 :前台启动 (debug做调试)
salt-master --log-level=debug## 方式二: 后台(daemon)启动salt-master -d## 方式三: 系统脚本启动
systemctl enable salt-master.service
systemctl start salt-master.service

salt minion

安装

yum install https://repo.saltstack.com/yum/redhat/salt-repo-latest.el7.noarch.rpm
yum install salt-minion
pip install salt

配置

http://docs.saltstack.cn/ref/configuration/minion.html

安装后操作

systemctl enable salt-minion.service
systemctl start salt-minion.service

日常操作整理

命令整理

查看帮助

模块

查看模块列表module

salt ‘minion’ sys.list_modules
查看指定module的function用法
salt ‘minion’ sys.list_functions file
查看指定模块的详细用法
salt ‘minion’ sys.doc cmd

模块使用说明

查看配置管理state模块列表
salt ‘minion’ sys.list_state_modules
查看配置管理sate列表指定模块所有方法列表
salt ‘minion’ sys.list_state_functions svn
查看配置管理state列表指定模块详细用法
salt ‘minion’ sys.state_doc file
查看配置管理state列表指定模块的方法分支
salt ‘minion’ sys.state_doc file.managed

pillar变量

查看主机对应的所有pillar变量值
salt ‘’ pillar.data
salt '’ pillar.items
查看主机对应的多个pillar变量值
salt ‘’ pillar.item roles appname
修改pillar值后需要刷新pillar数据
salt '’ saltutil.refresh_pillar
查看pillar模块详细用法,其他类似
salt ‘minion’ sys.doc pillar
查看pillar的相关方法
salt ‘minion’ sys.list_functions pillar
“”"
shuke:
- pillar.data
- pillar.ext
- pillar.get
- pillar.item
- pillar.items
- pillar.raw
“”"

grains变量

查看模块用法
salt ‘minion’ sys.list_functions grains
查看item项
salt ‘minion’ grains.ls
查看所有iteams
salt ‘minion’ grains.items
获得某个item值
salt ‘minion’ grains.get os
同步_grains目录下的py脚本至minion
salt ‘minion’ saltutil.sync_all
如果py模块有修改,修改后进行重载
salt ‘minion’ sys.reload_modules

minions在线状态

查看所有minion状态
salt-run manage.status
查看所有minion在线状态
salt-run manage.up
查看所有minion不在线状态
salt-run manage.down

key管理

salt-key 密钥管理，通常在master端执行
salt-key [options]
salt-key -L ##查看所有minion-key
salt-key -a ##接受某个minion-key
salt-key -d ##删除某个minion-key
salt-key -A ##接受所有的minion-key
salt-key -D ##删除所有的minion-key

salt-call相关

salt-call 该命令通常在minion上执行，minion自己执行可执行模块，不是通过master下发job
salt-call [options] [arguments]
salt-call test.ping ##自己执行test.ping命令
salt-call cmd.run ‘ifconfig’ ##自己执行cmd.run函数

文件分发

salt-cp 分发文件到minion上,不支持目录分发，通常在master运行
salt-cp [options] ‘’ SOURCE DEST
salt-cp ‘’ testfile.html /tmp
salt-cp 'test’ index.html /tmp/a.html
salt ‘S1_0_001_Room’ cp.get_dir salt://package /tmp -v 同步目录
salt ‘S1_0_001_Room’ cp.get_file salt://package/minions.tar.gz /tmp/minions.tar.gz gzip=5 同步文件

其他*

salt-run jobs.active #查看所有minion当前正在运行的jobs
salt ‘’ saltutil.running # 查看正在运行的任务，找到jid
salt '’ saltutil.kill_job jid # 根据jid杀掉任务
salt ‘*’ saltutil.clear_cache # 清除minion缓存

执行单个命令
salt ‘minion’ cmd.run ‘ps -ef | grep mongod’

测试单个sls模块
salt ‘minion’ state.sls nginx test=True

执行前进行测试
salt ‘minion’ state.highstate test=True

在所有minion上执行状态:
salt ‘minion’ sate.highstate

获取执行jib任务的md5值
salt ‘minion’ hashutil.md5_digest 20170202150211366486

low数据可以使用state.show_lowstate方法查看
salt ‘minion’ state.show_lowstate --out yaml

High State数据可以使用state.show_hoghstate方法查看
salt ‘minion’ state.show_highstate --out yaml

#查看highstate
salt ‘minion’ state.show_highstate
#查看lowdata
salt ‘minion’ state.show_lowstate

#执行所有top.sls
salt ‘*’ state.apply

#执行指定环境下top.sls
salt ‘*’ state.apply saltenv=dev

注:

name：要执行的命令，记住该命令将会在salt-minion的路径和权限下执行
onlyif：用于检查的命令，仅当onlyif选项指向的命令返回true时才执行name定义的命令
unless：用于检查的命令，仅当unless选项指向的命令返回false时才执行name指向的命令

查看wyd用户下进程
salt -N ‘Z1_S2’ cmd.run ‘su -c "ps -u wyd | grep -v top | grep -v bash | grep -v sshd | grep -v grep | grep -v ps | grep -v CMD " wyd’

state中(钩子函数)
requisiterequisite:require/watch/onchanges/onfail/use/prereq/require_in(反转)

==Targeting Minion=

#Glob(默认)
salt ‘*’ test.ping
salt * test.ping

#PCRE 正则表达式
salt -E ‘¹in.[e|o|u]n${}^{\prime }test.ping=salt-E^{\prime [}mM]in.[eou]n$’ test.ping

#list
salt -L web1,web2,db1 test.ping

#Subnet
salt -S 192.168.1.100 test.ping
salt -S 192.168.0.0/16 test.ping

#Grain
salt -G ‘os:ubuntu’ test.ping
salt -G ‘os_family:Debian’ test.ping
salt -G ‘ip_interfaces:eth0:192.168.1.100’ test.ping
salt -G ‘ipv6:::1’ test.ping
salt --grain-pcre ‘os:red(hat|flag)’ test.ping

#Pillar
salt -I ‘my_var:my_val’ test.ping

#混合(Compound)
salt -C ‘G@os:Ubuntu,I@role:web,S@192.168.1.100/24’ test.ping
salt -C ‘min* or ion’ test.ping
salt -C 'web or *qa,G@os:Arch’ test.ping

#Nodegroup
salt -N　webdev test.ping

添加计划任务
salt ‘S1__Center’ cron.set_job root ‘0’ ‘5’ '’ ‘’ '’ ‘/usr/sbin/logrotate -vf /etc/logrotate.d/acl >/tmp/cutacl_log 2>&1’ identifier=cutacl

删除计划任务
salt -C ‘E@S1_(10001|10002|10003)_’ cron.rm_job wyd 'cd /data/wyd/game_server_1.2.0/log;find . -type f -mtime +15 -name ".log*" -exec rm -rf {} ; 2>&1’ identifier=‘clear log’

相关URL:
http://blog.csdn.net/death_kada/article/details/48547271
http://blog.csdn.net/cnweike/article/details/12746399 pillar

普通用户执行salt （默认root）

普通用户执行salt两种方案:1,salt ACL 2.salt external_auth1.ACL1) 设置master配置文件client_acl:monitor:- test*:- test.*dev:- service.*sa:- .*
2) 重启Masterservice salt-master restart
3) 目录和文件权限chmod +r /etc/salt/master
chmod +x /var/run/salt
chmod +x /var/cache/salt
4) 测试# su - monitor
# salt 'test*' test.ping
# exit; su - sa
# salt '*' test.ping
# salt '*' cmd.run 'uptime'
# exit;
2.external_auth1) 修改master配置文件external_auth:
pam: monitor: – ‘test‘: – test. sa: – .* – 2) 3)与ACL相同4) 测试# salt -a pam 'test*' test.ping    ##会提示输入账号密码，所以external_auth与当前用户无关username: monitorpassword:# su - monitor# salt -a pam '*' cmd.run 'uptime'
username: sa
password:
5) 使用Token不必每次都输入账号密码，使用external_auth每次都是需要密码的，这样多麻烦，这里引入了Token，它会保存一串字符到在当前用户家目录下.salt_token中，在有效时间内使用external_auth是不需要输入密码的，默认时间12hour，可以通过master配置文件修改# salt -T -a pam '*' test.ping
username: sapassword:

target 操作主机匹配

指定你的命令或者模块应用哪写Minion上

globbing 默认

salt ‘test*’ test.ping

RE 正则

salt -E ‘web1-(pro|devel)’ test.ping

List 列表

salt -L ‘127.0.0.1, test*’ test.ping

grains

salt -G ‘os:CentOS’ test.ping

#查看所有grains键/值
salt ‘test*’ grains.items
#查看所有grains项
salt ‘test*’ grains.ls
查看某个grains的值
salt ‘test*’ grains.item num_cpus
在top file中匹配grains

‘node_type:web’:

• match: grain #没有s
• webserver
  top file中使用jinja模板

{% set self = grains[‘node_type’] %}
- match: grain

• {{ self }}

nodegroups 其实就是对Minion分组

首先在master的配置文件中对其分组,推荐写到/etc/salt/master.d/中一个独立的配置文件中，比如nodegroup.conf

vim /etc/salt/master.d/nodegroup.conf
#写到master中也是这个格式，master.d中*.conf是默认动态加载的
nodegroups:
test1: ‘L@test1,test2 or test3*’
test2: ‘G@os:CenOS or test2’

salt -N test1 test.ping #-N指定groupname

在top file中使用nodegroups

‘test1’:

• match: nodegroup ##意没s
• webserver

混合指定,就是将以上的混合起来用

G Grains glob G@os:Ubuntu
E PCRE Minion ID E@web\d+.(dev|qa|prod).loc
P Grains PCRE P@os:(RedHat|Fedora|CentOS)
L List of minions L@minion1.example.com,minion3.domain.com or bl*.domain.com
I Pillar glob I@pdata:foobar
S Subnet/IP address S@192.168.1.0/24 or S@192.168.1.100
R Range cluster R@%foo.bar

salt -C ‘G@os:CentOS and L@127.0.0.1,192.168.1.12’ test.ping
top file 指定:

‘webserver* and G:CentOS or L@127.0.0.1,test1’:

• match: compound
• webserver

一次在n个minion上执行

-b n
–batch-size n
示例：
salt ‘*’ -b 5 test.ping 5个5个的ping

#salt -a pam ‘*’ test.ping #不会提示输入密码了

salt-minion和salt-master之间如何重新认证

修改了minion端的id之后 比如修改了hostname之后，

在minion端

minion端会将minion的id 存放在/etc/salt/minion_id

文件中，重启不会改变。所以要重新认证就需要以下2步：

1、清空minion_id

/etc/salt/minion_id

2、删除minion存放masterkey的文件pki文件夹下所以的东西
rm -rf /etc/salt/pki/*

3、重启minion
service salt-minion restart

在master端

1、删除pki文件之后，重启即可：
rm -f /etc/salt/pki/master/minions/
2、重启salt-master
service salt-master restart
之后就可以salt-key看到新的minion id了。

salt-api

saltstack提供了一套完整的api，称为salt-api。需要安装部署，完成后可通过编程语言连接api执行日常操作

基于https协议的两个url地址

• https://x.x.x.x:port/login 调用saltAPI，实现用户认证，返回用户令牌
• https://x.x.x.x:port 调用saltstack模块

在master端操作：安装配置salt-api

安装salt-api

yum install salt-api pyOpenSSL -y

生成证书及key文件

由于salt-api是基于https的,所有需要相对应的证书和key

生成证书

# 安装完软件自动生成的目录 /etc/pki/tls/certs/cd /etc/pki/tls/certs/make testcert
umask 77 ; \
/usr/bin/openssl genrsa -aes128 2048 > /etc/pki/tls/private/localhost.key
Generating RSA private key, 2048 bit long modulus
...+++
..+++
e is 65537 (0x10001)
Enter pass phrase:
Verifying - Enter pass phrase:
umask 77 ; \
/usr/bin/openssl req -utf8 -new -key /etc/pki/tls/private/localhost.key -x509 -days 365 -out /etc/pki/tls/certs/localhost.crt 
Enter pass phrase for /etc/pki/tls/private/localhost.key:
140243069622160:error:28069065:lib(40):UI_set_result:result too small:ui_lib.c:831:You must type in 4 to 1023 characters
Enter pass phrase for /etc/pki/tls/private/localhost.key:
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [XX]:cn
State or Province Name (full name) []:bj
Locality Name (eg, city) [Default City]:bj
Organization Name (eg, company) [Default Company Ltd]:bj
Organizational Unit Name (eg, section) []:bj
Common Name (eg, your name or your server's hostname) []:salt-master
Email Address []:bj@qq.com

基于现有的key，生成一个免密的key：否则直接使用key时，每次启动salt-api时，需要输入密码 （master）

cd /etc/pki/tls/private
openssl rsa -in localhost.key  -out localhost_nopass.key 
ll

修改证书及key的权限

chmod 755  /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key /etc/pki/tls/private/localhost_nopass.key 

创建saltapi用户(密码 master)

useradd -M -s /sbin/nologin saltapi
passwd saltapi

master端：编辑salt-api 配置文件

打开include子配置的注释

default_include: master.d/*.conf

添加认证的配置文件 /etc/salt/master.d/eauth.conf

external_auth:pam: //使用pam实现认证saltapi: //salt-api用户名- .*   //允许saltapi用户调用所有salt模块

添加 saltapi配置文 /etc/salt/master.d/api.conf

rest_cherrypy:port: 8001ssl_crt: /etc/pki/tls/certs/localhost.crtssl_key: /etc/pki/tls/private/localhost_nopass.key

重启master;启动salt-api

systemctl restart salt-master.service
systemctl enable salt-api.service 
systemctl start salt-api.service 
ss -lutnp

通过curl命令测试salt-api可正常工作

实现用户认证,获取用户token

curl -k https://10.13.139.6:8001/login -H "Accept: application/x-yaml" -d username="saltapi" -d password="master" -d eauth="pam"# 返回结果
return:
- eauth: pamexpire: 1592234530.94308perms:- .*start: 1592191330.943079token: 426c3e6d108e724fd2be0c0c54648a34cb446a2cuser: saltapi

基于token测试执行test.ping

curl -k https://10.13.139.6:8001/ -H "Accept: application/x-yaml" -H "X-Auth-Token: 5481c7672e68a1139ede58da7d8372f14c57ab82" -d client='local' -d tgt='*' -d fun='test.ping'# 返回值如下
return:
- l-elkstack1.ops.bj2.test.com: truel-k8s1.ops.bj4.test.com: truel-k8s2.ops.bj4.test.com: truel-k8s3.ops.bj4.test.com: truel-k8s4.ops.bj4.test.com: truel-k8s5.ops.bj4.test.com: truel-k8s6.ops.bj4.test.com: truel-k8s7.ops.bj4.test.com: true

使用python调用salt-api执行命令

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/6/15 11:01 
# @Author : wzsimport requests
import json
try:import cookielib
except:import http.cookiejar as cookielib# 使用urllib2请求https出错，做的设置
import ssl
context = ssl._create_unverified_context()# 使用requests请求https出现警告，做的设置
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
salt_api = "https://10.13.139.6:8001/"class SaltApi:"""定义salt api接口的类初始化获得token"""def __init__(self, url):self.url = urlself.username = "saltapi"self.password = "master"self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36","Content-type": "application/json"# "Content-type": "application/x-yaml"}self.params = {'client': 'local', 'fun': '', 'tgt': ''}self.login_url = salt_api + "login"self.login_params = {'username': self.username, 'password': self.password, 'eauth': 'pam'}#获取tokenself.token = self.get_data(self.login_url, self.login_params).get('token')self.headers['X-Auth-Token'] = self.tokendef get_data(self, url, params):send_data = json.dumps(params)request = requests.post(url, data=send_data, headers=self.headers, verify=False)response = request.json()# print('----->>>>',response)result = dict(response)# print('result集合--->', result['return'][0])return result['return'][0]def salt_command(self, tgt, method, arg=None):"""远程执行命令，相当于salt 'client1' cmd.run 'free -m'"""if arg:# salt内置keyparams = {'client':'local', 'fun': method, 'tgt': tgt, 'arg': arg}else:#salt内置key，定义params参数params = {'client':'local', 'fun': method, 'tgt': tgt}# print ('命令参数: ', params)result = self.get_data(self.url, params)# print ('result--->',result)return resultdef main():print ('==================')print ('同步执行命令')salt = SaltApi(salt_api)# print('token-->',salt.token)salt_client = '*'salt_test = 'test.ping'#salt_test ="grains.items"salt_method = 'cmd.run'salt_params = 'free -m'# 下面只是为了打印结果好看点result1 = salt.salt_command(salt_client, salt_test)for i in result1.keys():print (i, ': ', result1[i])result2 = salt.salt_command(salt_client, salt_method, salt_params)for i in result2.keys():print (i)print (result2[i])printif __name__ == '__main__':main()

---

1. m|M ↩︎