Skip to content

Praxisprojekte: Kommandozeilen-Tools für Administratoren

Praxisnahe Werkzeuge entwickeln und das bisher erlernte Wissen in vollständigen Automatisierungsprojekten anwenden.

Viele Aufgaben in der Systemadministration wiederholen sich täglich. Dateien müssen ausgewertet, Systeme überprüft, APIs abgefragt oder Berichte erstellt werden.

Python eignet sich hervorragend, um solche Aufgaben in Form kleiner Kommandozeilenprogramme zu automatisieren. Diese Werkzeuge lassen sich direkt in Shell-Skripte, Cronjobs, CI/CD-Pipelines oder andere Automatisierungsprozesse integrieren.

In diesem Kapitel werden mehrere vollständige Praxisprojekte umgesetzt. Dabei kommen zahlreiche Themen aus den vorherigen Kapiteln zusammen: Dateiverarbeitung, APIs, Logging, Fehlerbehandlung, Argumentverarbeitung und Datenanalyse.

Ziel ist es, typische Werkzeuge zu entwickeln, die auch in realen Administrationsumgebungen eingesetzt werden könnten.

Systeminventarisierung

Überblick

Ein Systeminventarisierungs-Tool sammelt wichtige Informationen über das Betriebssystem, die Hardware und die Python-Laufzeitumgebung. Solche Daten helfen Administratoren, den Zustand von Servern oder Arbeitsstationen zu dokumentieren, Probleme schneller zu erkennen und automatisierte Berichte zu erstellen.

Python bietet mit Standardbibliotheken und bewährten Drittanbieter-Modulen einfache Möglichkeiten, diese Informationen plattformübergreifend zu erfassen.

Betriebssystem- und Hardwareinformationen erfassen

Für grundlegende Systeminformationen nutzt man das Modul platform und für detaillierte Hardware-Daten das weit verbreitete Paket psutil.

import platform
import psutil

# Betriebssysteminformationen
print(f"System: {platform.system()}")
print(f"Release: {platform.release()}")
print(f"Version: {platform.version()}")
print(f"Architektur: {platform.machine()}")

# CPU-Informationen
print(f"CPU-Kerne (logisch): {psutil.cpu_count(logical=True)}")
print(f"CPU-Kerne (physisch): {psutil.cpu_count(logical=False)}")

# Arbeitsspeicher
mem = psutil.virtual_memory()
print(f"Gesamter RAM: {mem.total // (1024 ** 2)} MB")
print(f"Verfügbarer RAM: {mem.available // (1024 ** 2)} MB")

Python-Laufzeitumgebung

Neben Systemdaten ist es oft hilfreich, die Python-Version und installierte Pakete zu dokumentieren:

import sys
import pkg_resources

print(f"Python-Version: {sys.version}")

# Liste installierter Pakete
installed_packages = sorted([f"{p.key}=={p.version}" for p in pkg_resources.working_set])
print("Installierte Pakete:")
for pkg in installed_packages:
    print(f"  - {pkg}")

Ein vollständiges Inventarisierungs-Skript

Das folgende Beispiel zeigt, wie Sie die wichtigsten Informationen sammeln und als strukturierten Bericht ausgeben können:

import platform
import psutil
import sys
import json

def system_inventory() -> dict:
    """Sammelt System- und Laufzeitinformationen."""
    mem = psutil.virtual_memory()
    inventory = {
        "os": {
            "system": platform.system(),
            "release": platform.release(),
            "version": platform.version(),
            "architecture": platform.machine()
        },
        "cpu": {
            "logical_cores": psutil.cpu_count(logical=True),
            "physical_cores": psutil.cpu_count(logical=False)
        },
        "memory": {
            "total_mb": mem.total // (1024 ** 2),
            "available_mb": mem.available // (1024 ** 2)
        },
        "python": {
            "version": sys.version,
        }
    }
    return inventory

if __name__ == "__main__":
    report = system_inventory()
    print(json.dumps(report, indent=4))

Warum Python statt Shell-Skripte?

  • Plattformunabhängigkeit: Python läuft unter Linux, Windows und macOS mit identischem Code.
  • Lesbarkeit: Python-Code ist klar strukturiert und leichter wartbar als komplexe Shell-Skripte.
  • Erweiterbarkeit: Sie können das Tool später leicht um Netzwerk- oder API-Abfragen ergänzen.
  • Bessere Fehlerbehandlung: Python bietet Ausnahmen und Logging, was robuste Skripte ermöglicht.

Best Practices

  • Verwenden Sie klare Funktionen für einzelne Aufgaben (z. B. system_inventory).
  • Nutzen Sie JSON als Ausgabeformat – es ist maschinen- und menschenlesbar.
  • Dokumentieren Sie, welche Informationen gesammelt werden und warum.
  • Testen Sie Ihr Skript auf verschiedenen Systemen, um plattformspezifische Unterschiede zu erkennen.

Mit diesem Grundgerüst können Sie Ihr Inventarisierungs-Tool Schritt für Schritt erweitern, z. B. um Netzwerkinformationen, installierte Software oder laufende Prozesse.

API-Monitor

API-Monitor: Erreichbarkeit von Webdiensten prüfen

Im Administrationsalltag ist es wichtig, die Verfügbarkeit von Webdiensten zuverlässig zu überwachen. Ein Python-Tool für API-Monitoring kann automatisiert prüfen, ob Dienste erreichbar sind, und Statusinformationen protokollieren. Dies erleichtert die Fehlerdiagnose und das proaktive Handeln.

Warum Python für API-Monitoring?

Shell-Skripte können einfache HTTP-Anfragen mit curl durchführen, doch Python bietet mehr Flexibilität:

  • Leichtes Parsen von JSON-Antworten
  • Einfache Fehlerbehandlung
  • Automatisiertes Logging
  • Zeitgesteuerte Ausführung (z.B. via Cron)

Schritt 1: HTTP-Anfrage mit requests

Das externe Paket requests ist das Standardwerkzeug für HTTP in Python. Es ist einfach zu verwenden und gut lesbar.

import requests

url = "https://api.github.com"

try:
    response = requests.get(url, timeout=5)
    response.raise_for_status()  # Prüft HTTP-Statuscode
    print(f"Dienst erreichbar, Status: {response.status_code}")
except requests.RequestException as e:
    print(f"Fehler bei der Anfrage: {e}")

Schritt 2: Statusinformationen erfassen und speichern

Für die Protokollierung speichern wir Zeitstempel, URL, HTTP-Status und Antwortzeit in einer CSV-Datei. So können wir später Trends analysieren.

import csv
import datetime

logfile = "api_monitor_log.csv"

with open(logfile, "a", newline="", encoding="utf-8") as csvfile:
    writer = csv.writer(csvfile)
    timestamp = datetime.datetime.now().isoformat(sep=' ', timespec='seconds')
    status = response.status_code if response else "Fehler"
    elapsed = response.elapsed.total_seconds() if response else None
    writer.writerow([timestamp, url, status, elapsed])

Schritt 3: Komplettes Beispiel mit Funktion und Fehlerbehandlung

import requests
import csv
import datetime

LOGFILE = "api_monitor_log.csv"


def check_api(url: str) -> None:
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()
        status = response.status_code
        elapsed = response.elapsed.total_seconds()
        print(f"{url} erreichbar, Status: {status}, Antwortzeit: {elapsed:.2f}s")
    except requests.RequestException as e:
        status = "Fehler"
        elapsed = None
        print(f"Fehler bei {url}: {e}")

    timestamp = datetime.datetime.now().isoformat(sep=' ', timespec='seconds')
    with open(LOGFILE, "a", newline="", encoding="utf-8") as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow([timestamp, url, status, elapsed])


if __name__ == "__main__":
    urls = [
        "https://api.github.com",
        "https://invalid.example.com"
    ]
    for url in urls:
        check_api(url)

Best Practices für den Einsatz

  • Timeout setzen: Verhindert, dass das Skript bei nicht reagierenden Diensten ewig wartet.
  • Fehler protokollieren: Auch Fehler sollten im Log erfasst werden, um Ausfälle nachvollziehen zu können.
  • Regelmäßige Ausführung: Kombinieren Sie das Skript mit Cron (Linux) oder Aufgabenplanung (Windows) für automatisches Monitoring.
  • Erweiterung: JSON-Antworten können mit response.json() ausgewertet werden, um spezifische API-Daten zu prüfen.

Hinweis: Installation von requests

Das Paket ist nicht in der Standardbibliothek enthalten und muss installiert werden:

pip install requests

Fazit

Mit wenigen Zeilen Python-Code lässt sich ein zuverlässiger API-Monitor bauen, der über einfache HTTP-Checks hinausgeht und durch Logging und Fehlerbehandlung den Administrationsalltag erleichtert. Im Vergleich zu Shell-Skripten bietet Python mehr Flexibilität bei der Auswertung und Weiterverarbeitung der Daten.

Reporting- und Auswertungstool

Daten aus CSV und JSON einlesen

Ein typischer Anwendungsfall in der Administration ist das Einlesen von Daten aus CSV- oder JSON-Dateien, die z. B. Monitoring- oder Konfigurationsinformationen enthalten. Python bietet mit den Modulen csv und json einfache und leistungsfähige Werkzeuge, um diese Formate zu verarbeiten.

import csv
import json

# CSV-Datei einlesen und als Liste von Dictionaries speichern
with open('monitoring_data.csv', newline='', encoding='utf-8') as csvfile:
    reader = csv.DictReader(csvfile)
    data_csv = list(reader)

# JSON-Datei einlesen
with open('config.json', encoding='utf-8') as jsonfile:
    data_json = json.load(jsonfile)

print(f"CSV-Daten: {data_csv[:2]}")
print(f"JSON-Daten: {data_json}")

Daten filtern und zusammenfassen

Oft möchte man aus den eingelesenen Daten nur bestimmte Informationen extrahieren oder zusammenfassen, z. B. alle Server mit hoher CPU-Auslastung oder die Anzahl der Fehler pro Tag.

# Beispiel: Filtere Server mit CPU-Auslastung > 80%
high_cpu = [entry for entry in data_csv if float(entry['cpu_usage']) > 80]

# Beispiel: Fehleranzahl pro Tag aus JSON-Monitoringdaten zählen
from collections import Counter

error_dates = [entry['date'] for entry in data_json['errors']]
errors_per_day = Counter(error_dates)

print(f"Server mit hoher CPU-Auslastung: {len(high_cpu)}")
print(f"Fehler pro Tag: {errors_per_day}")

Berichte als Textdatei erzeugen

Die Auswertung kann als übersichtlicher Bericht in eine Textdatei geschrieben werden. So lassen sich Ergebnisse archivieren oder per E-Mail versenden.

with open('report.txt', 'w', encoding='utf-8') as report:
    report.write('=== Server mit hoher CPU-Auslastung ===\n')
    for server in high_cpu:
        report.write(f"{server['hostname']}: {server['cpu_usage']}%\n")

    report.write('\n=== Fehler pro Tag ===\n')
    for date, count in errors_per_day.items():
        report.write(f"{date}: {count} Fehler\n")

Warum Python statt Shell-Skripte?

Shell-Skripte sind oft schnell geschrieben, stoßen aber bei komplexeren Datenformaten oder Auswertungen an Grenzen. Python bietet:

  • Einfache Handhabung von CSV und JSON mit Standardbibliotheken
  • Klare, lesbare Syntax auch für komplexere Filter und Aggregationen
  • Gute Erweiterbarkeit z. B. für weitere Formate oder Ausgabeoptionen

Dadurch sind Python-Skripte robuster und leichter wartbar, gerade bei wachsender Datenmenge und Komplexität.

Best Practices

  • Verwenden Sie with-Blöcke zum sicheren Öffnen von Dateien
  • Nutzen Sie csv.DictReader für klar benannte Spaltenzugriffe
  • Vermeiden Sie harte Kodierungen von Dateipfaden; Parameter oder Konfigurationen sind besser
  • Schreiben Sie Berichte so, dass sie auch von anderen Tools weiterverarbeitet werden können (z. B. CSV, JSON oder gut strukturierter Text)

Zusammenfassung

Mit wenigen Zeilen Python-Code lassen sich CSV- und JSON-Daten effizient einlesen, filtern und als Berichte ausgeben. Dieses Vorgehen erleichtert tägliche Auswertungen, automatisiert wiederkehrende Aufgaben und verbessert die Übersicht über komplexe Monitoring- oder Konfigurationsdaten.