Verwenden von Ansible zum Konfigurieren von Junos-Geräten
Verwenden Sie die Ansible-Module von Juniper Networks, um die Konfiguration auf Junos-Geräten zu verwalten.
Juniper Networks stellt ein Ansible-Modul bereit, mit dem Sie Junos-Geräte konfigurieren können. Tabelle 1 gibt einen Überblick über das verfügbare Modul. Das Benutzerkonto, das zum Vornehmen von Konfigurationsänderungen verwendet wird, muss über Berechtigungen zum Ändern der relevanten Teile der Konfiguration auf jedem Gerät verfügen.
| Inhaltsgruppe |
Modulname |
|---|---|
|
|
In den folgenden Abschnitten wird erläutert, wie Sie das Modul verwenden, um die Konfiguration auf Junos-Geräten zu ändern und zu bestätigen.
Modulübersicht
Mit dem juniper.device.config Modul können Sie die folgenden Vorgänge auf Junos-Geräten ausführen:
-
Konfigurationsdaten laden
-
Bestätigen der Konfiguration
-
Zurücksetzen der Konfiguration
-
Laden der Wiederherstellungskonfiguration
Um die Konfiguration zu ändern, muss die Argumentliste des Moduls entweder den load Parameter zum Laden neuer Konfigurationsdaten oder den Parameter zum Zurücksetzen auf die Wiederherstellungskonfiguration oder eine rollback zuvor festgeschriebene Konfiguration enthalten. Der grundlegende Prozess zum Vornehmen von Konfigurationsänderungen besteht darin, die Konfiguration zu sperren, die Konfigurationsänderungen zu laden, die Konfiguration zu bestätigen, um sie zu aktivieren, und dann die Konfiguration zu entsperren.
Standardmäßig nimmt das Modul mithilfe von config mode Änderungen an der Kandidatenkonfigurationsdatenbank configure exclusive vor, wodurch die globale Kandidatenkonfiguration automatisch gesperrt und entsperrt wird. Sie können auch einen anderen Konfigurationsmodus angeben. Sie können z. B. Änderungen an einer privaten Kopie der Kandidatenkonfiguration oder an der kurzlebigen Konfigurationsdatenbank vornehmen. Weitere Informationen zum Angeben des Konfigurationsmodus finden Sie unter Angeben des Konfigurationsmodus.
Beim Laden neuer Konfigurationsdaten können Sie neben dem Konfigurationsmodus auch den Ladevorgang sowie die Quelle und das Format der Änderungen angeben.
-
Ladevorgang – Der Ladevorgang bestimmt, wie die Konfigurationsdaten in die ausgewählte Konfigurationsdatenbank geladen werden. Die Funktion unterstützt viele der Ladevorgänge, die auch in der Junos OS CLI verfügbar sind. Weitere Informationen finden Sie unter Angeben der Ladeaktion.
-
Format: Sie können Junos-Geräte 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. Informationen zum Angeben des Formats der Konfigurationsdaten finden Sie unter Angeben des Formats der zu ladenden Konfigurationsdaten. -
Konfigurationsdatenquelle: Sie können Konfigurationsdaten aus einer Liste von Zeichenfolgen, einer Datei auf dem lokalen Ansible-Kontrollknoten, einer Jinja2-Vorlage oder einer URL, die vom Client-Gerät aus erreichbar ist, laden, indem Sie den
linesParameter ,srctemplateoderurleinschließen. Weitere Informationen zum Angeben der Quelle der Konfigurationsdaten finden Sie in den folgenden Abschnitten:
Das config Modul ermöglicht es Ihnen auch, die Wiederherstellungskonfiguration zu laden und zu bestätigen oder die Konfiguration auf eine zuvor bestätigte Konfiguration zurückzusetzen. Um die Wiederherstellungskonfiguration oder eine zuvor festgeschriebene Konfiguration zu laden, müssen Sie das rollback Argument module einschließen. Weitere Informationen finden Sie in den folgenden Abschnitten:
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. Standardmäßig überträgt das config Modul die Änderungen an die Konfiguration. Informationen zum Ändern dieses Verhaltens oder zum Bereitstellen zusätzlicher Commit-Optionen finden Sie unter Ausführen eines Commit-Commits für die Konfiguration.
Wenn das config Modul die load Argumente or rollback zum Ändern der Konfiguration enthält, gibt das Modul standardmäßig automatisch die Konfigurationsänderungen im Diff - oder Patch-Format in der Antwort des Moduls zurück. Die Differenzen werden in den diff diff_lines Variablen und zurückgegeben. Um zu verhindern, dass das Modul die Differenzen berechnet und zurückgibt, legen Sie das diff Modulargument auf falsefest.
Festlegen des Konfigurationsmodus
Sie können den Konfigurationsmodus angeben, der beim Ändern der Gerätekonfiguration verwendet werden soll. Um den Konfigurationsmodus in Ihrer Aufgabe anzugeben, fügen Sie den Parameter des config Moduls config_mode ein. Zu den unterstützten Konfigurationsmodi gehören:
-
batch -
dynamic -
ephemeral -
exclusive -
private
Standardmäßig nimmt das Modul mithilfe configure exclusive von juniper.device.config mode Änderungen an der Kandidatenkonfigurationsdatenbank vor. Der exklusive Konfigurationsmodus sperrt die globale Kandidatenkonfiguration (auch als freigegebene Konfigurationsdatenbank bezeichnet), solange das Modul 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.
In den folgenden Beispielen wird gezeigt, wie eine private Kopie der Kandidatenkonfiguration und die kurzlebige Datenbank konfiguriert werden.
Beispiel: config_mode: "private"
Im folgenden Playbook wird der Konfigurationsmodus verwendet private , um eine private Kopie der Kandidatenkonfiguration zu ändern:
---
- name: "Configure Device"
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: "Configure op script"
juniper.device.config:
config_mode: "private"
load: "set"
lines:
- "set system scripts op file bgp.slax"
register: response
- name: "Print the config changes"
ansible.builtin.debug:
var: response.diff_lines
user@ansible-cn:~/ansible$ ansible-playbook configure-script.yaml
PLAY [Configure Device] *******************************************************
TASK [Configure op script] ****************************************************
changed: [dc1a.example.net]
TASK [Print the config changes] ***********************************************
ok: [dc1a.example.net] => {
"response.diff_lines": [
"",
"[edit system scripts op]",
"+ file bgp.slax;"
]
}
PLAY RECAP ********************************************************************
dc1a.example.net : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Konfigurieren der flüchtigen Datenbank
Sie können das juniper.device.config Modul verwenden, um die flüchtige Konfigurationsdatenbank auf Geräten zu aktualisieren, die diese Datenbank unterstützen. Bei der flüchtigen Datenbank handelt es sich um eine alternative Konfigurationsdatenbank, die eine schnelle programmatische Schnittstelle zum Ausführen von Konfigurationsaktualisierungen auf Junos-Geräten bereitstellt.
Um die Standardinstanz der kurzlebigen Konfigurationsdatenbank zu öffnen und zu konfigurieren, schließen Sie das config_mode: "ephemeral" Argument ein. Zum Beispiel:
---
- name: "Configure ephemeral database"
hosts: dc1a
connection: local
gather_facts: no
tasks:
- name: "Configure the default ephemeral database"
juniper.device.config:
config_mode: "ephemeral"
load: "set"
lines:
- "set protocols mpls label-switched-path to-hastings to 192.0.2.1"
Um eine vorhandene benutzerdefinierte Instanz der kurzlebigen Konfigurationsdatenbank zu öffnen und zu konfigurieren, schließen Sie das config_mode: "ephemeral" Argument ein, und legen Sie das ephemeral_instance Argument auf den Namen der Instanz fest.
tasks:
- name: "Configure a user-defined ephemeral instance"
juniper.device.config:
config_mode: "ephemeral"
ephemeral_instance: "eph1"
load: "set"
lines:
- "set protocols mpls label-switched-path to-hastings to 192.0.2.2"
Angeben der Ladeaktion
Das juniper.device.config Modul unterstützt das Laden von Konfigurationsänderungen mit vielen der Ladevorgänge, die auch in der Junos OS CLI unterstützt werden. Sie geben den Ladevorgang an, indem Sie den load Parameter in die Argumentliste des Moduls aufnehmen und auf den Wert des entsprechenden Ladevorgangs festlegen. Tabelle 2 fasst die Parametereinstellungen zusammen, die für jeden Typ von Ladevorgang erforderlich sind.
| Ladevorgang |
load-Argument |
Beschreibung |
|---|---|---|
|
|
|
Führen Sie die geladene Konfiguration mit der vorhandenen Konfiguration zusammen. |
|
|
|
Ersetzen Sie die gesamte Konfiguration durch die geladene Konfiguration. |
|
|
|
Laden Sie Konfigurationsdaten aus einer Patch-Datei. |
|
|
|
Führen Sie die geladene Konfiguration mit der vorhandenen Konfiguration zusammen, aber ersetzen Sie Anweisungen in der vorhandenen Konfiguration durch diejenigen, die das |
|
|
|
Laden Sie Konfigurationsdaten, die im |
|
|
|
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. |
Festlegen des Formats der zu ladenden Konfigurationsdaten
Das juniper.device.config Modul ermöglicht es Ihnen, Junos-Geräte in einem der unterstützten Standardformate zu konfigurieren. Sie können Konfigurationsdaten als Zeichenfolgen oder Dateien bereitstellen. Dateien können entweder Konfigurationsdaten oder Jinja2-Vorlagen enthalten. Wenn Sie Konfigurationsdaten in einer Zeichenfolge, einer Datei oder einer Jinja2-Vorlage bereitstellen, werden Text, Junos-XML-Elemente, Junos OS-Befehle set und JSON unterstützt.
Das config Modul versucht, das Format der Konfigurationsdaten, die Sie als Zeichenfolgen innerhalb des lines Arguments angeben, automatisch zu erkennen. Sie können jedoch das Format für Zeichenfolgen explizit angeben, indem Sie das format Argument einschließen. Wenn Sie Konfigurationsdaten in einer Datei oder Jinja2-Vorlage bereitstellen, müssen Sie das Format der Daten angeben, indem Sie der Datei entweder die entsprechende Erweiterung hinzufügen oder das format Argument einschließen.
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 sowohl das Format für die automatische Erkennung von Zeichenfolgen als auch das Format, das durch eine Dateierweiterung angegeben wird.
| Konfigurationsdatenformat |
Dateiendung |
format-Parameter |
|---|---|---|
| CLI-Konfigurationsanweisungen (Text) |
.Conf |
" |
| JavaScript-Objektnotation (JSON) |
.json |
" |
|
|
.Garnitur |
" |
| Junos XML-Elemente |
.XML |
" |
Wenn Sie das load Argument des Moduls auf 'override' oder 'update'setzen, können Sie das Junos OS-Befehlsformat set nicht verwenden.
Laden von Konfigurationsdaten als Zeichenfolgen
Das juniper.device.config Modul ermöglicht es Ihnen, Konfigurationsdaten aus einer Liste von Zeichenfolgen zu laden. Um Konfigurationsdaten als Zeichenfolgen zu laden, fügen Sie das entsprechende load Argument und das lines Argument ein. Das lines Argument akzeptiert eine Liste von Zeichenfolgen, die die zu ladenden Konfigurationsdaten enthalten.
Das Modul versucht, das Format der lines Konfigurationsdaten automatisch zu erkennen. Sie können das Format jedoch explizit angeben, indem Sie das format Argument einschließen. Informationen zum Angeben des Formats finden Sie unter Angeben des Formats der zu ladenden Konfigurationsdaten. Wenn Sie das format Argument einschließen, wird das automatisch erkannte Format überschrieben.
Im folgenden Playbook werden zwei Op-Skripts konfiguriert und ausgeführt. In diesem Fall hat das load Argument den Wert 'set', da die Konfigurationsdaten in lines das Junos OS-Anweisungsformat set verwenden.
---
- name: "Load and commit configuration"
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: "Load configuration data using strings and commit"
juniper.device.config:
load: "set"
lines:
- "set system scripts op file bgp.slax"
- "set system scripts op file bgp-neighbor.slax"
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
Im folgenden Playbook werden die gleichen Anweisungen mithilfe von lines with-Konfigurationsdaten im Textformat konfiguriert. In diesem Fall wird verwendet. load: "merge"
---
- name: "Load and commit configuration"
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: "Load configuration data using strings and commit"
juniper.device.config:
load: "merge"
lines:
- |
system {
scripts {
op {
file bgp.slax;
file bgp-neighbor.slax;
}
}
}
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
Laden von Konfigurationsdaten aus einer lokalen oder Remote-Datei
Das juniper.device.config Modul ermöglicht es Ihnen, Konfigurationsdaten aus einer Datei zu laden. Die Datei kann sich an einem der folgenden Speicherorte befinden:
-
Ansible-Steuerungsknoten
-
Client-Gerät
-
URL, die vom Client-Gerät aus erreichbar ist
Wenn Sie Konfigurationsdaten aus einer Datei laden, müssen Sie den Speicherort der Datei und das Format der Konfigurationsdaten in der Datei angeben. Zu den unterstützten Konfigurationsdatenformaten gehören Text, Junos XML-Elemente, Junos OS-Befehle set und JSON. Informationen zum Laden von Dateien, die Jinja2-Vorlagen enthalten, finden Sie unter Laden von Konfigurationsdaten mithilfe einer Jinja2-Vorlage.
Sie können das Format der Konfigurationsdaten angeben, indem Sie den format Parameter entweder explizit in die Argumentliste des Moduls aufnehmen oder der Konfigurationsdatendatei die entsprechende Erweiterung hinzufügen. Wenn Sie den format Parameter angeben, wird das durch die Dateierweiterung angegebene Format überschrieben. Informationen zum Angeben des Formats finden Sie unter Angeben des Formats der zu ladenden Konfigurationsdaten. Wenn die Konfigurationsdaten das Junos XML-Format verwenden, müssen Sie die Daten in das Tag der obersten Ebene <configuration> einschließen.
Sie müssen keine Konfigurationsdaten, die als ASCII-Text, Junos OS-Befehle set oder JSON formatiert <configuration-text>sind, in , oder Tags wie erforderlich einschließen, <configuration-set>wenn <configuration-json> Sie das Gerät direkt in einer NETCONF-Sitzung konfigurieren.
In Tabelle 4 sind die Modulparameter aufgeführt, die Sie einschließen können, um den Speicherort der Datei anzugeben.
| Modulparameter |
Beschreibung |
|---|---|
|
|
Absoluter oder relativer Pfad zu einer Datei auf dem Ansible-Steuerknoten. Das Standardverzeichnis ist das Playbook-Verzeichnis. |
|
|
Absoluter oder relativer Pfad zu einer Datei auf dem Clientgerät, einem FTP-Speicherort oder einer HTTP-URL. Das Standardverzeichnis auf dem Clientgerät ist das aktuelle Arbeitsverzeichnis, das standardmäßig das Home-Verzeichnis des Benutzers ist. |
Um Konfigurationsdaten aus einer lokalen Datei auf dem Ansible-Steuerungsknoten zu laden, legen Sie das src Argument auf den absoluten oder relativen Pfad der Datei fest, die die Konfigurationsdaten enthält. Zum Beispiel:
---
- name: "Load and commit configuration"
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: "Load configuration from a local file and commit"
juniper.device.config:
load: "merge"
src: "build_conf/{{ inventory_hostname }}/junos.conf"
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
Um Konfigurationsdaten aus einer Datei auf dem Junos-Gerät oder von einer FTP- oder HTTP-URL zu laden, verwenden Sie den url Parameter und geben Sie den Pfad der Datei an, die die zu ladenden Konfigurationsdaten enthält. Zum Beispiel:
---
- name: "Load and commit configuration"
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: "Load configuration from a remote file and commit"
juniper.device.config:
load: "merge"
url: "/var/tmp/junos.conf"
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
Der Wert für url kann ein absoluter oder relativer lokaler Dateipfad, ein FTP-Speicherort oder eine HTTP-URL sein.
-
Der Dateipfad für eine lokale Datei auf dem Zielgerät hat eine der folgenden Formen:
-
/path/filename—Datei auf einem eingehängten Dateisystem, entweder auf der lokalen Flash-Festplatte oder auf der Festplatte.
-
ein:filename oder a:path/filename—Datei auf dem lokalen Laufwerk. Der Standardpfad ist / (das Verzeichnis auf Stammebene). Der Wechseldatenträger kann im MS-DOS- oder UNIX-Format (UFS) vorliegen.
-
-
Der Dateipfad für eine Datei auf einem FTP-Server hat die folgende Form:
ftp://username:password@hostname/path/filename -
Der Dateipfad für eine Datei auf einem HTTP-Server hat die folgende Form:
http://username:password@hostname/path/filename
In jedem Fall ist der Standardwert für die Variable path das Home-Verzeichnis für den Benutzer. Um einen absoluten Pfad anzugeben, beginnt die Anwendung den Pfad mit den Zeichen %2F. Beispiel: ftp://username:password@hostname/%2Fpath/filename.
Laden von Konfigurationsdaten mithilfe einer Jinja2-Vorlage
Das juniper.device.config Modul ermöglicht es Ihnen, Konfigurationsdaten aus einer Jinja2-Vorlagendatei auf dem Ansible-Steuerungsknoten zu rendern und die Konfiguration auf ein Junos-Gerät zu laden und zu bestätigen. 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. Das Ansible-Modul verwendet die Jinja2-Vorlage und ein bereitgestelltes Variablenwörterbuch, um die Konfigurationsdaten zu rendern.
Um Konfigurationsdaten mithilfe einer Jinja2-Vorlage zu laden und zu bestätigen, fügen Sie die template Parameter und vars in die Argumentliste des Moduls ein.
-
template—Pfad der Jinja2-Vorlagendatei -
vars– Wörterbuch der Schlüssel und Werte, die zum Rendern der Jinja2-Vorlage erforderlich sind
Sie müssen den format Parameter auch dann angeben, wenn die Dateierweiterung der Vorlage das Format der Daten nicht angibt. Informationen zum Angeben des Formats finden Sie unter Angeben des Formats der zu ladenden Konfigurationsdaten.
Die Datei interfaces-mpls.j2 enthält beispielsweise die folgende Jinja2-Vorlage:
interfaces {
{% for item in interfaces %}
{{ item }} {
description "{{ description }}";
unit 0 {
family {{ family }};
}
} {% endfor %}
}
protocols {
mpls {
{% for item in interfaces %}
interface {{ item }};
{% endfor %}
}
rsvp {
{% for item in interfaces %}
interface {{ item }};
{% endfor %}
}
}
Um das juniper.device.config Modul zum Laden der Jinja2-Vorlage zu verwenden, setzen Sie das template Argument auf den Pfad der Vorlagendatei und definieren Sie die Variablen, die für die Vorlage im vars Wörterbuch erforderlich sind. Im folgenden Playbook werden die Jinja2-Vorlage und die darin vars definierten Variablen verwendet, um die Konfigurationsdaten zu rendern und sie auf den Zielhost zu laden und zu committen. Der format Parameter gibt das Format der Konfigurationsdaten in der Vorlagendatei an.
---
- name: "Load and commit configuration"
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: "Load a configuration from a Jinja2 template and commit"
juniper.device.config:
load: "merge"
template: "build_conf/templates/interfaces-mpls.j2"
format: "text"
vars:
interfaces: ["ge-1/0/1", "ge-1/0/2", "ge-1/0/3"]
description: "MPLS interface"
family: "mpls"
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
Das Modul 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;
interface ge-1/0/2;
interface ge-1/0/3;
}
rsvp {
interface ge-1/0/1;
interface ge-1/0/2;
interface ge-1/0/3;
}
}
So laden Sie die Rescue-Konfiguration
Mit einer Wiederherstellungskonfiguration können Sie eine bekannte funktionierende Konfiguration oder eine Konfiguration mit einem bekannten Status definieren, die Sie jederzeit wiederherstellen können. Sie verwenden die Wiederherstellungskonfiguration, wenn Sie zu einer bekannten Konfiguration zurückkehren müssen, oder als letzten Ausweg, wenn die Gerätekonfiguration und die Sicherungskonfigurationsdateien irreparabel beschädigt sind. Wenn Sie eine Wiederherstellungskonfiguration erstellen, speichert das Gerät die zuletzt bestätigte Konfiguration als Wiederherstellungskonfiguration.
Mit dem juniper.device.config Modul können Sie zu einer vorhandenen Wiederherstellungskonfiguration auf Junos-Geräten zurückkehren. Um die Wiederherstellungskonfiguration auf einem Gerät zu laden und zu bestätigen, schließen Sie das Argument des Moduls rollback: "rescue" ein. Zum Beispiel:
---
- name: "Revert to rescue configuration"
hosts: dc1a
connection: local
gather_facts: no
tasks:
- name: "Load and commit rescue configuration"
juniper.device.config:
rollback: "rescue"
register: response
- name: "Print response"
ansible.builtin.debug:
var: response
Zurücksetzen der Konfiguration
Junos-Geräte 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 dem juniper.device.config Modul können Sie auf Junos-Geräten auf eine zuvor festgelegte Konfiguration zurücksetzen. Um die Konfiguration zurückzusetzen und einen Commit auszuführen, fügen Sie das rollback Argument des Moduls ein, und geben Sie die ID der Rollback-Konfiguration an. 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).
Das folgende Playbook fordert zur Eingabe der Rollback-ID der wiederherzustellenden Konfiguration auf, führt ein Rollback der Konfiguration durch, führt einen Commit für die Konfiguration aus und gibt dann die Konfigurationsänderungen in der Standardausgabe aus:
---
- name: "Roll back the configuration"
hosts: dc1a
connection: local
gather_facts: no
vars_prompt:
- name: "ROLLBACK"
prompt: "Rollback ID of the configuration to restore"
private: no
tasks:
- name: "Roll back the configuration and commit"
juniper.device.config:
rollback: "{{ ROLLBACK }}"
register: response
- name: "Print the configuration changes"
ansible.builtin.debug:
var: response.diff_lines
user@ansible-cn:~/ansible$ ansible-playbook configuration-rollback.yaml
Rollback ID of the configuration to restore: 1
PLAY [Roll back the configuration] ********************************************
TASK [Roll back the configuration and commit] *********************************
changed: [dc1a.example.net]
TASK [Print the configuration changes] ***************************************
ok: [dc1a.example.net] => {
"response.diff_lines": [
"",
"[edit interfaces]",
"- ge-0/0/0 {",
"- unit 0 {",
"- family mpls;",
"- }",
"- }"
]
}
PLAY RECAP ********************************************************************
dc1a.example.net : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Bestätigen der Konfiguration
Wenn Sie das juniper.device.config Modul verwenden, um die Konfiguration mit dem load Argument oder rollback zu ändern, führt das Modul standardmäßig automatisch eine Commit-Prüfung durch und führt einen Commit für die Änderungen durch. Um zu verhindern, dass das Modul eine Commit-Prüfung durchführt oder die Änderungen festschreibt, legen Sie das check Argument or commit auf falsefest.
Sie können den Commit-Vorgang auch mit vielen der Optionen anpassen, die auch in der Junos OS CLI verfügbar sind. In Tabelle 5 sind die Modulargumente aufgeführt, mit denen Sie verschiedene Commit-Optionen angeben können.
| Modul-Argument |
Beschreibung |
Standardwert für |
|---|---|---|
|
|
Führen Sie eine Commit-Prüfung durch, oder bestätigen Sie einen zuvor bestätigten Commit-Vorgang. |
|
|
|
Warten Sie die angegebene Anzahl von Sekunden zwischen der Commit-Prüfung und dem Commit-Vorgang. |
– |
|
|
Protokollieren Sie einen Kommentar für diesen Commit-Vorgang in der Systemprotokolldatei und im Commit-Verlauf des Geräts. |
– |
|
|
Bestätigen Sie die Konfigurationsänderungen, oder bestätigen Sie einen zuvor bestätigten Commit-Vorgang. |
|
|
|
Übernehmen Sie die Konfigurationsänderungen, auch wenn es keine Unterschiede zwischen der Kandidatenkonfiguration und der bestätigten Konfiguration gibt. |
|
|
|
Synchronisieren Sie die Konfiguration, und bestätigen Sie sie auf allen Routing-Modulen, auch wenn offene Konfigurationssitzungen oder nicht festgeschriebene Konfigurationsänderungen auf der anderen Routing-Engine vorhanden sind. |
|
|
|
Synchronisieren und bestätigen Sie die Konfiguration auf allen Routing-Engines. |
|
|
|
Erfordern, dass ein Commitvorgang innerhalb eines bestimmten Zeitraums nach dem ersten Commit bestätigt wird. Wenn der Commit nicht innerhalb der angegebenen Zeit bestätigt wird, führen Sie ein Rollback auf die zuvor bestätigte Konfiguration durch. Entweder die |
– |
|
|
Warten Sie auf den Abschluss des Vorgangs, indem Sie den angegebenen Wert als Timeout verwenden. |
30 Sekunden |
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, schließen Sie das comment: "comment string" Argument in die Meldungszeichenfolge ein.
Commit-Prüfung
Standardmäßig führt das config Modul sowohl eine Commit-Prüfung als auch eine Commit-Operation aus. Das check_commit_wait Argument definiert die Anzahl der Sekunden, die zwischen der Commit-Prüfung und dem Commit-Vorgang gewartet werden soll. Schließen Sie dieses Argument ein, wenn Sie dem Gerät ausreichend Zeit einräumen müssen, um den Commit-Überprüfungsvorgang abzuschließen und die Konfigurationssperre aufzuheben, bevor Sie den Commit-Vorgang initiieren. Wenn Sie das check_commit_wait Argument weglassen, kann es bestimmte Umstände geben, unter denen ein Gerät den Commit-Vorgang initiiert, bevor der Commit-Check-Vorgang seine Sperre für die Konfiguration aufhebt, was zu einem fehlgeschlagenen CommitError Commit-Vorgang führt.
Commit für leere Änderungen
Wenn es keine Unterschiede zwischen der Kandidatenkonfiguration und der festgeschriebenen Konfiguration gibt, führt das Modul standardmäßig keinen Commit für die Änderungen aus. Um einen Commitvorgang zu erzwingen, auch wenn keine Unterschiede vorhanden sind, schließen Sie das commit_empty_changes: true Argument ein.
Commit-Synchronisierung
Wenn das Gerät über zwei Routing-Module verfügt, können Sie die Konfiguration auf beiden Routing-Modulen synchronisieren und bestätigen, indem Sie das commit_sync: true Argument einschließen. Verwenden Sie das commit_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. Wenn Sie die commit_force_sync: true Option einschließen, beendet das Gerät alle Konfigurationssitzungen auf der anderen Routing-Engine, bevor es synchronisiert und die Konfiguration festschreibt.
Bestätigen
Wenn Sie festlegen möchten, dass ein Commitvorgang innerhalb eines bestimmten Zeitraums nach dem ersten Commit bestätigt wird, fügen Sie das confirmed: minutes Argument ein. Wenn der Commit nicht innerhalb des angegebenen Zeitlimits bestätigt wird, wird für die Konfiguration automatisch ein Rollback auf die zuvor festgelegte Konfiguration ausgeführt. Der zulässige Bereich liegt zwischen 1 und 65.535 Minuten. 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, ermöglicht das automatische Rollback auf die vorherige Konfiguration den Zugriff auf das Gerät nach Ablauf der Rollback-Frist. Um den Commit-Vorgang zu bestätigen, rufen Sie das config Modul mit dem check: true Argument or commit: true auf.
Im folgenden Playbook ändert die erste Aufgabe die Konfiguration, wartet 10 Sekunden zwischen der Commitüberprüfung und dem Commitvorgang und erfordert, dass der Commitvorgang innerhalb von 5 Minuten bestätigt wird. Außerdem wird ein Kommentar für den Commit protokolliert. Die zweite Aufgabe gibt einen commit check Vorgang aus, um den Commit zu bestätigen. In einem realen Szenario führen Sie möglicherweise Validierungsaufgaben nach dem ersten Commit aus und führen die Commitbestätigung nur aus, wenn die Aufgaben bestimmte Validierungskriterien erfüllen.
---
- name: "Load configuration and confirm within 5 minutes"
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: "Load configuration. Wait 10 seconds between check and commit. Confirm within 5 min."
juniper.device.config:
load: "merge"
format: "text"
src: "build_conf/{{ inventory_hostname }}/junos.conf"
check_commit_wait: 10
confirmed: 5
comment: "updated using Ansible"
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
- name: "Confirm the commit with a commit check"
juniper.device.config:
check: true
diff: false
commit: false
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
So ignorieren Sie Warnungen beim Konfigurieren von Geräten
Mit dem juniper.device.config Modul können Sie die Konfiguration auf Junos-Geräten ändern und bestätigen. In einigen Fällen kann die RPC-Antwort Elemente mit dem Schweregrad Warnung oder höher enthalten <rpc-error> , die dazu führen, dass das Modul eine RpcError Ausnahme auslöst. Eine RpcError Ausnahme kann dazu führen, dass der Lade- oder Commitvorgang fehlschlägt.
In bestimmten Fällen kann es notwendig oder wünschenswert sein, die Ausnahmen zu unterdrücken, die RpcError als Reaktion auf Warnungen für Lade- und Commitvorgänge ausgelöst werden. Sie können das config Modul anweisen, Ausnahmen zu unterdrücken RpcError , die für Warnungen ausgelöst werden, indem Sie den ignore_warning Parameter in die Argumentliste des Moduls aufnehmen. Das ignore_warning Argument nimmt einen booleschen Wert, eine Zeichenfolge oder eine Liste von Zeichenfolgen an.
Um das Modul anzuweisen, alle Warnungen für Lade- und Commitvorgänge, die vom Modul ausgeführt werden, zu ignorieren, schließen Sie das ignore_warning: true Argument ein. Im folgenden Beispiel werden alle Warnungen für Lade- und Commitvorgänge ignoriert.
---
- name: Configure Device
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Configure op script
juniper.device.config:
config_mode: "private"
load: "set"
lines:
- "set system scripts op file bgp.slax"
ignore_warning: true
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Wenn Sie alle Elemente einschließen ignore_warning: true und alle <rpc-error> Elemente den Schweregrad Warnung aufweisen, ignoriert die Anwendung alle Warnungen und löst keine Ausnahme aus RpcError . Alle <rpc-error> Elemente mit höheren Schweregraden lösen jedoch weiterhin Ausnahmen aus.
Um das Modul anzuweisen, bestimmte Warnungen zu ignorieren, legen Sie das ignore_warning Argument auf eine Zeichenfolge oder eine Liste von Zeichenfolgen fest, die die zu ignorierenden Warnungen enthalten. Im folgenden Beispiel werden zwei spezifische Warnungen ignoriert:
---
- name: Configure Device
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Configure Junos device and ignore warnings
juniper.device.config:
config_mode: "private"
load: "merge"
src: "build_conf/{{ inventory_hostname }}/junos.conf"
ignore_warning:
- "Advertisement-interval is less than four times"
- "Chassis configuration for network services has been changed."
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Das Modul unterdrückt RpcError Ausnahmen, wenn alle <rpc-error> Elemente den Schweregrad Warnung aufweisen und jede Warnung in der Antwort mit einer oder mehreren der angegebenen Zeichenfolgen übereinstimmt.
Beispiel: Verwenden von Ansible zum Konfigurieren von Junos-Geräten
Mit dem juniper.device.config Modul können Sie die Konfiguration auf Junos-Geräten verwalten. In diesem Beispiel wird das config Modul verwendet, um Konfigurationsänderungen auf einem Junos-Gerät über NETCONF über SSH vorzunehmen.
- Anforderungen
- Überblick
- Konfiguration
- Ausführen des Playbooks
- Verifizierung
- Beheben von Playbookfehlern
Anforderungen
In diesem Beispiel werden die folgenden Hardware- und Softwarekomponenten verwendet:
-
Configuration Management Server mit Ansible 2.17 oder höher und auf dem die
juniper.deviceSammlung installiert ist -
Junos-Gerät mit aktiviertem NETCONF und einem Benutzerkonto mit entsprechenden Berechtigungen
-
Öffentliches/privates SSH-Schlüsselpaar, das für den entsprechenden Benutzer auf dem Ansible-Controller und dem Junos-Gerät konfiguriert ist
-
Vorhandene Ansible-Bestandsdatei mit definierten erforderlichen Hosts
Überblick
In diesem Beispiel wird ein Ansible-Playbook dargestellt, das das juniper.device.config Modul verwendet, um ein neues Op-Skript in der Konfiguration der Junos-Zielgeräte zu aktivieren. Die Konfigurationsdatendatei junos-config.conf enthält die relevanten Konfigurationsdaten im Textformat.
Das Playbook enthält die Check NETCONF connectivity Aufgabe, die das ansible.builtin.wait_for Ansible-Modul verwendet, um zu versuchen, eine NETCONF-Sitzung mit dem Zielgerät über den NETCONF-Standardport (830) einzurichten. Wenn der Steuerungsknoten während der Ausführung des Playbooks keine NETCONF-Sitzung mit einem Zielgerät einrichten kann, überspringt er die verbleibenden Aufgaben in der Wiedergabe für dieses Gerät.
Das Playbook verwendet das juniper.device.file_copy Modul, um das neue OP-Skript vom Ansible-Steuerungsknoten auf das Junos-Gerät zu kopieren. Die Modulargumente geben das Verzeichnis und den Dateinamen des Skripts auf dem lokalen Gerät und das Zielverzeichnis auf dem Remotegerät an.
Die Aufgabe zur Konfiguration des Geräts führt das juniper.device.config Modul aus, sofern die NETCONF-Prüfung erfolgreich war. Das load: "merge" Argument lädt die neuen Konfigurationsdaten mithilfe eines load merge Vorgangs in die Kandidatenkonfiguration. Standardmäßig überträgt das config Modul Konfigurationsdaten auf einem Gerät für load und rollback Operationen. Zu den Modulargumenten gehört das Argument, das comment einen Commit-Kommentar in der Systemprotokolldatei und im Commit-Verlauf des Geräts aufzeichnet.
Konfiguration
Erstellen der Konfigurationsdatendatei
Schritt-für-Schritt-Anleitung
So erstellen Sie die Konfigurationsdatendatei, die vom Modul verwendet wird:
Erstellen Sie eine neue Datei mit der entsprechenden Erweiterung, die auf dem Format der Konfigurationsdaten basiert, in diesem Beispiel Text.
Fügen Sie die gewünschten Konfigurationsänderungen in die Datei ein.
user@ansible-cn:~/ansible$ cat build_conf/dc1a.example.net/junos-config.conf system { scripts { op { file bgp.slax; } } }
Erstellen des Ansible-Playbooks
Schritt-für-Schritt-Anleitung
So erstellen Sie ein Playbook, das das config Modul verwendet, um Konfigurationsänderungen auf einem Junos-Gerät vorzunehmen:
Fügen Sie den Playbook-Textbaustein hinzu, der die Module lokal ausführt.
--- - name: Load and commit configuration data on a Junos device hosts: dc1 connection: local gather_facts: no
(Optional) Erstellen Sie eine Aufgabe, um die NETCONF-Konnektivität zu überprüfen.
tasks: - name: Check NETCONF connectivity ansible.builtin.wait_for: host: "{{ inventory_hostname }}" port: 830 timeout: 5Erstellen Sie eine Aufgabe, um das neue Op-Skript auf das Gerät zu kopieren.
- name: Copy the op script to the device juniper.device.file_copy: action: put file: bgp.slax local_dir: scripts remote_dir: /var/db/scripts/opErstellen Sie die Aufgabe, um die Konfiguration auf das Gerät zu laden und zu bestätigen.
- name: Merge configuration data from a file and commit juniper.device.config: load: "merge" src: "build_conf/{{ inventory_hostname }}/junos-config.conf" comment: "Configuring op script with Ansible" register: response(Optional) Erstellen Sie eine Aufgabe zum Drucken der Antwort, die die Konfigurationsänderungen im Diff-Format enthält.
- name: Print the response ansible.builtin.debug: var: response
Befund
Überprüfen Sie auf dem Ansible-Steuerungsknoten das fertige Playbook. Wenn das Playbook den beabsichtigten Code nicht anzeigt, wiederholen Sie die Anweisungen in diesem Beispiel, um das Playbook zu korrigieren.
---
- name: Load and commit configuration data on a Junos device
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Check NETCONF connectivity
ansible.builtin.wait_for:
host: "{{ inventory_hostname }}"
port: 830
timeout: 5
- name: Copy the op script to the device
juniper.device.file_copy:
action: put
file: bgp.slax
local_dir: scripts
remote_dir: /var/db/scripts/op
- name: Merge configuration data from a file and commit
juniper.device.config:
load: "merge"
src: "build_conf/{{ inventory_hostname }}/junos-config.conf"
comment: "Configuring op script with Ansible"
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Ausführen des Playbooks
So führen Sie das Playbook aus:
-
Geben Sie den
ansible-playbookBefehl auf dem Steuerungsknoten ein, und geben Sie den Playbookpfad und alle gewünschten Optionen an.user@ansible-cn:~/ansible$ ansible-playbook ansible-pb-junos-config.yaml PLAY [Load and commit configuration data on a Junos device] *************** TASK [Check NETCONF connectivity] ***************************************** ok: [dc1a.example.net] TASK [Copy the op script to the device] *********************************** changed: [dc1a.example.net] TASK [Merge configuration data from a file and commit] ******************** changed: [dc1a.example.net] TASK [Print the response] ************************************************* ok: [dc1a.example.net] => { "response": { "changed": true, "diff": { "prepared": "\n[edit system scripts op]\n+ file bgp.slax;\n" }, "diff_lines": [ "", "[edit system scripts op]", "+ file bgp.slax;" ], "failed": false, "file": "build_conf/dc1a.example.net/junos-config.conf", "msg": "Configuration has been: opened, loaded, checked, diffed, committed, closed." } } PLAY RECAP **************************************************************** dc1a.example.net : ok=4 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Verifizierung
Überprüfen der Konfiguration
Zweck
Vergewissern Sie sich, dass die Konfiguration auf dem Junos-Gerät korrekt aktualisiert wurde.
Aktion
Überprüfen Sie die Ausgabe des Ansible-Playbooks, um festzustellen, ob die Konfigurationsaufgabe erfolgreich war oder fehlgeschlagen ist. Sie können sich auch beim Junos-Gerät anmelden und die Konfiguration, den Commit-Verlauf und die Protokolldateien anzeigen, um die Konfiguration zu überprüfen und zu bestätigen, z. B.:
user@dc1a> show configuration system scripts
op {
file bgp.slax;
}
user@dc1a> show system commit
0 2020-12-17 15:33:50 PST by user via netconf
Configuring op script with Ansible
user@dc1a> show log messages Dec 17 15:33:39 dc1a mgd[33444]: UI_COMMIT: User 'user' requested 'commit' operation (comment: Configuring op script with Ansible) Dec 17 15:33:57 dc1a mgd[33444]: UI_COMMIT_COMPLETED: commit complete
Beheben von Playbookfehlern
- Beheben von Timeout-Fehlern
- Beheben von Konfigurationssperrfehlern
- Fehlerbehebung bei Konfigurationsänderungsfehlern
Beheben von Timeout-Fehlern
Problem
Das Playbook generiert eine TimeoutExpiredError Fehlermeldung und kann die Gerätekonfiguration nicht aktualisieren.
ncclient.operations.errors.TimeoutExpiredError: ncclient timed out while waiting for an rpc reply
Die Standardzeit für eine Zeitüberschreitung bei einem NETCONF-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.
Lösung
Um Konfigurationsänderungen zu berücksichtigen, die möglicherweise eine Commitzeit erfordern, die länger als das standardmäßige RPC-Timeoutintervall ist, legen Sie das timeout Argument des Moduls auf einen geeigneten Wert fest, und führen Sie das Playbook erneut aus.
Beheben von Konfigurationssperrfehlern
Problem
Das Playbook generiert eine LockError Fehlermeldung, die angibt, dass die Konfiguration nicht gesperrt werden kann. Zum Beispiel:
FAILED! => {"changed": false, "msg": "Unable to open the configuration in exclusive mode: LockError(severity: error, bad_element: None, message: configuration database modified)"}
oder
FAILED! => {"changed": false, "msg": "Unable to open the configuration in exclusive mode: LockError(severity: error, bad_element: lock-configuration, message: permission denied)"}
Ein Fehler bei der Konfigurationssperre kann aus den folgenden Gründen auftreten:
-
Ein anderer Benutzer hat eine exklusive Sperre für die Konfiguration.
-
Ein anderer Benutzer hat Änderungen an der Konfigurationsdatenbank vorgenommen, die Änderungen jedoch noch nicht übernommen.
-
Der Benutzer, der das Ansible-Modul ausführt, hat keine Berechtigungen zum Konfigurieren des Geräts.
Lösung
Die LockError Meldungszeichenfolge gibt in der Regel die Grundursache des Problems an. Wenn ein anderer Benutzer über eine exklusive Sperre für die Konfiguration verfügt oder die Konfiguration geändert hat, warten Sie, bis die Sperre aufgehoben wird oder die Änderungen festgeschrieben werden, und führen Sie das Playbook erneut aus. Wenn die Ursache des Problems darin besteht, dass der Benutzer nicht über die Berechtigungen zum Konfigurieren des Geräts verfügt, führen Sie entweder das Playbook mit einem Benutzer aus, der über die erforderlichen Berechtigungen verfügt, oder konfigurieren Sie das Junos-Gerät gegebenenfalls, um dem aktuellen Benutzer die erforderlichen Berechtigungen zum Vornehmen der Änderungen zu erteilen.
Fehlerbehebung bei Konfigurationsänderungsfehlern
Problem
Das Playbook generiert eine ConfigLoadError Fehlermeldung, die angibt, dass die Konfiguration nicht geändert werden kann, da die Berechtigung verweigert wird.
FAILED! => {"changed": false, "msg": "Failure loading the configuraton: ConfigLoadError(severity: error, bad_element: scripts, message: error: permission denied)"}
Diese Fehlermeldung wird generiert, wenn der Benutzer, der das Ansible-Modul ausführt, die Berechtigung zum Ändern der Konfiguration hat, aber nicht die Berechtigung, den angeforderten Abschnitt der Konfiguration zu ändern.
Lösung
Führen Sie entweder das Playbook mit einem Benutzer aus, der über die erforderlichen Berechtigungen verfügt, oder konfigurieren Sie das Junos-Gerät ggf. so, dass dem aktuellen Benutzer die erforderlichen Berechtigungen zum Vornehmen der Änderungen erteilt werden.