Turn off firewalld
systemctl disable firewalld
systemctl stop firewalld

Close iptables
iptables -F

Turn off selinux

wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
Clear all? Clear cache
yum makecache? Generates the yum cache

View salt packages
yum list salt

Install salt master
yum install salt-master -y

4505 publish? Port provides remote command sending function
 4506 ret_port provides authentication, file service, result collection and other functions
 Ensure that the client can communicate with the two ports of the server, and ensure that the firewall allows the ports to pass through. So shut down the firewall directly in the test environment.

The configuration file of salt master is / etc/salt/master
 The configuration file for salt minion is / etc/salt/minion
 The configuration file contains a large number of adjustable parameters, which control all aspects of the master and minion

test.echo under test

[root@master 192.168.199.155 ~]$salt '*' test.echo 'tiger nb666'
slave:
    tiger nb666

test.fib generate Fibonacci sequence

Fibonacci sequence is defined as 0 in item 0 and 1 in Item 1. The sequence starts from item 3, and each item is equal to the sum of the first two items.

[root@master 192.168.199.155 ~]$salt '*' test.fib 50
slave:
    |_
      - 0
      - 1
      - 1
      - 2
      - 3
      - 5
      - 8
      - 13
      - 21
      - 34
    - 1.09672546387e-05

Summary

Previously, salt minion and salt master were installed on the machine for the simplest connection. Then the master accepted the secret key of minion and ran the first test.ping command

salt command structure

The commands entered at the command line are all execution modules

When a command is written to a file, it is called a status module

salt --help #To view salt help

[root@master 192.168.199.155 ~]$salt --help
Usage: salt [options] '<target>' <function> [arguments]

salt Command parameter target salt Parameters for remote execution of function of module

Complete five part command

#--The summary parameter displays a summary of the salt command
[root@master 192.168.199.155 ~]$salt --summary '*' cmd.run 'hostname'
slave:
    slave


-------------------------------------------
Summary
-------------------------------------------
# of Minions Targeted: 1
# of Minions Returned: 1
# of Minions Did Not Return: 0
-------------------------------------------

List sys modules for all salt

#sys module interacting with the system
[root@master 192.168.11.72 ~]$salt 'slave' sys.list_modules

Remote execution command module

cmd is a super module. All shell commands can be executed

[root@master 192.168.11.72 ~]$salt 'slave' cmd.run 'ps -ef|grep python'
slave:
    root        905      1  0 07:31 ?        00:00:02 /usr/bin/python -Es /usr/sbin/tuned -l -P
    root       3843      1  0 11:05 ?        00:00:00 /usr/bin/python /usr/bin/salt-minion
    root       3846   3843  0 11:05 ?        00:00:01 /usr/bin/python /usr/bin/salt-minion
    root       4031      1  0 11:31 ?        00:00:00 /usr/bin/python /usr/bin/salt-minion
    root       4032   4031  0 11:31 ?        00:00:00 /bin/sh -c ps -ef|grep python
    root       4034   4032  0 11:31 ?        00:00:00 grep python

Remote installation of nginx

#Installing nginx on minion
[root@master 192.168.11.72 ~]$salt 'slave' pkg.install "nginx"
#Uninstall nginx on minion
[root@master 192.168.11.72 ~]$salt 'slave' pkg.remove "nginx"
#Check pkg package version
[root@master 192.168.11.72 ~]$salt 'slave' pkg.version "nginx"

Remote management service module

Management service is an important task for system administrator. It is very easy to manage minion service through salt. Use service module

[root@master 192.168.11.72 ~]$salt 'slave' service.start "nginx"
slave:
    True
[root@master 192.168.11.72 ~]$salt 'slave' service.status "nginx"
slave:
    True
[root@master 192.168.11.72 ~]$salt 'slave' service.stop "nginx"
slave:
    True

Like standard Linux commands, salt commands are used the same way

--out controls the format of the result output of the salt command

JSON

[root@master 192.168.199.155 ~]$salt --out=json '*' cmd.run_all 'hostname'
{
    "slave": {
        "pid": 2268,
        "retcode": 0,
        "stderr": "",
        "stdout": "slave"
    }
}

YAML

[root@master 192.168.199.155 ~]$salt --out=yaml '*' cmd.run_all 'hostname'
slave:
  pid: 2289
  retcode: 0
  stderr: ''
  stdout: slave

YAML explanation

In the process of learning saltstack, the first point is the writing skills of States, which is called SLS file for short. This file follows YAML syntax. It's easy for beginners to be confused. Come on, super brother saves you from learning YAML grammar
 json xml yaml data serialization format
 yaml is easy to parse and applied to configuration files

The configuration file of salt is yaml. You cannot use tab
 yaml format configuration file used by saltstack, k8s and ansible


Rule of grammar
    Case sensitive
    Use indents to represent hierarchy   
    tab key is forbidden when indenting, only space is allowed
    The number of indented spaces is not important. The left side of elements of the same level
    #Represents a comment line
 Data structure supported by yaml
    Object: key value pair, also known as mapping hash hashes dictionary dict colon indicates that there must be
    Array: a set of values arranged in order, also known as sequence list short bar - list1
    Pure quantity: a single value that cannot be subdivided

Objects: key value pairs
yaml
    first_key:
      second_key:second_value

python
    {
        'first_key':{
            'second_key':'second_value',
        }
    }

YAML yes YAML Ain't Markup Language The acronym for, YAML Its grammar is simple,
Structure is displayed by spaces
Project use '-' representative
Pass key value pair ':' Division

YAML syntax follows a fixed indentation style, indicating the hierarchical relationship of data. saltstack requires that each indentation level is composed of 2 spaces, and tabs are not allowed!!!

The dictionary in Python is a simple key value pair, which is called hash table map in go
Dictionary key s are separated by colons

The expression of key in YAML is a string of colon result
my_key: my_value
Convert to python syntax. The above command is
{'my_key':'my_value'}

value can also be associated with key through indentation, four spaces!!
my_key:
    my_value 
The same goes for converting to python syntax
{'my_key':'my_value'}

Dictionaries can be nested in YAML syntax
one_dict_key:
    two_dict_key:value_dict
Convert to python syntax

Short bar
 YAML syntax represents a list with a bar and a space
 Multiple items use the same indentation level as part of the same list
- list_value_one
- list_value_two
- list_value_three
List can be used as the value of a key value pair, for example, to install multiple software at one time
my_dict:
  - l1
  - l2
  - l3
The understanding of converting to python code is

Target location string

In the previous salt commands, we used salt '*' to control all minions, and we only have one "slave", but the servers in the production environment are likely to be hundreds of minions, so we need to flexibly locate the required servers and execute remote commands.

1.Global matching
[root@master 192.168.11.72 ~]$salt '*' test.ping
slave:
    True

Linux wildcard
*               Represents any character or empty string
?               Represents a character, cannot be empty
[a-z] [0-9]     Represents any lowercase letter

[root@master 192.168.11.72 ~]$salt 'slav?' test.ping
slave:
    True

[root@master 192.168.11.72 ~]$salt '[a-z]lave' test.ping
slave:
    True            
salt Sea support python Of re regular expression 

The state module defines the host state

The previously executed remote commands are all procedural, similar to the execution of a shell or python script, which triggers the same function once.

So a large number of remote commands running on minion must use the "state management" provided by salt. State is a description and definition of minion. Operation and maintenance do not need to care about how the deployment is completed, but only need to describe what state minion needs to achieve.

Next, deploy nginx through the state module

master terminal

vim /etc/salt/master 
#Open the comment, write the following, strictly follow the syntax, space
file_roots:
  base:
    - /srv/salt/base
 dev:
   - /srv/salt/dev
 test:
   - /srv/salt/test
 prod:
   - / srv/salt/prod

#This step needs to be executed in both the master and minion, folders and nginx.sls files
[root@master  ~]$mkdir -p /srv/salt/{base,dev,test,prod}

[root@slave   ~]$mkdir -p /srv/salt/{base,dev,test,prod}

#The nginx.sls status file must be available on both the master and minion
[root@master /srv/salt/base]$cat nginx.sls
nginx-install:
  pkg.installed:
    - name: nginx

nginx-service:
  service.running:
    - name: nginx
    - enable: True

Explain the nginx.sls description file
sls configuration files are described in YAML
 The first command uses the pkg.install command, which is relative to running yum install. At this time, the state module will determine whether nginx is installed. If it is not installed, install it, and do nothing if it is installed.
The state description will follow this principle. Only when the real state is detected and the required state is different, this function will be executed. This property is called idempotence.

At this time, we use the state module to deploy nginx software. Through the nginx.sls descriptive configuration file we wrote, the command line calls the SLS function of the state module.

#Start the command. At this time, the slave has been installed and nginx is alive for state management
[root@master  /srv/salt/base]$salt 'slave' state.sls nginx

You can go to the slave test to shut down nginx, delete nginx, and execute the command again. You can also install and start nginx

Check nginx status of slave through master

[root@master 192.168.199.155 /srv/salt/base]$salt 'slave' cmd.run 'ps -ef|grep nginx'
slave:
    root       8543      1  0 Sep14 ?        00:00:00 nginx: master process /usr/sbin/nginx
    nginx      8544   8543  0 Sep14 ?        00:00:00 nginx: worker process
    root       8592   8591  0 00:03 ?        00:00:00 /bin/sh -c ps -ef|grep nginx
    root       8594   8592  0 00:03 ?        00:00:00 /bin/sh -c ps -ef|grep nginx

Grains of static information collected by Salt

If you are employed, your boss asks you to collect hardware information about 300 servers in the company. Are you a login? Or choose to use salt to collect? Or write scripts with python's salt API

Grains is one of the most important components of saltstack. They are often used in configuration and deployment. Grains records the static information of minion, such as common properties, CPU, memory, disk, network information, etc.
The Grains information of Minions is collected and reported to Master when Minion is started
Grains is a database stored in the form of key value, which can be regarded as the metadata of the Host
Grains holds the collected client details
If the slave machine data changes, grains will be out of date
 You need to customize Grains in the production environment. You can use the
 Minion profile
 Grains related module definition
 Python script definition

salt 'slave' sys.doc grains view the command usage of grains

Grains

Grains describes the static attribute data inherent in minion and lists all grains data of the host

Retrieve some data

[root@master 192.168.11.72 ~]$salt 'slave' grains.item os id host
slave:
    ----------
    host:
        slave
    id:
        slave
    os:
        CentOS

Using Grains static information to locate the host

Before super brother, the company had 100 + redhat operating system and 80 + centos. Before knowing salt, it was very ignorant..

In addition to different systems, there are different system versions, RedHat 6. X CentOS 6. X

There are two ways of writing:
salt '*' grains.item key1 key2 key3
salt '*' -G

#Positioning the Cenots machine
[root@master 192.168.11.72 ~]$salt -G 'os:CentOS' test.ping
slave:
    True
#The positioning operating system is a 7-series machine

[root@master 192.168.11.72 ~]$salt -G 'osrelease:7*' test.ping
slave:
True

#Find out the ip address

salt '*' grains.item fqdn_ip4

Therefore, use grains.items to list all data matching hosts and locate data according to a single information. Grains can also be customized to meet different needs.

Custom settings Grains data

#Setting data
[root@master 192.168.11.72 ~]$salt 'slave' grains.setval cpu_num 8
slave:
    ----------
    cpu_num:
        8
#Query data

[root@master 192.168.11.72 ~]$salt 'slave' grains.item cpu_num
slave:
    ----------
    cpu_num:
        8

Set the Grains static data on the master side. The principle will add this data to the / etc/salt/grains of the configuration file of the minion server

[root@slave 192.168.11.71 ~]$cat /etc/salt/grains
cpu_num: 8

For complex data structures, flexible JSON syntax can be added

[root@master 192.168.11.72 ~]$salt 'slave' grains.setval cpu_info '["Intel","Xeon","10"]'
slave:
    ----------
    cpu_info:
        - Intel
        - Xeon
        - 10
[root@master 192.168.11.72 ~]$salt 'slave' grains.item cpu_info
slave:
    ----------
    cpu_info:
        - Intel
        - Xeon
        - 10

At this time, you can check the grains file on the minion server

[root@slave 192.168.11.71 ~]$cat /etc/salt/grains
cpu_info:
- Intel
- Xeon
- '10'
cpu_num: 8

Therefore, after Grains data is written to the configuration file, restart the salt minion service, and the data will not be lost

If you want to delete it, you can delete it by using the grains.dell command, or delete the configuration file of demiion (or delete the file)

1.Method 1, clear the value
[root@master 192.168.11.72 ~]$salt 'slave' grains.delval cpu_info
slave:
    None
[root@master 192.168.11.72 ~]$salt 'slave' grains.delval cpu_num
slave:
    None

2.Method 2 delete minion Of grains Profile, restart service

[root@slave 192.168.11.71 ~]$rm -rf /etc/salt/grains
[root@slave 192.168.11.71 ~]$!sys
systemctl restart salt-minion

Check result deleted successfully

Pillar component of data management center

Pillar is also one of the most important components of saltstack, which is called data management center. It is often used in large-scale configuration management with states.

The Pillar is dynamic, stored in the master side, provided and provided to the minion side

Pillar's main role in SaltStack is to store and define some data needed in configuration management, such as software version number, user account password, etc., so as to ensure that sensitive data is not seen by other minion s

The storage format is similar to Grains, which is YAML format

In the master configuration file, there is a section of Pillar settings options that specifically define the parameters of Pillar

cat /etc/salt/master  
#This configuration represents the working root directory of pillar. Under / srv/pillar, you can create a new sls file
#pillar_roots:
#  base:
#    - /srv/pillar

By default, the working directory of pillar is in / srv/pillar directory. Execute the following code

mkdir -p /srv/pillar
#Specify environment, mark, reference packages.sls and services.sls
vim /srv/pillar/top.sls
base:
  '*':
      - packages
      - services

vim /srv/pillar/packages.sls
nginx:
    packages-name: nginx
    version: 1.12.2

vim /srv/pillar/packages.sls
nginx:
    port: 80
    user: root

Check the pilar value we set

[root@master 192.168.199.155 /srv/pillar]$salt '*' pillar.item nginx
slave:
    ----------
    nginx:
        ----------
        packages-name:
            nginx
        port:
            80
        user:
            root
        version:
            1.12.2

Pillar vs. Grains

pillar vs. Grains

Type data collection method application scenario definition location
 Grains static minion collection data query target selection configuration management minion
 Pillar dynamic master for custom target selection configuration management sensitive data master

Python API calls SaltStack

SaltStack itself provides salt(usr/bin/salt) for interactive management, but it's certainly not a long way to go to the server and type commands. At this time, python embodies the function of nb.

Python API is the API provided for Python. It needs to be run on SaltStack master

Example code

[root@master  ~]$python
Python 2.7.5 (default, Jul 13 2018, 13:06:57)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import salt.client
>>> local = salt.client.LocalClient()  #<salt.client.LocalClient object at 0x7f886dbdd850>
>>> local.cmd('*','cmd.run',['hostname'])#Send commands to all minion s
{'slave': 'slave'}

So the python API provides an entry to send commands to saltstack.

Get the configuration file of saltstack through API

Get master profile

>>> import salt.config #Import salt configuration module
>>> m_opts=salt.config.client_config('/etc/salt/master') #Read the salt configuration file to get a dictionary data

Get minion profile

Python 2.7.5 (default, Jul 13 2018, 13:06:57)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import salt.client
>>> salt.config.minion_config('/etc/salt/minion') #Read minion configuration file, get dictionary data, and view information through dictionary method

Introduction to Python API

/usr/bin/salt The default interface used is LocalClient，This interface can only be used in salt master Upper use

[root@master  ~]$python
Python 2.7.5 (default, Jul 13 2018, 13:06:57)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import salt.client
>>> local = salt.client.LocalClient()  #<salt.client.LocalClient object at 0x7f886dbdd850>
>>> local.cmd('*','cmd.run',['hostname'])#Send commands to all minion s
{'slave': 'slave'}

Return results one by one, local. CMD writer()

>>> ret=local.cmd_iter('*','test.ping')
>>> ret
<generator object cmd_iter at 0x7f886d455c80>
>>> for i in ret:
...     print i
...
{'slave': {'retcode': 0, 'ret': True}}

Fibonacci series

>>> local.cmd('*','test.fib',[10])
{'slave': [[0, 1, 1, 2, 3, 5, 8], 2.1457672119140625e-06]}

Check minion server information

>>> local.cmd('*','cmd.run',['hostname'])
{'slave': 'slave'}
>>> local.cmd('*','cmd.run',['ifconfig'])
>>> local.cmd('*','cmd.run',['crontab -l'])
>>> local.cmd('*','cmd.run',['df -h'])

Start stop minion services, such as nginx

>>> local.cmd('*','service.stop',['nginx'])
{'slave': True}
>>> local.cmd('*','service.status',['nginx'])
{'slave': False}
>>> local.cmd('*','service.start',['nginx'])
{'slave': True}