Verwenden von Salt zum Konfigurieren von Geräten mit Junos OS
Juniper Networks bietet Unterstützung für die Verwendung von Salt zur Verwaltung von Geräten, auf denen Junos OS ausgeführt wird, und die Junos-Ausführungs- und Statusmodule (für Salt) definieren Funktionen, mit denen Sie die Junos OS-Konfiguration verwalten können. In diesem Thema wird die Verwendung von Salt zum Generieren, Bereitstellen und Verwalten von Junos OS-Konfigurationen erläutert.
Überblick über die Verwendung von Salt zur Bereitstellung von Junos OS-Konfigurationen
Mit den Junos-Ausführungs- und Statusmodulen (für Salt) können Sie Salt verwenden, um die Konfiguration eines Geräts zu verwalten, auf dem Junos OS ausgeführt wird. Die Module definieren Funktionen zur Ausführung der folgenden Aufgaben:
Sperren und Entsperren der Konfigurationsdatenbank
Konfigurationsdaten laden
Bestätigen der Konfiguration
Zurücksetzen der Konfiguration
Konfigurieren Sie den Hostnamen des Geräts und führen Sie einen Commit für die Änderung durch
Tabelle 1 listet die Funktionen auf, mit denen Sie die Konfiguration verwalten können, und enthält eine kurze Beschreibung der einzelnen Funktionen. Sie können die Ausführungsfunktionen verwenden, um die Vorgänge in der Salt-Master-Befehlszeile auszuführen. In den meisten Fällen definieren Sie jedoch den Zustand, in dem sich das verwaltete Gerät befinden muss, und verwenden die Zustandsfunktionen, um die Konfiguration anzuwenden.
Junos-Ausführungsfunktion |
Junos State-Funktion |
Beschreibung |
|---|---|---|
Übernehmen Sie die in die Zielkonfigurationsdatenbank geladenen Änderungen. |
||
Führen Sie einen |
||
Sperren, Ändern, Ausführen und Entsperren der Zielkonfigurationsdatenbank. |
||
Laden Sie die Konfigurationsdaten in der angegebenen Datei in die Zielkonfigurationsdatenbank. |
||
Fordern Sie eine exklusive Sperre für die Kandidatenkonfiguration an. |
||
Setzen Sie die Konfiguration auf eine zuvor bestätigte Konfiguration zurück, und führen Sie einen Commit durch. |
||
Konfigurieren Sie den Hostnamen eines verwalteten Geräts, auf dem Junos OS ausgeführt wird, und übernehmen Sie die Änderung. |
||
Heben Sie die exklusive Sperre für die Kandidatenkonfiguration auf. |
Der grundlegende Prozess zum Vornehmen von Konfigurationsänderungen besteht darin, die Konfigurationsdatenbank zu sperren, die Konfigurationsänderungen zu laden, die Konfiguration zu bestätigen, um sie zu aktivieren, und dann die Konfigurationsdatenbank zu entsperren. Sie können die entsprechende Funktion verwenden, um jeden Vorgang einzeln auszuführen, oder Sie können die junos.install_config Funktion verwenden, um alle Vorgänge mit einem einzigen Funktionsaufruf auszuführen.
Standardmäßig nimmt die Funktion mithilfe von junos.install_config mode Änderungen an der Kandidatenkonfigurationsdatenbank configure exclusive vor, wodurch die Konfigurationsdatenbank automatisch gesperrt und entsperrt wird. Die Funktion vergleicht die geladene Konfiguration mit der aktuellen Konfiguration und wendet die neue Konfiguration nur an, wenn Änderungen vorgenommen werden. Wenn die Funktion die Konfiguration ändert, führt sie eine commit check und-Operation commit aus.
Wir empfehlen, die junos.install_config Funktion zu verwenden, um Konfigurationsänderungen vorzunehmen, da sie den gesamten Konfigurationsworkflow abwickelt. Die Funktion ermöglicht es Ihnen auch, die Konfigurationsunterschiede in einer Datei zu speichern und verschiedene Konfigurationsmodi zu verwenden. Sie können den Modus z. B. verwenden configure private , um eine private Kopie der Kandidatenkonfiguration zu ändern, wie unter Angeben des Konfigurationsmodus beschrieben.
Wenn Sie neue Konfigurationsdaten mit der junos.load Funktion oder junos.install_config laden, können Sie den Ladevorgang sowie die Quelle und das Format der Änderungen angeben.
Ladevorgang – Der Ladevorgang bestimmt, wie die Konfigurationsdaten in die Kandidatenkonfiguration geladen werden. Die Funktionen unterstützen viele der Ladevorgänge, die auch in der Junos OS CLI verfügbar sind, einschließlich Zusammenführen, Überschreiben, Ersetzen und Aktualisieren. Weitere Informationen finden Sie unter Angeben des Ladevorgangs.
Format: Sie können Geräte, auf denen Junos OS ausgeführt wird, in einem der unterstützten Standardformate konfigurieren. Sie können Konfigurationsdaten oder Jinja2-Vorlagen als Text, Junos-XML-Elemente, Junos OS-Befehle
setoder JSON bereitstellen. Weitere Informationen finden Sie unter Angeben des Formats der zu ladenden Konfigurationsdaten.Konfigurationsdatenquelle: Sie können Konfigurationsdaten aus einer Datei laden, die eine teilweise oder vollständige Konfiguration oder eine Jinja2-Vorlage enthält. Weitere Informationen finden Sie unter Laden von Konfigurationsdaten und Laden von Konfigurationsdaten mithilfe einer Jinja2-Vorlage.
Nachdem Sie die Konfiguration geändert haben, müssen Sie die Konfiguration bestätigen, um sie zur aktiven Konfiguration auf dem Gerät zu machen. Die junos.install_configFunktionen , junos.rollbackund junos.set_hostname übernehmen die Änderungen automatisch für die Konfiguration. Sie können die junos.commit Funktion auch ausführen, um einen Commit-Vorgang auszuführen. Informationen zum Verhalten der verschiedenen Funktionen und zu den unterstützten Commit-Optionen finden Sie unter Ausführen eines Commit-Commits für die Konfiguration.
Zusätzlich zum Laden neuer Konfigurationsdaten können Sie die junos.rollback Funktion verwenden, um die Konfiguration auf eine zuvor festgelegte Konfiguration zurückzusetzen. Die Funktion schreibt die aktualisierte Konfiguration automatisch fest. Weitere Informationen finden Sie unter Zurücksetzen der Konfiguration.
Sperren und Entsperren der Konfigurationsdatenbank
Sie können die Kandidatenkonfiguration sperren, bevor Sie sie ändern, um zu verhindern, dass andere Benutzer oder Anwendungen sie aktualisieren, bis die Sperre aufgehoben wird. Dies entspricht dem configure exclusive Befehl in der CLI. Es wird empfohlen, die Konfiguration vor dem Vornehmen von Änderungen zu sperren, insbesondere auf Geräten, auf denen mehrere Benutzer berechtigt sind, die Konfiguration zu ändern, da ein Commitvorgang für alle Änderungen in der Kandidatenkonfiguration gilt, nicht nur für diejenigen, die vom Benutzer oder der Anwendung vorgenommen werden, die den Commit anfordert.
Die junos.install_config Funktion nimmt mithilfe von mode Änderungen an der Kandidatenkonfigurationsdatenbank configure exclusive vor, wodurch die Konfigurationsdatenbank automatisch gesperrt, die Änderungen geladen und festgeschrieben und die Datenbank entsperrt wird. Wenn Sie jedoch die Lade- und Commitvorgänge separat ausführen müssen, z. B. mithilfe der junos.load junos.commit and-Funktionen, können Sie die Datenbank explizit sperren und entsperren, indem Sie die junos.lock Funktionen and junos.unlock execution oder state verwenden.
Um die Konfigurationsdatenbank explizit zu sperren, bevor Sie sie ändern, verwenden Sie die junos.lock Funktion. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.lock
router1:
----------
message:
Successfully locked the configuration.
out:
True
Um die Datenbank zu entsperren und nicht festgeschriebene Änderungen zu verwerfen, verwenden Sie die junos.unlock Funktion. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.unlock
router1:
----------
message:
Successfully unlocked the configuration.
out:
True
Wenn die Konfigurationsdatenbank geändert wurde oder wenn ein anderer Benutzer bereits über eine exklusive Sperre verfügt, gibt die junos.lock Funktion eine LockError Meldung zurück, wie in den folgenden Beispielen gezeigt:
saltuser@salt-master:~$ sudo salt 'router1' junos.lock
router1:
----------
message:
Could not gain lock due to : "LockError(severity: error, bad_element: None, message: configuration database modified)"
out:
False
saltuser@salt-master:~$ sudo salt 'router1' junos.lock
router1:
----------
message:
Could not gain lock due to : "LockError(severity: error, bad_element: None, message: configuration database locked by:
admin terminal p1 (pid 28508) on since 2019-08-12 12:46:52 PDT
exclusive [edit])"
out:
False
Festlegen des Konfigurationsmodus
Die junos.install_config Funktion ermöglicht es Ihnen, Änderungen in verschiedenen Konfigurationsmodi vorzunehmen. Standardmäßig nimmt die Funktion mithilfe von mode Änderungen an der Kandidatenkonfigurationsdatenbank vor configure exclusive . Der configure exclusive Modus sperrt die globale Kandidatenkonfiguration (auch als freigegebene Konfigurationsdatenbank bezeichnet), solange die Funktion die angeforderten Änderungen an der Konfiguration vornehmen muss. Durch das Sperren der Datenbank wird verhindert, dass andere Benutzer Änderungen an der Datenbank vornehmen oder einen Commit für die Datenbank ausführen, bis die Sperre aufgehoben wird.
Um einen anderen Modus anzugeben, setzen Sie den mode Parameter auf den gewünschten Modus. Zu den unterstützten Modi gehören batch, dynamic, exclusiveephemeral, und private. Informationen zu den verschiedenen Modi finden Sie im CLI-Benutzerhandbuch.
Mit dem folgenden Befehl werden z. B. mithilfe von mode Änderungen an der Konfiguration configure private vorgenommen, wodurch eine private Kopie der Kandidatenkonfiguration geöffnet wird:
saltuser@salt-master:~$ sudo salt 'router1' junos.install_config 'salt://configs/mpls-config.set' mode=private
router1:
----------
message:
Successfully loaded and committed!
out:
True
Auf ähnliche Weise können Sie das Argument in eine Salt-Statusdatei aufnehmen.
saltuser@salt-master:~$ cat /srv/salt/junos_mpls_config.sls
Install MPLS Config:
junos.install_config:
- name: salt://configs/mpls-config.set
- mode: private
Sie können die junos.install_config Funktion auch verwenden, um die kurzlebige Konfigurationsdatenbank auf Geräten zu aktualisieren, die diese Datenbank unterstützen. Die flüchtige Datenbank ist eine alternative Konfigurationsdatenbank, die eine schnelle programmatische Schnittstelle zum Ausführen von Konfigurationsaktualisierungen auf Geräten mit Junos OS bereitstellt. Sie benötigen Salt Version 3001 und Junos PyEZ Version 2.1.3 oder höher, um diese Funktion nutzen zu können
Bei der kurzlebigen Konfigurationsdatenbank handelt es sich um eine erweiterte Funktion, die bei falscher Verwendung schwerwiegende negative Auswirkungen auf den Betrieb des Geräts haben kann. Weitere Informationen finden Sie unter Grundlegendes zur flüchtigen Konfigurationsdatenbank.
Um die Standardinstanz der kurzlebigen Konfigurationsdatenbank zu konfigurieren, legen Sie das mode Argument auf ephemeral. Zum Beispiel:
saltuser@salt-master:~$ cat /srv/salt/junos_ephemeral_config.sls
Install MPLS config in default ephemeral instance:
junos.install_config:
- name: salt://configs/mpls-ephemeral-config.set
- mode: ephemeral
Um eine benutzerdefinierte Instanz der kurzlebigen Konfigurationsdatenbank zu konfigurieren, legen Sie das mode Argument auf ephemeralund das Argument auf den Namen der Instanz fest ephemeral_instance .
saltuser@salt-master:~$ cat /srv/salt/junos_ephemeral_instance_config.sls
Install MPLS config in ephemeral instance:
junos.install_config:
- name: salt://configs/mpls-ephemeral-instance-config.set
- mode: ephemeral
- ephemeral_instance: eph1
Angeben des Ladevorgangs
Sie können die junos.load junos.install_config und-Funktionen verwenden, um Konfigurationsänderungen mit einem load merge, load overrideload replace, oder load update Vorgang zu laden. Sie geben den gewünschten Ladevorgang an, indem Sie die entsprechenden Argumente für diese Funktion einschließen oder weglassen. Wenn Sie keinen Ladevorgang angeben, ist load replaceder Standardwert . Tabelle 2 fasst die Argumente zusammen, die für jeden Typ von Ladevorgang erforderlich sind.
Ladevorgang |
Argument der Funktion |
Beschreibung |
|---|---|---|
|
|
Führen Sie die geladene Konfiguration mit der vorhandenen Konfiguration zusammen. |
|
|
Ersetzen Sie die gesamte Konfiguration durch die geladene Konfiguration. |
|
– |
Führen Sie die geladene Konfiguration mit der vorhandenen Konfiguration zusammen, aber ersetzen Sie Anweisungen in der vorhandenen Konfiguration durch diejenigen, die das |
|
|
Vergleichen Sie die gesamte geladene Konfiguration mit der vorhandenen Konfiguration. Jedes Konfigurationselement, das sich in der geladenen Konfiguration unterscheidet, ersetzt das entsprechende Element in der vorhandenen Konfiguration. Während des Commit-Vorgangs wird die neue Konfiguration nur von Systemprozessen analysiert, die von geänderten Konfigurationselementen betroffen sind. |
Mit dem folgenden Befehl wird die gesamte Konfiguration auf dem Zielgerät durch die angegebene Konfiguration ersetzt und ein Commit ausgeführt. Das RPC-Timeout wird erhöht, um genügend Zeit zum Laden und Bestätigen der vollständigen Konfiguration zu bieten.
saltuser@salt-master:~$ sudo salt 'router1' junos.install_config overwrite=True 'salt://configs/junos-complete-config.conf' dev_timeout=60
Die entsprechende Statusdatei lautet:
Replace complete configuration:
junos.install_config:
- name: salt://configs/junos-complete-config.conf
- overwrite: True
- dev_timeout: 60
Festlegen des Formats der zu ladenden Konfigurationsdaten
junos.install_config Mit den junos.load und-Funktionen können Sie Geräte, auf denen Junos OS ausgeführt wird, in einem der unterstützten Standardformate konfigurieren. Sie können Konfigurationsdaten aus einer Datei laden, die eine teilweise oder vollständige Konfiguration oder eine Jinja2-Vorlage enthält. Die Daten können als Text, Junos XML-Elemente, Junos OS-Befehle set oder JSON bereitgestellt werden.
Sie müssen das Format der Konfigurationsdaten angeben, indem Sie entweder der Konfigurationsdatei die entsprechende Erweiterung hinzufügen oder das format Argument explizit in den Funktionsaufruf aufnehmen. Tabelle 3 fasst die unterstützten Formate für die Konfigurationsdaten und den entsprechenden Wert für die Dateierweiterung und format den Parameter zusammen. Wenn Sie das format Argument einschließen, wird das durch die Dateierweiterung angegebene Format überschrieben.
Konfigurationsdatenformat |
Dateiendung |
format-Parameter |
|---|---|---|
CLI-Konfigurationsanweisungen (Text) |
.Conf |
|
JavaScript-Objektnotation (JSON) |
.json |
|
|
.Garnitur |
|
Junos XML-Elemente |
.XML |
|
Geräte, auf denen Junos OS ausgeführt wird, unterstützen das Laden von Konfigurationsdaten im JSON-Format ab Junos OS Version 16.1R1.
So wird's gemacht: Laden von Konfigurationsdaten
junos.install_config Mit den junos.load und-Funktionen können Sie Konfigurationsdaten aus einer Datei laden, die eine teilweise oder vollständige Konfiguration oder eine Jinja2-Vorlage enthält. Die Datei kann sich auf dem Salt-Master oder dem Proxy-Minion-Server befinden. Die Funktionen müssen die salt:// Notation verwenden, um einen Pfad auf dem Salt-Master anzugeben, und sie müssen einen absoluten Pfad verwenden, um einen Pfad auf dem Proxy-Minion-Server anzugeben. Wenn die Datei keine der akzeptierten Dateierweiterungen verwendet, um das Format der Konfigurationsdaten anzugeben, muss der Funktionsaufruf auch das format Argument zum Angeben des Datenformats enthalten.
In Tabelle 4 werden die Konfigurationsdatenquellen beschrieben, die Sie verwenden können, und es werden die Ausführungs- und Zustandsfunktionsargumente aufgeführt, die zum Angeben des Speicherorts der Datei erforderlich sind. Die Ausführungsfunktionen können den Pfad als Positionsargument oder mithilfe des Schlüsselworts path angeben.
Konfigurationsdatenquelle |
Beschreibung |
Ort |
Ausführungsfunktionsargument |
State-Funktionsargument |
|---|---|---|---|---|
Konfigurationsdatendatei |
Datei mit Konfigurationsdaten im ASCII-Format, Junos-XML-Elementen, Junos OS-Befehlen |
Salt-Master – salt:// Notation verwenden Proxy-Minion-Server: Verwenden Sie einen absoluten Pfad |
|
|
Jinja2-Vorlagendatei |
Datei mit einer Jinja2-Vorlage, die als ASCII-Text, Junos-XML-Elemente, Junos OS-Befehle Fügen Sie den |
Salt-Master – verwenden Sie salt:// Notation Proxy-Minion-Server: Verwenden Sie einen absoluten Pfad |
|
|
Die folgende Datei enthält beispielsweise Junos OS-Befehle set , mit denen zwei Op-Skripte konfiguriert werden. Die Dateierweiterung gibt das Format für die Konfigurationsdaten an.
saltuser@salt-master:~$ cat /srv/salt/configs/op-scripts.set set system scripts op file bgp.slax set system scripts op file ospf.slax
Der folgende Salt-Befehl verwendet die junos.install_config Ausführungsfunktion, um die Konfiguration auf dem Zielgerät zu laden und zu bestätigen. Der Pfad wird als Positionsargument angegeben.
saltuser@salt-master:~$ sudo salt 'router1' junos.install_config 'salt://configs/op-scripts.set'
router1:
----------
message:
Successfully loaded and committed!
out:
True
Die entsprechende Statusdatei lautet:
saltuser@salt-master:~$ cat /srv/salt/junos-config-op-scripts.sls
Installing op scripts:
junos.install_config:
- name: salt://configs/op-scripts.set
- comment: committed using Salt
saltuser@salt-master:~$ sudo salt 'router1' state.apply junos-config-op-scripts
router1:
----------
ID: Installing op scripts
Function: junos.install_config
Name: salt://configs/op-scripts.set
Result: True
Comment:
Started: 04:19:59.819155
Duration: 14853.384 ms
Changes:
----------
message:
Successfully loaded and committed!
out:
True
Summary for router1
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 14.853 s
Die junos.install_config Funktion führt automatisch einen Unterschied zwischen der Kandidatenkonfiguration und der angeforderten Konfiguration durch. Die Funktion wendet die Konfiguration nur an, wenn es Änderungen gibt. Wenn Sie versuchen, dieselbe Konfiguration ein zweites Mal anzuwenden, gibt die junos.install_config Funktion eine Meldung zurück, dass die Konfiguration bereits angewendet wurde, und lädt sie nicht erneut und führt keinen erneuten Commit aus, wie im folgenden Beispiel gezeigt:
saltuser@salt-master:~$ sudo salt 'router1' state.apply junos-config-op-scripts
router1:
----------
ID: Installing op scripts
Function: junos.install_config
Name: salt://configs/op-scripts.set
Result: True
Comment:
Started: 06:01:52.365353
Duration: 778.843 ms
Changes:
----------
message:
Configuration already applied!
out:
True
Summary for router1
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 778.843 ms
Laden von Konfigurationsdaten mithilfe einer Jinja2-Vorlage
junos.install_config Die junos.load Ausführungs- und Statusfunktionen unterstützen die Verwendung von Jinja2-Vorlagen für Junos OS-Konfigurationsdaten. Jinja ist eine Vorlagen-Engine für Python, mit der Sie Dokumente aus vordefinierten Vorlagen generieren können. Die Vorlagen, bei denen es sich um Textdateien in der gewünschten Sprache handelt, bieten Flexibilität durch die Verwendung von Ausdrücken und Variablen. Sie können Junos OS-Konfigurationsdaten mithilfe von Jinja2-Vorlagen in einem der unterstützten Konfigurationsformate erstellen, z. B. ASCII-Text, Junos-XML-Elemente, Junos OS-Befehle set und JSON. Die Funktionen verwenden die Jinja2-Vorlage und ein bereitgestelltes Variablenwörterbuch, um die Konfigurationsdaten zu rendern.
Jinja2-Vorlagen bieten eine leistungsstarke Methode zum Generieren von Konfigurationsdaten, insbesondere für ähnliche Konfigurationsbereichen. Anstatt z. B. manuell dieselben Konfigurationsanweisungen für jede Schnittstelle auf einem Gerät hinzuzufügen, können Sie eine Vorlage erstellen, die eine Liste von Schnittstellen durchläuft und die erforderlichen Konfigurationsanweisungen für jede Schnittstelle erstellt. In Jinja werden Blöcke durch '{%' und '%}' getrennt und Variablen werden in '{{' und '}}' eingeschlossen.
Um eine Jinja2-Vorlage zu laden, müssen Sie die folgenden Parameter in den junos.load Funktionsaufruf or junos.install_config einfügen:
Vorlagenpfad: Geben Sie den Pfad zu einer Vorlagendatei auf dem Salt-Master- oder Proxy-Minion-Server an, wie unter Laden von Konfigurationsdaten beschrieben.
Vorlagenformat: Legen Sie das
formatArgument fest, um das Format der Konfigurationsdaten anzugeben, wenn die Vorlagendatei keine der akzeptierten Dateierweiterungen verwendet, um das Format anzugeben. Informationen zum Angeben des Formats finden Sie unter Angeben des Formats der zu ladenden Konfigurationsdaten.Vorlagenvariablen: Die Vorlage kann auf interne Salt-Variablen verweisen, wie sie in Säulen- oder Korndaten definiert sind. Alle Variablen, die noch nicht im Salt-System definiert sind, müssen im
template_varsArgument angegeben werden. Dertemplate_varsWert ist ein Wörterbuch von Schlüsseln und Werten, die zum Rendern der Jinja2-Vorlage erforderlich sind.Anmerkung:Wenn Ihre Vorlage nur interne Salt-Variablen wie Säulendaten, Korndaten und Funktionen enthält, muss die
junos.install_configFunktion möglicherweise definierttemplate_vars: Truewerden, um die Vorlage zu rendern.
Die folgende Jinja2-Beispielvorlage generiert Konfigurationsdaten, die MPLS auf der logischen Einheit 0 für jede Schnittstelle in einer bestimmten Liste aktivieren, und konfiguriert die Schnittstelle auch unter den Protokollen MPLS und RSVP.
saltuser@salt-master:~$ cat /srv/salt/configs/junos-config-mpls-jinja2-template.conf
interfaces {
{% for item in template_vars['interfaces'] %}
{{ item }} {
description "{{ template_vars['description'] }}";
unit 0 {
family {{ template_vars['family'] }};
}
} {% endfor %}
}
protocols {
mpls {
{% for item in template_vars['interfaces'] %}
interface {{ item }};
{% endfor %}
}
rsvp {
{% for item in template_vars['interfaces'] %}
interface {{ item }};
{% endfor %}
}
}
Der folgende Befehl verwendet die Jinja2-Vorlage und die darin template_vars definierten Variablen, um die Konfigurationsdaten zu rendern, die dann auf dem Zielhost geladen und festgeschrieben werden:
saltuser@salt-master:~$ sudo salt 'router1' junos.install_config 'salt://configs/junos-config-mpls-jinja2-template.conf' template_vars='{ "interfaces" : ["ge-1/0/1", "ge-1/0/2", "ge-1/0/3"], "description" : "MPLS interface", "family" : "mpls" }'
router1:
----------
message:
Successfully loaded and committed!
out:
True
Die folgende Statusdatei lädt dieselbe Konfiguration. Die Konfigurationsunterschiede werden in der diffs_file Datei auf dem Proxy-Minion-Server gespeichert.
saltuser@salt-master:~$ cat /srv/salt/junos_install_config_mpls.sls
Install Junos OS config:
junos.install_config:
- name: 'salt://configs/junos-config-mpls-jinja2-template.conf'
- comment: committed using Salt
- diffs_file: /home/saltuser/junos-config-mpls-diff
- template_vars:
interfaces: ['ge-1/0/1', 'ge-1/0/2', 'ge-1/0/3']
description: MPLS interface
family: mpls
Wenn Sie den Zustand anwenden, rendert Salt die Konfiguration und lädt die Konfiguration und führt einen Commit für die Konfiguration auf dem Gerät aus.
saltuser@salt-master:~$ sudo salt 'router1' state.apply junos_install_config_mpls
router1:
----------
ID: Install Junos OS config
Function: junos.install_config
Name: salt://configs/junos-config-mpls-jinja2-template.conf
Result: True
Comment:
Started: 05:28:51.575045
Duration: 23675.957 ms
Changes:
----------
message:
Successfully loaded and committed!
out:
True
Summary for router1
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 23.676 s
Die Funktion generiert die folgenden Konfigurationsdaten, die in die Kandidatenkonfiguration auf dem Gerät geladen und übergeben werden:
interfaces {
ge-1/0/1 {
description "MPLS interface";
unit 0 {
family mpls;
}
}
ge-1/0/2 {
description "MPLS interface";
unit 0 {
family mpls;
}
}
ge-1/0/3 {
description "MPLS interface";
unit 0 {
family mpls;
}
}
}
protocols {
mpls {
interface ge-1/0/1.0;
interface ge-1/0/2.0;
interface ge-1/0/3.0;
}
rsvp {
interface ge-1/0/1.0;
interface ge-1/0/2.0;
interface ge-1/0/3.0;
}
}
Bestätigen der Konfiguration
Nachdem Sie die Konfiguration geändert haben, müssen Sie die Konfiguration bestätigen, um sie zur aktiven Konfiguration auf dem Gerät zu machen. Die junos.install_configFunktionen , junos.rollbackund junos.set_hostname und laden die angeforderten Konfigurationsänderungen und führen dann automatisch eine Commit-Prüfung und einen Commit-Vorgang aus. Sie können die Funktionen junos.commit_check individual und junos.commit auch verwenden, um eine Commit-Prüfung und einen Commit-Vorgang durchzuführen, z. B. nachdem Sie die junos.load Funktion zum Aktualisieren der Konfiguration verwendet haben.
Die Junos OS CLI bietet Optionen für den Commit-Vorgang, wie z. B. das Hinzufügen eines Commit-Kommentars oder die Synchronisierung der Konfiguration auf mehreren Routing-Engines. Einige dieser Optionen werden von den Junos-Ausführungs- und Statusmodulfunktionen unterstützt. Tabelle 5 gibt einen Überblick über die verfügbaren Commit-Optionen und die Funktionen, die sie unterstützen. Unterstützte Argumente sind sowohl für die Ausführungsfunktion als auch für die Zustandsfunktion gültig.
Argument der Funktion |
Beschreibung |
Funktionen, die das Argument unterstützen |
Entspricht dem CLI-Befehl |
|---|---|---|---|
|
Protokollieren Sie einen Kommentar für diesen Commit-Vorgang in der Systemprotokolldatei und im Commit-Verlauf des Geräts. |
|
|
|
Erfordern, dass ein Commitvorgang innerhalb eines bestimmten Zeitraums nach dem ersten Commit bestätigt wird. Andernfalls führen Sie ein Rollback auf die zuvor festgelegte Konfiguration durch. Legen Sie das Argument auf |
|
|
|
Gibt detaillierte Informationen über den Commit-Prozess zurück. |
|
|
|
Warten Sie auf den Abschluss des Vorgangs, indem Sie den angegebenen Wert als Timeout verwenden. |
|
– |
|
Synchronisieren Sie die Konfiguration, und bestätigen Sie sie auf beiden Routing-Modulen, auch wenn offene Konfigurationssitzungen oder nicht festgeschriebene Konfigurationsänderungen auf der anderen Routing-Engine vorhanden sind. |
|
|
|
Synchronisieren Sie die Konfiguration, und bestätigen Sie sie auf beiden Routing-Engines. |
|
|
Kommentar bestätigen
Wenn Sie die Konfiguration bestätigen, können Sie einen kurzen Kommentar einfügen, um den Zweck der bestätigten Änderungen zu beschreiben. Um einen Kommentar zu protokollieren, der die Änderungen beschreibt, fügen Sie das comment Argument und eine Meldungszeichenfolge ein. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.commit comment='Committed using Salt'
Ähnlich verhält es sich in einer Statusdatei:
saltuser@salt-master:~$ cat /srv/salt/junos_install_mx_config.sls
Install Junos OS config:
junos.install_config:
- name: salt://configs/mx-config-common.set
- comment: Committed using Salt
Der Commit-Kommentar ist in der Systemprotokollmeldung für den Commit enthalten und wird in der Commit-Historie protokolliert.
saltuser@salt-master:~$ sudo salt 'router1' junos.cli 'show system commit'
router1:
----------
message:
0 2019-08-05 15:08:01 PDT by saltuser via netconf
Committed using Salt
...
out:
True
Commit bestätigt
Wenn Sie die Kandidatenkonfiguration bestätigen, können Sie eine explizite Bestätigung anfordern, damit die Bestätigung dauerhaft wird. Wenn der Commit nicht innerhalb des angegebenen Zeitraums bestätigt wird, wird das Gerät automatisch geladen und führt einen Rollback zur zuvor bestätigten Konfiguration durch. Der bestätigte Commit-Vorgang ist nützlich, um zu überprüfen, ob eine Konfigurationsänderung ordnungsgemäß funktioniert, und verhindert nicht den Verwaltungszugriff auf das Gerät. Wenn die Änderung den Zugriff verhindert oder andere Fehler verursacht, stellt das automatische Rollback auf die vorherige Konfiguration den Zugriff auf das Gerät nach Ablauf der Rollback-Frist wieder her.
Wenn Sie festlegen möchten, dass ein Commitvorgang innerhalb eines bestimmten Zeitraums nach dem ersten Commit bestätigt wird, fügen Sie das confirm=minutes Argument ein. Der zulässige Bereich liegt zwischen 1 und 65.535 Minuten. Sie können auch angeben confirm=True , dass die Standardzeit von 10 Minuten verwendet werden soll.
Für den folgenden Befehl muss der Commit innerhalb von 15 Minuten bestätigt werden:
saltuser@salt-master:~$ sudo salt 'router1' junos.install_config 'salt://configs/mx-config-common.set' confirm=15
router1:
----------
message:
Successfully loaded and committed!
out:
True
Um den Commitvorgang zu bestätigen, rufen Sie entweder die junos.commit or-Funktion junos.commit_check auf.
saltuser@salt-master:~$ sudo salt 'router1' junos.commit comment='Confirming commit using Salt'
router1:
----------
message:
Commit Successful.
out:
True
Commit-Details
Wenn Sie die junos.commit Funktion verwenden, um einen Commit für die Konfiguration auszuführen, können Sie die Details des gesamten Commitvorgangs überprüfen, indem Sie das detail=True Argument einschließen. Wenn Sie dieses Argument einschließen, gibt die Funktion detaillierte Informationen über den Commit-Prozess zurück.
saltuser@salt-master:~$ sudo salt 'router1' junos.commit detail=True
router1:
----------
message:
----------
routing-engine:
----------
name:
re0
progress-indicator:
|_
----------
message:
Obtaining lock for commit
timestamp:
2019-08-14 11:17:50 PDT
|_
----------
message:
updating commit revision
timestamp:
2019-08-14 11:17:50 PDT
...
Commit-Synchronisierung
Wenn Sie die junos.commit Funktion verwenden, um die Konfiguration zu bestätigen, können Sie die Konfiguration auf beiden Routing-Modulen in einem System mit dualer Routing-Engine synchronisieren und bestätigen, indem Sie das sync=True Argument einschließen. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.commit sync=True
Wenn Sie das sync=True Argument einschließen, kopiert das Gerät die Kandidatenkonfiguration, die in der lokalen Routing-Engine gespeichert ist, in die andere Routing-Engine, überprüft die syntaktische Korrektheit des Kandidaten und überträgt sie auf beiden Routing-Engines. Verwenden Sie das force_sync=True Argument, um zu erzwingen, dass der commit synchronize Vorgang auch dann erfolgreich ausgeführt wird, wenn offene Konfigurationssitzungen oder nicht festgeschriebene Konfigurationsänderungen auf der anderen Routing-Engine vorhanden sind. Das Einfügen dieses Arguments bewirkt, dass das Gerät alle Konfigurationssitzungen auf der anderen Routing-Engine beendet, bevor die Synchronisierung und der Commit für die Konfiguration ausgeführt wird.
Commit-Timeout
Die Standardzeit für ein RPC beträgt 30 Sekunden. Große Konfigurationsänderungen können diesen Wert überschreiten, was zu einer Zeitüberschreitung des Vorgangs führt, bevor die Konfiguration hochgeladen und übergeben werden kann. Um Konfigurationsänderungen zu berücksichtigen, die möglicherweise eine Commitzeit erfordern, die länger als das Standardtimeoutintervall ist, schließen Sie das dev_timeout=seconds Argument ein, und legen Sie das Timeoutintervall auf einen geeigneten Wert fest. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.install_config 'salt://configs/junos_mx_config.conf' dev_timeout=60
saltuser@salt-master:~$ cat /srv/salt/junos_install_mx_config.sls
Install Config:
junos.install_config:
- name: salt://configs/junos_mx_config.conf
- dev_timeout: 60
Zurücksetzen der Konfiguration
Geräte, auf denen Junos OS ausgeführt wird, speichern je nach Plattform eine Kopie der zuletzt bestätigten Konfiguration und bis zu 49 vorherige Konfigurationen. Sie können zu jeder der gespeicherten Konfigurationen zurückkehren. Dies ist nützlich, wenn Konfigurationsänderungen zu unerwünschten Ergebnissen führen und Sie zu einer bekannten funktionierenden Konfiguration zurückkehren möchten. Das Zurücksetzen der Konfiguration ähnelt dem Prozess zum Vornehmen von Konfigurationsänderungen auf dem Gerät, aber anstatt Konfigurationsdaten zu laden, führen Sie ein Rollback durch, bei dem die gesamte Kandidatenkonfiguration durch eine zuvor festgelegte Konfiguration ersetzt wird.
Mit der salt.modules.junos.rollback Ausführungsfunktion und der salt.states.junos.rollback Statusfunktion können Sie die Konfiguration auf einem Gerät, auf dem Junos OS ausgeführt wird, auf eine zuvor festgelegte Konfiguration zurücksetzen. Um die Konfiguration zurückzusetzen und einen Commit auszuführen, führen Sie die Funktion aus, und legen Sie das id Argument auf die ID der gewünschten Rollbackkonfiguration fest. Gültige ID-Werte sind 0 (Null) für die zuletzt festgeschriebene Konfiguration bis eins weniger als die Anzahl der gespeicherten vorherigen Konfigurationen (maximal 49). Wenn Sie das Schlüsselwort weglassen, wird es id standardmäßig auf 0 gesetzt.
Mit dem folgenden Befehl wird die Konfiguration z. B. auf die zuvor festgeschriebene Konfiguration zurückgesetzt und ein Commit ausgeführt:
saltuser@salt-master:~$ sudo salt 'router1' junos.rollback id=1 comment='Rolling back configuration using Salt'
router1:
----------
message:
Rollback successful
out:
True
Um die Konfiguration zurückzusetzen und die Konfigurationsunterschiede in einer Datei für spätere Referenzen zu protokollieren, fügen Sie das diffs_file Argument ein, und legen Sie es auf den Pfad der Datei auf dem Proxyminionserver fest, in den die Unterschiede geschrieben werden.
saltuser@salt-master:~$ sudo salt 'router1' junos.rollback id=1 comment='Rolling back configuration using Salt' diffs_file='/home/saltuser/router1-rollback-diff'
router1:
----------
message:
Rollback successful
out:
True
Die Unterschiede werden in der angegebenen Datei auf dem Proxy-Minion-Server gespeichert.
saltuser@minion:~$ cat /home/saltuser/router1-rollback-diff [edit system scripts op] - file bgp-neighbors.slax;