Site icon bintorosoft.com

13.5 Massenkonfigurationen mit Python durchführen

bintorosoft@gmail.com

Massenkonfigurationen mit Python gehören zu den praktisch wichtigsten Anwendungsfällen der Netzwerkautomatisierung. Genau dann, wenn dieselbe oder eine sehr ähnliche Änderung auf viele Router, Switches oder Firewalls angewendet werden muss, zeigt sich der Unterschied zwischen manuellem Betrieb und automatisierter Arbeitsweise besonders deutlich. Was per CLI auf wenigen Geräten noch überschaubar wirkt, wird bei dutzenden oder hunderten Systemen schnell langsam, fehleranfällig und schwer nachvollziehbar. Python ermöglicht es, solche Änderungen strukturiert, wiederholbar und kontrolliert auszuführen. Für Network Engineers ist dabei entscheidend, nicht nur zu wissen, wie ein Skript Befehle an Geräte sendet, sondern wie Massenkonfigurationen sicher vorbereitet, validiert, protokolliert und bei Bedarf begrenzt oder zurückgerollt werden.

Warum Massenkonfigurationen im Netzwerk eine besondere Herausforderung sind

Manuelle Änderungen skalieren schlecht

Ein einzelner Konfigurationsblock auf einem Router oder Switch ist schnell per SSH gesetzt. Sobald dieselbe Änderung aber auf 20, 50 oder 300 Geräten ausgerollt werden muss, steigen Aufwand und Risiko erheblich. Jeder manuelle Login, jede kopierte CLI-Zeile und jeder nicht bemerkte Tippfehler vergrößert die Wahrscheinlichkeit von Inkonsistenzen.

Gerade bei Standardänderungen wie NTP, Syslog, AAA, DNS, Interface-Beschreibungen oder Access-Port-Profilen ist Massenkonfiguration deshalb ein idealer Kandidat für Python-Automatisierung.

Eine Massenkonfiguration ist kein bloßes Schleifenproblem

Viele Einsteiger denken zunächst: Wenn eine Änderung auf einem Gerät funktioniert, muss man sie nur in einer Schleife auf viele Geräte anwenden. Technisch stimmt das teilweise, operativ reicht es aber nicht aus. Eine sichere Massenkonfiguration braucht mehr als nur eine Schleife über IP-Adressen.

Python ist dabei nicht nur das Mittel zum Senden von Befehlen, sondern das Werkzeug zum Aufbau eines kontrollierten Change-Prozesses.

Welche Arten von Massenkonfigurationen typisch sind

Globale Basisparameter

Viele Massenänderungen betreffen grundlegende Management- oder Betriebsparameter, die auf großen Gerätegruppen konsistent gesetzt werden sollen. Genau diese Aufgaben lassen sich oft besonders gut mit Python automatisieren, weil sie klar definierte Sollwerte besitzen.

Ein klassischer CLI-Block dafür könnte so aussehen:

conf t
ntp server 10.10.10.10
ntp server 10.10.10.11
logging host 10.20.20.20
logging host 10.20.20.21
end
write memory

Wenn solche Änderungen auf viele Geräte verteilt werden müssen, entsteht schnell ein klarer Automatisierungsnutzen.

Interface- und Port-Standards

Auch Konfigurationen auf Interface-Ebene werden oft in größerer Zahl angepasst. Das gilt etwa für Beschreibungen, Access-VLANs, Trunk-Parameter oder Schutzmechanismen wie PortFast und BPDU Guard.

Ein Beispiel:

interface GigabitEthernet1/0/10
 description User-LAN-Floor3
 switchport mode access
 switchport access vlan 30
 spanning-tree portfast
 spanning-tree bpduguard enable

Bei dutzenden ähnlichen Ports auf mehreren Switches ist das ein klassischer Fall für Python-basierte Massenkonfiguration.

Standort- oder Rollenänderungen

In vielen Netzen werden Massenänderungen auch nach Rolle oder Standort durchgeführt. Beispielsweise sollen alle Access-Switches in einer Niederlassung neue Syslog-Ziele erhalten oder alle WAN-Router eines bestimmten Typs eine geänderte Management-ACL bekommen.

Hier zeigt sich bereits: Gute Massenkonfiguration basiert nicht auf einer beliebigen Geräteliste, sondern auf bewusst gewählten Zielgruppen.

Python als Werkzeug für Massenkonfigurationen

Warum Python besonders gut geeignet ist

Python ist für Massenkonfigurationen im Netzwerk besonders geeignet, weil die Sprache flexibel genug ist, um Gerätelisten, Variablen, Fehlerbehandlung, Logging und Konfigurationslogik miteinander zu verbinden. Zudem gibt es mit Bibliotheken wie Netmiko oder NAPALM bewährte Werkzeuge für typische Netzwerkaufgaben.

Damit ist Python nicht nur für Einzelskripte nützlich, sondern auch für strukturierte Massen-Changes.

Netmiko als naheliegender Einstieg

Für klassische SSH- und CLI-nahe Umgebungen ist Netmiko oft die praktikabelste Bibliothek. Sie vereinfacht die Verbindung zu Netzwerkgeräten und erlaubt das Senden von Konfigurationssätzen mit wenig Code.

Ein einfaches Beispiel für ein einzelnes Gerät:

from netmiko import ConnectHandler

device = {
    "device_type": "cisco_ios",
    "host": "192.0.2.10",
    "username": "admin",
    "password": "password"
}

commands = [
    "ntp server 10.10.10.10",
    "ntp server 10.10.10.11"
]

with ConnectHandler(**device) as conn:
    output = conn.send_config_set(commands)
    print(output)

Die Erweiterung zur Massenkonfiguration entsteht dann aus dem strukturierten Umgang mit vielen Geräten und nicht aus der Einzelverbindung selbst.

Die Grundstruktur einer Python-Massenkonfiguration

Geräteliste definieren

Am Anfang steht fast immer eine definierte Liste von Zielgeräten. Diese Liste sollte nicht zufällig wachsen, sondern klar festlegen, welche Geräte betroffen sind. Für erste Beispiele kann die Liste direkt im Skript stehen, produktiv ist oft eine externe Datei sinnvoller.

Ein einfaches Beispiel:

devices = [
    {
        "name": "fra-access-sw01",
        "device_type": "cisco_ios",
        "host": "192.0.2.10",
        "username": "admin",
        "password": "password"
    },
    {
        "name": "fra-access-sw02",
        "device_type": "cisco_ios",
        "host": "192.0.2.11",
        "username": "admin",
        "password": "password"
    }
]

Diese Struktur hat zwei wichtige Vorteile:

Konfigurationslogik definieren

Als Nächstes muss klar beschrieben werden, welche Konfiguration auf die Geräte angewendet werden soll. Für einfache Massenänderungen reicht häufig eine Liste von CLI-Zeilen.

Beispiel:

commands = [
    "ntp server 10.10.10.10",
    "ntp server 10.10.10.11",
    "logging host 10.20.20.20"
]

Für komplexere Szenarien können die Befehle auch pro Gerät, Rolle oder Standort variieren. Dann wird aus einer festen Liste eine dynamisch erzeugte Konfigurationsmenge.

Schleife und Verbindung

Die eigentliche Massenkonfiguration entsteht durch eine Schleife über alle Zielgeräte. Für jedes Gerät wird eine Verbindung aufgebaut, die Konfiguration übertragen und das Ergebnis protokolliert.

Ein einfaches Beispiel:

from netmiko import ConnectHandler

for device in devices:
    with ConnectHandler(**device) as conn:
        print(f"Verbunden mit {device['name']}")
        output = conn.send_config_set(commands)
        print(output)

Dieses Grundmuster ist einfach, aber noch nicht ausreichend für einen produktionsnahen Rollout. Es bildet nur das technische Senden der Änderung ab.

Pre-Checks vor der Massenkonfiguration

Warum Vorprüfungen unverzichtbar sind

Bevor eine Massenänderung ausgerollt wird, sollte geprüft werden, ob die Zielgeräte überhaupt im erwarteten Zustand sind. Pre-Checks reduzieren das Risiko, dass ein Change auf Geräten landet, die bereits abweichend konfiguriert sind oder technische Probleme haben.

Ein einfacher Pre-Check kann beispielsweise die Softwareversion, den Hostnamen oder die bestehende NTP-Konfiguration auslesen:

show version
show running-config | include ntp
show ip interface brief

Erst wenn diese Prüfungen plausibel sind, sollte ein produktiver Write-Change folgen.

Pilotgruppen statt Vollausrollung

Eine weitere Best Practice ist es, Massenkonfigurationen nicht sofort auf alle Geräte auszurollen, sondern zunächst auf eine kleine Pilotgruppe. Python-Skripte können dafür bewusst mit Teilmengen der Geräteliste arbeiten.

Dieses Vorgehen ist gerade bei produktiven Standardänderungen wesentlich sicherer als ein sofortiger Full-Scale-Rollout.

Fehlerbehandlung bei Massenkonfigurationen

Ein Gerätefehler darf nicht den ganzen Lauf zerstören

In realen Netzen werden einzelne Geräte immer wieder Probleme verursachen: falsche Zugangsdaten, fehlende Erreichbarkeit, Prompt-Probleme oder unerwartete Plattformunterschiede. Ein gutes Python-Skript muss solche Fehler sauber behandeln, ohne den kompletten Rollout abzubrechen.

Ein robustes Beispiel:

from netmiko import ConnectHandler
from netmiko.exceptions import NetMikoTimeoutException, NetMikoAuthenticationException

for device in devices:
    try:
        with ConnectHandler(**device) as conn:
            print(f"Verbunden mit {device['name']}")
            output = conn.send_config_set(commands)
            print(output)
    except NetMikoAuthenticationException:
        print(f"Authentifizierung fehlgeschlagen: {device['name']}")
    except NetMikoTimeoutException:
        print(f"Timeout oder keine Verbindung: {device['name']}")
    except Exception as e:
        print(f"Unerwarteter Fehler bei {device['name']}: {e}")

Diese Struktur stellt sicher, dass einzelne Fehler sichtbar bleiben, aber andere Geräte weiter verarbeitet werden können.

Fehler nicht nur anzeigen, sondern dokumentieren

Gerade bei Massenchanges reicht eine reine Konsolenausgabe oft nicht aus. Es ist sinnvoll, erfolgreiche und fehlgeschlagene Geräte systematisch zu protokollieren. Nur so lässt sich später nachvollziehen, was wirklich passiert ist.

Idempotenz bei Massenkonfigurationen berücksichtigen

Nicht blind immer wieder dieselben Befehle senden

Ein häufiger Fehler bei Python-Massenkonfigurationen besteht darin, dieselben CLI-Blöcke bei jedem Lauf blind erneut zu senden. Das ist technisch zwar oft möglich, aber operativ nicht sauber. Gute Massenkonfiguration sollte möglichst idempotent sein: Wenn der Soll-Zustand bereits vorhanden ist, sollte keine unnötige Änderung mehr erfolgen.

Typische Prüfbefehle:

show running-config | include ntp
show running-config | include logging

Erst wenn die Prüfung eine Abweichung zeigt, sollte das Skript den Konfigurationssatz senden.

Warum Idempotenz gerade bei vielen Geräten wichtig ist

Je größer die Zielgruppe, desto wichtiger wird idempotentes Verhalten. Sonst erzeugt jeder erneute Lauf unnötige Schreibzugriffe, irreführende Logs und potenziell unnötige Betriebseingriffe auf vielen Geräten gleichzeitig.

Konfigurationen dynamisch statt statisch erzeugen

Variablen pro Gerät oder Standort nutzen

Nicht jede Massenkonfiguration ist vollständig identisch. Oft gibt es Unterschiede nach Standort, Rolle oder Gerät. Python ist hier besonders stark, weil Konfigurationsblöcke dynamisch aus Variablen erzeugt werden können.

Ein einfaches Beispiel:

for device in devices:
    commands = [
        f"logging host {device['syslog_server']}",
        f"ntp server {device['ntp_server_1']}",
        f"ntp server {device['ntp_server_2']}"
    ]

Damit wird nicht nur ein statischer Block verteilt, sondern die Konfiguration passt sich an die hinterlegten Gerätedaten an.

Templates für komplexere Massenkonfigurationen

Wenn Konfigurationen umfangreicher werden, ist Template-basierte Erzeugung mit Jinja2 oft sinnvoller als einzelne String-Listen. Das gilt besonders für Interface-Standards, VLAN-Konfigurationen oder größere Basisblöcke.

Ein einfaches Template:

interface {{ interface_name }}
 description {{ description }}
 switchport mode access
 switchport access vlan {{ vlan_id }}

Python kann dieses Template mit Gerätedaten füllen und dadurch Massenkonfigurationen sauberer und wartbarer erzeugen.

Validierung nach dem Change

Post-Checks sind Pflicht

Eine Massenkonfiguration ist erst dann erfolgreich, wenn geprüft wurde, ob die Änderung wirklich auf dem Gerät angekommen ist. Der reine Erfolg eines SSH-Befehls reicht nicht aus. Gerade bei produktiven Standards müssen Post-Checks fester Teil des Prozesses sein.

Typische Post-Check-Kommandos:

show running-config | include ntp
show running-config | include logging
show ntp associations

Erst diese Prüfung macht aus einem SSH-Write-Vorgang einen kontrollierten Netzwerk-Change.

Vorher-Nachher-Vergleiche speichern

Besonders sinnvoll ist es, Ergebnisse vor und nach der Änderung zu speichern. So lässt sich später nachvollziehen, ob sich nur der gewünschte Teil der Konfiguration geändert hat oder ob unerwartete Nebeneffekte aufgetreten sind.

Logging, Reporting und Nachvollziehbarkeit

Ein Rollout braucht ein Ergebnisprotokoll

Je größer eine Massenkonfiguration, desto wichtiger wird ein sauberes Ergebnisprotokoll. Dieses sollte nicht nur Erfolg oder Fehler festhalten, sondern möglichst auch Zeitstempel, Zielgeräte und Kernaussagen zum Ergebnis.

Ein Rollout ohne nachvollziehbares Ergebnis erschwert jede spätere Analyse.

Änderungen versionieren

Wenn Konfigurationsartefakte, Templates oder Gerätestände im Zuge des Rollouts gespeichert werden, sollten diese idealerweise versioniert werden. Git ist dafür ein sehr hilfreiches Werkzeug.

Typische Git-Befehle:

git add .
git commit -m "Massenkonfiguration NTP und Syslog auf Access-Switches"
git diff

So wird Massenkonfiguration nicht nur technisch ausführbar, sondern auch organisatorisch nachvollziehbar.

Typische Fehler bei Python-Massenkonfigurationen

Zu früh auf alle Geräte gleichzeitig gehen

Ein häufiger Fehler ist der direkte Vollausrollungsgedanke. Auch wenn das Skript technisch funktioniert, sollte ein produktiver Change nie ohne Pilotphase sofort auf die gesamte Zielmenge angewendet werden.

Keine Trennung zwischen Daten und Logik

Wenn Gerätelisten, Zugangsdaten und Konfigurationslogik ungeordnet im Skript vermischt sind, wird Wartung schnell schwierig. Eine klare Trennung von Inventar, Variablen und Code ist auch in Python-Skripten wichtig.

Fehlende Ausnahmebehandlung

Ein einziger Timeout oder Login-Fehler darf nicht dazu führen, dass der gesamte Rollout unbrauchbar wird oder ohne klare Aussage endet.

Kein Rollback- oder Backup-Konzept

Vor jeder Massenkonfiguration sollte zumindest die aktuelle Konfiguration gesichert werden. Gerade bei größeren Änderungen ist ein Backup Pflicht.

Typische Sicherungsbefehle:

show running-config
show startup-config

Damit ist sichergestellt, dass ein definierter Ausgangszustand verfügbar bleibt.

Best Practices für Massenkonfigurationen mit Python

Damit werden Massenkonfigurationen mit Python zu einem sehr wirkungsvollen Werkzeug im Netzwerkbetrieb. Sie ermöglichen, wiederkehrende Änderungen schnell und konsistent auf viele Geräte auszurollen, ohne in rein manueller CLI-Arbeit stecken zu bleiben. Ihr wirklicher Wert entsteht jedoch nicht allein durch das Senden von Befehlen, sondern durch die kontrollierte Kombination aus Geräteliste, Pre-Checks, Fehlerbehandlung, idempotenter Logik, Validierung und sauberer Dokumentation.

Konfiguriere Cisco Router & Switches und liefere ein Packet-Tracer-Lab/GNS3

Ich biete professionelle Unterstützung im Bereich Netzwerkkonfiguration und Network Automation für private Anforderungen, Studienprojekte, Lernlabore, kleine Unternehmen sowie technische Projekte. Ich unterstütze Sie bei der Konfiguration von Routern und Switches, der Erstellung praxisnaher Topologien in Cisco Packet Tracer, dem Aufbau und Troubleshooting von GNS3- und EVE-NG-Labs sowie bei der Automatisierung von Netzwerkaufgaben mit Netmiko, Paramiko, NAPALM und Ansible. Kontaktieren Sie mich jetzt – klicken Sie hier.

Meine Leistungen umfassen:

Benötigen Sie Unterstützung bei Ihrem Netzwerkprojekt, Ihrer Simulation oder Ihrer Network-Automation-Lösung? Kontaktieren Sie mich jetzt – klicken Sie hier.

Exit mobile version