[Linux37-1] Operación y mantenimiento automatizados de Saltstack (maestro y minion + prueba remota + archivo .sls + módulos + grains + plantilla jinja)

1. Introducción a Saltstack

Instalación del sitio web oficial : http://repo.saltstack.com/

Documento del sitio web oficial del módulo : docs.saltstack.cn

• SaltStack es una plataforma de administración centralizada para infraestructura de servidores, con administración de configuración, ejecución remota, monitoreo y otras funciones, generalmente se puede entender como una versión simplificada de puppet y una versión mejorada de func. SaltStack se implementa en base al lenguaje Python, combinado con una cola de mensajes livianos (ZeroMQ) y módulos de terceros de Python (Pyzmq, PyCrypto, Pyjinjia2, python-msgpack, PyYAML, etc.) para compilar. Al implementar el entorno SaltStack, podemos ejecutar comandos en lotes en miles de servidores, configurar la gestión centralizada, distribuir archivos, recopilar datos del servidor, base del sistema operativo y gestión de paquetes de software de acuerdo con las diferentes características del negocio, etc. SaltStack es la operación Un arma para que el personal de mantenimiento mejore la eficiencia del trabajo y estandarice la configuración y el funcionamiento del negocio.
  
  

Caracteristicas

• Herramienta de gestión de configuración de arquitectura C / S basada en el desarrollo de Python
• La capa inferior utiliza la forma pub / sub de la cola de mensajes ZeroMQ para comunicarse
• Utilice la emisión de certificados SSL para la gestión de la autenticación y la transmisión adopta el cifrado AES
  
  

Arquitectura de servicio

• Lado del servidor: maestro
• Cliente: Minion
  
  

Caracteristicas

• Ejecución remota
• Gestión de configuración / gestión de estado
• Gestión de la nube (nube)
• Evento conducido

Modo de operación

• local ejecutar localmente
• Maestro / Minion de forma tradicional
• Síndico distribuido
• Sal ssh
  
  

Archivo de configuración

• / etc / salt / master： Archivo de configuración del host (terminal de control)
• / etc / salt / minion: Archivo de configuración del lado controlado
  
  

2. Instalación y configuración

maestro 端 ：
servidor1 ： 192.168.17.1

minion final:
servidor2: 192.168.17.2
servidor3: 192.168.17.3

2.1 configuración de minion

• Configurar el almacén de software

vim /etc/yum.repos.d/salt-3000.repo

[salt-3000]
name=SaltStack 3000 Release Channel for Python 2 RHEL/Centos $releasever
baseurl=https://mirrors.aliyun.com/saltstack/yum/redhat/7/$basearch/3000
failovermethod=priority
enabled=1
gpgcheck=0
gpgkey=file:///etc/pki/rpm-gpg/saltstack-signing-key, file:///etc/pki/rpm-gpg/centos7-signing-key

• Instalar sal-minion

yum install -y salt-minion

• Establecer el lado maestro correspondiente

vim /etc/salt/minion

 16 master: 192.168.17.1

• Servicio abierto

systemctl enable --now salt-minion

• Cada vez que modifique el nombre de host, elimine el archivo / etc / salt / minion_id y modifique la resolución

2.2 configuración maestra

• Configurar el almacén de software
  
  

yum install -y https://repo.saltstack.com/yum/redhat/salt-repo-3000.el7.noarch.rpm
sed -i "s/repo.saltstack.com/mirrors.aliyun.com\/saltstack/g" /etc/yum.repos.d/salt-latest.repo

cat /etc/yum.repos.d/salt-3000.repo

[salt-3000]
name=SaltStack 3000 Release Channel for Python 2 RHEL/Centos $releasever
baseurl=https://mirrors.aliyun.com/saltstack/yum/redhat/7/$basearch/3000
failovermethod=priority
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/saltstack-signing-key, file:///etc/pki/rpm-gpg/centos7-signing-key

• Instalar salt-master

yum install -y salt-master

• Servicio abierto

systemctl enable --now salt-master

• Certificación

salt-key -A: Acepta todas las claves de minion en espera de autenticación.

salt-key -L: Muestra toda la información de la clave pública

-a minion#接受指定minion等待认证的key
-r minion#拒绝指定minion等待认证的key
-R#拒绝所有minion等待认证的key

2.3 Prueba remota

• Ver puertos y procesos

yum install -y lsof#可以显示监听端口详细信息
yum install -y python-setproctitle#可以显示进程详细信息
systemctl restart salt-master.service

• prueba

salt '*' test.ping
salt '*' cmd.run hostname
salt '*' cmd.run 'uname -a'

3. Ejecutar comandos de shell de forma remota

salt 'server2' sys.doc pkg: Ver la documentación del módulo

• Prueba httpd

#安装httpd
salt server2 pkg.install httpd
#列出安装包
salt server2 cmd.run 'rpm -q httpd'
##开启服务
salt server2 service.start httpd

• Copiar archivos

echo server2 > index.html
salt-cp server2 index.html /var/www/html/

4. Escriba el archivo .sls

1. Hay directorios apache.sls y apache, primero coincida con apache.sls
2. No agregue el sufijo .sls al llamar

mkdir -p /srv/salt/apache/files

• Acerca de las diferentes formas de escribir httpd

Ejecución de salt minion主机 state.sls apache.installejecución

#apache/install.sls 
httpd:
  pkg.installed

#apache/install.sls 
apache:
  pkg.installed:
    - pkgs:
      - httpd
      - php

#apache/install.sls 
apache:
  pkg.installed:
    - pkgs:
      - httpd
      - php
  file.managed:
    - source: salt://apache/files/index.html#此文件内容一修改，运行时就会显示有改变，因为有md5sum码
    - name: /var/www/html/index.html

#apache/install.sls 
apache:
  pkg.installed:
    - pkgs:
      - httpd
      - php
/var/www/html/index.html:
  file.managed:
    - source: salt://apache/files/index.html
httpd:
  service.running

#apache/install.sls 
apache:
  pkg.installed:
    - pkgs:
      - httpd
      - php
  file.managed:
    - source: salt://apache/files/index.html
    - name: /var/www/html/index.html
  service.running:
    - name: httpd

• Modificar puerto

cp /etc/httpd/conf/httpd.conf apache/files/: Copiar archivo de plantilla

vim apache/files/httpd.conf: Modificar la detección de puertos

salt server2 state.sls apache.install

#apache/install.sls 
apache:
  pkg.installed:
    - pkgs:
      - httpd
      - php
  file.managed:
    - source: salt://apache/files/index.html
    - name: /var/www/html/index.html
  service.running:
    - name: httpd
    - enable: true
    - reload: true
    - watch:
        - file: /etc/httpd/conf/httpd.conf
/etc/httpd/conf/httpd.conf:
  file.managed:
    - source: salt://apache/files/httpd.conf

#apache/install.sls 
apache:
  pkg.installed:
    - pkgs:
      - httpd
      - php
  file.managed:
    - source: salt://apache/files/httpd.conf
    - name: /etc/httpd/conf/httpd.conf
  service.running:
    - name: httpd
    - enable: true
    - watch:
        - file: apache

5. Escribir módulo de ejecución remota _modules

1. mkdir /srv/salt/_modules: Crea un directorio de módulo

2. vim _modules/mydisk.py: Módulos de escritura

def df():
    return __salt__['cmd.run']('df -h')

3. salt server2 cmd.run df

4. salt server2 saltutil.sync_modules: Módulo de sincronización

5. Después de la sincronización, puede estar en el host minion / var / cache / salt / minion / extmods / modules / Ver a
   
   

6. Configuración de grano (almacenado en el lado de los minion)

• Granos es un componente de SaltStack, almacenado en el lado de los minions de SaltStack.

• Cuando se inicia salt-minion, los datos recopilados se almacenarán estáticamente en Grains, y los datos se actualizarán solo cuando se reinicie minion.

• Dado que los granos son datos estáticos, no se recomienda modificarlos con frecuencia.

• Escenarios de aplicación:

  • Consulta de información, se puede utilizar como CMDB
  • Usado en el objetivo para coincidir con el súbdito
  • Se utiliza en el sistema de estado para configurar el módulo de gestión.
    
    

• Ver información en el lado maestro

#列出每一项
salt server2 grains.ls
#查看每一项的具体值
salt server2 grains.items
#查看单项的值
salt server2 grains.item ipv4
salt server2 grains.item fqdn

6.1 Agregue granos en el lado de los minion

servidor2

[root@server2 ~]# vim /etc/salt/minion
129 grains:
130   roles:
131     - apache
[root@server2 ~]# systemctl restart salt-minion

servidor3

[root@server3 ~]# vim /etc/salt/minion
129 grains:
130   roles:
131     - nginx
[root@server3 ~]# systemctl restart salt-minion.service

Ver en maestro

salt server2 grains.item roles
salt server3 grains.item roles

6.2 Módulo de granos de escritura

• escribir

mkdir /srv/salt/_grains

vim /srv/salt/_grains/mygrains.py

def my_grains():
    grains = {
    
    }
    grains['salt'] = 'stack'
    grains['hello'] = 'world'
    return grains

• Sincronizar el módulo de grano con el final del minion

salt '*' saltutil.sync_grains

Se puede ver en el lado de los minion. /var/cache/salt/minion/files/base/_grains/mygrains.py

• Lista de granos

salt '*' grains.item salt
salt '*' grains.item hello

6.3 Aplicación de emparejamiento de granos

• Coincidir con el súbdito en el objetivo

salt -G roles:apache cmd.run hostname
salt -G roles:nginx test.ping
salt -G salt:stack test.ping
salt -G hello:world test.ping

• coincidencia de archivos top.sls

1. mkdir -p /srv/salt/nginx/files/

[root@server1 salt]# ls nginx/files/
nginx-1.18.0.tar.gz

2. vim /srv/salt/top.sls

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

3. vim /srv/salt/nginx/init.sls

nginx:
  file.managed:
    - source: salt://nginx/files/nginx-1.18.0.tar.gz
    - name: /mnt/nginx-1.18.0.tar.gz

4. salt '*' state.highstate: Leer archivos top.sls de todos los entornos

7. aplicación nginx

• cd /src/salt/

1. vim nginx/files/nginx.service

[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network.target remote-fs.target nss-lookup.target
[Service]
Type=forking
PIDFile=/usr/local/nginx/logs/nginx.pid
ExecStartPre=/usr/local/nginx/sbin/nginx -t
ExecStart=/usr/local/nginx/sbin/nginx
ExecReload=/usr/local/nginx/sbin/nginx -s reload
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true
[Install]
WantedBy=multi-user.target

2. vim nginx/install.sls

nginx-install:
  pkg.installed:
    - pkgs:
      - gcc
      - pcre-devel
      - openssl-devel
  file.managed:
    - source: salt://nginx/files/nginx-1.18.0.tar.gz
    - name: /mnt/nginx-1.18.0.tar.gz
  cmd.run:
    - name: cd /mnt && tar zxf nginx-1.18.0.tar.gz && cd nginx-1.18.0 && ./configure --prefix=/usr/local/nginx --with-http_ssl_module &> /dev/null && make &> /dev/null && make install &> /dev/null
    - creates: /usr/local/nginx

3. vim nginx/init.sls

include:
  - nginx.install

/usr/local/nginx/conf/nginx.conf:
  file.managed:
    - source: salt://nginx/files/nginx.conf

nginx-service:
  user.present:
    - name: nginx
    - shell: /sbin/nologin
    - home: /usr/local/nginx
    - createhome: false
  file.managed:
    - source: salt://nginx/files/nginx.service
    - name: /usr/lib/systemd/system/nginx.service
  service.running:
    - name: nginx
    - enable: true
    - reload: true
    - watch:
      - file: /usr/local/nginx/conf/nginx.conf

4. salt server3 state.sls nginx.install
5. scp server3:/usr/local/nginx/conf/nginx.conf nginx/files/
6. vim nginx/files/nginx.conf

user  nginx;

7. salt server3 state.sls nginx

8. tablero simulado de jinja

• Definición :{% XXX %}
• Cotización :{ { XXX }}
  
  

8.1 Ejemplo 1

1. vim test.sls

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

2. salt '*' state.sls test
3. Ver los resultados del experimento

8.2 apache combinado con plantilla jinja

• cd /src/salt/

1. vim apache/init.sls

apache:
  pkg.installed:
    - pkgs:
      - httpd
  file.managed:
    - source: salt://apache/files/httpd.conf
    - name: /etc/httpd/conf/httpd.conf
    - template: jinja
    - context:
      port: 80
      bind: {
    
    {
    
     grains['ipv4'][-1] }}
  service.running:
    - name: httpd
    - enable: true
    - watch:
        - file: apache
/var/www/html/index.html:
  file.managed:
    - source: salt://apache/files/index.html
    - template: jinja
    - context:
      NAME: {
    
    {
    
     grains['ipv4'][-1] }}

2. vim apache/files/index.html

{
    
    {
    
     grains['os'] }} - {
    
    {
    
     grains['fqdn'] }}
{
    
    {
    
     NAME }}

3. vim apache/files/httpd.conf

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

4. salt server2 state.sls apache
5. Ver los resultados experimentales en el lado de los minions