Site icon bintorosoft.com

4.3 Die ersten Python-Skripte für Network Automation schreiben

bintorosoft@gmail.com

Network Engineer Intently Analyzing Data Server Racks in a Neon-Lit High Tech Data Center

Die ersten Python-Skripte für Network Automation zu schreiben ist für viele Network Engineers der entscheidende Übergang von theoretischem Verständnis zu echter praktischer Automatisierung. Genau an diesem Punkt zeigt sich, dass Python im Netzwerkumfeld nicht als abstrakte Programmiersprache gelernt werden muss, sondern als Werkzeug für konkrete Infrastrukturaufgaben. Ein erstes Skript muss deshalb weder komplex noch perfekt sein. Entscheidend ist, dass es einen realen Bezug zur Netzwerktechnik hat: Geräteinformationen speichern, Hostlisten verarbeiten, Zustände prüfen, einfache Reports erzeugen oder Eingabedaten aus Dateien lesen. Solche frühen Skripte wirken auf den ersten Blick klein, bilden aber bereits die wichtigsten Muster späterer Automatisierung ab. Wer die ersten Python-Skripte für Network Automation bewusst aufbaut, lernt nicht nur Syntax, sondern entwickelt ein technisches Denken in Daten, Abläufen, Bedingungen und Wiederverwendbarkeit. Genau daraus entsteht mit der Zeit belastbare Automatisierungskompetenz.

Warum die ersten Netzwerkskripte bewusst einfach bleiben sollten

Ein häufiger Fehler beim Einstieg in die Netzwerkautomation besteht darin, zu früh mit komplexen Bibliotheken, APIs oder Multi-Device-Workflows beginnen zu wollen. Das wirkt motivierend, führt aber oft zu Frust, weil zu viele neue Konzepte gleichzeitig zusammenkommen. Sinnvoller ist es, mit kleinen, klaren Aufgaben zu starten. Ein gutes erstes Netzwerkskript löst genau ein überschaubares Problem und zeigt dabei nachvollziehbar, wie Python-Daten, Bedingungen, Schleifen und Ausgaben zusammenwirken.

Gerade für Network Engineers ist das wichtig, weil die Stärke der Automatisierung nicht in beeindruckend großem Code liegt, sondern in sauberer, wiederverwendbarer Logik. Ein Skript, das eine Liste von Geräten ausgibt oder aus einer Datei liest, ist deshalb kein „zu kleiner“ Einstieg, sondern ein realistischer erster Baustein.

Gute Eigenschaften eines ersten Netzwerkskripts

Die Arbeitsumgebung für erste Skripte vorbereiten

Bevor das erste Skript geschrieben wird, sollte die Python-Umgebung sauber funktionieren. Dazu gehört, dass Python im Terminal erreichbar ist, der Editor korrekt eingerichtet wurde und das Skript in einem eigenen Projektordner liegt. Für Einsteiger ist ein kleiner Projektordner mit einer Datei wie main.py oder erstes_script.py völlig ausreichend.

Gerade im Netzwerkumfeld ist Ordnung von Anfang an hilfreich. Wenn Hosts, JSON-Dateien oder Reports später hinzukommen, zahlt sich eine saubere Struktur sofort aus.

Typische Vorbereitungsschritte

Praktische Kommandos

mkdir erstes_netzwerkprojekt
cd erstes_netzwerkprojekt
python --version
python3 --version

Danach kann eine Datei wie main.py erstellt und im Editor geöffnet werden.

Das erste Python-Skript: Eine einfache Netzwerkausgabe

Der sinnvollste Einstieg beginnt mit einem sehr kleinen Skript, das netzwerknahe Informationen als Variablen speichert und ausgibt. Das mag simpel wirken, ist aber bereits ein echter Schritt in Richtung Automatisierung, weil Werte strukturiert verarbeitet werden.

Einfaches erstes Beispiel

hostname = "SW1"
mgmt_ip = "192.168.10.10"
rolle = "access-switch"

print("Hostname:", hostname)
print("Management-IP:", mgmt_ip)
print("Rolle:", rolle)

Dieses Skript zeigt drei zentrale Dinge: Daten werden in Variablen gespeichert, Variablen werden klar benannt und Informationen werden strukturiert ausgegeben. Genau diese Grundlogik taucht später in fast jedem Netzwerkskript wieder auf.

Ausführung im Terminal

python main.py

Mehrere Geräte mit Listen verarbeiten

Ein einzelnes Gerät ist für die Praxis selten genug. Deshalb ist der nächste sinnvolle Schritt die Arbeit mit Listen. Gerade in der Netzwerkautomation ist das zentral, weil fast immer mehrere Geräte, Interfaces, VLANs oder IP-Adressen verarbeitet werden müssen.

Einfaches Beispiel mit einer Geräteliste

switches = ["SW1", "SW2", "SW3", "SW4"]

for switch in switches:
    print("Pruefe Gerät:", switch)

Damit wird bereits ein echtes Automatisierungsmuster sichtbar: Ein Skript durchläuft eine Menge von Objekten und wendet auf jedes Objekt denselben Verarbeitungsschritt an.

Warum dieses Beispiel wichtig ist

Statuswerte mit Bedingungen prüfen

In Netzwerken geht es nicht nur darum, Daten zu speichern, sondern Zustände zu bewerten. Genau hier kommen Bedingungen ins Spiel. Ein erstes sinnvolles Beispiel ist die Prüfung eines Interface- oder Gerätestatus. Solche Bedingungen sind später überall nützlich: bei Portprüfungen, Health Checks, API-Auswertungen oder Inventarisierung.

Einfaches Beispiel zur Statusprüfung

status = "down"

if status == "up":
    print("Das Interface ist aktiv")
else:
    print("Das Interface ist nicht aktiv")

Das Beispiel ist bewusst klein, aber fachlich realistisch. In der Praxis wird genau diese Art von Prüfung später auf viele Ports oder Geräte übertragen.

Netzwerknahe Erweiterung

interfaces = {
    "Gi0/1": "up",
    "Gi0/2": "down",
    "Gi0/3": "up"
}

for interface, status in interfaces.items():
    if status == "up":
        print(interface, "ist aktiv")
    else:
        print(interface, "muss geprueft werden")

Hier kommen bereits Dictionaries, Schleifen und Bedingungen zusammen. Das ist ein sehr typisches Grundmuster für Netzwerkskripte.

Hostlisten aus Dateien einlesen

Ein weiterer sehr praktischer Schritt ist das Lesen von Daten aus einer Datei. Dadurch werden Skripte flexibler, weil die Eingaben nicht fest im Code stehen müssen. Für Network Engineers ist das besonders nützlich, wenn Zielhosts, Management-IP-Adressen oder Gerätelisten verarbeitet werden sollen.

Angenommen, die Datei hosts.txt enthält folgende Einträge:

192.168.10.10
192.168.10.11
192.168.10.12

Passendes Python-Skript

with open("hosts.txt", "r") as datei:
    for zeile in datei:
        host = zeile.strip()
        print("Host aus Datei:", host)

Das Beispiel zeigt einen direkten Praxisbezug. Statt Hostdaten fest einzubauen, werden sie dynamisch aus einer Eingabedatei gelesen. Genau dieses Prinzip ist in der Netzwerkautomation enorm wertvoll.

Wichtige Vorteile dieses Ansatzes

Einfache Reports in Dateien schreiben

Netzwerkskripte sollen oft nicht nur etwas anzeigen, sondern Ergebnisse dokumentieren. Ein Report, eine Inventarliste oder ein Prüfprotokoll in einer Datei ist deutlich nützlicher als reine Bildschirmausgabe. Deshalb sollte bereits bei den ersten Skripten auch das Schreiben von Dateien geübt werden.

Beispiel für einen kleinen Report

geraete = ["SW1", "SW2", "SW3"]

with open("report.txt", "w") as datei:
    for geraet in geraete:
        datei.write("Geprueft: " + geraet + "n")

Dieses Skript erzeugt eine einfache Textdatei mit einem Eintrag pro Gerät. Auch wenn das noch kein komplexer Health Check ist, zeigt es bereits die Grundidee produktiver Automatisierung: Eingaben verarbeiten und Ergebnisse persistent festhalten.

Praktische Kommandos

cat report.txt
type report.txt

Je nach Betriebssystem kann die Ausgabedatei danach direkt im Terminal betrachtet werden.

Funktionen früh einsetzen

Schon bei kleinen Netzwerkskripten lohnt es sich, wiederkehrende Logik in Funktionen auszulagern. Dadurch bleiben Skripte lesbarer und einfacher erweiterbar. Für Einsteiger muss das nicht sofort groß und modular sein. Schon eine kleine Funktion für die formatierte Ausgabe von Gerätedaten ist ein sinnvoller erster Schritt.

Einfaches Beispiel mit Funktion

def zeige_geraet(hostname, mgmt_ip, rolle):
    print("Hostname:", hostname)
    print("Management-IP:", mgmt_ip)
    print("Rolle:", rolle)
    print("---")

zeige_geraet("SW1", "192.168.10.10", "access-switch")
zeige_geraet("R1", "192.168.20.1", "router")

Damit wird bereits klar, warum Funktionen so nützlich sind: Die gleiche Logik kann mit unterschiedlichen Werten mehrfach verwendet werden, ohne doppelt geschrieben zu werden.

Mit Dictionaries realistische Gerätedaten modellieren

Ein sehr guter nächster Schritt ist die Nutzung von Dictionaries. Viele Informationen in Netzwerken liegen als Schlüssel-Wert-Paare vor: Hostname, IP-Adresse, Rolle, Standort oder Status. Wer damit früh arbeitet, bereitet sich direkt auf JSON und API-Daten vor.

Einfaches Gerät als Dictionary

geraet = {
    "hostname": "SW1",
    "mgmt_ip": "192.168.10.10",
    "rolle": "access-switch",
    "status": "online"
}

print("Hostname:", geraet["hostname"])
print("IP:", geraet["mgmt_ip"])
print("Rolle:", geraet["rolle"])
print("Status:", geraet["status"])

Dieses Beispiel ist für die Praxis sehr wertvoll, weil viele API-Antworten in Python ähnlich verarbeitet werden.

Mehrere Geräte als Liste von Dictionaries

geraete = [
    {"hostname": "SW1", "mgmt_ip": "192.168.10.10", "status": "online"},
    {"hostname": "SW2", "mgmt_ip": "192.168.10.11", "status": "offline"},
    {"hostname": "R1", "mgmt_ip": "192.168.20.1", "status": "online"}
]

for geraet in geraete:
    print(geraet["hostname"], geraet["mgmt_ip"], geraet["status"])

Damit entstehen bereits Strukturen, die stark an Inventar- oder API-Daten erinnern.

JSON-Dateien als Vorbereitung auf APIs nutzen

Da viele Netzwerkplattformen und Controller JSON verwenden, ist ein erstes JSON-Beispiel sehr sinnvoll. So lernen Einsteiger nicht nur Python-Syntax, sondern direkt den Umgang mit einem der wichtigsten Datenformate moderner Netzwerkautomation.

Angenommen, die Datei geraet.json enthält:

{
    "hostname": "SW1",
    "mgmt_ip": "192.168.10.10",
    "status": "online"
}

Passendes Python-Beispiel

import json

with open("geraet.json", "r") as datei:
    daten = json.load(datei)

print("Hostname:", daten["hostname"])
print("Management-IP:", daten["mgmt_ip"])
print("Status:", daten["status"])

Dieses Skript ist sehr wichtig für den späteren Übergang zu APIs. Wer JSON-Dateien lesen kann, versteht bereits einen großen Teil der späteren Antwortverarbeitung von Web- und Controller-Schnittstellen.

Fehlerbehandlung von Anfang an mitdenken

Auch erste Skripte sollten typische Fehler zumindest ansatzweise berücksichtigen. Besonders bei Dateiarbeit und Eingaben ist das wichtig. Ein gutes Netzwerkskript bricht nicht kommentarlos ab, wenn eine Datei fehlt oder eine VLAN-ID falsch eingegeben wird.

Beispiel für einfache Fehlerbehandlung

try:
    with open("hosts.txt", "r") as datei:
        for zeile in datei:
            print(zeile.strip())
except FileNotFoundError:
    print("Die Datei hosts.txt wurde nicht gefunden")

Schon dieses einfache Muster verbessert die Nutzbarkeit eines Skripts erheblich.

Typische frühe Fehlerfälle

Erste Skripte schrittweise erweitern statt neu schreiben

Ein sehr sinnvoller Lernansatz besteht darin, kleine Skripte nicht sofort wegzuwerfen, sondern schrittweise auszubauen. Ein erstes Skript, das nur Hostnamen ausgibt, kann im nächsten Schritt eine Datei lesen. Danach kann es nur bestimmte Zustände melden. Später kann es Ergebnisse in eine Reportdatei schreiben. Genau so entsteht aus einem Lernbeispiel langsam ein nützliches Werkzeug.

Diese schrittweise Erweiterung ist besonders wertvoll, weil Einsteiger dabei lernen, wie Code wächst und warum Struktur, Funktionen und Lesbarkeit so wichtig sind.

Ein sinnvoller Ausbaupfad

Typische praktische Netzwerkbezüge der ersten Skripte

Auch wenn die ersten Python-Skripte noch keine direkten SSH-Verbindungen oder API-Transaktionen ausführen, orientieren sie sich bereits klar an realen Netzwerkaufgaben. Hostlisten, VLAN-Daten, Interface-Zustände, Reportdateien und JSON-Strukturen sind keine künstlichen Lernobjekte, sondern typische Elemente des Netzwerkalltags.

Genau deshalb lohnt es sich, jedes kleine Skript fachlich mitzudenken. Eine Liste von Hosts steht für ein Inventar. Ein Dictionary mit Statuswerten steht für eine API-Antwort oder eine geparste CLI-Ausgabe. Ein Report in einer Textdatei steht für ein Prüfprotokoll. Wer diese Verbindung erkennt, lernt deutlich schneller in Richtung echter Automation.

Typische Befehle, deren Ergebnisse später in Python-Skripten verarbeitet werden

show ip interface brief
show vlan brief
show interfaces status
show access-lists
show running-config
ping
traceroute
python3 main.py

Die ersten Python-Skripte für Network Automation sollten deshalb nicht als isolierte Programmierübungen betrachtet werden, sondern als technische Vorstufe späterer echter Infrastrukturautomatisierung. Genau aus diesen kleinen, sauberen Beispielen entstehen später Skripte, die APIs nutzen, JSON verarbeiten, Geräte prüfen und Netzwerke strukturiert verwalten.

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