19.2 Mit Python und einfachen Netzwerkskripten im Lab arbeiten

Mit Python und einfachen Netzwerkskripten im Lab zu arbeiten ist einer der sinnvollsten Wege, um Netzwerkautomatisierung praktisch zu lernen. Gerade im CCNA-nahen Umfeld geht es dabei nicht darum, sofort komplexe Plattformen, große Frameworks oder produktionsreife Orchestrierung aufzubauen. Viel wichtiger ist, ein Gefühl dafür zu entwickeln, wie ein Skript Geräte anspricht, Daten ausliest, Ergebnisse verarbeitet und kleine Standardaufgaben reproduzierbar erledigt. Ein Lab ist dafür ideal, weil Fehler dort kein Betriebsrisiko darstellen und genau die Lernsituationen erzeugen, die im späteren Alltag entscheidend sind: Verbindung funktioniert nicht, ein Befehl liefert unerwartete Ausgabe, eine Variable ist falsch gesetzt oder ein Gerät reagiert anders als gedacht. Für Network Engineers ist Python deshalb nicht einfach nur eine Programmiersprache, sondern ein praktisches Werkzeug, um klassische Netzwerktechnik mit moderner Automatisierung zu verbinden.

Warum Python im Netzwerk-Lab so nützlich ist

Python verbindet Einfachheit mit praktischer Wirkung

Python hat sich in der Netzwerkautomatisierung vor allem deshalb durchgesetzt, weil die Sprache vergleichsweise gut lesbar ist und sich auch für Engineers ohne tiefen Software-Hintergrund schnell einsetzen lässt. Für Lab-Übungen ist das besonders wertvoll, weil die Aufmerksamkeit nicht vollständig von komplizierter Syntax gebunden wird, sondern auf Netzwerklogik und Automatisierungsabläufe gerichtet bleiben kann.

• Gut lesbare Syntax
• Schneller Einstieg für typische Automatisierungsaufgaben
• Große Auswahl an Netzwerkbibliotheken
• Gute Eignung für Skripte, Tests und kleine Werkzeuge

Gerade im Lab zeigt sich der Vorteil schnell: Schon mit wenigen Zeilen Code lässt sich eine SSH-Verbindung aufbauen, ein Show-Befehl senden oder eine kleine Gerätegruppe automatisiert abfragen.

Das Lab ist die beste Umgebung für frühe Fehler

Im produktiven Netzwerk wären Anfängerfehler in Skripten problematisch. Im Lab sind sie ausdrücklich erwünscht, weil genau dort der eigentliche Lernwert entsteht. Wer im Lab erlebt, wie sich Verbindungsfehler, falsche Inventardaten oder Logikprobleme auswirken, entwickelt deutlich schneller ein belastbares Verständnis.

• Fehler können ohne Produktionsrisiko analysiert werden.
• Skripte lassen sich schrittweise testen und verbessern.
• Zusammenhänge zwischen Code und Gerätereaktion werden sichtbar.
• Fehlersuche kann bewusst trainiert werden.

Python im Lab ist deshalb nicht nur ein Werkzeug zum Automatisieren, sondern auch ein Werkzeug zum Lernen.

Welche Voraussetzungen im Lab vorhanden sein sollten

Ein funktionierender Automation-Host

Bevor mit Python-Skripten gearbeitet wird, braucht das Lab einen sauberen Ausgangspunkt: einen Host, auf dem Python installiert ist und von dem aus die Netzwerkgeräte erreichbar sind. Das kann eine Linux-VM, ein lokaler Rechner mit passender Umgebung oder ein separates Lab-System sein.

• Python 3 sollte installiert sein.
• SSH-Zugriff auf die Geräte muss möglich sein.
• Ein Editor oder eine kleine Entwicklungsumgebung sollte vorhanden sein.
• Das Lab sollte ein klares Management-Netz haben.

Gerade am Anfang ist Stabilität wichtiger als Funktionsvielfalt. Wenn bereits der Basiszugriff instabil ist, werden viele spätere Python-Probleme unnötig unklar.

Geräte mit sauberem SSH-Zugang

Für die meisten ersten Python-Übungen wird SSH verwendet. Deshalb sollten die Geräte im Lab so vorbereitet sein, dass sie über Management-IP, Benutzername und Passwort oder Key erreichbar sind.

Eine typische Cisco-Grundkonfiguration könnte so aussehen:

conf t
hostname R1
ip domain-name lab.local
username admin privilege 15 secret MeinPasswort123
crypto key generate rsa modulus 2048
ip ssh version 2
line vty 0 4
 login local
 transport input ssh
end
write memory

Erst wenn diese Grundlage sauber steht, sollte mit Python-Skripten weitergearbeitet werden.

Erreichbarkeit vor dem ersten Skript prüfen

Ein häufiger Anfängerfehler besteht darin, direkt im Python-Code nach Problemen zu suchen, obwohl die Basisverbindung noch gar nicht stimmt. Deshalb sollte vor dem ersten Skript immer manuell geprüft werden, ob die Geräte aus Sicht des Automation-Hosts erreichbar sind.

Typische Tests:

ping 192.0.2.101
ssh admin@192.0.2.101

Auf dem Gerät selbst helfen außerdem:

show ip interface brief
show ip ssh
show running-config | section line vty

Diese Kontrollen sparen später viel Zeit bei der Fehlersuche.

Das Python-Umfeld sinnvoll einrichten

Mit virtueller Umgebung arbeiten

Auch im Lab lohnt es sich, eine kleine, saubere Python-Umgebung aufzubauen. Besonders praktisch ist eine virtuelle Umgebung, damit Bibliotheken nicht unkontrolliert systemweit vermischt werden.

Ein typischer Start:

python3 -m venv venv
source venv/bin/activate
pip install netmiko

Damit steht eine isolierte Arbeitsumgebung bereit, in der erste Netzwerkskripte sauber getestet werden können.

Nicht zu viele Bibliotheken gleichzeitig installieren

Gerade im Lab ist weniger oft mehr. Für den Einstieg reicht in vielen Fällen eine einzelne Bibliothek wie Netmiko, um SSH-basierte Grundlagen der Netzwerkautomatisierung zu verstehen. Zu viele Werkzeuge gleichzeitig erhöhen eher die Komplexität als den Lernwert.

• Python als Sprache verstehen
• Eine Bibliothek gezielt einsetzen
• Erst später weitere Tools ergänzen

Diese bewusste Begrenzung ist eine wichtige Best Practice für den Lab-Einstieg.

Mit dem ersten Netzwerkskript beginnen

Ein einzelnes Gerät ansprechen

Der beste Einstieg ist fast immer ein einfaches Skript, das genau ein Gerät verbindet und genau einen Show-Befehl ausführt. So wird der Ablauf klar und Fehler lassen sich leicht eingrenzen.

Ein einfaches Beispiel mit Netmiko:

from netmiko import ConnectHandler

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

with ConnectHandler(**device) as conn:
    output = conn.send_command("show ip interface brief")
    print(output)

Dieses Skript zeigt bereits mehrere wichtige Grundlagen:

• Gerätedaten werden strukturiert hinterlegt.
• Die Verbindung wird aufgebaut.
• Ein CLI-Befehl wird gesendet.
• Die Ausgabe wird im Terminal angezeigt.

Gerade dieser erste Erfolg ist didaktisch sehr wertvoll, weil er sofort eine Brücke zwischen Python und klassischem Netzwerkbetrieb schlägt.

Den Ablauf wirklich verstehen

Es ist wichtig, solche Beispielskripte nicht nur zu kopieren, sondern ihren Aufbau bewusst zu verstehen.

• Was macht das Dictionary device?
• Warum wird ConnectHandler mit **device aufgerufen?
• Was liefert send_command() zurück?
• Warum ist die Ausgabe zunächst nur ein Textblock?

Diese Fragen helfen dabei, aus einem Beispiel echten Lernfortschritt zu machen.

Sinnvolle erste Übungen im Netzwerk-Lab

Read-Only-Aufgaben zuerst

Für den Einstieg sind lesende Skripte ideal. Sie sind risikoarm und erlauben es, die wesentlichen Bausteine von Verbindung, Ausgabe und Datenverarbeitung zu trainieren.

• Hostname auslesen
• Interfaces prüfen
• Version und Inventar erfassen
• Routing-Tabelle anzeigen
• Laufende Konfiguration sichern

Typische Befehle:

show version
show inventory
show ip interface brief
show ip route
show running-config

Aus solchen Befehlen lassen sich viele kleine Übungen aufbauen, ohne gleich produktive Risiken zu simulieren.

Mehrere Befehle in einem Skript senden

Der nächste sinnvolle Schritt ist, nicht nur einen einzelnen Befehl, sondern mehrere Kommandos in Folge abzusetzen. So entsteht ein kleines Diagnoseskript oder ein einfacher Report.

Ein Beispiel:

from netmiko import ConnectHandler

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

commands = [
    "show version",
    "show ip interface brief",
    "show inventory"
]

with ConnectHandler(**device) as conn:
    for cmd in commands:
        print(f"=== {cmd} ===")
        print(conn.send_command(cmd))

Damit wird bereits klar, wie Schleifen und Listen praktische Netzwerkaufgaben vereinfachen.

Mit mehreren Geräten arbeiten

Nicht sofort hartkodiert skalieren

Wenn das erste Skript auf einem Gerät funktioniert, entsteht schnell der Wunsch, mehrere Systeme zu automatisieren. Genau hier ist es sinnvoll, nicht einfach Kopien des Device-Dictionarys im Skript anzulegen, sondern strukturierter zu arbeiten.

Ein einfacher Anfang kann so aussehen:

from netmiko import ConnectHandler

devices = [
    {
        "device_type": "cisco_ios",
        "host": "192.0.2.101",
        "username": "admin",
        "password": "MeinPasswort123"
    },
    {
        "device_type": "cisco_ios",
        "host": "192.0.2.102",
        "username": "admin",
        "password": "MeinPasswort123"
    }
]

for device in devices:
    print(f"Verbinde zu {device['host']}")
    with ConnectHandler(**device) as conn:
        output = conn.send_command("show ip interface brief")
        print(output)

Damit wird ein wichtiger Gedanke trainiert: dieselbe Logik auf mehrere Ziele anwenden.

Mit kleinen Inventaren arbeiten

Noch besser ist es, Gerätedaten früh aus dem eigentlichen Skript herauszulösen. Auch im Lab lohnt sich ein kleines Inventar, etwa in YAML. So wird von Anfang an datengetrieben gearbeitet.

Ein einfaches Inventar:

devices:
  - name: R1
    host: 192.0.2.101
    role: router
  - name: SW1
    host: 192.0.2.102
    role: switch

Diese Trennung von Daten und Logik ist eine wichtige Grundlage für spätere Automatisierungsreife.

Ausgaben sinnvoll speichern und weiterverwenden

Nicht nur drucken, sondern sichern

Im Lab ist es hilfreich, Ergebnisse nicht nur im Terminal auszugeben, sondern auch in Dateien zu speichern. Das trainiert einen sehr praktischen Ablauf, der später für Backups, Inventarisierung oder Dokumentation wichtig wird.

Ein einfaches Beispiel:

from netmiko import ConnectHandler

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

with ConnectHandler(**device) as conn:
    output = conn.send_command("show running-config")

with open("R1_running_config.txt", "w") as f:
    f.write(output)

So wird aus einem einfachen Show-Befehl bereits ein kleiner, nützlicher Backup- oder Dokumentationsprozess.

Strukturierte Auswertung vorbereiten

Am Anfang reicht oft die reine Textausgabe. Später ist es sinnvoll, bestimmte Informationen gezielter weiterzuverarbeiten. Schon im Lab kann man üben, wie relevante Zeilen gefiltert oder einfache Werte extrahiert werden.

• Nur Interface-Status suchen
• Hostname aus der Konfiguration lesen
• NTP- oder Syslog-Einträge prüfen
• Bestimmte Fehlerzähler hervorheben

Diese Schritte führen direkt in Richtung kleiner Analyse- und Prüfskripte.

Erste schreibende Skripte bewusst klein halten

Konfigurationsänderungen im Lab üben

Sobald Read-Only-Skripte stabil funktionieren, können erste schreibende Übungen folgen. Dabei sollte im Lab mit sehr kleinen, klaren Änderungen gearbeitet werden.

Ein einfaches Beispiel:

from netmiko import ConnectHandler

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

commands = [
    "banner motd ^Lab-Zugriff aktiv^",
    "ntp server 192.0.2.200"
]

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

Damit wird geübt, wie Konfigurationsmodi, Befehlslisten und Gerätereaktionen zusammenarbeiten.

Immer mit Verifikation arbeiten

Eine wichtige Gewohnheit ist, nach jeder schreibenden Automatisierung bewusst zu prüfen, ob der gewünschte Zustand wirklich erreicht wurde. Auch im Lab sollte nicht nur auf die Rückmeldung des Skripts vertraut werden.

Typische Nachkontrolle:

show running-config | include ntp
show running-config | include banner

Diese Verifikation trainiert eine professionelle Arbeitsweise von Anfang an.

Fehler im Lab bewusst als Lernchance nutzen

Typische Probleme erkennen

Beim Arbeiten mit Python im Lab treten fast zwangsläufig Fehler auf. Gerade darin liegt aber einer der größten Lernvorteile. Typische Probleme sind:

• Falsche IP-Adresse oder Management-IP
• SSH nicht aktiv oder falscher Login
• Syntaxfehler im Skript
• Netmiko erhält einen falschen device_type
• Ein Befehl ist auf dem Zielgerät nicht gültig
• Ausgabe wird falsch interpretiert

Wer diese Probleme systematisch einordnet, lernt deutlich nachhaltiger als durch reine Erfolgsbeispiele.

Strukturiert debuggen

Im Lab sollte bewusst geübt werden, Probleme nicht hektisch, sondern systematisch zu analysieren.

• Ist das Gerät erreichbar?
• Funktioniert SSH manuell?
• Ist der Fehler im Code oder im Netzwerk?
• Welche Zeile im Traceback ist relevant?
• Welche Zwischenausgabe hilft weiter?

Einfaches Debugging mit Python kann schon so beginnen:

print(device)
print(device["host"])

Diese kleinen Zwischenschritte machen Datenfluss und Logik sichtbar.

Git und saubere Arbeitsweise im Lab nutzen

Auch kleine Lab-Skripte versionieren

Schon im Lab ist es sinnvoll, Skripte, Inventare und kleine Notizen mit Git zu versionieren. Dadurch werden Änderungen nachvollziehbar und spätere Fehler leichter zurückverfolgbar.

Ein einfacher Start:

git init
git add .
git commit -m "Erstes Python-Skript fuer Show-Befehle im Lab"

Gerade wenn ein Skript nach mehreren Änderungen plötzlich nicht mehr funktioniert, ist eine Versionierung sehr hilfreich.

Das Lab wie eine kleine Produktionsumgebung behandeln

Der größte Lerneffekt entsteht oft dann, wenn das Lab nicht als chaotischer Spielplatz, sondern als kleine kontrollierte Umgebung behandelt wird.

• Saubere Dateinamen verwenden
• Inventare pflegen statt Daten mehrfach einzutragen
• Änderungen nachvollziehbar speichern
• Vor und nach Konfigurationsänderungen prüfen

So werden nicht nur Python-Grundlagen gelernt, sondern auch professionelle Arbeitsmuster.

Welche Übungen besonders sinnvoll sind

Kleine Praxisprojekte mit hohem Lernwert

Ein gutes Lab lebt von Übungen, die überschaubar, aber praktisch relevant sind. Sehr sinnvoll sind zum Beispiel:

• Backups der Running-Config automatisiert speichern
• Ein Inventar mit Hostnamen und Rollen abfragen
• Interface-Status mehrerer Geräte sammeln
• NTP- oder Banner-Konfiguration auf einem Gerät setzen
• Fehlerzähler und Logs auslesen

Diese Projekte trainieren viele wichtige Grundlagen gleichzeitig: Verbindung, Schleifen, Datenspeicherung, Validierung und Fehlersuche.

Den Schwierigkeitsgrad bewusst steigern

Eine sinnvolle Reihenfolge ist:

• Ein Gerät, ein Befehl
• Ein Gerät, mehrere Befehle
• Mehrere Geräte, gleicher Befehl
• Ausgaben speichern
• Kleine Konfigurationsänderung auf einem Gerät
• Read-Only-Prüfung vor und nach einer Änderung

So wächst die Komplexität kontrolliert und der Lernfortschritt bleibt nachvollziehbar.

Best Practices für Python und einfache Netzwerkskripte im Lab

• Immer zuerst die manuelle Erreichbarkeit und SSH-Funktion prüfen, bevor Skriptfehler vermutet werden.
• Mit einfachen Read-Only-Skripten beginnen und schreibende Änderungen erst später einführen.
• Nur wenige Bibliotheken gezielt nutzen statt viele Tools gleichzeitig einzuführen.
• Inventardaten früh von der Skriptlogik trennen.
• Geräte zunächst einzeln testen, bevor mehrere Systeme automatisiert angesprochen werden.
• Ausgaben nicht nur anzeigen, sondern auch strukturiert speichern und weiterverwenden.
• Nach jeder Konfigurationsänderung den tatsächlichen Gerätezustand prüfen.
• Fehler im Lab bewusst analysieren und nicht nur schnell umgehen.
• Skripte, Inventare und Änderungen mit Git versionieren.
• Das Lab klein, übersichtlich und reproduzierbar halten.

Mit Python und einfachen Netzwerkskripten im Lab zu arbeiten bedeutet damit vor allem, die Verbindung zwischen klassischer Netzwerktechnik und moderner Automatisierung praktisch zu erleben. Wer im Lab Geräte sicher per SSH erreicht, Show-Befehle automatisiert sammelt, kleine Konfigurationsänderungen kontrolliert ausführt und Fehler strukturiert analysiert, baut genau das Fundament auf, das später für produktionsnahe Netzwerkautomatisierung entscheidend ist. Gerade in dieser frühen Phase ist nicht Komplexität der Schlüssel, sondern klare, kleine und gut verstandene Schritte.

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:

• Professionelle Konfiguration von Routern und Switches

• Einrichtung von VLANs, Trunks, Routing, DHCP, NAT, ACLs und weiteren Netzwerkfunktionen

• Erstellung von Topologien und Simulationen in Cisco Packet Tracer

• Aufbau, Analyse und Fehlerbehebung von Netzwerk-Labs in GNS3 und EVE-NG

• Automatisierung von Netzwerkkonfigurationen mit Python, Netmiko, Paramiko, NAPALM und Ansible

• Erstellung von Skripten für wiederkehrende Netzwerkaufgaben

• Dokumentation der Konfigurationen und Bereitstellung nachvollziehbarer Lösungswege

• Konfigurations-Backups, Optimierung bestehender Setups und technisches Troubleshooting

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