Salt-Mine

Informationsaustausch zwischen den Minions

In die Mine speichern

Die Salt-Mine erlaubt es Minions, auf Daten andere Minions zuzugreifen.

Dabei bestimmt jeder Minion, welche Daten er in der Mine ablegt und damit "freigibt". Eine Standard-Konfiguration für die Mine existiert nicht. Legen Sie mit folgendem Inhalt an:

/etc/salt/minion.d/mine.conf

mine_interval: 2
mine_functions:
    network.ip_addrs: []

Nach dem Restart des Minions hinterlegt dieser nun all 2 Minuten seine IP-Adressen in der Mine.

The Salt Mine functions are executed when the Minion starts and at a given interval by the scheduler. The default interval is every 60 minutes 📖 Salt Doku

Sie können mit salt '*' mine.update ein Update erzwingen.

Testen Sie, was in der Mine abgelegt wurde:

salt <MINION> config.get mine_functions
salt <MINION> mine.get '*' <FUNCTION>

Achtung: Daten, welche in der Mine liegen, können von allen Minions gelesen werden! salt-call mine.get '*' network.ip_addrs

Als Mine-Funktion können alle Salt-Module verwendet werden. Beispiel für eine mine.conf:

mine_functions:
  network.ip_addrs: []
  test.ping: []
  file.read: [/etc/hosts]
  cmd.run: [/bin/date]

Mine zentral vom Master auf den Minion aktivieren

/srv/salt/mine/activate.sls

/etc/salt/minion.d/mine.conf:
  file.managed:
    - contents: |
        mine_interval: 2
        mine_functions:
          network.ip_addrs: []
minion-restart:
  cmd.run:
    - name: salt-call service.restart salt-minion
    - bg: true

Aus der Mine lesen

Nachdem Restart des Minions kann man testen, was in der Mine liegt:

salt <MINION> config.get mine_functions

minion1:
    ----------
    cmd.run:
        - /bin/date
    file.read:
        - /etc/hosts
    network.ip_addrs:
    test.ping:
    
salt <MINION> mine.get '*' cmd.run
<MINION>:
    ----------
    <MINION>:
        Thu Nov  8 09:10:45 UTC 2018

Daten aus der Mine können nun wie folgt in States verwendet werden:

/srv/salt/exmaples/mine-read.sls

/tmp/mine-data.txt:
    file.managed:
        - contents: |
                IP Adressen:
                {% for minion, ip_addr in salt['mine.get']('*', 'network.ip_addrs', tgt_type='glob') | dictsort() %}
                    minion: {{ minion }}, ip: {{ ip_addr[0] }}
                {% endfor %}
                Datum:
                {% for minion, date in salt['mine.get']('*', 'cmd.run', tgt_type='glob') | dictsort() %}
                    minion: {{ minion }}, date: {{ date }}
                {% endfor %}

In die Mine hereinschauen

salt '*' mine.get '*' network.ip_addrs

Beispiel 1: Namensauflösung ohne DNS

Im nachfolgenden Beispiel werden sich all Minions gegenseitig in die lokale /etc/hosts Datei eintragen. Die Minions können sich dann per Namen erreichen, ohne dass diese in einen DNS Server eingetragen werden müssen.

/srv/salt/network/hosts.sls

#
# Read all minion ids from the mine and add them to the hosts file
#
{% for minion_id, addrs in salt['mine.get']('*', 'network.ip_addrs', tgt_type='glob') | dictsort() %}
{{ minion_id }}:
  host.present:
    - ip: {{ addrs[0] }}
    - clean: True
    - names:
      - {{ minion_id }}
      - {{ minion_id }}.local
{% endfor %}

Beispiel 2: Webserver-Cluster und Loadbalancer

Ein klassischer Anwendungsfall ist die Konfiguration von Loadbalancern. Diese müssen wissen, über welche Server die Last verteilt werden soll.

Über die Salt Mine können sich Server registrieren und der Minion des Loadbalancers hat Zugriff auf eine Serverliste, welche aus der Salt Mine generiert wird.

Schritt 1: Salt Mine auf den Minions aktivieren

Die Salt Mine kann auf den Minions zentral vom Salt Master mit dem nachfolgenden State aktiviert werden:

Schritt 2: Loadbalancer mit Mine-Daten konfigurieren

Und der Loadbalancer kann wie folgt auf die Liste zugreifen:

/tmp/loadbalancer.conf:
    file.managed:
        - contents: |
{% for server, addrs in salt['mine.get']('roles:web', 'network.ip_addrs', tgt_type='grain') | dictsort() %}
            server {{ server }} ip {{ addrs[0] }}
{% endfor %}

Das Beispiel setzt voraus, dass die Backend-Minions ein Grain roles:web gesetzt haben.

/srv/salt/caddy/loadbalancer.sls

{% if 'loadbalancer' not in pillar.get('roles',[]) %}
always-fails:
  test.fail_without_changes:
    - name: Requirement not met. Your role does not allow to become a loadbalancer 
    - failhard: True
{% else %}
include:
  - caddy

extend:
  /etc/caddy/Caddyfile:
    file.managed:
        - contents: |
            :80 {
                reverse_proxy * {% for server, addrs in salt['mine.get']('roles:php-backend', 'network.ip_addrs', tgt_type='pillar') | dictsort() -%}
                 {{ addrs[0]+" " }}
                {%- endfor %} {
                  lb_policy round_robin
              }
            }
{% endif %}

🧩 Aufgabe: Starten Sie einen neuen LXD Container und rollen Sie alle nötigen States aus, damit das neue System als Backend dem Cluster beitritt.