Verwenden von Salt zur Konfiguration von Geräten mit Junos OS
Juniper Networks unterstützt die Verwendung von Salt zur Verwaltung von Geräten, auf denen Junos OS ausgeführt wird, und die Junos-Ausführungs- und Zustandsmodule (für Salt) definieren Funktionen, mit denen Sie die Junos OS-Konfiguration verwalten können. In diesem Thema wird erläutert, wie Sie Salt zum Generieren, Bereitstellen und Verwalten von Junos OS-Konfigurationen verwenden.
Übersicht über die Verwendung von Salt zur Bereitstellung von Junos OS-Konfigurationen
Mit den Junos-Ausführungs- und Zustandsmodulen (für Salt) können Sie mit Salt die Konfiguration eines Geräts 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
Commit für die Konfiguration
Zurücksetzen der Konfiguration
Konfigurieren Sie den Geräte-Hostnamen und übernehmen Sie die Änderung
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 auf der Salt Master-Befehlszeile auszuführen. Häufiger definieren Sie jedoch den Zustand, in dem sich das verwaltete Gerät befinden muss, und verwenden die Statusfunktionen, um die Konfiguration anzuwenden.
Junos-Ausführungsfunktion |
Junos State-Funktion |
Beschreibung |
---|---|---|
Commit der in die Zielkonfigurationsdatenbank geladenen Änderungen. |
||
Führen Sie einen |
||
Sperren, Ändern, Commit 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 festgelegte Konfiguration zurück und bestätigen Sie sie. |
||
Konfigurieren Sie den Hostnamen eines verwalteten Geräts, auf dem Junos OS ausgeführt wird, und übernehmen Sie die Änderung. |
||
Lassen Sie die exklusive Sperre für die Kandidatenkonfiguration frei. |
Der grundlegende Prozess für Konfigurationsänderungen besteht darin, die Konfigurationsdatenbank zu sperren, die Konfigurationsänderungen zu laden, die Konfiguration 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 macht die junos.install_config
Funktion Änderungen an der Kandidatenkonfigurationsdatenbank im configure exclusive
Modus 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 dann einen und commit
Vorgang auscommit check
.
Wir empfehlen, die Funktion zum Vornehmen von junos.install_config
Konfigurationsänderungen zu verwenden, da sie den gesamten Konfigurationsworkflow verwaltet. Die Funktion ermöglicht es Ihnen auch, die Konfigurationsunterschiede in einer Datei zu speichern und verschiedene Konfigurationsmodi zu verwenden. Sie können beispielsweise den Modus verwenden configure private
, um eine private Kopie der Kandidatenkonfiguration zu ändern, wie unter Angeben des Konfigurationsmodus beschrieben.
Beim Laden neuer Konfigurationsdaten mit der junos.load
oder junos.install_config
Funktion können Sie den Lastvorgang sowie die Quelle und das Format der Änderungen angeben.
Lastvorgang: Der Lastvorgang bestimmt, wie die Konfigurationsdaten in die Kandidatenkonfiguration geladen werden. Die Funktionen unterstützen viele der gleichen Lastvorgänge, die in der Junos OS CLI verfügbar sind, einschließlich Merge, Außerkraftsetzung, Ersetzen und Aktualisieren. Weitere Informationen finden Sie unter Angeben des Lastvorgangs.
Format: Sie können Geräte mit Junos OS mit einem der unterstützten Standardformate konfigurieren. Sie können Konfigurationsdaten oder Jinja2-Vorlagen als Text, Junos XML-Elemente, Junos OS-Befehle
set
oder JSON bereitstellen. Weitere Informationen finden Sie unter So geben Sie das Format der konfigurationsdaten an, die geladen werden sollen.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 So laden Sie Konfigurationsdaten mithilfe einer Jinja2-Vorlage.
Nach dem Ändern der Konfiguration müssen Sie die Konfiguration festlegen, um sie zur aktiven Konfiguration auf dem Gerät zu machen. Die junos.install_config
Änderungen an der Konfiguration werden automatisch vom , junos.rollback
, und junos.set_hostname
den Funktionen vorgenommen. Sie können die junos.commit
Funktion auch ausführen, um einen Commit-Vorgang auszuführen. Informationen zum Verhalten der verschiedenen Funktionen und deren unterstützten Commit-Optionen finden Sie unter So legen Sie die Konfiguration fest.
Zusätzlich zum Laden neuer Konfigurationsdaten können Sie die Funktion verwenden, um die junos.rollback
Konfiguration auf eine zuvor festgelegte Konfiguration zurück zu setzen. Die Funktion beschreibt die aktualisierte Konfiguration automatisch. Weitere Informationen finden Sie unter So setzen Sie die Konfiguration zurück.
So sperren und entsperren Sie die Konfigurationsdatenbank
Sie können die Kandidatenkonfiguration sperren, bevor Sie sie ändern, um zu verhindern, dass andere Benutzer oder Anwendungen sie aktualisieren, bis die Sperre freigegeben wird. Dies entspricht dem configure exclusive
Befehl in der CLI. Wir empfehlen, die Konfiguration zu sperren, bevor Sie Änderungen vornehmen, insbesondere auf Geräten, auf denen mehrere Benutzer zur Änderung der Konfiguration autorisiert sind, da ein Commit-Vorgang für alle Änderungen in der Kandidatenkonfiguration gilt, nicht nur für diejenigen, die vom Benutzer oder der Anwendung vorgenommen werden, die das Commit anfordert.
Die junos.install_config
Funktion ändert die Datenbank der Kandidatenkonfiguration im configure exclusive
Modus, der die Konfigurationsdatenbank automatisch sperrt, die Änderungen lädt und festschreibt und die Datenbank entsperrt. Wenn Sie die Load- und Commit-Vorgänge jedoch separat ausführen müssen, z. B. durch Verwendung der junos.load
Funktionen und junos.commit
Funktionen, können Sie die Datenbank explizit sperren und entsperren, indem Sie die junos.lock
Ausführungs- oder junos.unlock
Zustandsfunktionen verwenden.
Verwenden Sie die junos.lock
Funktion, um die Konfigurationsdatenbank vor dem Ändern explizit zu sperren. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.lock router1: ---------- message: Successfully locked the configuration. out: True
Verwenden junos.unlock
Sie die Funktion, um die Datenbank zu entsperren und nicht freigegebene Änderungen zu verwerfen. 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 ein anderer Benutzer bereits über eine exklusive Sperre verfügt, gibt die junos.lock
Funktion eine LockError
Nachricht aus, wie in den folgenden Beispielen dargestellt:
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
So legen Sie den Konfigurationsmodus fest
Die junos.install_config
Funktion ermöglicht es Ihnen, Änderungen in verschiedenen Konfigurationsmodi vorzunehmen. Standardmäßig ändert die Funktion die Datenbank der Kandidatenkonfiguration im configure exclusive
Modus. Der configure exclusive
Modus sperrt die globale Kandidatenkonfiguration (auch als freigegebene Konfigurationsdatenbank bezeichnet), so lange, wie die Funktion die angeforderten Änderungen an der Konfiguration vornehmen muss. Das Sperren der Datenbank verhindert, dass andere Benutzer Änderungen an der Datenbank ändern oder festlegen, bis die Sperre freigegeben wird.
Um einen anderen Modus anzugeben, legen Sie den mode
Parameter gleich dem gewünschten Modus fest. Zu den unterstützten Modi gehören batch
, dynamic
, , ephemeral
, exclusive
und private
. Informationen zu den verschiedenen Modi finden Sie im CLI-Benutzerhandbuch.
Der folgende Befehl nimmt beispielsweise Änderungen an der Konfiguration im Modus vor configure private
, 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
Ebenso können Sie das Argument in eine Salt-Zustandsdatei einschließen.
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 kurzlebige Datenbank ist eine alternative Konfigurationsdatenbank, die eine schnelle programmgesteuerte Schnittstelle für die Ausführung 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 zu verwenden
Die kurzlebige Konfigurationsdatenbank ist eine erweiterte Funktion, die bei falscher Verwendung erhebliche negative Auswirkungen auf den Betrieb des Geräts haben kann. Weitere Informationen finden Sie unter Understanding the Ephemeral Configuration Database.For more information, see Understanding the Ephemeral Configuration Database.
Um die Standardinstanz der kurzlebigen Konfigurationsdatenbank zu konfigurieren, legen Sie das mode
Argument gleich 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 gleich mit ephemeral
, und legen Sie das ephemeral_instance
Argument gleich dem Namen der Instanz fest.
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
So definieren Sie den Lastvorgang
Sie können die Funktionen und die junos.load
Funktionen verwenden, um Konfigurationsänderungen mit einem load merge
, load replace
, oder load override
load update
einem Vorgang zu junos.install_config
laden. Sie geben den gewünschten Lastvorgang an, indem Sie die entsprechenden Argumente für diese Funktion ein- oder weglassen. Wenn Sie keinen Lastvorgang angeben, ist load replace
der Standard . Tabelle 2 fasst die argumente zusammen, die für jede Art von Lastvorgang erforderlich sind.
Load-Betrieb |
Funktionsargument |
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, ersetzen Sie jedoch Anweisungen in der vorhandenen Konfiguration durch diejenigen, die das |
|
|
Vergleichen Sie die vollständige geladene Konfiguration mit der vorhandenen Konfiguration. Jedes andere Konfigurationselement in der geladenen Konfiguration ersetzt das entsprechende Element in der vorhandenen Konfiguration. Während des Commit-Vorgangs analysieren nur Systemprozesse, die von geänderten Konfigurationselementen betroffen sind, die neue Konfiguration. |
Der folgende Befehl ersetzt die gesamte Konfiguration auf dem Zielgerät durch die angegebene Konfiguration und committ sie. Der RPC-Timeout wird erhöht, um ausreichend Zeit zum Laden und Commit 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 Zustandsdatei ist:
Replace complete configuration: junos.install_config: - name: salt://configs/junos-complete-config.conf - overwrite: True - dev_timeout: 60
So geben Sie das Format der zu ladenen Konfigurationsdaten an
Mit junos.load
diesen junos.install_config
Funktionen können Sie Geräte mit Junos OS mit 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 der Konfigurationsdatei entweder die entsprechende Erweiterung hinzufügen oder das format
Argument explizit in den Funktionsaufruf einfügen. 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, überschreibt es das format, das von der Dateierweiterung angegeben wird.
Konfigurationsdatenformat |
Dateierweiterung |
format-Parameter |
---|---|---|
CLI-Konfigurationsanweisungen (Text) |
.Conf |
|
JavaScript Object Notation (JSON) |
.Json |
|
Junos OS-Befehle |
.Festgelegt |
|
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 laden Sie Konfigurationsdaten
Mit junos.load
diesen junos.install_config
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 Proxy-Minion-Server befinden. Die Funktionen müssen die salt:// -Notation verwenden, um einen Pfad im 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 enthalten, um das Format der Daten anzugeben.
Tabelle 4 beschreibt die Konfigurationsdatenquellen, die Sie verwenden können, und listet die Argumente für die Ausführungs- und Zustandsfunktion auf, die zum Angeben des Speicherorts der Datei erforderlich sind. Die Ausführungsfunktionen können den Pfad als Positionsargument angeben oder das Schlüsselwort verwenden path
.
Konfigurationsdatenquelle |
Beschreibung |
Lage |
Ausführungsfunktionsargument |
Zustandsfunktionsargument |
---|---|---|---|---|
Konfigurationsdatendatei |
Datei mit Konfigurationsdaten, die als ASCII-Text, Junos XML-Elemente, Junos OS-Befehle |
Salt Master – Verwendung salt:// Notation Proxy-Minion-Server – verwenden Sie einen absoluten Pfad |
|
|
Jinja2-Vorlagendatei |
Datei, die eine Jinja2-Vorlage enthält, die als ASCII-Text, Junos XML-Elemente, Junos OS-Befehle Fügen Sie den |
Salt Master – Verwendung salt:// Notation Proxy-Minion-Server – verwenden Sie einen absoluten Pfad |
|
|
Die folgende Datei enthält beispielsweise Junos OS-Befehle set
, die zwei Op-Skripte konfigurieren. 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 Ausführungsfunktion junos.install_config
, 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 Zustandsdatei ist:
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 Diff zwischen der Kandidatenkonfiguration und der angeforderten Konfiguration durch. Die Funktion wendet die Konfiguration nur an, wenn Änderungen vorgenommen werden. Wenn Sie dieselbe Konfiguration ein zweites Mal anwenden möchten, gibt die junos.install_config
Funktion eine Meldung zurück, dass die Konfiguration bereits angewendet wurde und nicht geladen und erneut committ wird, 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
So laden Sie Konfigurationsdaten mit einer Jinja2-Vorlage
Die junos.load
Ausführungs junos.install_config
- und Zustandsfunktionen 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 mit Jinja2-Vorlagen in einem der unterstützten Konfigurationsformate erstellen, das ASCII-Text, Junos XML-Elemente, Junos OS-Befehle set
und JSON umfasst. Die Funktionen verwenden die Vorlage Jinja2 und ein bereitgestelltes Variablenwörterbuch, um die Konfigurationsdaten zu rendern.
Jinja2-Vorlagen bieten eine leistungsstarke Methode zur Generierung von Konfigurationsdaten, insbesondere für ähnliche Konfigurationsstrophen. Anstatt beispielsweise die gleichen Konfigurationsanweisungen für jede Schnittstelle auf einem Gerät manuell hinzuzufügen, können Sie eine Vorlage erstellen, die über eine Liste von Schnittstellen verteilt wird und die erforderlichen Konfigurationsanweisungen für jedes Gerät erstellt. In Jinja werden Blöcke durch "{%
" und "%}
" begrenzt und Variablen werden in "" und "{{
}}
" umschlossen.
Zum Laden einer Jinja2-Vorlage müssen Sie die folgenden Parameter in den Oder Funktionsaufruf junos.load
junos.install_config
einschließen:
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
format
Argument so fest, dass das Format der Konfigurationsdaten angegeben wird, wenn die Vorlagendatei nicht eine der akzeptierten Dateierweiterungen verwendet, um das Format anzugeben. Informationen zum Festlegen des Formats finden Sie unter So geben Sie das Format der konfigurationsdaten an, die geladen werden sollen.Vorlagenvariablen: Die Vorlage kann auf interne Salt-Variablen verweisen, wie die in Pfeiler- oder Getreidedaten definierten. Alle Variablen, die nicht bereits im Salt-System definiert sind, müssen im
template_vars
Argument angegeben werden. Dertemplate_vars
Wert ist ein Wörterbuch der Schlüssel und Werte, die zum Rendern der Jinja2-Vorlage erforderlich sind.Hinweis:Wenn Ihre Vorlage nur interne Salt-Variablen wie Säulendaten, Getreidedaten und Funktionen enthält, muss die
junos.install_config
Funktion möglicherweise definierentemplate_vars: True
, um die Vorlage zu rendern.
Die folgende Beispielvorlage Jinja2 generiert Konfigurationsdaten, die MPLS auf der logischen Einheit 0 für jede Schnittstelle in einer bestimmten Liste aktivieren, und konfiguriert auch die Schnittstelle 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 Vorlage Jinja2 und die in template_vars
definierten Variablen, um die Konfigurationsdaten zu rendern, die dann auf dem Zielhost geladen und festgelegt 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 Zustandsdatei 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 Status anwenden, rendert Salt die Konfiguration und lädt und committ die Konfiguration auf dem Gerät.
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 festgelegt 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; } }
So übernehmen Sie die Konfiguration
Nach dem Ändern der Konfiguration müssen Sie die Konfiguration festlegen, um sie zur aktiven Konfiguration auf dem Gerät zu machen. Die junos.install_config
, , junos.rollback
und junos.set_hostname
Funktionen laden die angeforderten Konfigurationsänderungen und führen dann automatisch einen Commit-Check-and-Commit-Vorgang durch. Sie können die Einzelperson junos.commit_check
und junos.commit
die Funktionen 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, z. B. das Hinzufügen eines Commit-Kommentars oder die Synchronisierung der Konfiguration auf mehreren Routing-Engines. Einige dieser Optionen werden von den Funktionen für die Ausführungs- und Zustandsmodulfunktionen von Junos unterstützt. Tabelle 5 zeigt 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 Statusfunktion gültig.
Funktionsargument |
Beschreibung |
Funktionen, die das Argument unterstützen |
CLI-Befehlsäquivalent |
---|---|---|---|
|
Protokollieren Sie einen Kommentar für diesen Commit-Vorgang in der Systemprotokolldatei und im Commit-Verlauf des Geräts. |
|
|
|
Fordern Sie, dass ein Commit-Vorgang innerhalb einer bestimmten Zeit nach dem ersten Commit bestätigt wird. Andernfalls setzen Sie ein Rollback zur zuvor festgelegten Konfiguration ein. Legen Sie das Argument so fest, dass |
|
|
|
Geben Sie detaillierte Informationen über den Commit-Prozess zurück. |
|
|
|
Warten Sie auf den Abschluss des Vorgangs und verwenden Sie den angegebenen Wert als Timeout. |
|
– |
|
Synchronisieren und bestätigen Sie die Konfiguration auf beiden Routing-Engines, selbst wenn es offene Konfigurationssitzungen oder nicht zweckgebundene Konfigurationsänderungen auf der anderen Routing-Engine gibt. |
|
|
|
Synchronisierung und Commit der Konfiguration auf beiden Routing-Engines. |
|
|
Commit-Kommentar
Wenn Sie die Konfiguration festlegen, können Sie einen kurzen Kommentar einfügen, um den Zweck der vorgenommenen Änderungen zu beschreiben. Um einen Kommentar zu protokollieren, der die Änderungen beschreibt, fügen Sie das comment
Argument und eine Nachrichtenzeichenfolge ein. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.commit comment='Committed using Salt'
In einer Zustandsdatei gilt folgendes:
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 wird in der Systemprotokollnachricht für das Commit enthalten und im Commit-Verlauf 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 festlegen, können Sie eine explizite Bestätigung benötigen, damit der Commit dauerhaft wird. Wenn der Commit innerhalb der angegebenen Zeit nicht bestätigt wird, lädt das Gerät automatisch die zuvor festgelegte Konfiguration und committ (rollt zurück zu). Der bestätigte Commit-Vorgang ist nützlich, um zu überprüfen, ob eine Konfigurationsänderung korrekt funktioniert, und verhindert den Verwaltungszugriff auf das Gerät nicht. Wenn die Änderung den Zugriff verhindert oder andere Fehler verursacht, stellt das automatische Rollback zur vorherigen Konfiguration den Zugriff auf das Gerät wieder her, nachdem die Rollback-Frist abgelaufen ist.
Geben Sie das confirm=minutes
Argument ein, um zu verlangen, dass ein Commit-Vorgang innerhalb einer bestimmten Zeit nach dem ersten Commit bestätigt wird. Der zulässige Bereich beträgt 1 bis 65.535 Minuten. Sie können auch angeben, dass confirm=True
die Standardzeit von 10 Minuten verwendet wird.
Der folgende Befehl erfordert, dass der Commit innerhalb von 15 Minuten bestätigt wird:
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
Rufen Sie die Funktion oder junos.commit_check
die Funktion auf, um den junos.commit
Commit-Vorgang zu bestätigen.
saltuser@salt-master:~$ sudo salt 'router1' junos.commit comment='Confirming commit using Salt' router1: ---------- message: Commit Successful. out: True
Commit-Detail
Wenn Sie die junos.commit
Funktion zum Commit der Konfiguration verwenden, können Sie die Details des gesamten Commit-Vorgangs überprüfen, indem Sie das detail=True
Argument angeben. 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 zum Commit der Konfiguration verwenden, können Sie die Konfiguration auf beiden Routing-Engines in einem dualen Routing-Engine-System synchronisieren und festlegen, indem Sie das sync=True
Argument angeben. Zum Beispiel:
saltuser@salt-master:~$ sudo salt 'router1' junos.commit sync=True
Wenn Sie das sync=True
Argument einbeziehen, kopiert das Gerät die auf der lokalen Routing-Engine gespeicherte Kandidatenkonfiguration in die andere Routing-Engine, überprüft die syntaktische Korrektheit des Kandidaten und begeht es auf beiden Routing-Engines. Verwenden Sie das force_sync=True
Argument, um den Erfolg des commit synchronize
Vorgangs auch dann zu erzwingen, wenn offene Konfigurationssitzungen oder nicht zweckgebundene Konfigurationsänderungen auf der anderen Routing-Engine vorhanden sind. Dieses Argument bewirkt, dass das Gerät alle Konfigurationssitzungen auf der anderen Routing-Engine beendet, bevor die Konfiguration synchronisiert und konfiguriert wird.
Commit-Timeout
Die Standardzeit für ein RPC-Time out beträgt 30 Sekunden. Große Konfigurationsänderungen können diesen Wert überschreiten, was dazu führt, dass die Operation eine Zeitüberschreitung verursacht, bevor die Konfiguration hochgeladen und übertragen werden kann. Um Konfigurationsänderungen zu berücksichtigen, die möglicherweise eine Commit-Zeit erfordern, die länger als das Standard-Timeout-Intervall ist, fügen Sie das dev_timeout=seconds
Argument ein, und legen Sie das Timeout-Intervall auf einen entsprechenden 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
So setzen Sie die Konfiguration zurück
Geräte mit Junos OS speichern je nach Plattform eine Kopie der zuletzt vorgenommenen 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 Arbeitskonfiguration zurückkehren möchten. Das Rollback der Konfiguration ähnelt dem Prozess für 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 salt.modules.junos.rollback
der Ausführungsfunktion und der salt.states.junos.rollback
Statusfunktion können Sie die Konfiguration auf eine zuvor festgelegte Konfiguration auf einem Gerät mit Junos OS zurücksetzen. Führen Sie die Funktion aus, und setzen Sie das id
Argument auf die ID der gewünschten Rollback-Konfiguration, um die Konfiguration zurück zu setzen und sie zu bestätigen. Gültige ID-Werte sind 0 (Null) für die zuletzt festgelegte Konfiguration bis hin zu einem weniger als die Anzahl der gespeicherten vorherigen Konfigurationen (maximal 49). Wenn Sie das id
Schlüsselwort weglassen, ist es standardmäßig 0.
Mit dem folgenden Befehl wird die Konfiguration beispielsweise wieder auf die zuvor festgelegte Konfiguration zurückgedreht und festgeschrieben:
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ückzustellen und die Konfigurationsunterschiede in einer Datei für einen späteren Verweis zu protokollieren, fügen Sie das diffs_file
Argument ein, und legen Sie es auf den Pfad der Datei auf dem Proxy-Minion-Server fest, auf dem 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;