3.7 Sauberen und wartbaren Code schreiben für Network Engineers

Sauberen und wartbaren Code zu schreiben ist für Network Engineers weit mehr als eine Stilfrage. In der Netzwerkautomatisierung entscheidet die Qualität des Codes direkt darüber, ob ein Skript im Alltag zuverlässig, nachvollziehbar und sicher eingesetzt werden kann. Ein kurzes Testskript, das einmal lokal funktioniert, ist noch kein brauchbares Werkzeug für den Betrieb. Erst wenn Code klar strukturiert, gut lesbar, sauber benannt und sinnvoll organisiert ist, lässt er sich langfristig pflegen, erweitern und von anderen verstehen. Genau das ist im Netzwerkumfeld besonders wichtig. Automatisierung arbeitet hier nicht mit folgenlosen Testdaten, sondern mit echten Geräten, VLANs, ACLs, Firewalls, APIs und Management-Zugängen. Unübersichtlicher Code erhöht deshalb nicht nur den Wartungsaufwand, sondern auch das Risiko von Fehlkonfigurationen und Betriebsstörungen. Wer als Network Engineer sauberen und wartbaren Code schreibt, macht Automatisierung nicht nur effizienter, sondern professioneller und sicherer.

Warum sauberer Code in der Netzwerkautomatisierung so wichtig ist

Im Alltag entsteht Automatisierung oft aus einem konkreten Problem. Ein Engineer möchte schnell eine Liste von Switches prüfen, eine Konfiguration erzeugen oder API-Daten auslesen. Daraus entstehen zunächst kleine Skripte, die ihren Zweck erfüllen. Genau hier beginnt aber häufig das eigentliche Problem: Aus dem schnellen Hilfsskript wird später ein regelmäßig genutztes Werkzeug, das immer weiter erweitert wird. Wenn der ursprüngliche Code unklar, unstrukturiert oder schwer lesbar ist, wird jede spätere Änderung aufwendiger und riskanter.

In der Netzwerkautomatisierung wirkt sich das besonders stark aus, weil viele Aufgaben wiederkehrend, aber zugleich sicherheits- und betriebsrelevant sind. Ein schlecht lesbares Skript, das VLANs verarbeitet, Firewall-Daten prüft oder Gerätezugänge automatisiert, ist nicht nur unbequem, sondern potenziell gefährlich. Wartbarer Code reduziert dieses Risiko, weil seine Logik nachvollziehbar bleibt.

Typische Folgen von unsauberem Code

• Fehler sind schwer zu finden und zu beheben
• Änderungen dauern unnötig lange
• Andere Kollegen verstehen den Ablauf nicht
• Logik wird doppelt oder widersprüchlich umgesetzt
• Automatisierung wird im Betrieb gemieden statt genutzt

Lesbarkeit ist wichtiger als Kürze

Ein häufiger Anfängerfehler besteht darin, Code möglichst kurz oder „clever“ schreiben zu wollen. Für produktive Netzwerkautomatisierung ist jedoch Lesbarkeit fast immer wichtiger als Kürze. Ein Skript soll nicht beeindrucken, sondern verständlich sein. Gerade im Team oder nach einigen Wochen Abstand muss auf einen Blick klar werden, was ein Abschnitt tut, welche Daten verarbeitet werden und welche Entscheidung getroffen wird.

Lesbarer Code ist meist expliziter. Er verwendet klare Namen, saubere Einrückungen und nachvollziehbare Zwischenschritte. Das kann ein paar Zeilen mehr bedeuten, spart aber später sehr viel Zeit bei Analyse und Wartung.

Woran lesbarer Code erkennbar ist

• Klare und aussagekräftige Namen
• Saubere Einrückung und sinnvolle Abstände
• Keine unnötig verschachtelten Konstruktionen
• Logische Reihenfolge der Verarbeitungsschritte
• Kommentare nur dort, wo sie wirklich helfen

Gute Namen machen Code sofort verständlicher

Eine der einfachsten und wirksamsten Maßnahmen für wartbaren Code ist die Wahl guter Namen. Das gilt für Variablen, Funktionen, Listen, Dictionaries und Dateinamen gleichermaßen. In der Netzwerkautomatisierung sollte ein Name möglichst direkt erkennen lassen, welche Information gespeichert oder welche Aufgabe ausgeführt wird.

Ein Name wie mgmt_ip ist aussagekräftiger als x. Eine Funktion wie pruefe_ssh_status() ist deutlich verständlicher als check1(). Gute Namen wirken unscheinbar, sind aber einer der größten Unterschiede zwischen Einsteigercode und brauchbaren Betriebsskripten.

Sinnvolle Namensbeispiele

• hostname
• mgmt_ip
• interface_status
• geraete_liste
• pruefe_vlan_konfiguration()

Weniger sinnvolle Namensbeispiele

• x
• wert1
• test
• funktion_neu
• abc

Code in kleine, klar abgegrenzte Funktionen aufteilen

Wartbarer Code entsteht fast nie in einem einzigen langen Block. Gerade in der Netzwerkautomatisierung sollte Logik in kleine, gut benannte Funktionen aufgeteilt werden. Jede Funktion sollte möglichst genau eine Aufgabe übernehmen. So wird nicht nur der Code klarer, sondern auch das Testen und spätere Anpassen einfacher.

Ein typisches Netzwerkskript könnte etwa getrennte Funktionen für das Laden einer Hostliste, das Prüfen der Erreichbarkeit, das Verarbeiten von API-Daten und das Schreiben eines Reports enthalten. Wenn alle diese Aufgaben in einem einzigen Block stehen, verliert man schnell den Überblick.

Beispiel für sinnvolle Funktionsaufteilung

• Hostliste aus Datei laden
• Erreichbarkeit eines Geräts prüfen
• Statusdaten formatieren
• Reportdatei schreiben

Ein einfaches Beispiel

def lade_hosts(dateiname):
    with open(dateiname, "r") as datei:
        return [zeile.strip() for zeile in datei]

def zeige_hosts(hosts):
    for host in hosts:
        print(host)

Diese Trennung ist deutlich wartbarer als ein langer Mischblock aus Dateioperation, Schleife und Ausgabe.

Doppelten Code vermeiden

Doppelter Code ist einer der größten Feinde wartbarer Skripte. Wenn dieselbe Logik an mehreren Stellen auftaucht, steigt der Pflegeaufwand sofort. Jede Änderung muss dann mehrfach erfolgen, und die Gefahr wächst, dass einzelne Stellen vergessen werden. Genau deshalb sollte wiederkehrende Logik möglichst früh in Funktionen oder Hilfsbausteine ausgelagert werden.

Im Netzwerkumfeld betrifft das häufig Prüfungen, Formatierungen oder API-Aufrufe. Wenn zum Beispiel dieselbe Statusbewertung für Interfaces an drei Stellen im Code auftaucht, ist das ein klares Zeichen, dass eine Funktion sinnvoll wäre.

Typische doppelte Logik in Netzwerkskripten

• Wiederholte Erreichbarkeitsprüfung
• Mehrfach verwendete API-URL-Bausteine
• Immer gleiche Statusmeldungen
• Mehrfach kopierte Datei- oder Reportlogik

Eingaben, Verarbeitung und Ausgabe sauber trennen

Ein sehr hilfreiches Prinzip für wartbaren Code ist die Trennung von Eingaben, Verarbeitung und Ausgabe. Ein Skript wird deutlich klarer, wenn diese drei Bereiche nicht wild vermischt sind. Eingaben können aus Dateien, Variablen, APIs oder Benutzereingaben stammen. Die Verarbeitung ist die eigentliche Logik. Die Ausgabe erfolgt dann als Bildschirmtext, Reportdatei oder JSON-Ergebnis.

Wenn diese Ebenen vermischt werden, wird später oft unklar, welche Funktion eigentlich Daten lädt, welche Logik sie verändert und welche sie nur darstellt. Gerade in der Netzwerkautomatisierung ist diese Trennung sehr wertvoll.

Eine sinnvolle Struktur

• Eingaben einlesen
• Daten prüfen und verarbeiten
• Ergebnisse ausgeben oder speichern

Einfaches Beispiel

def lade_vlan_ids():
    return [10, 20, 30]

def filtere_vlan_ids(vlans):
    return [vlan for vlan in vlans if vlan > 15]

def zeige_vlan_ids(vlans):
    for vlan in vlans:
        print(vlan)

Hier bleibt die Verantwortlichkeit jeder Funktion klar.

Kommentare gezielt und nicht als Ersatz für Klarheit verwenden

Kommentare können sehr hilfreich sein, aber nur dann, wenn sie gezielt eingesetzt werden. Ein häufiger Fehler ist, schlechten oder unklaren Code mit vielen Kommentaren zu „retten“. Besser ist es, den Code selbst so klar wie möglich zu schreiben. Kommentare sollten vor allem dort eingesetzt werden, wo Fachlogik, Annahmen oder nicht sofort offensichtliche Entscheidungen erklärt werden müssen.

In der Netzwerkautomatisierung sind Kommentare besonders nützlich, wenn ein Skript auf einer spezifischen Infrastrukturannahme basiert, etwa einem festen VLAN-Schema, einer bestimmten API-Besonderheit oder einer absichtlich strengen Fehlerbehandlung.

Sinnvolle Kommentar-Inhalte

• Warum ein bestimmter Schritt nötig ist
• Welche Annahme über die Infrastruktur gilt
• Warum ein Sonderfall anders behandelt wird
• Welche Datenstruktur erwartet wird

Weniger sinnvolle Kommentare

• Kommentare, die nur den offensichtlichen Code wiederholen
• Kommentare, die veraltete Logik beschreiben
• Kommentare als Ersatz für schlechte Namen

Fehlerbehandlung gehört zu sauberem Code dazu

Wartbarer Code muss nicht nur im Idealfall funktionieren, sondern auch mit Fehlern sauber umgehen. Gerade im Netzwerkumfeld treten Probleme regelmäßig auf: Geräte sind nicht erreichbar, Dateien fehlen, API-Antworten enthalten unerwartete Daten oder Benutzereingaben sind falsch. Ein sauberes Skript behandelt solche Fälle kontrolliert und verständlich.

Das bedeutet nicht, dass jedes Skript maximal komplexe Ausnahmebehandlung braucht. Aber typische Fehlerquellen sollten bewusst abgefangen werden. Das erhöht die Betriebssicherheit und macht das Verhalten des Skripts für andere nachvollziehbarer.

Typische Fehlerquellen in Netzwerkskripten

• Dateien fehlen oder enthalten unerwartete Werte
• JSON-Daten sind unvollständig
• Geräte oder APIs antworten nicht
• Benutzer geben ungültige Daten ein

Ein einfaches Beispiel

try:
    with open("hosts.txt", "r") as datei:
        hosts = datei.readlines()
except FileNotFoundError:
    print("Die Datei hosts.txt wurde nicht gefunden")

Schon solche einfachen Schutzmechanismen verbessern die Wartbarkeit deutlich.

Konstanten und feste Werte bewusst behandeln

In vielen Skripten gibt es feste Werte, die nicht über den gesamten Code verstreut stehen sollten. Dazu gehören beispielsweise Dateinamen, Standardpfade, URL-Bausteine, VLAN-IDs oder Rollenbezeichnungen. Solche Werte sollten möglichst zentral definiert werden. Dadurch lassen sie sich leichter ändern und werden im restlichen Code klarer verwendet.

Gerade in der Netzwerkautomatisierung ist das nützlich, weil viele Skripte auf wiederkehrenden Standards beruhen. Wenn ein Dateiname, eine API-Basis-URL oder ein VLAN-Schema an mehreren Stellen fest eincodiert ist, wird eine Änderung unnötig mühsam.

Einfaches Beispiel

HOST_DATEI = "hosts.txt"
REPORT_DATEI = "report.txt"
STANDARD_VLAN = 10

Schon diese kleine Struktur macht den Rest des Skripts klarer und anpassbarer.

Dateien, Module und Projektstruktur sauber organisieren

Sobald ein Skript wächst, reicht eine einzige Datei oft nicht mehr aus. Wartbarer Code profitiert dann von einer sauberen Struktur über mehrere Dateien oder Module hinweg. Hilfsfunktionen, API-Logik, Datenverarbeitung und der eigentliche Hauptablauf sollten nicht zwangsläufig alle in derselben Datei stehen. Gerade Network Engineers, die wiederkehrende Automatisierung aufbauen, profitieren stark von modularer Struktur.

Das bedeutet nicht, dass Einsteiger sofort ein komplexes Softwareprojekt anlegen müssen. Aber schon einfache Trennung in Hilfsfunktionen und Hauptskript macht einen großen Unterschied.

Sinnvolle kleine Projektstruktur

• Eine Datei für Hilfsfunktionen
• Eine Datei für Hauptlogik
• Separate Eingabe- oder Datendateien
• Ein Ordner für Reports oder Logs

Typische Befehle im Arbeitsalltag

ls
pwd
cat hosts.txt
python3 main.py

Formatierung und Einrückung konsequent einhalten

Python lebt stark von Einrückung und klarer Struktur. Deshalb ist konsistente Formatierung nicht nur eine Schönheitsfrage, sondern direkt Teil der Lesbarkeit. Unterschiedliche Einrückungen, chaotische Leerzeilen oder uneinheitliche Namensmuster erschweren das Verständnis erheblich. Gerade wenn mehrere Personen mit einem Skript arbeiten oder wenn Code nach Wochen erneut geöffnet wird, zahlt sich saubere Formatierung aus.

Network Engineers müssen dafür keine Style-Guides auswendig lernen, sollten aber auf klare Abschnitte, saubere Einrückung und einheitliche Muster achten. Das macht selbst einfache Skripte sofort professioneller.

Wichtige Formatierungsgrundsätze

• Einheitliche Einrückung verwenden
• Funktionen durch Leerzeilen trennen
• Lange Blöcke logisch gliedern
• Namen und Schreibweisen konsistent halten

Code für Menschen schreiben, nicht nur für den Interpreter

Ein sehr wichtiger Grundsatz für wartbaren Code lautet: Code wird zwar von Python ausgeführt, aber von Menschen gelesen, gepflegt und erweitert. Gerade in der Netzwerkautomatisierung ist dieser Gedanke entscheidend. Ein Skript lebt oft länger als ursprünglich geplant. Es wird angepasst, erweitert, im Team geteilt oder in andere Prozesse eingebaut. Wenn der Code nur technisch funktioniert, aber menschlich schwer lesbar ist, verliert er schnell seinen praktischen Wert.

Sauberer Code ist deshalb immer auch eine Form technischer Kommunikation. Er erklärt nicht nur dem Interpreter, was zu tun ist, sondern anderen Engineers, wie die Logik gedacht ist.

Woran menschlich lesbarer Code erkennbar ist

• Die Absicht eines Abschnitts ist schnell erkennbar
• Funktionen und Variablen sind verständlich benannt
• Der Ablauf ist logisch gegliedert
• Fehlerfälle sind nachvollziehbar behandelt

Kleine Beispiele für sauberen und weniger sauberen Code

Der Unterschied wird oft am besten an kurzen Beispielen sichtbar. Unten steht zunächst ein eher unklarer Stil, danach eine sauberere Variante mit besserer Lesbarkeit.

Weniger wartbar

hosts = ["SW1", "SW2", "SW3"]
for h in hosts:
    if h == "SW1":
        print("ok")
    else:
        print("check")

Wartbarer

def pruefe_switch_status(hostname):
    if hostname == "SW1":
        print(hostname, "ist erreichbar")
    else:
        print(hostname, "muss geprueft werden")

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

for switch in switches:
    pruefe_switch_status(switch)

Die zweite Variante ist zwar etwas länger, aber deutlich verständlicher und einfacher erweiterbar.

Warum wartbarer Code direkte Auswirkungen auf Betrieb und Sicherheit hat

In der Netzwerkautomatisierung ist wartbarer Code nicht nur angenehm, sondern betrieblich relevant. Skripte greifen auf Geräte, Konfigurationen, APIs und sicherheitsrelevante Daten zu. Wenn solche Werkzeuge schlecht strukturiert sind, steigt die Wahrscheinlichkeit von Fehlbedienung, Missverständnissen und unbeabsichtigten Änderungen. Wartbarer Code reduziert dieses Risiko, weil seine Wirkung besser verstanden und kontrolliert werden kann.

Gerade in produktiven Netzen ist dieser Punkt entscheidend. Automatisierung soll nicht nur Arbeit sparen, sondern kontrollierte, nachvollziehbare und sichere Abläufe schaffen. Ohne sauberen Code wird genau dieses Ziel schnell verfehlt.

Typische Bereiche mit hoher Relevanz

• Konfigurationsprüfung auf Routern und Switches
• Inventarisierung von Management-Zugängen
• Verarbeitung von Firewall- oder ACL-Daten
• Automatisierte Reports und Statusmeldungen

Praktische Grundlage für sauberen Code im Netzwerkalltag

Für Network Engineers muss sauberer und wartbarer Code kein akademisches Ziel sein. Schon einige wenige Grundprinzipien bringen sehr viel: klare Namen, kleine Funktionen, wenig doppelter Code, einfache Projektstruktur, sinnvolle Fehlerbehandlung und konsequente Lesbarkeit. Wer diese Prinzipien in kleinen Skripten übt, legt damit die Grundlage für deutlich stärkere Automatisierungswerkzeuge.

Praktische Grundregeln auf einen Blick

• Spreche Variablen und Funktionen fachlich klar an
• Halte Funktionen klein und eindeutig
• Vermeide Copy-and-Paste-Logik
• Trenne Eingabe, Verarbeitung und Ausgabe
• Behandle typische Fehler bewusst
• Schreibe Code so, dass Kollegen ihn verstehen können

Typische CLI- und Praxisbefehle, die später mit sauberem Code verknüpft werden

show ip interface brief
show vlan brief
show interfaces status
show access-lists
show running-config
python3
cat hosts.txt

Genau daraus entsteht Code, der nicht nur heute funktioniert, sondern morgen noch gepflegt, verstanden und sicher eingesetzt werden kann. Für Network Engineers ist das keine Nebensache, sondern eine Kernkompetenz moderner Automatisierung.

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.