Linux记录-salt分析

salt-master建立分组

如dn: 'L@dnxxx,dyyy'

salt -N dn  state.apply  hadoop test=true

salt -N dn  cmd.run  'ls -ll /'

salt -N dn  test.ping

salt 'dnxxx'  test.ping

salt-minion修改minion配置：master   id

salt-key   -L

salt-key   -A

systemctl start salt-minion.service

systemctl start salt-master.service

apache:
  pkg.installed: []
  service.running:
    - watch:
      - pkg: apache
      - file: /etc/httpd/conf/httpd.conf
      - user: apache
  user.present:
    - uid: 87
    - gid: 87
    - home: /var/www/html
    - shell: /bin/nologin
    - require:
      - group: apache
  group.present:
    - gid: 87
    - require:
      - pkg: apache

/etc/httpd/conf/httpd.conf:
  file.managed:
    - source: salt://apache/httpd.conf
    - user: root
    - group: root
    - mode: 644

目录文件：/etc/salt/master
interface: 192.168.0.1 ---接口（默认是0.0.0.0）
ipv6: True   ---侦听ipv6
publish_port: 4505 ---发布端口
master_id: MasterOfMaster ---发布master传递给minion的id，返回请求给主服务器，这必须与配置syndic的字符串相同
user: root ---用户运行salt进程
enable_ssh_minions: True  ---是否启用salt-ssh命令
ret_port: 4506  ---接收端口
pidfile: /var/run/salt-master.pid  ---pidfile文件所在位置
root_dir: /   ---系统运行根目录
conf_file: /etc/salt/master  ---配置文件
pki_dir: /etc/salt/pki/master  ---存储pki身份验证密钥的目录
extension_modules: /root/salt_extmods   ---自定义扩展模块（modules、states、grains、proxy、pillar）
module_dirs:
  - /var/cache/salt/minion/extmods   ---自定义扩展目录
cachedir: /var/cache/salt/master ---缓存信息（如salt执行的作业信息）
verify_env:True  ---启动时验证并设置配置目录的权限
keep_jobs ： 24  ---保留旧作业的小时数
gather_job_timeout ： 10   ---客户端请求有关正在运行的作业等待的秒数
TIMEOUT:5 ---设置salt命令和api的默认超时
LOOP_INTERVAL：60  ---loop_interval选项控制主维护过程检查周期的秒数。此过程更新文件服务器后端，清除作业缓存并执行调度程序。
OUTPUT：nested  ---设置salt命令使用的默认输出器。
outputter_dirs ： [] ---用于搜索salt输出器的其他目录列表。
OUTPUT_FILE：/path /output/file ---设置salt命令使用的默认输出文件。默认是输出到CLI而不是文件。功能与“--out-file”CLI选项的功能相同，仅将其设置为所有salt命令的单个文件。
SHOW_TIMEOUT：TRUE ---是否启用显示超时
SHOW_JID:False  --是否启用显示JID
color:True ---默认输出为彩色
color_theme:/etc/salt/color_theme ---颜色主题路径
cli_summary:false 是否显示minions的数量
sock_dir:/var/run/salt/master  ---套接字目录
enable_gpu_grains ： True ---是否启用GPU
job_cache:true ---主服务器临时作业缓存（大型部署）
minion_data_cache:True ---minion数据缓存
cache: consul/localfs ---缓存子系统模块用于minion数据缓存。
memcache_expire_seconds ： 30  ---Memcache是​​一个额外的缓存层，可以在内存中保留从minion数据缓存中获取有限数量的有限数据，从而使缓存操作更快。它对localfs 缓存驱动程序没有多大意义，但有助于更复杂的驱动程序，如consul。此选项设置memcache项目到期时间。默认设置为0 禁用memcache。
memcache_max_items ： 1024  ---memcache项目限制
memcache_full_cleanup ：True  ---缓存已满会清除其存储空间
memcache_debug：True  ---启用收集memcache统计信息并记录在调试日志级别
ext_job_cache ： redis  ---默认返回者-minion，也会禁用主服务器的作业缓存
event_return ：
  -  syslog
  -  splunk   ---记录事件的返回者
event_return_queue ： 0  ---在繁忙的系统上，启用event_returns会对返回者造成相当大的存储系统负载。事件可以在主服务器上排队，并使用单个事务以批处理方式存储多个事件。默认情况下，事件不会排队。
event_return_whitelist ：
  -  salt / master / a_tag
  -  salt / run / * / ret     ---仅返回与白名单中的标记匹配的事件。
event_return_blacklist ：
  -  salt / master / not_this_tag
  -  salt / wheel / * / ret  ---存储所有事件将_except_标记返回黑名单。
max_event_size ： 1048576  ---传递非常大的事件会导致minion消耗大量内存。该值调整允许进入主事件总线的消息的最大大小。该值以字节表示。
master_job_cache ： redis  ---指定要用于作业缓存的返回者。作业缓存只能与salt master进行交互，因此不需要从minions访问。
enforce_mine_cache ：false  ---默认情况下，当禁用minion_data_cache时，它将停止工作，因为它基于缓存数据，通过启用此选项，我们只显示mine系统的缓存。
max_minions ： 100  ---主服务器允许的最大连接数
con_cache:True  ---如果在大型安装中使用max_minions，则主服务器可能会遇到高负载情况，因为必须检查每个身份验证的已连接的minions数。此缓存为所有MWorker进程提供所有连接的minions的minion-id，并极大地提高了max_minions的性能。
presence_events：false ---是否寻找积极连接的minoin
ping_on_rotate ：false ---秘钥每24小时轮换一次，ping所有的minions
TRANSPORT：zeromq  ---支持zeromq、raet、tcp三种传输
transport_opts ：
  tcp ：
    publish_port ： 4605
    ret_port ： 4606
  zeromq ： []
MASTER_STATS：False  ---启用主统计信息可以从主事件总线触发运行时吞吐量和统计信息事件。这些事件将报告在主服务器上运行的功能以及这些运行在给定时间段内平均花费的时间。
MASTER_STATS_EVENT_ITER：60  ---解雇master_stats事件的时间（以秒为单位）。这只会在接收到主设备的请求时触发，空闲主设备不会触发这些事件。
sock_pool_size ： 15  ---为了避免在将数据写入套接字时阻塞等待，我们支持Salt应用程序的套接字池。
ipc_mode ： ipc  ---ipc策略。（即套接字与tcp等）Windows平台缺少POSIX IPC，必须依赖基于TCP的进程间通信。在Windows上默认ipc_mode 设置为tcp。
tcp_master_pub_port ： 4512 ---如果ipc_mode是TCP，则应发布主节点事件的TCP端口。
tcp_master_pull_port ： 4513 ---TCP端口，如果ipc_mode是TCP ，则应该在该端口上提取主节点的事件。
tcp_master_publish_pull ： 4514 ---主端口上的事件应该被拉出的TCP端口，然后重新发布到主服务器上的事件总线上。
tcp_master_workers ： 4515  ---用于mworkers连接到主服务器的TCP端口。
auth_events:True ---主服务器是否启用触发身份验证事件
minion_data_cache_events ：True ---主服务器是否启用触发minion数据缓存事件，当minion请求minion数据高速缓存刷新时会触发Minion数据高速缓存事件。
-------------------------------------------------------
salt-ssh配置
roster: cache ---默认为flat，使用名单模块
roster_defaults ：
  user ： daniel
  sudo ： True
  priv ： /root/.ssh/id_rsa
  tty ： True  ---所有名单都将继承的默认设置
roster_file ： / root / roster  ---传入salt-ssh flat名单文件的替代位置。
rosters:
 - /etc/salt/roster.d
 - /opt/salt/some/more/rosters
ssh_passwd: ''  ---密码
ssh_port: 22   ---端口
ssh_scan_ports: 22
ssh_scan_timeout: 0.01
ssh_sudo: False
ssh_timeout: 60
ssh_user: root
ssh_log_file: /var/log/salt/ssh
ssh_minion_opts:
  gpg_keydir: /root/gpg
ssh_use_home_key: False
ssh_identities_only: False
ssh_list_nodegroups:
  groupA: minion1,minion2
  groupB: minion1,minion3
THIN_EXTRA_MODS : None  ---Thin附加模块列表
MIN_EXTRA_MODS：None  ---与thin_extra_mods类似的附加模块列表
----------------------------------------------------------------------------
Master安全设置
open_mode：false  ---打开模式应该只在短时间内用于清理pki键。要打开打开模式，请将此值设置为True。
auto_accept: false   ---自动接受来自minion的所有传入公钥
keysize：2048 ---秘钥大小
autosign_timeout：120 ---自动接受在pki_dir / minion_autosign / keyid中找到匹配名称的传入公钥的时间（以分钟为单位）。
AUTOSIGN_FILE：not defined
AUTOREJECT_FILE：not defined
autosign_grains_dir：not defined
permissive_pki_access：false  ---是否启用对salt秘钥的允许访问
publisher_acl:
  fred:
    - test.ping
    - pkg.*
publisher_acl_blacklist:
  users:
    - root
    - '^(?!sudo_).*$'   #  all non sudo users
  modules:
    - cmd.*
    - test.echo
sudo_acl: False  ---强制publisher_acl以及publisher_acl_blacklist用户何时可以访问salt命令。
external_auth ：
  pam ：
    fred ：
      -  test.*
token_expire ： 43200  ---口令生效的时间（以秒为单位）
token_expire_user_override ：
  pam ：
    -  fred
    -  tom
  ldap ：
    -  gary
keep_acl_in_token ：false ---是否保存身份验证列表到口令文件里
eauth_acl_module ： django
file_recv：false ---允许minion将文件推送到master
file_recv_max_size ： 100  ---推送文件的大小设置
master_sign_pubkey ：True ---使用主公钥的加密签名对主auth-reply进行
MASTER_SIGN_KEY_NAME： master_sign ---可以自定义的签名密钥对的名称，不带后缀。
MASTER_PUBKEY_SIGNATURE：master_pubkey_signature
--------------------------------------------------------------------------------------
MASTER LARGE SCALE TUNING SETTINGS
max_open_files: 100000  ---最大打开文件数
worker_threads: 5  ---工作线程
pub_hwm ： 1000  ---zeromq高位标记
zmq_backlog ： 1000  ---zeromq的log
----------------------------------------------------------------------------------------
主服务器log设置
log_file ： / var / log / salt / master
log_file ： file：/// dev / log
log_file ： udp：// loghost：10514
log_level ：warning
log_level_logfile ：warning
log_datefmt: '%H:%M:%S'
log_datefmt_logfile: '%Y-%m-%d %H:%M:%S'
log_fmt_console: '%(colorlevel)s %(colormsg)s'
log_fmt_console: '[%(levelname)-8s] %(message)s'
log_fmt_logfile: '%(asctime)s,%(msecs)03d [%(name)-17s][%(levelname)-8s] %(message)s'
----------------------------------------------------------------------------------------------------
NODE GROUPS
nodegroups:
  group1: 'L@foo.domain.com,bar.domain.com,baz.domain.com or bl*.domain.com'
  group2: 'G@os:Debian and foo.domain.com'
  group3: 'G@os:Debian and N@group1'
  group4:
    - 'G@foo:bar'
    - 'or'
    - 'G@foo:baz'
---------------------------------------------------------------------------------------------------------
RANGE CLUSTER SETTINGS
range_server: range:80
DEFAULT_INCLUDE：master.d/*.conf
# Include files from a master.d directory in the same
# directory as the master config file
include: master.d/*

# Include a single extra file into the configuration
include: /etc/roles/webserver

# Include several files and the master.d directory
include:
  - extra_config
  - master.d/*
  - /etc/roles/webserver
------------------------------------------------------------------------------------------------------------
KEEPALIVE SETTINGS-TCP
tcp_keepalive: True
tcp_keepalive_cnt: -1
tcp_keepalive_idle: 300
tcp_keepalive_intvl': -1

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

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

配置目录
/etc/salt
/var/cache/salt
/var/log/salt
/var/run/salt

firewall-cmd --permanent --zone=<zone> --add-port=4505-4506/tcp
firewall-cmd --reload
-A INPUT -m state --state new -m tcp -p tcp --dport 4505 -j ACCEPT
-A INPUT -m state --state new -m tcp -p tcp --dport 4506 -j ACCEPT

SaltStack是(C/S)架构的集中化管理平台，SaltStack基于Python语言，
采用zeromq消息队列进行通信(tcp,ipc)。
一. 部署环境
系统：centos7.3
centos7默认防火墙是firewall，修改为iptables(方法自行百度)
salt-master:192.168.1.100
salt-minion-1:192.168.1.200
salt-minion-2:192.168.1.300
1.1 查看centos的版本和内核版本以及安装配置阿里云yum源
#cat /etc/redhat-release
CentOS Linux release 7.3.1611 (Core)
#wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

1.2 安装epel-release和salt-master工具包
#yum install epel-release -y
#yum install salt-master -y

1.3 配置saltstatck开机自启动服务
#systemctl enable salt-master.service

1.4 启动saltstack master服务
#systemctl start salt-master

1.5 检查saltstack端口及进程的运行状态
　　4505是saltstack管理服务器发送命令消息的端口，4506是消息返回时所用的端口，saltstack一般是启动多个进程并发工作的
#netstat -ntlp|grep python
tcp 0 0 120.76.40.16:4505 0.0.0.0:* LISTEN 4916/python
tcp 0 0 120.76.40.16:4506 0.0.0.0:* LISTEN 4936/python
#ps -aux |grep salt-master|grep -v grep
root 4906 0.0 0.0 314468 27816 ? Ss 10:47 0:00 /usr/bin/python /usr/bin/salt-master
root 4915 0.3 0.1 414628 37948 ? Sl 10:47 0:36 /usr/bin/python /usr/bin/salt-master
root 4916 0.0 0.0 396528 23580 ? Sl 10:47 0:00 /usr/bin/python /usr/bin/salt-master
root 4917 0.0 0.0 396528 25920 ? Sl 10:47 0:00 /usr/bin/python /usr/bin/salt-master
root 4920 0.0 0.0 314468 22936 ? S 10:47 0:00 /usr/bin/python /usr/bin/salt-master
root 4923 0.0 0.0 1057776 32016 ? Sl 10:47 0:01 /usr/bin/python /usr/bin/salt-master
root 4924 0.0 0.1 1205240 34072 ? Sl 10:47 0:01 /usr/bin/python /usr/bin/salt-master
root 4928 0.0 0.1 1205976 34252 ? Sl 10:47 0:01 /usr/bin/python /usr/bin/salt-master
root 4931 0.0 0.1 1206252 34200 ? Sl 10:47 0:01 /usr/bin/python /usr/bin/salt-master
root 4933 0.0 0.0 1057964 32280 ? Sl 10:47 0:01 /usr/bin/python /usr/bin/salt-master
root 4936 0.0 0.0 691476 23472 ? Sl 10:47 0:00 /usr/bin/python /usr/bin/salt-master
1.6 配置iptables防火墙)（ps：注意selinux状态，阿里云服务器默认是disabled）
#vim /etc/systconfig/iptables加入两行
-A INPUT -p tcp -m state --state NEW -m tcp --dport 4505 -j ACCEPT
-A INPUT -p tcp -m state --state NEW -m tcp --dport 4506 -j ACCEPT
#systemctl restart iptables

salt master 会启动两个端口 tcp 4505和tcp 4506
more /etc/salt/master |grep 450
#publish_port: 4505
#ret_port: 4506
#syndic_master_port: 4506
其中 tcp 4506 是master的端口，在minion配置文件中能看到，允许minion访问后 执行salt-key时 会获取到

2.配置salt-minion
2.1 查看centos的版本和内核版本以及安装配置阿里云yum源
#cat /etc/redhat-release
CentOS Linux release 7.3.1611 (Core)
#wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

2.2 安装epel-release和salt-minion工具包
#yum install epel-release -y
#yum install salt-minion -y

2.3 配置minion配置
master参数指定master 的ip (或者主机名)，必配参数，如果minion启动时不能解析到master 主机，启动会失败；
#sed -i 's/#master: salt/master: 192.168.1.100/g' /etc/salt/minion

id参数设置salt-minion名，默认未设置，minio名取主机hostname中设定的主机名
#sed -i 's/#id:/id: 192.168.200/g' /etc/salt/minion

2.4 配置saltstatck开机自启动服务
#systemctl enable salt-minion

2.5 启动saltstack minion服务
#systemctl start salt-minion
3.其他minion同样配置
4.saltstack具体操作
# salt-key -L                                #查看salt-key
Accepted Keys:
salt-minion-01
salt-minion-02
Denied Keys:
Unaccepted Keys:
Rejected Keys:

# salt-key -A -y                      #添加salt-key
The following keys are going to be accepted:
Unaccepted Keys:
salt-minion-01
salt-minion-02
Key for minion salt-minion-01 accepted.
Key for minion salt-minion-02 accepted.

# salt-key -L                                #查看salt-key
Accepted Keys:
salt-minion-01
salt-minion-02
Denied Keys:
Unaccepted Keys:
Rejected Keys:

salt-key -a  slaver.test.com
说明：-a ：accept ，-A：accept-all，-d：delete，-D：delete-all。可以使用 salt-key 命令查看到已经签名的客户端。此时我们在客户端的 /etc/salt/pki/minion 目录下面会多出一个minion_master.pub 文件。

# salt salt-minion* test.ping        #简单测试
示例1： salt '*' test.ping                  //检测通讯是否正常，也可以指定其中一个 'slaver.test.com'
示例2:  salt '*' cmd.run   'df -h'        //远程执行命令

说明： 这里的 * 必须是在 master 上已经被接受过的客户端，可以通过 salt-key 查到，通常是我们已经设定的 id 值。关于这部分内容，它支持通配、列表以及正则。 比如两台客户端 web10、web11， 那我们可以写成  salt 'web*'    salt 'web1[02]'  salt -L 'web10,web11'   salt -E 'web(10|11)' 等形式，使用列表，即多个机器用逗号分隔，而且需要加-L，使用正则必须要带-E选项。 它还支持 grains 和 pillar，分别加 -G 和 -I 选项，下面会介绍到。

salt-minion-01:
    True
salt-minion-02:
    True

# salt salt-minion* cmd.run 'uname -r'        #运行linux命令
salt-minion-01:
    3.10.0-327.el7.x86_64
salt-minion-02:
    3.10.0-327.el7.x86_64

salt '*' test.ping　　##  '*' 表示所有的minion，可以输入指定的minion_id,或者使用正则匹配 匹配指定的minion

认证过程
启动minion服务后，会产生一个密钥对，然后minion会根据配置的master地址去连接master，并尝试把公钥发给master，minion_id表示minio的身份。

在master上可以使用salt-key来查看密钥认证的情况，直到密钥认证后，master和minion就可以通信了，我们就可以通过state模块来管理minion。
minon密钥目录
 ll /etc/salt/pki/minion/
total 12
-rw-r--r--. 1 root root  450 Nov 15 09:59 minion_master.pub　　##认证通过后master发过来的master公钥
-r--------. 1 root root 1674 Nov 15 09:58 minion.pem
-rw-r--r--. 1 root root  450 Nov 15 09:58 minion.pub
在minion服务没有启动时，pki目录是不存在的。minion服务启动后，会创建pki目录，minion目录和密钥对。
我们可以把pki目录删除，然后重启服务会重新生成pik目录。

master密钥目录
 ll /etc/salt/pki/master/minions
-rw-r--r--. 1 root root 450 Nov 15 17:59 cong-49　　##已通过的minion密钥
master接受minion的公钥后会存放在/etc/salt/pki/master/minions目录下，以minion的id来命名。
同时master会把自身的公钥发给minion。

master端的pki目录千万不要删除，因为这个目录包含了所有minion的认证密钥。不过我们可以删除指定minion的密钥文件。
也可以 用命令salt-key删除指定minion的key认证

在master把对应的minion的key删掉：
salt-key -d 192.168.1.49

查看密钥保存目录是否存在对应mining的密钥key，如果存在删除它
[root@cong-33 nginx]# ll /etc/salt/pki/master/minions

minion端
停止minion服务：
[root@cono-49 ~]# /etc/init.d/salt-minion stop
删除key目录让其重新生成：

rm -rf /etc/salt/pki
启动服务
/etc/init.d/salt-minion start

salt-key命令
salt-key -L  列出master的key认证情况
salt-key -a minion_id  通过指定minion的key认证
salt-key -A   批量通过minion的key认证
salt-key -d minion_id 删除指定minion的key认证
salt-key -D   批量删除minion的key认证

minion没有监听端口的。minion在通过与master的key认证后一直与master的4505端口保持连接。
master监听4505和4506两个端口，
4505是消息发布端口，
4506是消息接收端口，接收执行返回结果和命令执行情况的

一、salt常用命令
1.salt 该命令执行salt的执行模块，通常在master端运行，也是我们最常用到的命令
salt [options] '<target>' <function> [arguments]
如: salt '*' test.ping

2.salt-run 该命令执行runner(salt带的或者自定义的，runner以后会讲)，通常在master端执行，比如经常用到的manage
salt-run [options] [runner.func]
salt-run manage.status   ##查看所有minion状态
salt-run manage.down     ##查看所有没在线minion
salt-run manged.up       ##查看所有在线minion

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

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

5.salt-cp 分发文件到minion上,不支持目录分发，通常在master运行
salt-cp [options] '<target>' SOURCE DEST
salt-cp '*' testfile.html /tmp
salt-cp 'test*' index.html /tmp/a.html

6.salt-ssh 0.17.1版本加入的salt-ssh

7.salt-master master运行命令
salt-master [options]
salt-master            ##前台运行master
salt-master -d         ##后台运行master
salt-master -l debug   ##前台debug输出

8.salt-minion minion运行命令
salt-minion [options]
salt-minion            ##前台运行
salt-minion -d         ##后台运行
salt-minion -l debug   ##前台debug输出

9.salt-syndic syndic是salt的代理，以后会说到

二、普通用户执行salt
普通用户执行salt两种方案:1,salt ACL 2.salt external_auth
1.ACL
1) 设置master配置文件
client_acl:
    monitor:
     - test*:
    - test.*
    dev:
     - service.*
    sa:
     - .*
2) 重启Master
service 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_auth
1) 修改master配置文件
 external_auth:
pam: monitor: – ‘test‘: – test. sa: – .* – 2) 3)与ACL相同
4) 测试
# salt -a pam 'test*' test.ping    ##会提示输入账号密码，所以external_auth与当前用户无关
   username: monitor
       password:
 # 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: sa
password:
#salt -a pam '*' test.ping #不会提示输入密码了

三、target
指定你的命令或者模块应用哪写Minion上
1.globbing 默认
salt 'test*' test.ping
2.RE 正则
salt -E 'web1-(pro|devel)' test.ping
3.List 列表
salt -L '127.0.0.1, test*' test.ping
4.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 }}

5.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

6.混合指定,就是将以上的混合起来用
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

7.一次在n个minion上执行
-b n
--batch-size n
示例：
salt '*' -b 5 test.ping 5个5个的ping

四、远程批量执行
格式：
salt '<target>' <function> [argument]
注： function是salt带的或自己写的可执行模块里面的function，自带的所有列表http://docs.saltstack.com/ref/modules/all/index.html?highlight=full%20list%20builtin 实例：

salt '*' at.at 10.10am 'uptime'
salt '*' test.ping

五、多Master
1.在另一台机器上安装salt-master
yum -y install salt-master
2.将原来master上的master密钥拷贝到新的master是一份
scp /etc/salt/pki/master/master* newmaster:/etc/salt/pki/master/
3.启动新的Master
service salt-master start
4.修改minion配置文件/etc/salt/minion设置两个master
 master:
   - master1
- master2
5.重启minion
service salt-minion restart
6.在新的master上接受所有key
salt-key -L
salt-key -A
注意:
1.2个master并不会共享Minion keys，一个master删除了一个key不会影响另一个
2.不会自动同步File_roots,所以需要手动去维护，如果用git就没问题了
3.不会自动同步Pillar_Roots，所以需要手工去维护，也可以用git
4.Master的配置文件也是独立的

六、pillar
Pillar在salt中是非常重要的组成部分，利用它可以完成很强大的功能，它可以指定一些信息到指定的minion上，不像grains一样是分发到所有Minion上的，它保存的数据可以是动态的,Pillar以sls来写的，格式是键值对
适用情景：
1.比较敏感的数据，比如密码，key等
2.特殊数据到特定Minion上
3.动态的内容
4.其他数据类型
查看Minion的Pillar信息
salt '*' pillar.items
查看某个Pillar值
salt '*' pillar.item <key>      #只能看到顶级的
salt '*' pillar.get <key>:<key> #可以取到更小粒度的
编写pillar数据
1.指定pillar_roots，默认是/srv/pillar(可通过修改master配置文件修改),建立目录
mkdir /srv/pillar
cd /srv/pillar
2.编辑一个pillar数据文件
vim test1.sls
name: 'salt'
 users:
   hadoop: 1000
redhat: 2000
ubuntu: 2001
3.建立top file指定minion到pillar数据文件
 vim top.sls
 base:
   '*':
     - test1
4.刷新Pillar数据
salt '*' saltutil.refresh_pillar
5.测试
salt '*' pillar.get name
salt '*' pillar.item name
在state中通过jinja使用pillar数据
vim /srv/salt/user.sls
 {% for user, uid in pillar.get(’users’, {}).items() %}  ##pillar.get('users',{})可用pillar['users']代替，前者在没有得到值的情况下，赋默认值
 {{user}}:
   user.present:
     - uid: {{uid}}
 {% endfor %}
当然也可以不使用jinja模板
vim /srv/salt/user2.sls
{{ pillar.get('name','') }}:
 user.present:
   - uid: 2002
通过jinja模板配合grains指定pillar数据
/srv/pillar/pkg.sls
pkgs:
 {% if grains[’os_family’] == ’RedHat’ %}
 apache: httpd
 vim: vim-enhanced
 {% elif grains[’os_family’] == ’Debian’ %}
 apache: apache2
 vim: vim
 {% elif grains[’os’] == ’Arch’ %}
 apache: apache
 vim: vim
 {% endif %}
七、grains
服务器的一些静态信息，这里强调的是静态，就是不会变的东西，比如说os是centos，如果不会变化，除非重新安装系统
定义minion的grains可以写在/etc/salt/minion中格式如下
grains:
 roles:
   - webserver
   - memcache
 deployment: datacenter4
 cabinet: 13
 cab_u: 14-15
或者写在/etc/salt/grains中，格式如下
roles:
 - webserver
 - memcache
deployment: datacenter4
cabinet: 13
cab_u: 14-15
也可以在master中编写grains的模块，同步到minion中，用Python来写很简单的
1.在/srv/salt中建立_grains目录
mkdir /srv/salt/_grains
2.编写grains文件，需要返回一个字典
 vim test1.py
 def hello():                      ##函数名字无所谓，应该是所有函数都会运行
   agrain = {}
   agrain['hello'] = 'saltstack'
return agrain                   ##返回这个字典
3.同步到各个minion中去
salt '*' saltutil.sync_grains
salt '*' saltutil.sync_all
salt '*' state.highstate
4.验证
salt '*' grains.item hello

***********模块***********
查看模块列表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 <key-name>   ##接受某个minion-key
salt-key -d <key-name>   ##删除某个minion-key
salt-key -A              ##接受所有的minion-key
salt-key -D              ##删除所有的minion-key

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

***********文件分发***********
salt-cp 分发文件到minion上,不支持目录分发，通常在master运行
salt-cp [options] '<target>' 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 '^[m|M]in.[e|o|u]n$' test.ping = salt -E '^[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'

SLS文件
简述
SLS（代表SaLt State文件）是Salt State系统的核心。SLS描述了系统的目标状态，由格式简单的数据构成。这经常被称作配置管理

top.sls
top.sls 是配置管理的入口文件，一切都是从这里开始，在master 主机上，默认存放在/srv/salt/目录.
top.sls 默认从 base 标签开始解析执行,下一级是操作的目标，可以通过正则，grain模块,或分组名,来进行匹配,再下一级是要执行的state文件，不包换扩展名。

创建 /srv/salt/top.sls

通过正则进行匹配的示例，
base:
  '*':
    - webserver
通过分组名进行匹配的示例，必须要有 - match: nodegroup
base:
  group1:
    - match: nodegroup
    - webserver
通过grain模块匹配的示例，必须要有- match: grain
base:
  'os:Fedora':
    - match: grain
    - webserver
准备好top.sls文件后，编写一个state文件

/srv/salt/webserver.sls
apache:                 # 标签定义
  pkg:                  # state declaration
    - installed         # function declaration
第一行被称为（ID declaration） 标签定义，在这里被定义为安装包的名。注意：在不同发行版软件包命名不同,比如 fedora 中叫httpd的包 Debian/Ubuntu中叫apache2
第二行被称为（state declaration）状态定义， 在这里定义使用（pkg state module）
第三行被称为（function declaration）函数定义， 在这里定义使用（pkg state module）调用 installed 函数
最后可以在终端中执行命令来查看结果：

salt '*' state.highstate
或附件 test=True参数 测试执行

salt '*' state.highstate -v test=True
主控端对目标主机（targeted minions）发出指令运行state.highstatem模块，目标主机首先会对top.sls下载，解析，然后按照top.sls内匹配规则内的定义的模块将被下载,解析,执行，然后结果反馈给 master.

SLS文件命名空间
注意在以上的例子中,SLS文件 webserver.sls 被简称为webserver. SLS文件命名空间有如下几条基本的规则：

SLS文件的扩展名 .sls 被省略。 (例如. webserver.sls 变成 webserver)
子目录可以更好的组织,每个子目录都由一个点来表示.(例如 webserver/dev.sls 可以简称为 webserver.dev）
如果子目录创建一个init.sls的文件，引用的时候仅指定该目录即可. (例如 webserver/init.sls 可以简称为 webserver）
如果一个目录下同时存在webserver.sls 和 webserver/init.sls，那么 webserver/init.sls 将被忽略，SLS文件引用的webserver将只引用webserver.sls
state多文件示例
下面是一个state多文件示例，

apache/init.sls
apache/httpd.conf
ssh/init.sls
ssh/server.sls
ssh/banner
ssh/ssh_config
ssh/sshd_config
创建一个引用这些目录的 server.sls

server:
  - apache
  - ssh
state的层级关系
include 示例：
include 包含某个state文件
/srv/salt/apache.sls

apache:
  pkg:
    - installed
  service:
    - running
    - require:
      - pkg: apache
使用 include 可以包换有state文件而不必重新写

/srv/salt/apache-custom.sls
include:
  apache
extend 示例：
extend 与include配合使用，作用是 修改，或扩展引用的state文件的某个字段
/srv/salt/apache.sls

apache:
  pkg:
    - installed
  service:
    - running
    - require:
      - pkg: apache
extend默认是替换引用文件的某个字段的属性，如例

/srv/salt/apache-change.sls
include:
  - apache
extend：
  apache
    pkg:
      - name: vim
      - installed
当extend与watch，或require结合使用的时候，则是扩展某个字段的属性，如例：

/srv/salt/apache-custom.sls
include:
  - apache
extend：
  apache
    service:
      - watch:
        - file: /etc/redis.conf
state的逻辑关系列表
match: 配模某个模块，比如 match: grain match: nodegroup
require： 依赖某个state，在运行此state前，先运行依赖的state，依赖可以有多个
watch： 在某个state变化时运行此模块
order： 优先级比require和watch低，有order指定的state比没有order指定的优先级高
state的逻辑关系实例
require：依赖某个state，在运行此state前，先运行依赖的state，依赖可以有多个
httpd:                                  # maps to "name"
  pkg:
    - installed
  file：                                # maps to State module filename
    - managed:                          # maps to the managed function in the file State module
    - name: /etc/httpd/conf/httpd.conf  # one of many options passed to the manage function
    - source: salt://httpd/httpd.conf
    - require:
      - pkg: httpd
watch：在某个state变化时运行此模块，watch除具备require功能外，还增了关注状态的功能。
redis:
  pkg:
    - latest
  file.managed:
    - source: salt://redis/redis.conf
    - name: /etc/redis.conf
    - require:
      - pkg: redis
  service.running:
    - enable: True
    - watch:
      - file: /etc/redis.conf
      - pkg: redis
order：优先级比require和watch低，有order指定的state比没有order指定的优先级高
vim:
  pkg.installed:
    - order: 1
想让某个state最后一个运行，可以用last

进阶主题：模板
使用模板来精简SLS，使SLS可以使用python的 循环，分支，判断 等逻辑
{% for item in ['tmp','test'] %}
/opt/{{ item }}:
  file.directory:
    - user: root
    - group: root
    - mode: 755
    - makedirs: True
{% endfor %}
```markdown
httpd:
  pkg.managed:
{% if grains['os'] == 'Ubuntu' %}
    - name: apache2
{% elif grains['os'] == 'CentOS' %}
    - name: httpd
{% endif %}
    - installed
通过加载jinja模板引擎，可以模板配置文件按照预订条件来生成最终的配置文件
/opt/test.conf

{% if grains['os'] == 'Ubuntu' %}
host: {{ grains['host'] }}
{% elif grains['os'] == 'CentOS' %}
host: {{ grains['fqdn'] }}
{% endif %}
```markdown
/opt/test.conf:
  file.managed:
    - source: salt://test.conf
    - user: root
    - group: root
    - mode: 644
    - template: jinja

#########################################

scp与rsync  远程同步拷贝

#########################################

swapoff -a关掉

永久生效：

echo "vm.swappiness = 0">> /etc/sysctl.conf

（尽量不使用交换分区，注意不是禁用）

刷新
SWAP

可以执行命令刷新一次SWAP（将SWAP里的数据转储回内存，并清空SWAP里的数据）

swapoff -a && swapon -a

sysctl -p  (执行这个使其生效，不用重启)