Grundlegendes zu Salt für Junos OS-Komponenten
Verstehen Sie die verschiedenen Salt-Komponenten im Allgemeinen und wie sie sich auf die Verwaltung von Geräten mit Junos OS beziehen.
Komponenten im Überblick
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. Die einzelnen Komponenten werden in den folgenden Abschnitten ausführlicher beschrieben.
Bestandteil |
Beschreibung |
|---|---|
Salz-Meister |
Hauptsteuerungsserver, der einen oder mehrere Minions verwaltet. |
Salz-Diener |
Mit Salt verwalteter Knoten. |
Salt-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 es dem Salt-Master, Geräte zu verwalten, auf denen Junos OS ausgeführt wird. |
Körner |
Statische Informationen oder Fakten über einen Salt-Diener. Salt ruft bei der ersten Verbindung mit dem Gerät Fakten von einem Gerät ab, auf dem Junos OS ausgeführt wird. Junos OS-Fakten werden in Salt-Grains gespeichert und können auf die gleiche Weise wie andere Grains aufgerufen werden. |
Säulen |
Benutzerdefinierte Daten, die einem Minion zugeordnet sind und auf die dieser zugreifen kann. |
Status-Dateien |
Definieren Sie Datenstrukturen, die vom Salt-System verwendet werden und auf bestimmte Ziele angewendet werden können. Sie können beispielsweise verwendet werden, um Säulendaten oder den Zustand eines Systems zu definieren. |
Datei oben |
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 Saltmaster-Befehlszeile 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 gesendet werden, auf denen Junos OS ausgeführt wird, 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 verwendet, auf denen Junos OS ausgeführt wird:
Salt-Master, Diener und Stellvertreter-Diener
Der Salt-Master ist der Hauptsteuerungsserver, der einen oder mehrere Knoten oder Salt-Minions verwaltet. Salt verwendet in der Regel eine agentenbasierte 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 zur Verwaltung eines Geräts, das einen Salt-Minion nicht direkt ausführen kann, aber über ein anderes Protokoll verwaltet werden kann, z. B. NETCONF. Ein Minion (Proxy oder Regular) ist nur ein Softwareprozess, der zum Verwalten eines Geräts verwendet wird, und Sie können mehrere Prozesse auf demselben Server ausführen. Ein Proxy-Minion-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-Proxy-Modul , mit dem ein Salt-Master Geräte mit Junos OS über einen Salt-Proxy-Diener 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. Sie benötigen einen Proxy-Minion-Prozess für jedes verwaltete Gerät, auf dem Junos OS ausgeführt wird. Der Junos-Proxy stellt Ausführungs- und Statusmodule bereit, 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 Python-Module und installiert jxmlease yamlordereddictloader sein. Junos PyEZ ist ein Microframework für Python, mit dem Sie Geräte unter Junos OS verwalten und automatisieren können. Der Junos Proxy-Minion stellt über den ZeroMQ-Ereignisbus eine Verbindung zum 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
Körner sind statische Daten, die der Salt-Master über einen Diener sammelt. Zu den Körnungsdaten gehören Eigenschaften über das System, z. B. das Modell oder die Seriennummer des Geräts. Wenn der Salt-Master Befehle ausführt oder Zustände erzwingt, kann er Grains verwenden, um bestimmte Gruppen von Minions anzuvisieren. 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, erfasst er die Junos OS-Fakten und speichert sie in Grains. Auf Junos OS-Fakten kann auf die gleiche Weise wie auf andere Grains zugegriffen werden.
Führen Sie die grains.items Funktion aus, um die Grains für ein Gerät mit Junos OS anzuzeigen, einschließlich der junos_facts Grains.
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 Körnungselement 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 auch 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ätefakten 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 also der Wert eines bereits zwischengespeicherten Fakts ändert, wird er im Salt-System nicht automatisch 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örnungen 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 mit dem Minion verknüpft sind. Sie können die Säulendaten, auf die ein Diener zugreifen kann, einschränken, indem Sie die Säule den entsprechenden Zielen in der oberen Säulendatei zuordnen.
Pillar-Daten können in einfachen YAML-Dateien definiert werden, können aber auch in einer Datenbank wie SQL gespeichert und aus 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-Proxy-Konfiguration 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 im Allgemeinen 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 Pillar-Datei 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
SaLt State (SLS)-Dateien definieren Datenstrukturen, die vom Salt-System für verschiedene Zwecke verwendet werden. Sie können beispielsweise verwendet werden, um Säulendaten oder den Zustand eines Systems zu definieren. Standardmäßig werden Salt-Statusdateien im YAML-Format geschrieben und verwenden die Dateierweiterung .sls . Unterstützung von Statusdateien mithilfe der Jinja-Syntax für zusätzliche Flexibilität.
Salt ermöglicht es Ihnen, deklarativ mit den Konfigurationen verwalteter Systeme zu arbeiten. Das Junos-Statusmodul (für Salt) salt.states.junosstellt Funktionen bereit, 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, sieht wie folgt aus, obwohl dies je nach Modul und Funktion variieren kann:
State name:
module.function:
- param1: value1
- param2: value2
In der folgenden Statusdatei wird beispielsweise die junos.install_config Funktion verwendet, um die Konfiguration in der angegebenen Vorlage auf die 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 einzelnen 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 Highstate einen oder mehrere Zustände auf einen Minion anzuwenden.
saltuser@salt-master:~$ cat /srv/salt/top.sls
base:
router1:
- junos_bgp_config
- junos_ospf_config
Wenn Sie einen Highstate auf einem bestimmten 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 Status-Salt-Modulen.
Datei nach oben
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, aber Sie können andere Minions in einer Entwicklungs- oder Produktionsumgebung platzieren. Eine Salt-Top-Datei ordnet ein Gerät oder eine Gruppe von Geräten den Zustandsdateien zu, die auf sie angewendet werden sollen, und den Säulendaten, auf die sie in der jeweiligen Umgebung zugreifen können. Die Top-Dateien haben standardmäßig den Namen top.sls und befinden sich am Anfang der Verzeichnishierarchie, die Salt-Statusdateien enthält.
Standardmäßig befindet sich die oberste Datei, die für Zustände verwendet wird, unter /srv/salt/top.sls. Die folgende Syntax wird verwendet, um die Zielgeräte den entsprechenden Statusdateien in der jeweiligen Umgebung zuzuordnen. Die Datei muss immer die base Umgebung definieren.
environment1:
target:
- state1
- state2
environment2:
target:
- state1
- state2
In der folgenden Datei werden z. B. die Statusdateien core.sls und common_config.sls auf alle Minions in der Basisumgebung angewendet, 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 der Statusdatei eine Junos-Proxy-Minion-ID zu, die die Pillar-Daten für das entsprechende Gerät mit Junos OS enthält, wie im Abschnitt "Pillars " beschrieben.
Ausführungs- und Zustandsmodule
Salt ist ein Konfigurationsmanagement- und Remote-Ausfü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, die es Ihnen ermöglichen, Aufgaben auf dem Minion auszuführen. 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 einen Minion verwalten.
Um z. B. die Konnektivität mit allen Minions zu testen, können Sie die Funktion des test Moduls ping ausführen und das Ziel angeben, um '*' alle Minions anzugeben.
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 mit Junos OS verwalten können. Ausführliche Informationen zur Verwendung der Junos-Ausführungs- und Statusmodule finden Sie unter Grundlegendes zu den Junos-Ausführungs- und Zustandssaltmodulen.
Junos Syslog-Engine, Salt-Ereignisbus und Salt-Reaktoren
Die Salt-Architektur basiert auf einem leistungsstarken Ereignisbus, der ZeroMQ als Standardmechanismus für den Nachrichten- und Ereignistransport für die Kommunikation zwischen dem Salt-Master und Minions verwendet. Komponenten kommunizieren durch das Senden von Nachrichten über den Bus, und externe Ereignisse können in den Bus eingespeist werden. Der Salzmeister und jeder Salzdiener haben ihren eigenen Ereignisbus.
Das Ereignissystem verwendet ein Publish-Subscribe-Modell (Publish/Subscribe). 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 einen Minion ausführen, veröffentlicht der Salt-Master ein Auftragsereignis, und der entsprechende Minion führt den Auftrag aus und löst ein Rückgabeereignis aus, das die Auftragsergebnisse enthält, auf dem Bus. Salt bietet Methoden zum Veröffentlichen externer Ereignisse auf dem Bus und zum Reagieren auf Ereignisse, wodurch Sie Salt verwenden können, um Ereignisse in Echtzeit zu überwachen und darauf zu reagieren.
Salt-Engines sind externe Systemprozesse, mit denen Sie Ereignisse im Salt-Ereignisbus exportieren oder importieren können. Die Salt-Installation umfasst die Junos-Syslog-Engine (für Salt), mit der an den Salt-Server gesendete Systemprotokollmeldungen (Syslog-Meldungen) von Junos OS überwacht und im Salt-Ereignisbus veröffentlicht werden können. Wenn diese Option aktiviert ist, überwacht die Junos Syslog-Engine den 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 auf dem 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-Reaktoren für die ereignisbasierte Statusverwaltung von Geräten verwenden, auf denen Junos OS ausgeführt wird. Mit Salt-Reaktoren können Sie Aktionen als Reaktion auf Ereignisse im Salt-Ereignisbus ausführen. 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 Salzreaktorsystem zu aktivieren, konfigurieren Sie die reactor Option in der Salzmasterkonfigurationsdatei und ordnen einer oder mehreren Reaktor-SLS-Dateien Ereignis-Tags zu. Die Reaktordateien definieren die Aktionen, die beim Eintreten dieses Ereignisses ausgeführt werden sollen.
Weitere Hinweise zur Junos-Syslog-Engine und zum Erstellen von Reaktoren für Junos OS-Ereignisse finden Sie unter: