Orchestrierung

States, Targets und Module in Abhängigkeit bringen

Mit der Orchestrierung können Sie wiederkehrende Aufgaben bündeln und das Zusammenspiel von States und Minions definieren. In einer Orchestrierungsdatei bestimmen Sie, welcher Minion was machen, und in welcher Reihenfolge dies geschieht.

https://docs.saltproject.io/en/latest/topics/orchestrate/index.html

/srv/salt/orch/ping.sls

# Super simple orchestration exmaple
# /srv/salt/orch/ping.sls
ping:
  salt.function:
    - name: test.ping
    - tgt: '*'
# salt-run state.orchestrate orch.ping

Orchestrierungsjobs werden mit salt-run state.orchestrate ausgeführt. Orchestrierungs-SLS-Dateien müssen sich im File-Root, i.d.R. /srv/salt befinden. Diese Orchestrierungsdateien in einem Unterordner z.B. orch zu sammeln, ist eine umvebrindliche Empfehlung, aber keine Bedingung,

Beispiel Webcluster

/srv/salt/orch/webcluster.sls

#
# Install caddy on all backends in paralell
#
install-backends:
  salt.state:
    - tgt: backends
    - tgt_type: nodegroup
    - sls:
      - caddy.backend

#
# Install the loadbalancer after the backends
#
install-loadbalancer:
  salt.state:
    - tgt: loadbalancers
    - tgt_type: nodegroup
    - sls:
      - caddy.loadbalancer
    - require:
      - salt: install-backends

salt-run state.orchestrate orch.webcluster

Trageting Minions

Ein Targeting per Pillar ist ebenfalls möglich.

install-backends:
  salt.state:
    - tgt: 'roles:php-backend'
    - tgt_type: pillar
    - sls:
      - caddy.php

Targeting über eine Liste mit Minions-IDs

install-backends:
  salt.state:
    - tgt:
      - minion1
      - minion2
    - tgt_type: list
    - sls:
      - caddy.backend

Beispiel Targeting per Minion-ID und Regex.

#
# Install caddy on all backends in paralell
#
install-backends:
  salt.state:
    - tgt: webserver[2,3]
    - sls:
      - caddy.backend

/srv/salt/orch/webcluster.sls

#
# Install caddy on all backends
# but one after another
#
{% for minion in pillar['master']['nodegroups']['backends'] %}
install-backend-{{ minion }}:
  salt.state:
    - tgt: {{ minion }}
    - sls:
      - caddy.backend
    - require_in:
      - salt: install-loadbalancer
{% endfor %}
#
# Install the loadbalancer after the backends
#
install-loadbalancer:
  salt.state:
    - tgt: loadbalancers
    - tgt_type: nodegroup
    - sls:
      - caddy.loadbalancer

Diese Variante erfordert die Einstellung pillar_opts: True in der Master-Konfiguration, damit Sie über alle Minions einer Nodegroup iterieren können,

Master local execute

per Orchestrierung gibt es die Möglichkeit, Kommandos und Module direkt auf dem Master auszuführen. Diese werden nicht über den ggf. auf dem Master installieren Minion ausgeführt.

date>/tmp/master.txt:
  cmd.run: []

Beispiel Rsync Backup

Vorbereitungen auf dem Master

mkdir /srv/salt/backup
useradd -s /bin/sh -r -m -b /var/lib/ rsync
mkdir /var/lib/rsync/.ssh
chown -R rsync:rsync /var/lib/rsync/
chmod 0700 /var/lib/rsync/.ssh/
chsh -s /bin/bash salt
echo 'salt ALL=(ALL) NOPASSWD:ALL' > /etc/sudoers.d/salt

Prüfen Sie, ob sudo Dateien aus dem Verzeichnis /etc/sudoers.d einliest. In der Datei /etc/sudoers muss die Zeile @includedir /etc/sudoers.d enthalten sein.

/etc/sshd/sshd_config

... snip
Port 22
Port 2000
#AddressFamily any
#ListenAddress 0.0.0.0
#ListenAddress ::
... snap

Ablauf der Orchestrierung

1. Auf einer Gruppe Minions wird per State ein Rsync Backup angestoßen

2. Die Minions bekommen temporär einen privaten SSH Key zur Verfügung gestellt

3. Mit dem Key "schieben" die Minions das Backup per Rsync+SSH zum Master

4. Der Private Key wird gelöscht

5. Der Master schließt nachdem alle Minions das Backup beendet haben den Port 2000 wieder.

/srv/salt/orch/backup.sls

#
# Create new ssh keys for each run of the backup
#
gen-tmp-keys:
  cmd.run:
    - name: |
        test -e id_ed25519 && rm -f id_ed25519
        test -e id_ed25519.pub && rm -f id_ed25519.pub
        ssh-keygen -q -t ed25519 -N "" -f ./id_ed25519
        sudo cp id_ed25519.pub /var/lib/rsync/.ssh/authorized_keys
        sudo chown rsync:rsync /var/lib/rsync/.ssh/authorized_keys
        sudo chmod 0600 /var/lib/rsync/.ssh/authorized_keys
    - cwd: /srv/salt/backup

#
# Open the firewall
#
open-ufw:
  cmd.run: 
    - name: ufw allow 2000
    - require:
      - cmd: gen-tmp-keys

#
# Perform the backup via a state
#
backup:
  salt.state:
    - tgt: minion*
    - sls:
      - backup
    - require:
      - cmd: open-ufw

#
# Close the firewall again
#
close-ufw:
  cmd.run: 
    - name: ufw deny 2000

/srv/salt/backup/init.sls

#
# Copy the private key
#
/root/.backup.key:
  file.managed:
    - source: salt://backup/id_ed25519
    - mode: 0600

#
# Execute the backup
#
backup:
  cmd.run:
    - name: >
        rsync -aq --numeric-ids 
        -e "ssh -i .backup.key -o StrictHostKeyChecking=no -p 2000" 
        /etc /root
        rsync@192.168.122.1:~/{{ grains['id'] }}/
    - cwd: /root

#
# Destroy the key
#
destroy:
  cmd.run:
    - name: |
        shred -n1 /root/.backup.key
        rm -f /root/.backup.key