aiMOOC

IT-Service Projekte und Automatisierung – Wiederkehrende IT-Aufgaben automatisieren

QR-Code

Einleitung

IT-Service Projekte und Automatisierung – Wiederkehrende IT-Aufgaben automatisieren

Zielgruppe: Ausbildung in IT-Berufen · Dauer: etwa 70 Minuten plus Projektaufgaben · Werkzeug: Python 3.10 oder neuer.

Du automatisierst einen wiederkehrenden IT-Service-Bericht: fiktive Tickets einlesen, Eingaben prüfen, Status zählen und den Lauf protokollieren. Das Ergebnis ist ein kleines, lokal ausführbares Skript.

Lernziele: Du kannst einen Ablauf planen, CSV-Daten validieren, verständlich loggen, Tests in einem temporären Ordner durchführen und Risiken vor einer späteren Freigabe benennen.

Sicherheitsrahmen: Verwende ausschließlich Deinen eigenen lokalen Übungsordner und fiktive Daten. Keine fremden Netze, produktiven Systeme, Zugangsdaten oder Kundendaten verwenden. Das Programm enthält keine Netzwerkfunktionen. Externe Videos und Lernseiten sind optionale Zusatzangebote und erfordern einen bewussten Aufruf.

Ausbildungsfall: Fiktive Tickets auswerten

Ein Ausbildungsbetrieb erfasst Testtickets. Bisher zählt eine Person die Status täglich manuell. Dein Skript soll die gleichen Regeln jedes Mal nachvollziehbar anwenden.

Ticket	Status
T-001	offen
T-002	erledigt
T-003	offen
T-004	wartet
T-005	offen

Erwartung: offen = 3, wartet = 1, erledigt = 1. Die Ticketkennungen und Status sind erfunden.

Sechs kurze Lerneinheiten

Lerneinheit 1: Prozess planen – 8 Minuten

Ein Algorithmus benötigt Eingabe, Verarbeitung und Ausgabe. Vor dem Speichern müssen fehlerhafte Eingaben erkannt werden.

CSV → Kopfzeile prüfen → jede Zeile prüfen → Status zählen
    → Bildschirmbericht → optional lokale Dateien speichern

Mini-Auftrag: Markiere im Ablauf den Punkt, an dem ein unbekannter Status zurückgewiesen werden muss.

Lerneinheit 2: Eingaben prüfen – 10 Minuten

Eine CSV-Datei speichert hier genau die Spalten ticket,status. Erlaubt sind die Status offen, wartet und erledigt; eine Kennung muss aus T- und genau drei ASCII-Ziffern bestehen.

Vertiefung (englisch): Corey Schafer erklärt das CSV-Modul. Für den Kurs genügt der Teil zu DictReader.

Datensatz	Prüfergebnis	Begründung
T-123,offen	gültig	Kennung und Status passen
X-123,offen	ungültig	Kennung beginnt nicht mit T-
T-124,neu	ungültig	Status ist nicht erlaubt

Merke: Datenfehler nicht stillschweigend übernehmen. Das Laborprogramm stoppt bei einem fehlerhaften Datensatz, statt einen unvollständigen Bericht auszugeben.

Lerneinheit 3: Lokales Skript ausführen – 20 Minuten

Speichere folgenden vollständigen Code als dienstcheck.py in einem neuen, ausschließlich dafür angelegten lokalen Übungsordner. Er nutzt nur die Python-Standardbibliothek. Beim ersten Aufruf erzeugt er ausschließlich im Unterordner labor die fiktive Datei tickets.csv.

import argparse
import csv
import logging
from collections import Counter
from pathlib import Path

STATUS = ("offen", "wartet", "erledigt")
DEMO = "ticket,status\nT-001,offen\nT-002,erledigt\nT-003,offen\nT-004,wartet\nT-005,offen\n"

def pruefe(zeile):
    ticket = zeile.get("ticket", "")
    status = zeile.get("status", "")
    if not (isinstance(ticket, str) and len(ticket) == 5
            and ticket.startswith("T-") and ticket[2:].isascii()
            and ticket[2:].isdigit()):
        raise ValueError("Ticketkennung ungueltig")
    if status not in STATUS:
        raise ValueError("Status ungueltig")
    return status

def auswerten(pfad):
    if not pfad.is_file() or pfad.suffix.lower() != ".csv":
        raise ValueError("CSV-Datei im Labor fehlt")
    zaehler = Counter()
    with pfad.open(encoding="utf-8", newline="") as datei:
        leser = csv.DictReader(datei)
        if leser.fieldnames != ["ticket", "status"]:
            raise ValueError("Kopfzeile muss ticket,status sein")
        for nummer, zeile in enumerate(leser, start=2):
            try:
                status = pruefe(zeile)
            except ValueError as fehler:
                raise ValueError(f"Zeile {nummer}: {fehler}") from fehler
            zaehler[status] += 1
    return zaehler

def main():
    parser = argparse.ArgumentParser(description="Lokales Ticket-Labor")
    parser.add_argument("--datei", default="tickets.csv")
    parser.add_argument("--speichern", action="store_true")
    args = parser.parse_args()
    if (Path(args.datei).name != args.datei
            or Path(args.datei).suffix.lower() != ".csv"):
        parser.error("Nur CSV-Dateinamen ohne Pfadangabe verwenden")
    labor = Path(__file__).resolve().parent / "labor"
    if labor.is_symlink():
        parser.error("Labor darf keine Verknuepfung sein")
    labor.mkdir(exist_ok=True)
    quelle = labor / args.datei
    if any(p.is_symlink() for p in
           (quelle, labor / "bericht.csv", labor / "ablauf.log")):
        parser.error("Dateiverknuepfungen sind im Labor verboten")
    if args.datei == "tickets.csv" and not quelle.exists():
        quelle.write_text(DEMO, encoding="utf-8")
    handlers = [logging.StreamHandler()]
    if args.speichern:
        handlers.append(logging.FileHandler(labor / "ablauf.log", encoding="utf-8"))
    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s",
                        handlers=handlers)
    try:
        zahlen = auswerten(quelle)
        for status in STATUS:
            print(f"{status}: {zahlen[status]}")
        if args.speichern:
            with (labor / "bericht.csv").open("w", encoding="utf-8",
                                               newline="") as datei:
                writer = csv.writer(datei)
                writer.writerow(["status", "anzahl"])
                writer.writerows((status, zahlen[status]) for status in STATUS)
            logging.info("Bericht im Labor gespeichert")
        logging.info("Lauf erfolgreich")
    except (OSError, UnicodeError, ValueError) as fehler:
        logging.error("%s", fehler)
        raise SystemExit(1) from fehler

if __name__ == "__main__":
    main()

Starte im eigenen Übungsordner:

python dienstcheck.py
python dienstcheck.py --speichern
python dienstcheck.py --datei tickets.csv

Auf manchen Systemen heißt der Befehl python3 oder py. --speichern schreibt zusätzlich labor/bericht.csv und labor/ablauf.log. Ohne diese Option wird kein neuer Bericht und keine neue Logdatei geschrieben; die Beispiel-CSV wird bei Bedarf dennoch angelegt. Bereits vorhandene Dateien werden nicht automatisch gelöscht.

Erwartete Bildschirmausgabe:

offen: 3
wartet: 1
erledigt: 1
INFO: Lauf erfolgreich

Hinweis: Die INFO-Meldung kann wegen getrennter Ausgabekanäle vor den Zählwerten erscheinen.

Lerneinheit 4: Protokollierung verstehen – 8 Minuten

Logging dokumentiert Ereignisse. INFO zeigt einen erfolgreichen Lauf, ERROR den Abbruch. Die Protokolle enthalten hier keine Ticketinhalte oder personenbezogenen Daten, sondern nur knappe Meldungen und gegebenenfalls die Zeilennummer.

Vertiefung (englisch): Corey Schafer zu Log-Leveln und Logdateien.

INFO: Bericht im Labor gespeichert
INFO: Lauf erfolgreich

# Nach einem fehlerhaften Test:
ERROR: Zeile 2: Status ungueltig

Mini-Auftrag: Begründe, weshalb der vollständige Inhalt einer späteren echten Servicemeldung nicht ungeprüft im Log stehen darf.

Lerneinheit 5: Isoliert testen – 15 Minuten

Mit automatisierten Tests prüfst Du einzelne Regeln. TemporaryDirectory erstellt einen kurzlebigen, getrennten Testordner; nach dem Test wird er wieder entfernt. Es wird keine Produktivdatei benötigt.

Vertiefung (englisch): Corey Schafer demonstriert unittest.

Speichere dies als test_dienstcheck.py direkt neben dem Skript:

import tempfile
import unittest
from pathlib import Path
from dienstcheck import auswerten, pruefe

class LaborTests(unittest.TestCase):
    def test_gueltige_zeile(self):
        self.assertEqual(pruefe({"ticket": "T-123", "status": "offen"}), "offen")

    def test_ungueltige_zeile(self):
        with self.assertRaises(ValueError):
            pruefe({"ticket": "X-123", "status": "offen"})

    def test_isolierte_datei(self):
        with tempfile.TemporaryDirectory() as ordner:
            pfad = Path(ordner) / "fiktiv.csv"
            pfad.write_text("ticket,status\nT-001,offen\nT-002,wartet\n",
                            encoding="utf-8")
            zahlen = auswerten(pfad)
            self.assertEqual(zahlen["offen"], 1)
            self.assertEqual(zahlen["wartet"], 1)
            self.assertFalse((Path(ordner) / "bericht.csv").exists())

    def test_abbruch_bei_fehler(self):
        with tempfile.TemporaryDirectory() as ordner:
            pfad = Path(ordner) / "fehler.csv"
            pfad.write_text("ticket,status\nT-001,unbekannt\n", encoding="utf-8")
            with self.assertRaises(ValueError):
                auswerten(pfad)

if __name__ == "__main__":
    unittest.main()

Testlauf:

python -m unittest -v

Erwartung: Vier Tests enden mit ok. Mit assertRaises prüfst Du auch gewollte Fehler. Die Testdateien werden in isolierten temporären Ordnern erzeugt.

Lerneinheit 6: Daten deuten – 9 Minuten

Du kannst die Ausgabe ohne zusätzliche Bibliothek visualisieren. Ein Quadrat steht für ein Ticket.

Status	Anzahl	Darstellung
offen	3	■■■
wartet	1	■
erledigt	1	■

Auswertung: 3 von 5 Testtickets sind offen; das entspricht 60 Prozent. Die Grafik zeigt nur die fiktive Übungsdatei, nicht die Leistungsfähigkeit eines realen Service-Teams.

Lokales Fehlerlabor: Erstelle selbst im Ordner labor eine neue Datei probe.csv mit dem Inhalt:

ticket,status
T-006,neu

Starte python dienstcheck.py --datei probe.csv. Erwartung: Abbruch mit ERROR, Exitcode 1. Verwende nur den selbst angelegten Laborordner. Eine schon früher erzeugte bericht.csv bleibt unverändert und darf nicht als Ergebnis des Fehlversuchs gelesen werden.

Gestufte Hilfen und begründetes Feedback

Drei Hilfestufen

Hilfe 1 – Orientierung: Prüfe erst die Kopfzeile und anschließend jede Datenzeile. Die Reihenfolge verhindert eine falsche Zuordnung der Werte.
Hilfe 2 – Codehinweis: Suche in pruefe nach den Regeln für Kennung und Status. Dort gehört der Eingabefehler hin, nicht in die Zählung.
Hilfe 3 – Testhilfe: Nutze python -m unittest -v und danach die separate probe.csv. So siehst Du gültige und ungültige Fälle ohne echte Systeme.

Selbstkontrolle mit Feedback

Beobachtung	Bewertung und Begründung
3 offen, 1 wartet, 1 erledigt	Richtig: Alle fünf gültigen Zeilen wurden genau einmal gezählt.
Unbekannter Status wird mitgezählt	Überarbeiten: Nicht erlaubte Werte müssen vor der Auswertung scheitern, sonst wird der Bericht unzuverlässig.
Ein Pfad wie ../datei.csv wird zurückgewiesen	Richtig: Die Dateinamenprüfung begrenzt den vorgesehenen Zugriff auf den lokalen Laborordner.
Eine Logdatei enthält vollständige Ticketbeschreibungen	Überarbeiten: Für die Fehlersuche genügen hier Status und Zeilennummer; unnötige Inhalte erhöhen Datenschutzrisiken.
Ein Test verändert Dateien außerhalb des Labors	Überarbeiten: Isolierte Tests müssen ihre eigenen fiktiven Daten und kurzlebigen Testordner verwenden.

Grenze des Beispiels: Es ist ein Ausbildungsskript, kein freigegebenes Produktionswerkzeug. Eine produktive Nutzung erfordert zusätzlich Berechtigungsprüfung, Review, Backupkonzept, Datenschutzprüfung, Tests mit freigegebenen Daten und einen dokumentierten Rollback.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Warum wird eine wiederkehrende Aufgabe automatisiert? (Um gleiche Abläufe nachvollziehbar zu wiederholen) (!Um jede Eingabe ungeprüft zu akzeptieren) (!Um fremde Systeme zu durchsuchen) (!Um Tests vollständig zu vermeiden)

Welche Umgebung ist für dieses Ausbildungsbeispiel vorgesehen? (Ein eigener lokaler Übungsordner) (!Ein fremdes Unternehmensnetz) (!Ein Kundensystem ohne Auftrag) (!Eine öffentliche Datenbank mit Echtdaten)

Wozu dient csv.DictReader? (Zum Einlesen von Spalten anhand ihrer Namen) (!Zum Verschlüsseln von Zugangsdaten) (!Zum Herstellen einer Netzwerkverbindung) (!Zum automatischen Neustart von Servern)

Welche Kopfzeile erwartet das Skript? (ticket,status) (!name,passwort) (!ticket,adresse,status) (!status,ticket)

Welche Ticketkennung ist gültig? (T-123) (!X-123) (!T-12) (!T-ABC)

Wie behandelt das Skript den Status neu? (Es bricht mit einem Eingabefehler ab) (!Es zählt ihn als offen) (!Es sendet ihn an einen Server) (!Es ersetzt ihn automatisch durch wartet)

Wann schreibt das Skript einen neuen Bericht? (Nach einem gültigen Lauf mit der Option --speichern) (!Bei jedem Test der Funktion pruefe) (!Schon beim Import des Moduls) (!Beim Aufruf mit einem ungültigen Dateipfad)

Welches Log-Level kennzeichnet hier den Abbruch? (ERROR) (!INFO) (!DEBUG) (!TRACE)

Wofür wird TemporaryDirectory verwendet? (Für kurzlebige getrennte Testordner) (!Für den Zugriff auf fremde Computer) (!Für das dauerhafte Speichern von Passwörtern) (!Für das Versenden von Kundendaten)

Warum werden Pfadangaben mit Verzeichniswechsel abgelehnt? (Damit der vorgesehene Dateizugriff im Labor bleibt) (!Damit die Statuszählung schneller wird) (!Damit die CSV mehr Spalten erhält) (!Damit keine Tests mehr nötig sind)

Memory

Eingabeprüfung	Ungültige Werte ablehnen
CSV	Tabellarische Textdatei
DictReader	Spaltennamen nutzen
Logging	Programmläufe protokollieren
TemporaryDirectory	Kurzlebiger Testordner
Speicheroption	Lokalen Bericht schreiben
Unittest	Regeln automatisch prüfen

Drag and Drop

Ordne die richtigen Begriffe zu.	Thema
Eingabe	CSV-Datei
Validierung	Erlaubte Werte prüfen
Verarbeitung	Statuszählung
Protokollierung	Ereignismeldung
Ausgabe	Ergebnisbericht

Kreuzworträtsel

Validierung	Wie heißt die Kontrolle, ob Eingaben den Regeln entsprechen?
Python	Welche Programmiersprache wird im lokalen Labor verwendet?
Protokoll	Wie nennt man die Aufzeichnung wichtiger Programmläufe?
Status	Welches Feld beschreibt den Bearbeitungszustand eines Tickets?
Testfall	Wie heißt eine einzelne Prüfung mit erwartetem Ergebnis?
Bericht	Wie heißt die zusammenfassende Ausgabe der gezählten Tickets?

LearningApps

Optionales externes Übungsmaterial; keine echten Daten eingeben.

Lückentext

Die Eingabedaten werden als

gelesen.

Der Spaltenname für die Ticketkennung lautet

.

Ein erlaubter Bearbeitungszustand ist

.

Die Funktion

kontrolliert die einzelnen Datensätze.

Das Modul

verarbeitet die Befehlszeilenoptionen.

Die Zählung benutzt einen

.

Das Modul

erstellt Meldungen über den Programmablauf.

Die Option

erzeugt einen lokalen Bericht.

Ein temporärer Testordner entsteht durch

.

Automatisierte Tests werden mit

ausgeführt.

Offene Aufgaben

Leicht

Basisaufgaben

Automatisierung: Zeichne den Ticket-Ablauf als eigenes Flussdiagramm und begründe die Reihenfolge.
CSV: Erstelle drei neue, ausschließlich fiktive gültige Testtickets im Labor und berechne die erwarteten Statuszahlen.
Validierung: Formuliere drei absichtlich fehlerhafte Eingaben und erläutere, welche Regel sie verletzen.
Logging: Verfasse zwei sinnvolle INFO- oder ERROR-Meldungen ohne personenbezogene Inhalte.

Standard

Anwendungsaufgaben

Python: Führe das Skript mit Deinen Testdaten aus und dokumentiere Soll- und Ist-Ausgabe.
Softwaretest: Ergänze einen fünften Unit-Test für eine falsche CSV-Kopfzeile und begründe das erwartete Scheitern.
Datenvisualisierung: Visualisiere zwei eigene fiktive Statusverteilungen und erkläre den Unterschied.
Fehlerbehandlung: Simuliere einen unbekannten Status und belege anhand der ERROR-Meldung, dass kein neuer Bericht entsteht.

Schwer

Transferaufgaben

Softwarequalität: Entwirf eine Regel gegen doppelte Ticketkennungen, ergänze einen Test und begründe die Auswirkung auf die Kennzahlen.
Datenschutz: Entwickle eine datensparsame Logging-Richtlinie für einen fiktiven IT-Service, ohne reale Daten zu verarbeiten.
IT-Service-Management: Plane eine fachlich geprüfte spätere Einführung der Automatisierung mit Rollen, Freigabe, Überwachung und Rückfalllösung.
Testautomatisierung: Übertrage das Vorgehen auf eine lokale fiktive Inventarliste und begründe neue Prüfregeln, ohne Netze oder Produktivanlagen anzusprechen.

Lernkontrolle

Qualitätssicherung: Erkläre, warum Eingabeprüfung vor der Zählung erfolgen muss. Verwende einen eigenen Fehlerfall.
Datenschutz: Bewerte den Zielkonflikt zwischen aussagekräftigen Logmeldungen und dem Schutz vertraulicher Informationen.
Fehlertoleranz: Vergleiche einen Abbruch bei ungültigen Daten mit dem stillen Überspringen von Zeilen. Wann wäre welches Vorgehen fachlich vertretbar?
Softwaretest: Begründe, weshalb vier bestandene Tests allein noch keine Freigabe für einen Produktiveinsatz darstellen.
IT-Sicherheit: Erstelle einen Freigabeplan für ein ähnliches Skript mit klarer Testumgebung, minimalen Berechtigungen und Rückfalloption.
Datenanalyse: Erkläre, warum ein hoher Anteil offener Tickets aus fünf Testdatensätzen keine Aussage über die echte Servicequalität erlaubt.

Lernnachweis

Für Deinen Lernnachweis reichen die folgenden Ergebnisse aus Deinem lokalen Labor:

Ablaufskizze: Ein selbst erstelltes Schema mit Eingabeprüfung vor der Verarbeitung.
Code: Ein funktionsfähiges Python-Skript mit eindeutig erlaubten Eingaben.
Testnachweis: Vier erfolgreich ausgeführte Unit-Tests und ein dokumentierter Fehlerfall.
Auswertung: Zahlenvergleich zwischen Erwartung und tatsächlicher Ausgabe samt kurzer Grafik.
Reflexion: Begründung für datensparsame Protokollierung, Berechtigungsgrenzen und eine mögliche Freigabeprüfung.

Bewertung: Richtiges Ergebnis, begründete Fehlerbehandlung, nachweisbare Isolation und verständliche Erklärung zählen mehr als die Anzahl zusätzlicher Funktionen.

OERs zum Thema

Fachquellen (amtliche Python-Dokumentation):

Verwendete Bilder von Wikimedia Commons (Dateiseiten mit Lizenzinformationen):

Python-logo-notext.svg – einfache Geometrie, gemeinfrei; Markenrecht beachten.
Flowgorithm Input Process Output.svg – Dave Braunschweig, CC BY-SA 4.0.
Flowchart de.svg – Erik Streb, CC BY-SA 3.0.
CsvDelimited001.svg – Dreftymac, CC BY-SA 2.5.
Software Development Lifecycle Diagram.png – Shawn Rider, CC BY-SA 4.0.

Videonachweise: Corey Schafer – CSV, Logging und Unit Testing. Die Videos sind verlinkt bzw. eingebettet, nicht als frei lizenzierte Kopien ausgewiesen. Ihre Nutzung kann eine Verbindung zu YouTube herstellen; der Python-Code selbst ist vollständig offline.

Wikipedia (thematisch verwandter Überblick):