Grundlegendes zu Salt für Junos OS-Komponenten
ZUSAMMENFASSUNG Machen Sie sich mit den verschiedenen Salt-Komponenten im Allgemeinen und in Bezug auf die Verwaltung von Geräten mit Junos OS vertraut.
Komponentenübersicht
Sie können Salt verwenden, um Geräte zu verwalten, auf denen Junos OS ausgeführt wird. Tabelle 1 bietet einen allgemeinen Überblick über die verschiedenen Salt-Komponenten. Jede Komponente wird in den folgenden Abschnitten ausführlicher beschrieben.
Komponente |
Beschreibung |
---|---|
Meister des Salzes |
Hauptsteuerungsserver, der einen oder mehrere Minions verwaltet. |
Diener des Salzes |
Mit Salt verwalteter Knoten. |
Salz-Proxy |
Prozess, der auf dem Salt-Master oder einem separaten Server ausgeführt wird und es dem Salt-Master ermöglicht, Geräte zu verwalten, die keinen standardmäßigen Salt-Minion-Prozess direkt auf dem Gerät ausführen. Der Junos-Proxy (für Salt) ermöglicht dem Salt-Master die Verwaltung von Geräten, auf denen Junos OS ausgeführt wird. |
Körner |
Statische Informationen oder Fakten über einen Salzdiener. Salt ruft Fakten von einem Gerät ab, auf dem Junos OS ausgeführt wird, wenn zum ersten Mal eine Verbindung mit dem Gerät hergestellt wird. Junos OS-Fakten werden in Salt-Grains gespeichert und können auf die gleiche Weise wie auf andere Grains aufgerufen werden. |
Säulen |
Benutzerdefinierte Daten, die einem Minion zugeordnet sind und auf die er zugreifen kann. |
Status-Dateien |
Definieren Sie Datenstrukturen, die vom Salt-System verwendet werden und auf bestimmte Ziele angewendet werden können. Sie können zum Beispiel verwendet werden, um Säulendaten oder den Zustand einer Anlage zu definieren. |
Top-Datei |
Ordnet Gruppen von Geräten den Salt-Statusdateien zu, die in einer bestimmten Umgebung auf sie angewendet werden sollen. |
Ausführungsmodul |
Definiert Ausführungsfunktionen, mit denen Sie Ad-hoc-Aufgaben für Minions über die Salt-Masterbefehlszeile ausführen können. Mit dem Junos-Ausführungsmodul (für Salt) können Sie Betriebs- und Konfigurationsaufgaben auf Geräten ausführen, auf denen Junos OS ausgeführt wird. |
Zustandsmodul |
Definiert Zustandsfunktionen, mit denen Sie den gewünschten Zustand eines Minions deklarieren und erzwingen können. Das Junos-Statusmodul (für Salt) stellt Funktionen bereit, die Sie in Salt-Statusdateien verwenden können, um einen bestimmten Status auf Geräten mit Junos OS zu deklarieren und durchzusetzen. |
Junos Syslog-Engine |
Überwacht Systemprotokollmeldungen, die von Geräten mit Junos OS gesendet werden, extrahiert die Ereignisinformationen und veröffentlicht sie im Salt-Format auf dem Salt-Ereignisbus. |
Reaktor |
Ermöglicht es Ihnen, Aktionen zu definieren, die für bestimmte Ereignisse ausgeführt werden sollen, die auf dem Salt-Ereignisbus empfangen werden. |
Die folgenden Salt-Komponenten, die in die Salt-Software integriert sind, werden zur Verwaltung von Geräten mit Junos OS verwendet:
Salt Master, Minions und Proxy Minions
Der Salt-Master ist der Hauptsteuerungsserver, der einen oder mehrere Knoten oder Salt-Minions verwaltet. Salt verwendet in der Regel eine agentbasierte Architektur, in der der verwaltete Knoten den Salt-Minion-Prozess ausführt. Einige Geräte, z. B. Netzwerkgeräte, unterstützen möglicherweise nicht die Installation und Ausführung des Salt-Minion-Prozesses direkt auf dem Gerät. In diesen Fällen unterstützt Salt die Verwendung eines Proxy-Minions zum Verwalten eines Geräts, auf dem ein Salt-Minion nicht direkt ausgeführt werden kann, das jedoch über ein anderes Protokoll, z. B. NETCONF, verwaltet werden kann. Ein Minion (Proxy oder regulär) ist nur ein Softwareprozess, der zur Verwaltung eines Geräts verwendet wird, und Sie können mehrere Prozesse auf demselben Server ausführen. Ein Proxyminion-Prozess kann entweder auf dem Salt-Master oder auf einem separaten Server ausgeführt werden und ist standardmäßig immer mit dem verwalteten Knoten verbunden.
Die standardmäßige Salt-Installation umfasst das Junos-Proxymodul, mit dem ein Salt-Master Geräte mit Junos OS über ein Salt-Proxy-Minion verwalten kann. Der Junos-Proxy-Minion-Prozess kann entweder auf dem Salt-Master oder einem separaten Server ausgeführt werden und benötigt ca. 40 bis 100 MB RAM pro Prozess. Für jedes verwaltete Gerät, auf dem Junos OS ausgeführt wird, muss ein Proxy-Minion-Prozess vorhanden sein. Der Junos-Proxy bietet Ausführungs- und Statusmodule, mit denen Sie Betriebs- und Konfigurationsaufgaben auf Geräten ausführen können, auf denen Junos OS ausgeführt wird.
Auf dem Junos-Proxy-Minion-Server müssen die Junos PyEZ-Bibliothek und die Module und yamlordereddictloader
Python jxmlease
installiert sein. Junos PyEZ ist ein Microframework für Python, mit dem Sie Geräte mit Junos OS verwalten und automatisieren können. Der Junos-Proxy-Minion stellt über den ZeroMQ-Ereignisbus eine Verbindung mit dem Salt-Master her und verwendet Junos PyEZ, um eine NETCONF-Sitzung über SSH mit dem Gerät einzurichten, auf dem Junos OS ausgeführt wird. Das jxmlease
Modul konvertiert XML- in Python-Datenstrukturen und Python-Datenstrukturen in XML.
Körner
Grains sind statische Datenelemente, die der Salt-Master über einen Diener sammelt. Zu den Korndaten gehören Eigenschaften des Systems, z. B. das Modell oder die Seriennummer des Geräts. Wenn der Salt-Master Befehle ausführt oder Zustände erzwingt, kann er Körner verwenden, um bestimmte Gruppen von Minions als Ziel zu verwenden. Beispielsweise kann ein Status auf alle Minions angewendet werden, auf denen ein bestimmtes Betriebssystem oder eine bestimmte Version ausgeführt wird.
Wenn der Junos-Proxy-Minion eine Verbindung mit einem Gerät herstellt, auf dem Junos OS ausgeführt wird, sammelt er die Junos OS-Fakten und speichert sie in Grains. Auf Junos OS-Fakten kann auf die gleiche Weise zugegriffen werden wie auf andere Grains.
Führen Sie die Funktion aus, um die Grains für ein Gerät anzuzeigen, auf dem Junos OS ausgeführt wird und das die junos_facts
grains.items
Grains enthält.
saltuser@salt-master:~$ sudo salt 'router1' grains.items router1: ---------- cpuarch: x86_64 dns: ---------- domain: ip4_nameservers: - 198.51.100.252 ip6_nameservers: nameservers: - 198.51.100.252 options: - edns0 search: - example.com sortlist: ... junos_facts: ---------- 2RE: True HOME: /var/home/saltuser RE0: ---------- last_reboot_reason: 0x1:power cycle/failure mastership_state: master model: RE-MX-104 status: OK up_time: 29 days, 2 hours, 35 minutes, 25 seconds ...
Wenn Sie nur die Junos OS-Fakten anzeigen möchten, können Sie nur das junos_facts
Grain-Element anfordern.
saltuser@salt-master:~$ sudo salt 'router1' grains.item junos_facts router1: ---------- junos_facts: ---------- 2RE: True HOME: /var/home/saltuser RE0: ---------- last_reboot_reason: 0x1:power cycle/failure mastership_state: master model: RE-MX-104 status: OK up_time: 29 days, 2 hours, 37 minutes, 15 seconds ...
Alternativ können Sie die facts
Funktion aus dem junos
Ausführungsmodul heraus ausführen. Die junos.facts
Funktion gibt die gleichen Daten wie der vorherige Befehl zurück.
saltuser@salt-master:~$ sudo salt 'router1' junos.facts router1: ---------- facts: ---------- 2RE: True HOME: /var/home/saltuser RE0: ---------- last_reboot_reason: 0x1:power cycle/failure mastership_state: master model: RE-MX-104 status: OK up_time: 29 days, 2 hours, 37 minutes, 15 seconds ...
Die Gerätedaten werden abgerufen und zwischengespeichert, wenn der Junos-Proxy-Minion eine Verbindung mit dem Gerät herstellt, auf dem Junos OS ausgeführt wird. Wenn Sie die Fakten anzeigen, werden sie aus dem Cache bereitgestellt. Wenn sich der Wert eines bereits zwischengespeicherten Fakts ändert, wird er daher nicht automatisch im Salt-System aktualisiert. Um die Fakten vom Gerät neu zu laden und anzuzeigen, rufen Sie die junos.facts_refresh
Funktion auf.
saltuser@salt-master:~$ sudo salt 'router1' junos.facts_refresh
Sie können Körner verwenden, um die Gruppe von Minions zu verfeinern, für die Aufgaben ausgeführt werden sollen. Mit dem folgenden Befehl wird der show chassis routing-engine
Befehl beispielsweise nur auf Geräten ausgeführt, auf denen Junos OS ausgeführt wird und die über zwei Routing-Engines verfügen:
saltuser@salt-master:~$ sudo salt -G 'junos_facts:2RE:True' junos.cli 'show chassis routing-engine'
Säulen
Mit dem Salt-Säulensystem können Sie Daten definieren, die an Minions verteilt werden können. Salt-Säulen sind baumartige Strukturen aus benutzerdefinierten Daten, die auf dem Salt-Master definiert sind und auf die Minions zugreifen können. Pillar-Daten können Konfigurationsdaten, benutzerdefinierte Variablen oder vertrauliche Informationen definieren, die dem Minion zugeordnet sind. Sie können die Säulendaten, auf die ein Minion zugreifen kann, einschränken, indem Sie die Säule den entsprechenden Zielen in der oberen Säulendatei zuordnen.
Säulendaten können in einfachen YAML-Dateien definiert werden, können aber auch in einer Datenbank wie SQL gespeichert und von dieser abgerufen werden. Standardmäßig werden Pillar-Datendateien im Verzeichnis / srv/pillar des Salt-Masters gespeichert. Um den Speicherort der Säulendaten zu ändern, legen Sie den pillar_roots
Parameter in der Salt-Masterkonfigurationsdatei auf das gewünschte Verzeichnis fest.
Bei der Verwaltung von Geräten, auf denen Junos OS ausgeführt wird, werden Säulen verwendet, um die Daten für den Junos-Proxy zu definieren, einschließlich des Hostnamens und der Authentifizierungsinformationen für ein bestimmtes Gerät, auf dem Junos OS ausgeführt wird. Die folgende Beispiel-Pillar-Datei enthält die Junos-Proxykonfiguration für ein Gerät, auf dem Junos OS ausgeführt wird:
saltuser@salt-master:~$ cat /srv/pillar/router1-proxy.sls proxy: proxytype: junos host: router1.example.com username: saltuser password: lab123 port: 830 # NETCONF port
Die Salt-Pillar-Top-Datei, die sich in der Regel unter / srv/pillar/top.sls befindet, definiert die Pillar-Daten, auf die ein Minion zugreifen kann. Bei der Verwaltung von Geräten, auf denen Junos OS ausgeführt wird, ordnet die Pillar-Top-Datei die Junos-Proxy-Minion-ID der Pillar-Datei zu, die die Proxy-Daten für das entsprechende Gerät mit Junos OS enthält. Im folgenden Beispiel ordnet die oberste Datei die Proxy-Minion-ID router1 der Säulendatei router1-proxy.sls in der Basisumgebung zu:
saltuser@salt-master:~$ cat /srv/pillar/top.sls base: 'router1': # proxy minion ID - router1-proxy # State file name 'router2': - router2-proxy
Sie können die Säulendaten eines Minions anzeigen, indem Sie die pillar.items
Funktion ausführen.
saltuser@salt-master:~$ sudo salt 'router1' pillar.items router1: ---------- proxy: ---------- host: router1.example.com password: lab123 port: 830 proxytype: junos username: saltuser
Salt State (SLS)-Dateien
SLS-Dateien (SaLt State) definieren Datenstrukturen, die vom Salt-System für verschiedene Zwecke verwendet werden. Sie können zum Beispiel verwendet werden, um Säulendaten oder den Zustand einer Anlage zu definieren. Standardmäßig werden Salt-Statusdateien im YAML-Format geschrieben und verwenden die Dateierweiterung . sls. Statusdateien unterstützen die Verwendung der Jinja-Syntax für zusätzliche Flexibilität.
Mit Salt können Sie deklarativ mit den Konfigurationen verwalteter Systeme arbeiten. Das Junos-Statusmodul (für Salt) salt.states.junos
bietet Funktionen, die Sie in Statusdateien verwenden können, um bestimmte Zustände auf Geräten mit Junos OS zu deklarieren und durchzusetzen. Sie können z. B. sicherstellen, dass die Gerätekonfiguration einen bestimmten Satz von Anweisungen enthält oder dass das Gerät einen bestimmten Betriebszustand widerspiegelt.
Die allgemeine Struktur für eine SLS-Datei, die den Status für ein verwaltetes Gerät definiert, lautet wie folgt, obwohl dies je nach Modul und Funktion variieren kann:
State name: module.function: - param1: value1 - param2: value2
Beispielsweise wird in der folgenden Statusdatei die Funktion verwendet, um die Konfiguration in der angegebenen Vorlage auf die junos.install_config
Zielgeräte anzuwenden, auf denen Junos OS ausgeführt wird:
saltuser@salt-master:~$ cat /srv/salt/junos_bgp_config.sls Apply BGP configuration: junos.install_config: - name: salt://configs/junos-config-bgp-template.set - comment: Configuring BGP using Salt - diffs_file: /var/log/salt/output/{{ grains['id'] }}_junos_bgp_config_diff
Sie können einen individuellen Status auf ein oder mehrere Zielgeräte anwenden. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' state.apply junos_bgp_config
Alternativ kann die Salt-Top-Datei verwendet werden, um während der Ausführung eines High-Zustands einen oder mehrere Zustände auf ein Minion anzuwenden.
saltuser@salt-master:~$ cat /srv/salt/top.sls base: router1: - junos_bgp_config - junos_ospf_config
Wenn Sie einen highstate für ein bestimmtes Ziel ausführen, wendet das Salt-System alle Zustände an, die in der top.sls
Datei für dieses Ziel konfiguriert sind.
saltuser@salt-master:~$ sudo salt 'router1' state.apply
Weitere Informationen zum Junos-Statusmodul finden Sie unter Grundlegendes zu den Junos-Ausführungs- und State-Salt-Modulen.
Top-Datei
Wenn Sie Salt zum Verwalten von Geräten verwenden, können Sie Minions in verschiedene Kategorien oder Umgebungen gruppieren. Standardmäßig befinden sich alle Minions in der Basisumgebung, Sie können jedoch andere Minions in einer Entwicklungs- oder Produktionsumgebung platzieren. Eine Salt-Top-Datei ordnet ein Gerät oder eine Gruppe von Geräten den Statusdateien zu, die auf sie angewendet werden sollen, sowie den Säulendaten, auf die sie in der jeweiligen Umgebung zugreifen können. Top-Dateien heißen standardmäßig top.sls und befinden sich an der Spitze der Verzeichnishierarchie, die Salt-Statusdateien enthält.
Standardmäßig befindet sich die Top-Datei, die für Zustände verwendet wird, unter / srv/salt/top.sls. Es verwendet die folgende Syntax, um die Zielgeräte den entsprechenden Statusdateien in der angegebenen Umgebung zuzuordnen. Die Datei muss immer die base
Umgebung definieren.
environment1: target: - state1 - state2 environment2: target: - state1 - state2
Die folgende Top-Datei wendet z. B. die Statusdateien core.sls und common_config.sls auf alle Minions in der Basisumgebung an, deren ID mit "router" beginnt:
base: 'router*' - core - common_config
Um die Zustände anzuwenden, führen Sie einen highstate aus und geben Sie die Zielgeräte an.
saltuser@salt-master:~$ sudo salt 'router1' state.apply
In ähnlicher Weise ordnet die Pillar-Top-Datei, die sich im Allgemeinen unter / srv/pillar/top.sls befindet, eine Pillar-Datei den Minions zu, die auf die Daten in dieser Datei zugreifen dürfen. Bei der Verwaltung von Geräten, auf denen Junos OS ausgeführt wird, ordnet die Pillar-Top-Datei eine Junos-Proxy-Minion-ID der Statusdatei zu, die die Säulendaten für das entsprechende Gerät mit Junos OS enthält, wie im Abschnitt Pillars beschrieben.
Ausführungs- und Zustandsmodule
Salt ist ein Konfigurationsverwaltungs- und Remoteausführungstool, mit dem Sie den Status eines Systems deklarieren und durchsetzen sowie Betriebs- und Konfigurationsaufgaben auf verwalteten Geräten ausführen können. Salt-Ausführungsmodule sind Python-Module, die auf einem Salt-Minion ausgeführt werden. Sie definieren Funktionen, mit denen Sie Aufgaben auf dem Minion ausführen können. Sie können Ad-hoc-Befehle auf dem Salt-Master ausführen, die die Zielminions anweisen, die angegebene Funktion auszuführen und das Ergebnis zurückzugeben. Auf ähnliche Weise definieren Salt-Zustandsmodule Funktionen, die die Anwendung eines Zustands auf ein Minion verwalten.
Um z. B. die Konnektivität mit allen Minions zu testen, können Sie die ping
Funktion des test
Moduls ausführen und das Ziel so angeben, dass '*'
alle Minions angegeben werden.
saltuser@master:~$ sudo salt '*' test.ping router1: True router2: True
Die Salt-Installation umfasst die Junos-Ausführungs- und Statusmodule, die Funktionen definieren, mit denen Sie Betriebs- und Konfigurationsaufgaben ausführen und die Anwendung von Zuständen auf Geräten verwalten können, auf denen Junos OS ausgeführt wird. Ausführliche Informationen zur Verwendung der Junos-Ausführungs- und -Statusmodule finden Sie unter Grundlegendes zu den Junos-Ausführungs- und Status-Salt-Modulen.
Junos Syslog Engine, Salt Event Bus und Salt Reactors
Die Salt-Architektur basiert auf einem leistungsstarken Ereignisbus, der ZeroMQ als Standard-Nachrichten- und Ereignistransportmechanismus für die Kommunikation zwischen dem Salt-Master und Minions verwendet. Komponenten kommunizieren, indem sie Nachrichten über den Bus senden, und externe Ereignisse können in den Bus eingespeist werden. Der Salzmeister und jeder Salzdiener hat seinen eigenen Eventbus.
Das Ereignissystem verwendet ein Publish-Subscribe-Modell (Pub/Sub). Ereignisse werden im Ereignisbus veröffentlicht, und Abonnenten lauschen auf veröffentlichte Ereignisse und reagieren wie angewiesen. Wenn Sie z. B. eine Funktion für ein Minion ausführen, veröffentlicht der Salt-Master ein Auftragsereignis, und das entsprechende Minion führt den Auftrag aus und löst ein return-Ereignis aus, das die Auftragsergebnisse enthält, auf dem Bus. Salt bietet Methoden zum Veröffentlichen externer Ereignisse im Bus und zum Reagieren auf Ereignisse, sodass Sie Salt verwenden können, um Ereignisse in Echtzeit zu überwachen und darauf zu reagieren.
Salt-Engines sind externe Systemprozesse, mit denen Sie Ereignisse auf dem Salt-Ereignisbus exportieren oder importieren können. Die Salt-Installation umfasst die Junos-Syslog-Engine (für Salt), die Syslog-Meldungen (Junos OS-Systemprotokolle) überwachen kann, die an den Salt-Server gesendet werden, und sie im Salt-Ereignisbus veröffentlichen kann. Wenn diese Option aktiviert ist, lauscht die Junos-Syslog-Engine am angegebenen Port auf Syslog-Ereignisse von verwalteten Geräten, auf denen Junos OS ausgeführt wird. Wenn die Junos-Syslog-Engine ein Ereignis empfängt, extrahiert sie die Ereignisinformationen, übersetzt sie in das Salt-Format und veröffentlicht sie im Salt-Ereignisbus.
Die folgende Ausgabe ist ein Beispielereignis UI_COMMIT_COMPLETED
, das von einem Gerät mit Junos OS gesendet und von der Junos-Syslog-Engine auf dem Salt-Ereignisbus veröffentlicht wurde:
jnpr/syslog/router1/UI_COMMIT_COMPLETED { "_stamp": "2019-07-24T17:17:30.390374", "daemon": "mgd", "event": "UI_COMMIT_COMPLETED", "facility": 23, "hostip": "198.51.100.2", "hostname": "router1", "message": "commit complete", "pid": "5795", "priority": 188, "raw": "<188>Jul 24 10:17:38 router1 mgd[5795]: UI_COMMIT_COMPLETED: commit complete", "severity": 4, "timestamp": "2019-07-24 17:17:30"
Sie können die Junos-Syslog-Engine in Verbindung mit Salt Reactors für die ereignisbasierte Statusverwaltung von Geräten verwenden, auf denen Junos OS ausgeführt wird. Salt-Reaktoren ermöglichen es Ihnen, als Reaktion auf Ereignisse im Salt-Ereignisbus Maßnahmen zu ergreifen. Wenn Sie das Salt Reactor-System aktivieren, überwacht es den Salt-Ereignisbus und löst Aktionen für übereinstimmende Ereignisse basierend auf Ihren konfigurierten Regeln aus. Um das Salt Reactor-System zu aktivieren, konfigurieren Sie die reactor
Option in der Salt-Masterkonfigurationsdatei und ordnen Ereignis-Tags einer oder mehreren Reaktor-SLS-Dateien zu. Die Reaktordateien definieren die Aktionen, die ausgeführt werden sollen, wenn dieses Ereignis eintritt.
Weitere Informationen zur Junos-Syslog-Engine und zum Erstellen von Reaktoren für Junos OS-Ereignisse finden Sie unter: