Saltstack

• Dev ops
• Sre

Einführung

SaltStack, bekannt auch als Salt, ist eine Open-Source-Konfigurationsmanagement- und Automatisierungssoftware. Sie ermöglicht es, Server in einem Rechenzentrum oder in der Cloud effizient zu verwalten. Mit SaltStack können wir Konfigurationen zentralisieren und automatisieren, was hilft, die Konsistenz und Zuverlässigkeit von Systemen sicherzustellen.

Die Basis von Salt besteht aus einem Master-Server und mehreren Minions (Client-Systemen), die vom Master aus gesteuert werden. Minions melden sich beim Master an und können dann Befehle empfangen und ausführen.

Salt verwendet eine einfache Konfigurationssprache namens YAML in Kombination mit Jinja-Templates zur Definition der Systemzustände. Diese Zustandsdateien, bekannt als “States”, beschreiben, wie ein System konfiguriert sein sollte. Zum Beispiel können States definiert werden, um Pakete zu installieren, Dienste zu starten oder Konfigurationsdateien zu verwalten.

Ein zentrales Feature von Salt ist das Remote Execution Framework, das es ermöglicht, Befehle gleichzeitig auf mehreren Systemen auszuführen. Dies wird durch Salt’s Event-Driven-Architektur ermöglicht, die eine hohe Skalierbarkeit und schnelle Reaktionsfähigkeit bietet.

Durch die Modulstruktur von Salt ist es möglich, das System durch eigene Module zu erweitern und spezifische Anforderungen zu erfüllen. Salt kann auch mit anderen Tools und Plattformen integriert werden, um eine umfassende Automatisierungslösung zu bieten.

Geschichte und Technologie

SaltStack wurde im Jahr 2011 von Thomas S. Hatch entwickelt und als Open-Source-Software freigegeben, um eine effiziente, skalierbare und einfach zu bedienende IT-Automatisierungslösung zu bieten. Der Ansatz zielte darauf ab, einige der Herausforderungen anzugehen, die andere Konfigurationsmanagement-Tools wie Puppet oder Chef hatten, insbesondere im Hinblick auf Geschwindigkeit und die Handhabung von sehr großen Infrastrukturen.

SaltStack ist hauptsächlich in Python geschrieben. Dies macht es zugänglich für viele Systemadministratoren und Entwickler, da Python eine weit verbreitete und gut unterstützte Programmiersprache ist. Python bietet auch eine umfangreiche Standardbibliothek und zahlreiche Module, die die Entwicklung von zusätzlichen Funktionen für Salt erleichtern.

Für die Kommunikation zwischen dem Master und den Minions verwendet SaltStack ZeroMQ, ein High-Performance-Nachrichtenbibliothek und Framework. ZeroMQ ermöglicht es Salt, Nachrichten schnell und effizient über das Netzwerk zu senden, was für die Skalierbarkeit und Leistung von Salt essentiell ist. Es unterstützt auch Muster wie Pub/Sub, was nützlich ist, um Befehle an eine Gruppe von Minions zu verteilen, ohne dabei die Netzwerkressourcen übermäßig zu belasten.

Setup des Masters

Um SaltStack auf einem Fedora-System zu installieren und zu konfigurieren, kannst Du die folgenden Schritte befolgen:

1. Installation

Öffne ein Terminal und führe die folgenden Befehle aus, um SaltStack zu installieren:

sudo dnf install https://repo.saltstack.com/py3/redhat/salt-py3-repo-latest.el8.noarch.rpm
sudo dnf clean expire-cache
sudo dnf install salt-master salt-minion

Dies installiert sowohl den Salt Master als auch den Minion auf dem System. Falls Du nur den Master ohne Minions installieren möchtest, kannst Du den Befehl entsprechend anpassen.

2. Konfiguration des Masters

Nach der Installation musst Du die Konfiguration des Salt Masters anpassen. Die Hauptkonfigurationsdatei des Masters befindet sich unter /etc/salt/master. Du kannst diese Datei mit einem Texteditor öffnen und bearbeiten, um verschiedene Einstellungen wie Netzwerkeinstellungen, Dateipfade und mehr anzupassen.

Ein wichtiger Teil der Konfiguration ist die Einstellung der Netzwerkschnittstelle, an die der Master gebunden ist, um Anfragen der Minions zu akzeptieren. Bearbeite die Zeile interface, um die IP-Adresse des Netzwerk-Interfaces anzugeben, das der Master verwenden soll:

# Setze die IP-Adresse des Netzwerk-Interfaces, das der Salt Master verwenden soll
interface: 192.168.1.50

3. Starten des Salt Masters

Nachdem Du die Konfiguration angepasst hast, kannst Du den Salt Master starten:

sudo systemctl start salt-master

Um sicherzustellen, dass der Salt Master bei jedem Systemstart automatisch gestartet wird, kannst Du ihn mit folgendem Befehl aktivieren:

sudo systemctl enable salt-master

4. Überprüfung des Status

Überprüfe den Status des Salt Master-Dienstes, um sicherzustellen, dass alles korrekt läuft:

sudo systemctl status salt-master

Diese Schritte richten den Salt Master auf einem Fedora-System ein. Danach kannst Du beginnen, Minions zu registrieren und die Automatisierung Deiner Infrastruktur mit SaltStack zu planen. Um einen Salt Minion in dein Netzwerk aufzunehmen, folge diesen knappen Schritten:

1. Installiere Salt Minion auf dem Ziel-System mit dem Befehl sudo dnf install salt-minion.

2. Bearbeite die Konfigurationsdatei des Minions unter /etc/salt/minion. Stelle sicher, dass die master-Direktive auf die IP-Adresse oder den Hostnamen deines Salt Masters zeigt:

   master: ip_des_salt_masters

3. Starte den Minion-Dienst mit:

   sudo systemctl start salt-minion

4. Stelle sicher, dass der Minion-Dienst bei jedem Systemstart automatisch gestartet wird:

   sudo systemctl enable salt-minion

5. Auf dem Salt Master musst Du den Schlüssel des Minions akzeptieren, damit Befehle gesendet werden können:

   sudo salt-key -A

/etc/myconfigfile.conf:
file.managed:
    - source: salt://myconfigfile.conf
    - user: root
    - group: root
    - mode: 644

Um eine Salt Formula zu erstellen, die eine Konfigurationsdatei verteilt, kannst Du folgende Schritte befolgen:

1. Lege in deinem Salt Fileserver-Verzeichnis (standardmäßig /srv/salt/) eine neue Verzeichnisstruktur für deine Formula an. Zum Beispiel für eine Formula namens myconfig:

   mkdir -p /srv/salt/myconfig/files

2. Platziere die zu verteilende Konfigurationsdatei im files-Verzeichnis. Zum Beispiel custom.conf:

   cp path/to/your/custom.conf /srv/salt/myconfig/files/

3. Erstelle eine State-Datei, die angibt, wie und wo die Datei verteilt wird. Erstelle dazu eine Datei init.sls im myconfig-Verzeichnis:

   # /srv/salt/myconfig/init.sls
   distribute_custom_conf:
     file.managed:
       - name: /etc/custom.conf
       - source: salt://myconfig/files/custom.conf
       - user: root
       - group: root
       - mode: 644
       - template: jinja

   Diese State-Datei verwendet den file.managed-State, um die Datei custom.conf aus dem Salt Fileserver an den Zielort /etc/custom.conf zu kopieren. Die Eigentümerschaft, Gruppenzugehörigkeit und Berechtigungen werden ebenfalls festgelegt.

4. Wende die State-Datei auf die gewünschten Minions an, entweder über die Salt Command Line oder durch Einbinden in Top-Files für die automatische Anwendung:

   sudo salt 'minion_id' state.apply myconfig

   Dieser Befehl wendet die Formula myconfig auf den Minion mit der ID minion_id an.

Durch diese Schritte wird deine Konfigurationsdatei zentralisiert verwaltet und automatisiert auf die Minions in deiner Salt-Umgebung verteilt.

Pillars & Grains

Um Minions in SaltStack zu gruppieren, sodass spezifische Konfigurationen nur auf bestimmten Hosts angewendet werden, kannst Du die „Grains“ oder die „Pillar“-Daten verwenden oder die Minions direkt in der Top-File konfigurieren. Hier ist, wie Du jede Methode verwendest:

Grains

Grains sind statische Informationen über die Minions, wie Betriebssystem, IP-Adresse, und mehr. Du kannst eigene Grains definieren und sie nutzen, um Minions zu gruppieren:

1. Bearbeite die Datei /etc/salt/minion.d/grains.conf und füge eigene Grains hinzu:

   custom_group: group1

2. In der Top-File (/srv/salt/top.sls) kannst Du Grains verwenden, um States auf spezifische Minions anzuwenden:

   base:
     'grains.custom_group:group1':
       - match: grain
       - some_state

Pillar

Pillar-Daten sind dynamische Daten, die Du für jeden Minion individuell konfigurieren kannst. Sie eignen sich gut, um sensible Daten oder spezifische Konfigurationen zu verwalten:

1. Bearbeite die Pillar-Datei in /srv/pillar, z. B. group1.sls:

   config_group: group1

2. Binde Pillar-Daten in die Top-File ein (/srv/pillar/top.sls):

   base:
     'minion_id':
       - group1

3. In deiner State-Datei kannst Du auf die Pillar-Daten zugreifen:

   include_based_on_pillar:
     file.managed:
       - name: /etc/someconfig.conf
       - source: salt://path/to/file
       - template: jinja
       - context:
           data: {{ pillar['config_group'] }}

Direkte Gruppierung in der Top-File

Du kannst Minions auch direkt in der Top-File gruppieren, ohne Grains oder Pillar:

1. Bearbeite das Top-File (/srv/salt/top.sls):

   base:
     'minion1_id,minion2_id':
       - match: list
       - some_state

   Oder verwende Wildcards und andere Muster:

   base:
     'webservers-*':
       - match: glob
       - webserver_config

Diese Methoden erlauben es Dir, Minions zu gruppieren und States gezielt nur auf bestimmte Hosts oder Gruppen von Hosts anzuwenden, was die Verwaltung großer und heterogener Umgebungen erheblich vereinfacht.