[Linux37-1] Operação e manutenção automatizadas do Saltstack (mestre e minion + teste remoto + arquivo .sls + módulos + grãos + modelo jinja)

1. Introdução ao Saltstack

Instalação do site oficial : http://repo.saltstack.com/

Documento do site oficial do módulo : docs.saltstack.cn

• O SaltStack é uma plataforma de gerenciamento centralizado para infraestrutura de servidores, com gerenciamento de configuração, execução remota, monitoramento e outras funções, geralmente pode ser entendido como uma versão simplificada do fantoche e uma versão aprimorada do func. SaltStack é implementado com base na linguagem Python, combinada com uma fila de mensagens leve (ZeroMQ) e módulos de terceiros Python (Pyzmq, PyCrypto, Pyjinjia2, python-msgpack, PyYAML, etc.) para construir. Ao implementar o ambiente SaltStack, podemos executar comandos em lotes em milhares de servidores, configurar o gerenciamento centralizado, distribuir arquivos, coletar dados do servidor, base de sistema operacional e gerenciamento de pacote de software de acordo com diferentes características de negócios, etc. SaltStack é a operação Uma arma para o pessoal de manutenção melhorar a eficiência do trabalho e padronizar a configuração e operação do negócio.
  
  

Características

• Ferramenta de gerenciamento de configuração de arquitetura C / S baseada no desenvolvimento python
• A camada inferior usa o modo pub / sub da fila de mensagens ZeroMQ para se comunicar
• Use a emissão de certificado SSL para gerenciamento de autenticação e a transmissão adota criptografia AES
  
  

Arquitetura de serviço

• Lado do servidor: Mestre
• Cliente: Minion
  
  

Características

• Execução remota
• Gerenciamento de configuração / gerenciamento de estado
• Gerenciamento de nuvem (nuvem)
• Orientado por eventos

Modo de operação

• local executado localmente
• Mestre / Minion tradicional
• Syndic distribuído
• Sal ssh
  
  

Arquivo de configuração

• / etc / salt / master： Arquivo de configuração do host (terminal de controle)
• / etc / salt / minion: Arquivo de configuração do lado controlado
  
  

2. Instalação e configuração

master 端 ：
server1 ： 192.168.17.1

fim do minion:
server2: 192.168.17.2
server3: 192.168.17.3

2.1 configuração minion

• Configurar armazém 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

• Instale minion de sal

yum install -y salt-minion

• Defina o lado mestre correspondente

vim /etc/salt/minion

 16 master: 192.168.17.1

• Serviço aberto

systemctl enable --now salt-minion

• Cada vez que você modificar o nome do host, exclua o arquivo / etc / salt / minion_id e modifique a resolução

2.2 configuração mestre

• Configurar armazém 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

• Serviço aberto

systemctl enable --now salt-master

• Certificação

salt-key -A: Aceite todas as chaves minion que aguardam autenticação

salt-key -L: Liste todas as informações de chave pública

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

2.3 Teste Remoto

• Ver portas e processos

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

• teste

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

3. Execute comandos shell remotamente

salt 'server2' sys.doc pkg: Ver a documentação do módulo

• Teste httpd

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

• Copiar arquivos

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

4. Grave o arquivo .sls

1. Existem diretórios apache.sls e apache, primeiro corresponda apache.sls
2. Não adicione o sufixo .sls ao chamar

mkdir -p /srv/salt/apache/files

• Sobre diferentes maneiras de escrever httpd

Execução de salt minion主机 state.sls apache.installexecução

#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 porta

cp /etc/httpd/conf/httpd.conf apache/files/: Copiar arquivo de modelo

vim apache/files/httpd.conf: Modificar detecção de porta

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. Escreva o módulo de execução remota _modules

1. mkdir /srv/salt/_modules: Crie um diretório de módulo

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

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

3. salt server2 cmd.run df

4. salt server2 saltutil.sync_modules: Módulo de sincronização

5. Após a sincronização, ele pode estar no host minion / var / cache / salt / minion / extmods / modules / Ver para
   
   

6. Configuração do grão (armazenado no lado do minion)

• Grãos é um componente do SaltStack, armazenado no lado asseclas do SaltStack.

• Quando o minion de sal for iniciado, os dados coletados serão armazenados estaticamente em grãos, e os dados serão atualizados apenas quando o minion for reiniciado.

• Como os grãos são dados estáticos, não é recomendável modificá-los com frequência.

• Cenários de aplicação:

  • Consulta de informações, pode ser usado como CMDB
  • Usado no alvo para corresponder ao lacaio
  • Usado no sistema de estado para configurar o módulo de gerenciamento.
    
    

• Ver informações no lado mestre

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

6.1 Adicione os grãos no lado do lacaio

servidor2

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

server3

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

Ver no mestre

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

6.2 Módulo de escrita de grãos

• Escreva

mkdir /srv/salt/_grains

vim /srv/salt/_grains/mygrains.py

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

• Sincronize o módulo de grãos com a extremidade do lacaio

salt '*' saltutil.sync_grains

Pode ser visto do lado dos minions /var/cache/salt/minion/files/base/_grains/mygrains.py

• Listar grãos

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

6.3 Aplicação de correspondência de grãos

• Combine o lacaio no alvo

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

• correspondência de arquivo 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: Leia os arquivos top.sls de todos os ambientes

7. aplicativo 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. jinja mock board

• Definição :{% XXX %}
• Citação :{ { XXX }}
  
  

8.1 Exemplo 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 os resultados da experiência

8.2 apache combinado com modelo 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. Veja os resultados experimentais do lado dos minions