aiMOOC

IT-Service Projekte und Automatisierung – Projektunterlagen prüfbar zusammenstellen

QR-Code

IT-Service Projekte und Automatisierung – Projektunterlagen prüfbar zusammenstellen

Ein praxisorientierter aiMOOC für die IT-Ausbildung

Kurzbeschreibung: Anforderung, Umsetzung und Ergebnisnachweis. Du lernst, IT-Service-Projekte nachvollziehbar zu dokumentieren, lokale Automatisierungen zu testen und Projektunterlagen so zusammenzustellen, dass andere Deine Ergebnisse überprüfen können.

Zielgruppe: Auszubildende der IT-Berufe, insbesondere Fachinformatiker für Systemintegration und Anwendungsentwicklung.

Lernzeit: Ca. 60 Minuten für den Grundkurs, zusätzlich Zeit für die Projektaufgaben.

Voraussetzungen: Grundkenntnisse im Umgang mit Dateien und Ordnern. Für das lokale Labor benötigst Du Python 3.8 oder neuer.

Einleitung

Ein erfolgreiches IT-Projekt benötigt mehr als eine funktionierende technische Lösung.

Du musst zeigen können:

Anforderung: Was sollte erreicht werden?
Umsetzung: Wie wurde die Lösung entwickelt?
Ergebnisnachweis: Welche überprüfbaren Belege zeigen, dass die Anforderungen erfüllt sind?

Die Projektdokumentation verbindet Planung, Entscheidungen, Umsetzung, Tests und Übergabe. Diese Zusammenhänge sind auch für betriebliche Projektarbeiten in der IT-Ausbildung wichtig.

Dein Kursziel: Am Ende erstellst Du eine kleine digitale Projektakte mit Anforderungen, fiktiven Testdaten, Verarbeitungsergebnissen, Testbericht und Prüfsummen.

Dein Lernpfad

Einheit	Thema	Dauer	Ergebnis
1	Anforderungen erfassen	8 Minuten	Prüfkriterien
2	Umsetzung planen	8 Minuten	Projektplan
3	Lokal automatisieren	18 Minuten	Testlabor
4	Ergebnisse nachweisen	10 Minuten	Projektakte
5	Unterlagen prüfen	8 Minuten	Übergabeprüfung

Sicherheitsregel: Alle praktischen Übungen verwenden ausschließlich fiktive Daten und lokale Dateien. Nutze keine fremden Netzwerke, Produktivsysteme, Kundendaten, Zugangsdaten oder fremden IT-Dienste. Übertrage keine Projektdateien an externe Plattformen.

Die fiktive Projektarbeit in diesem Kurs ist ein Lernbeispiel und kein Ersatz für eine genehmigte betriebliche IHK-Projektarbeit. Bei echten Prüfungsprojekten gelten die Vorgaben Deiner zuständigen IHK; tatsächliche Arbeitsabläufe müssen wahrheitsgemäß dokumentiert werden.

Ausbildungsfall: Automatisierte IT-Service-Ticketprüfung

Situation: Im vollständig fiktiven Ausbildungsbetrieb „Lernwerk IT“ werden Service-Tickets bisher manuell sortiert.

Projektauftrag: Entwickle eine kleine lokale Automatisierung, die sechs fiktive Tickets einliest, nach vorgegebenen Regeln priorisiert, unvollständige Einträge erkennt und die Ergebnisse dokumentiert.

Abgrenzung: Es gibt kein echtes Ticketsystem, keinen Serverzugriff, keine Netzwerkverbindung und keine reale Kundenkommunikation.

Ausgangsdaten

Ticket	Typ	Erwartete Priorität
T01	Störung	hoch
T02	Anfrage	normal
T03	Information	niedrig
T04	Anfrage	normal
T05	Störung	hoch
T06	Typ fehlt	zurückweisen

Die Prioritäten sind ausschließlich vereinfachte Regeln des Ausbildungsfalls. In einem echten IT-Service würden Dringlichkeit, Auswirkung und vereinbarte Serviceziele berücksichtigt.

Lerneinheit 1 – Anforderungen prüfbar formulieren

Merksatz: Eine gute Anforderung beschreibt ein überprüfbares Soll-Ergebnis.

„Das System soll gut funktionieren“ ist zu ungenau.

„Das Programm weist Tickets ohne gültigen Typ zurück und dokumentiert den Fehler“ lässt sich testen.

Anforderungen und Akzeptanzkriterien

ID	Anforderung	Akzeptanzkriterium
A1	CSV-Daten einlesen	Sechs fiktive Tickets werden eingelesen
A2	Fehlerhafte Einträge erkennen	T06 wird im Fehlerfall zurückgewiesen
A3	Tickets priorisieren	Zwei hohe, zwei normale und ein niedriger Eintrag entstehen im Fehlerfall
A4	Sicher lokal arbeiten	Keine Netzwerkzugriffe oder echten Kundendaten

Wichtig: A1 bis A3 werden durch programmierte Tests überprüft. A4 erfordert zusätzlich eine nachvollziehbare Kontrolle von Code und Testumgebung.

Mini-Aufgabe: Basis

Formuliere ein eigenes Akzeptanzkriterium für A2. Nenne dabei Eingabe, erwartetes Verhalten und Nachweis.

Begründetes Feedback: „Fehler erkennen“ allein reicht nicht. Ein prüfbares Kriterium benennt beispielsweise den fehlenden Typ, die Zurückweisung und den Eintrag in der Fehlerdatei.

Lerneinheit 2 – Umsetzung planen und dokumentieren

Bei einem IT-Service-Projekt solltest Du Arbeitsschritte, Entscheidungen und Risiken nachvollziehbar festhalten.

Datei:GANTT Chart.JPG

Ein Gantt-Diagramm macht Arbeitsschritte und ihre zeitliche Abfolge sichtbar.

Beispiel: Projektablauf

Phase	Tätigkeit	Nachweis
Planung	Anforderungen festlegen	Anforderungsliste
Entwicklung	CSV-Verarbeitung programmieren	Lokaler Programmcode
Test	Soll und Ist vergleichen	Testbericht
Abschluss	Ergebnisse zusammenstellen	Projektakte

Ein Kanban-Board ermöglicht es Dir, Aufgaben zwischen „Offen“, „In Arbeit“, „Prüfung“ und „Erledigt“ zu verschieben.

Entscheidungen begründen

Alternative	Vorteil	Nachteil
Manuelle Tabellenprüfung	Kein Programmieraufwand	Wiederkehrende Handarbeit
Lokales Python-Programm	Wiederholbare Verarbeitung	Entwicklungs- und Testaufwand

Entscheidung im Lernfall: Python wird verwendet, weil dieselben Prüfschritte wiederholbar durchgeführt und Ergebnisse in Dateien festgehalten werden können.

Die Wirtschaftlichkeit einer echten Automatisierung müsste zusätzlich anhand von Aufwand, Häufigkeit und Betriebskosten bewertet werden.

Videolernangebot: Git-Grundlagen und lokale Versionskontrolle. Für diese Übung sind weder GitHub noch ein Onlinekonto erforderlich.

Mini-Aufgabe: Anwendung

Zeichne ein kleines Kanban-Board für den Ausbildungsfall und verteile die vier Projektphasen auf passende Spalten.

Begründetes Feedback: Ein gutes Board zeigt den aktuellen Bearbeitungsstand. Eine erledigte Entwicklungsaufgabe bedeutet noch nicht, dass die gesamte Lösung getestet oder freigegeben wurde.

Lerneinheit 3 – Automatisierung im isolierten Testlabor

Du arbeitest jetzt in einem lokalen Python-Labor. Das Programm benötigt nur Module der Python-Standardbibliothek.

Es führt keine Netzwerkzugriffe aus. Eingabe- und Zwischendateien liegen in einem temporären lokalen Verzeichnis. Nur das fertige ZIP-Archiv wird im aktuellen Arbeitsordner gespeichert.

Vorbereitung

Erstelle auf Deinem eigenen Computer einen neuen leeren Übungsordner.
Speichere den nachfolgenden Python-Code als projektlabor.py.
Öffne ein Terminal in diesem Ordner.
Starte das Programm mit python projektlabor.py oder unter vielen Linux-Systemen mit python3 projektlabor.py.

Lokales Python-Labor: Projektakte erzeugen

from pathlib import Path
from tempfile import TemporaryDirectory
from zipfile import ZipFile, ZIP_DEFLATED
from hashlib import sha256
from collections import Counter
import csv
import json

def csv_schreiben(pfad, spalten, zeilen):
    with pfad.open("w", newline="", encoding="utf-8") as datei:
        writer = csv.DictWriter(datei, fieldnames=spalten)
        writer.writeheader()
        writer.writerows(zeilen)

try:
    korrektur = input(
        "Ticket T06 lokal korrigieren? j/N: "
    ).strip().lower() == "j"
except EOFError:
    korrektur = False

dateiname = (
    "projektakte_korrigiert.zip" if korrektur
    else "projektakte_fehlfall.zip"
)
ziel = Path.cwd() / dateiname

if ziel.exists():
    raise SystemExit(
        "Die ZIP-Datei existiert schon. "
        "Bitte bewusst umbenennen oder verschieben."
    )

tickets = [
    {"id": "T01", "typ": "Stoerung"},
    {"id": "T02", "typ": "Anfrage"},
    {"id": "T03", "typ": "Info"},
    {"id": "T04", "typ": "Anfrage"},
    {"id": "T05", "typ": "Stoerung"},
    {"id": "T06", "typ": "Info" if korrektur else ""},
]

regeln = {
    "Stoerung": "hoch",
    "Anfrage": "normal",
    "Info": "niedrig",
}

with TemporaryDirectory(
    prefix="it_service_labor_"
) as temp:

    ort = Path(temp)

    csv_schreiben(
        ort / "eingang.csv",
        ["id", "typ"],
        tickets
    )

    with (ort / "eingang.csv").open(
        newline="", encoding="utf-8"
    ) as datei:
        eingang = list(csv.DictReader(datei))

    ergebnis = []
    fehler = []

    for ticket in eingang:
        if not ticket["id"] or ticket["typ"] not in regeln:
            fehler.append({
                "id": ticket["id"],
                "grund": "Typ fehlt oder unbekannt"
            })
        else:
            ergebnis.append({
                **ticket,
                "prioritaet": regeln[ticket["typ"]]
            })

    csv_schreiben(
        ort / "ergebnis.csv",
        ["id", "typ", "prioritaet"],
        ergebnis
    )

    csv_schreiben(
        ort / "fehler.csv",
        ["id", "grund"],
        fehler
    )

    soll = {
        "hoch": 2,
        "normal": 2,
        "niedrig": 2 if korrektur else 1
    }

    ist = dict(Counter(
        ticket["prioritaet"] for ticket in ergebnis
    ))

    tests = {
        "P1_Eingangsmenge": len(eingang) == 6,
        "P2_Fehleranzahl": len(fehler) == (
            0 if korrektur else 1
        ),
        "P3_Ausgabemenge": len(ergebnis) == (
            6 if korrektur else 5
        ),
        "P4_Prioritaeten": ist == soll,
        "P5_T06": (
            "T06" in {t["id"] for t in fehler}
        ) == (not korrektur)
    }

    anforderungen = {
        "A1": "Sechs fiktive CSV-Tickets einlesen",
        "A2": "Ungueltige Typen zurueckweisen",
        "A3": "Gueltige Tickets priorisieren",
        "A4": "Nur lokale fiktive Testdaten"
    }

    (ort / "anforderungen.json").write_text(
        json.dumps(
            anforderungen,
            ensure_ascii=False,
            indent=2
        ),
        encoding="utf-8"
    )

    (ort / "testbericht.json").write_text(
        json.dumps({
            "bestanden": all(tests.values()),
            "tests": tests,
            "zaehlung": ist
        }, ensure_ascii=False, indent=2),
        encoding="utf-8"
    )

    (ort / "uebergabe.txt").write_text(
        "Fiktiver Ausbildungsfall.\n"
        "Entscheidung: CSV und lokales Python.\n"
        "Keine Produktivsysteme oder Netzanfragen.\n"
        "Echte Abnahme: AUSSTEHEND.\n"
        "Testbericht ersetzt keine Freigabe.\n",
        encoding="utf-8"
    )

    manifest = {
        datei.name: sha256(
            datei.read_bytes()
        ).hexdigest()
        for datei in sorted(ort.iterdir())
    }

    (ort / "manifest.json").write_text(
        json.dumps(manifest, indent=2),
        encoding="utf-8"
    )

    with ZipFile(ziel, "x", ZIP_DEFLATED) as archiv:
        for datei in sorted(ort.iterdir()):
            archiv.write(datei, arcname=datei.name)

print("Projektakte:", ziel.name)
print(
    "Tests:",
    "BESTANDEN" if all(tests.values())
    else "FEHLGESCHLAGEN"
)
print("Balken: Ein Zeichen entspricht einem Ticket")

for status in ("hoch", "normal", "niedrig"):
    anzahl = ist.get(status, 0)
    print(f"{status:8} {'#' * anzahl} {anzahl}")

print("Abgewiesen:", "#" * len(fehler), len(fehler))

Was passiert?

Das Programm erzeugt fiktive Eingabedaten, verarbeitet gültige Tickets, dokumentiert Fehler, führt fünf automatische Prüfungen aus und speichert sieben Dateien in einem ZIP-Archiv.

Falls das gewünschte ZIP bereits vorhanden ist, wird es nicht überschrieben.

Interaktiver Testfall A: Fehlerzustand

Antworte bei der Programmabfrage mit N oder drücke die Eingabetaste.

Erwartete Ergebnisse:

Ergebnis	Visualisierung	Anzahl
Hohe Priorität	■■	2
Normale Priorität	■■	2
Niedrige Priorität	■	1
Zurückgewiesen	■	1

Das Programm erstellt projektakte_fehlfall.zip.

Feedback: Die Tests können erfolgreich sein, obwohl ein Ticket zurückgewiesen wird. Der Fehlerfall ist vorgesehen; korrekt ist, dass der ungültige Datensatz erkannt, nicht verarbeitet und dokumentiert wird.

Interaktiver Testfall B: Korrigierter Zustand

Starte das Programm erneut und antworte diesmal mit j.

Ergebnis	Visualisierung	Anzahl
Hohe Priorität	■■	2
Normale Priorität	■■	2
Niedrige Priorität	■■	2
Zurückgewiesen	–	0

Das Programm erstellt projektakte_korrigiert.zip.

Feedback: Nach der Korrektur wird T06 gültig verarbeitet. Beide ZIP-Dateien bilden unterschiedliche, reproduzierbare Testzustände ab.

Lernvideo: CSV mit Python

Das Video erklärt das Lesen und Schreiben von CSV-Dateien. Nutze für eigene Versuche weiterhin ausschließlich lokale fiktive Daten.

Gestufte Hilfen für das Testlabor

Hilfe	Unterstützung
Stufe 1: Hinweis	Überprüfe zuerst Dateiname, Arbeitsordner und Python-Version.
Stufe 2: Leitfrage	Welche Funktion liest die CSV-Daten, und an welcher Stelle wird ein ungültiger Typ erkannt?
Stufe 3: Lösungsweg	Verfolge den Ablauf von `csv.DictReader` über `regeln` und `fehler` bis zum `testbericht.json`.

Bei Fehlern: Lies die erste relevante Fehlermeldung, prüfe den Speicherort und ändere jeweils nur eine Sache. Verwende keine Online-Codeausführung mit echten Projektdaten.

Lerneinheit 4 – Ergebnisnachweise erstellen

Merksatz: Ein Testbericht zeigt ein Prüfergebnis. Eine Prüfsumme hilft dabei, nachträgliche Dateiänderungen zu erkennen.

Die Testpyramide unterscheidet verschiedene Testebenen. Unser Beispiel nutzt einfache automatische Funktionsprüfungen des lokalen Verarbeitungsablaufs. Es ist keine vollständige Teststrategie für ein Produktivsystem.

Die sieben Dateien Deiner Projektakte

Datei	Prüffunktion
`anforderungen.json`	Beschreibt die Projektanforderungen
`eingang.csv`	Belegt die verwendeten Testdaten
`ergebnis.csv`	Enthält gültige Verarbeitungsergebnisse
`fehler.csv`	Dokumentiert zurückgewiesene Tickets
`testbericht.json`	Enthält Testergebnisse und Auswertung
`uebergabe.txt`	Beschreibt Entscheidung, Grenzen und Abnahmestatus
`manifest.json`	Enthält SHA-256-Prüfsummen der übrigen Dateien

Anforderung, Test und Beleg verbinden

Anforderung	Test	Ergebnisbeleg
A1	P1	eingang.csv
A2	P2 und P5	fehler.csv
A3	P3 und P4	ergebnis.csv und testbericht.json
A4	Manuelle Kontrolle	Programmcode und uebergabe.txt

Diese Verbindung heißt Rückverfolgbarkeit. Sie erleichtert es einer anderen Person, die Erfüllung einer Anforderung zu überprüfen.

Dateien mit SHA-256 prüfen

Fehler beim Erstellen des Vorschaubildes:

Eine schematische Darstellung von Hashfunktionen. Das Bild verwendet ältere Beispiel-Hashwerte; unser Labor nutzt ausdrücklich SHA-256.

Speichere den folgenden Code als pruefen.py im selben lokalen Ordner wie die ZIP-Dateien.

from pathlib import Path
from zipfile import ZipFile
from hashlib import sha256
import json

name = input(
    "ZIP-Datei [projektakte_fehlfall.zip]: "
).strip() or "projektakte_fehlfall.zip"

if not Path(name).is_file():
    raise SystemExit("Die angegebene ZIP-Datei fehlt.")

with ZipFile(name, "r") as archiv:
    pruefsummen = json.loads(
        archiv.read("manifest.json")
    )

    dateien = set(archiv.namelist()) - {"manifest.json"}

    ok = dateien == set(pruefsummen)

    for datei, erwartet in pruefsummen.items():
        aktuell = sha256(
            archiv.read(datei)
        ).hexdigest()
        if aktuell != erwartet:
            ok = False
            print("Abweichung:", datei)

    print("Integritaet:", "OK" if ok else "ABWEICHUNG")

    original = archiv.read("ergebnis.csv")
    veraendert = original + b"!"

    test = sha256(veraendert).hexdigest()
    print(
        "Simulierte Aenderung erkannt:",
        test != pruefsummen["ergebnis.csv"]
    )

Erwartete Ausgabe:

Integritaet: OK
Simulierte Aenderung erkannt: True

Die Gegenprobe verändert ausschließlich Bytes im Arbeitsspeicher. Die gespeicherte ZIP-Datei bleibt unverändert.

Fachliche Grenze: Ein Hashvergleich mit dem Manifest kann unbeabsichtigte oder nicht gleichzeitig im Manifest aktualisierte Änderungen sichtbar machen. Er beweist nicht, wer die Dateien erstellt hat. Dafür wären zusätzliche Vertrauensmechanismen wie eine verifizierte digitale Signatur erforderlich.

Lernvideo: Automatische Softwaretests

Englischsprachiges Tutorial zur Testautomatisierung mit Python und unittest. Der Kurscode benötigt dieses zusätzliche Tutorial nicht.

Lerneinheit 5 – Projektunterlagen prüfen und übergeben

Ein guter Projektabschluss umfasst Kontrolle, Bewertung und eine dokumentierte Übergabe.

Der PDCA-Zyklus beschreibt einen wiederholbaren Verbesserungsprozess: Planen, Durchführen, Überprüfen und Verbessern.

Peer-Review: Ist die Projektakte prüfbar?

Prüffrage	Erwarteter Beleg
Ist das Ziel eindeutig?	Anforderungen und Kriterien
Ist die Umsetzung nachvollziehbar?	Code und Entscheidung
Sind die Testdaten erkennbar?	Fiktive Eingangsdaten
Werden Fehler dokumentiert?	Fehlerdatei
Sind Ergebnisse überprüfbar?	Testbericht und Soll-Ist-Vergleich
Sind Dateiänderungen erkennbar?	Manifest und Hashkontrolle
Liegt eine echte Abnahme vor?	Nein, im Übungsfall ausdrücklich ausstehend

Begründetes Feedback: Eine erfolgreiche technische Prüfung ist nicht automatisch eine fachliche Abnahme. Eine Freigabe benötigt eine dafür berechtigte Person und die vereinbarten Abnahmekriterien.

Übergabe in drei Sätzen

Formuliere eine kurze Übergabe für Deinen fiktiven Auftraggeber:

Was wurde umgesetzt?
Welche Tests wurden durchgeführt und was haben sie ergeben?
Welche Einschränkungen oder offenen Entscheidungen bestehen?

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was macht eine Projektanforderung prüfbar? (Ein eindeutig überprüfbares Akzeptanzkriterium) (!Ein möglichst langer Beschreibungstext) (!Ein besonders großes Projektdiagramm) (!Eine ungeprüfte mündliche Zusage)

Feedback: Erst ein konkretes Soll-Ergebnis ermöglicht einen nachvollziehbaren Soll-Ist-Vergleich.

Welche Priorität erhält eine Störung im Ausbildungsfall? (hoch) (!normal) (!niedrig) (!unbekannt)

Feedback: Diese Zuordnung ist im vereinfachten Regelwerk des Lernfalls ausdrücklich festgelegt.

Was geschieht im Fehlerfall mit Ticket T06? (Es wird zurückgewiesen und dokumentiert) (!Es wird ungeprüft übernommen) (!Es wird automatisch gelöscht ohne Nachweis) (!Es wird an einen externen Server gesendet)

Feedback: Fehlerhafte Eingaben werden getrennt erfasst und dürfen nicht unbemerkt in das Verarbeitungsergebnis gelangen.

Wozu dient ein Akzeptanzkriterium? (Zur Überprüfung einer Anforderung) (!Zum automatischen Veröffentlichen der Dateien) (!Zum Ersetzen des Programmtests) (!Zum Verbergen technischer Entscheidungen)

Feedback: Ein Akzeptanzkriterium definiert, wann eine Anforderung als erfüllt betrachtet werden kann.

Warum verwendet das Labor ein temporäres Verzeichnis? (Zur Trennung und vorübergehenden Speicherung der Testdateien) (!Zum automatischen Zugriff auf Kundensysteme) (!Zum Versenden der Ergebnisse ins Internet) (!Zum dauerhaften Löschen fremder Dateien)

Feedback: Die Zwischendateien bleiben lokal und werden nach dem Laborlauf wieder entfernt.

Welche Datei enthält die automatischen Testergebnisse? (testbericht.json) (!eingang.csv) (!uebergabe.txt) (!manifest.json)

Feedback: Die Testdatei dokumentiert Prüfungen und Ergebnisse. Das Manifest dokumentiert dagegen Prüfsummen.

Was kann der Vergleich von SHA-256-Prüfsummen feststellen? (Ob sich Dateiinhalte gegenüber einem bekannten Prüfwert verändert haben) (!Wer eine Datei ursprünglich erstellt hat) (!Ob ein Auftraggeber die Lösung freigegeben hat) (!Ob ein Projekt wirtschaftlich sinnvoll ist)

Feedback: Prüfsummen unterstützen Integritätsprüfungen, ersetzen aber weder Signaturen noch Abnahmen.

Was zeigt eine Rückverfolgbarkeitsmatrix? (Die Verbindung von Anforderungen, Tests und Nachweisen) (!Nur die Namen des Projektteams) (!Nur die verwendete Programmiersprache) (!Nur den Speicherplatz des Archivs)

Feedback: Eine solche Zuordnung macht sichtbar, welcher Beleg welche Anforderung unterstützt.

Wie viele gültige Tickets enthält der ursprüngliche Fehlerfall? (Fünf) (!Vier) (!Sechs) (!Drei)

Feedback: Von sechs Eingaben wird T06 wegen des fehlenden Typs zurückgewiesen.

Welche Aussage zur Projektübergabe ist richtig? (Ein bestandener technischer Test ersetzt keine autorisierte Abnahme) (!Ein ZIP-Archiv gilt immer als formale Abnahme) (!Ein Screenshot ersetzt alle Projektnachweise) (!Eine Dokumentation benötigt keine Entscheidungen)

Feedback: Test, Ergebnisnachweis und Abnahme sind unterschiedliche Vorgänge.

Memory

Ordne die passenden Begriffe und Beschreibungen einander zu.

Anforderung	Beschreibung eines geforderten Soll-Zustands
Akzeptanzkriterium	Messbare Erfüllungsbedingung
Eingangstabelle	Sammlung fiktiver Testtickets
Fehlerprotokoll	Dokumentation zurückgewiesener Einträge
Testbericht	Ergebnisse systematischer Prüfungen
Prüfsumme	Aus Dateiinhalten berechneter Kontrollwert
Abnahme	Autorisierte Bestätigung der vereinbarten Leistung

Feedback: Achte darauf, dass Anforderung, Prüfung und Bestätigung verschiedene Funktionen im Projekt haben.

Drag and Drop

Ordne jeder Projektphase ihren passenden Arbeitsschritt zu.

Ordne die richtigen Begriffe zu.	Projektphase
Anforderungserfassung	Soll-Ergebnis beschreiben
Implementierung	Tickets automatisiert verarbeiten
Testdurchführung	Soll und Ist vergleichen
Ergebnisdokumentation	Testbericht und Nachweise sichern
Projektübergabe	Ergebnisse und offene Freigabe vorlegen

Feedback: Die Reihenfolge unterstützt eine prüfbare Dokumentation. Nachträgliche Änderungen können neue Tests erforderlich machen.

Kreuzworträtsel

Ticket	Wie nennt man einen dokumentierten IT-Service-Fall?
Hashwert	Wie heißt das berechnete Ergebnis einer Hashfunktion?
Manifest	Welche Datei enthält im Labor die Liste der Prüfsummen?
Testfall	Wie heißt eine festgelegte Prüfung mit Eingabe und Erwartung?
Abnahme	Wie heißt die formale Bestätigung einer vereinbarten Leistung?
Anforderung	Welcher Begriff beschreibt eine geforderte Eigenschaft der Lösung?

LearningApps

Ergänzende freiwillige Aufgabensuche zum Kursthema. Verwende dort keine echten Projekt- oder Kundendaten.

Lückentext

Ein IT-Projekt beginnt mit der Ermittlung der

.

Eine prüfbare Erfüllungsbedingung heißt

.

Für tabellarische Testdaten verwendet das Labor das Format

.

Das Programm wird lokal mit der Programmiersprache

ausgeführt.

Die fiktiven Servicefälle werden als

bezeichnet.

Ein Eintrag ohne gültigen Typ wird

.

Die Überprüfung erwarteter Ergebnisse erfolgt durch

.

Die Prüfergebnisse stehen im

.

Die Verknüpfung von Anforderungen und Nachweisen nennt man

.

Für die Dateiprüfsummen wird der Algorithmus

verwendet.

Die Prüfsummen werden in einem

gespeichert.

Eine fachliche Freigabe heißt

.

Offene Aufgaben

Bearbeite die Aufgaben entsprechend Deinem Lernstand. Verwende nur das lokale Labor und fiktive Daten. Zu jeder Aufgabe findest Du ein begründetes Bewertungskriterium.

Leicht – Basisaufgaben

Anforderungen beschreiben: Formuliere drei Anforderungen an eine lokale Ticketverarbeitung. Feedback: Jede Anforderung sollte ein erkennbares Ergebnis oder Verhalten benennen.
Akzeptanzkriterien entwickeln: Ergänze zu Deinen Anforderungen jeweils eine konkrete Prüfmöglichkeit. Feedback: Gute Kriterien erlauben eine eindeutige Entscheidung zwischen erfüllt und nicht erfüllt.
Projektphasen visualisieren: Zeichne einen kleinen Zeitplan für Planung, Umsetzung, Test und Abschluss. Feedback: Die Planung ist sinnvoll, wenn Abhängigkeiten sichtbar sind und Testzeit vorgesehen ist.
Dateistruktur erklären: Erstelle eine beschriftete Zeichnung der sieben Dateien aus dem ZIP-Archiv. Feedback: Die Zuordnung ist gelungen, wenn jede Datei eine nachvollziehbare Belegfunktion hat.

Standard – Anwendungsaufgaben

Fehlerfall untersuchen: Führe den lokalen Fehlerfall durch, dokumentiere die Ergebnisse und begründe die Zurückweisung. Feedback: Entscheidend sind der Nachweis des fehlenden Typs und die korrekte Trennung gültiger und ungültiger Daten.
Testfallvergleich: Erzeuge beide ZIP-Varianten und vergleiche die Zahlen aus den Testberichten. Feedback: Erkläre, warum fünf und sechs gültige Tickets jeweils zum gewählten Testzustand passen.
Änderungen dokumentieren: Erstelle lokal zwei Versionen eines selbst verfassten Projektprotokolls und markiere die Unterschiede. Feedback: Eine Versionshistorie sollte den Grund jeder Änderung erkennen lassen.
Projektakte auditieren: Tausche ausschließlich fiktive, selbst erstellte Ergebnisse mit einer autorisierten Lernpartnerin oder einem Lernpartner aus und überprüft die Anforderungen gegenseitig. Feedback: Eine unabhängige Prüfung sollte ihre Ergebnisse anhand der vorhandenen Dateien begründen können.

Schwer – Transferaufgaben

Serviceprozess erweitern: Entwickle ein Konzept für zusätzliche fiktive Tickettypen mit neuen Prioritätsregeln. Feedback: Die Erweiterung ist tragfähig, wenn Regeln, Sonderfälle und Akzeptanzkriterien gemeinsam angepasst werden.
Negativtests entwerfen: Ergänze in einer lokalen Kopie des Laborprogramms einen Test für einen unbekannten Tickettyp. Feedback: Die Verarbeitung muss den neuen ungültigen Eintrag kontrolliert zurückweisen, ohne ihn als gültiges Ergebnis auszugeben.
Integritätskontrolle bewerten: Untersuche, warum eine veränderte Datei und ein ebenfalls angepasstes Manifest eine einfache Hashkontrolle umgehen können. Erstelle dazu nur eine theoretische Analyse. Feedback: Eine gute Antwort unterscheidet Integrität, Herkunftsnachweis und Vertrauenswürdigkeit des Referenzwertes.
Verbesserungsvorschlag entwickeln: Entwirf ein eigenes kleines IT-Service-Automatisierungsprojekt für eine rein lokale Modellumgebung. Vergleiche manuelle und automatisierte Bearbeitung anhand realistischer Annahmen. Feedback: Der Vorschlag überzeugt, wenn Nutzen, Aufwand, Risiken, Testkonzept und Nachweise aufeinander abgestimmt sind.

Lernkontrolle

Diese Aufgaben überprüfen Zusammenhänge und Transferleistungen statt isoliertem Faktenwissen.

Unklare Anforderungen verbessern: Ein Auftrag lautet „Die Ticketbearbeitung soll schneller sein“. Formuliere daraus zwei prüfbare Anforderungen und begründe die Wahl Deiner Messgrößen.
Fehlernachweise beurteilen: Ein Programm meldet „Test erfolgreich“, aber die Fehlerdatei fehlt. Erkläre, warum die Projektakte trotzdem unvollständig ist und wie Du die Lücke behebst.
Testabdeckung reflektieren: Die fünf Labortests bestehen. Beschreibe mindestens drei Risiken, die damit noch nicht ausreichend geprüft sind, beispielsweise unerwartete Eingaben, größere Datenmengen oder unklare Priorisierungsregeln.
Sicheren Transfer planen: Ein Lernbetrieb möchte das Beispiel später auf ein reales Ticketsystem übertragen. Erkläre, welche Genehmigungen, Datenschutzmaßnahmen, Schnittstellenprüfungen und Sicherheitskontrollen zunächst erforderlich wären. Führe keine Verbindung zu diesem System aus.
Nachweiskette bewerten: Vergleiche Testbericht, SHA-256-Manifest und digitale Signatur. Erkläre, welches Beweisziel jeweils unterstützt wird und welche Grenzen bestehen.
Projektentscheidung begründen: Die Automatisierung spart rechnerisch Bearbeitungszeit, verursacht aber Wartungsaufwand. Entwickle eine einfache Kosten-Nutzen-Abwägung und erkläre, unter welchen Bedingungen Du das Projekt empfehlen würdest.

Bewertungskriterien: Fachlich richtige Begründung, nachvollziehbarer Bezug zu Anforderungen, geeignete Prüfnachweise, Berücksichtigung von Risiken und klare Unterscheidung zwischen Modell und realem IT-Betrieb.

Lernnachweis

Dein Lernnachweis besteht aus einer nachvollziehbaren, ausschließlich mit fiktiven Daten erstellten Projektakte.

Projektziel: Ausgangssituation und gewünschte Verbesserung sind beschrieben.
Anforderungen: Mindestens drei Anforderungen mit passenden Akzeptanzkriterien sind enthalten.
Projektplanung: Arbeitsschritte, Alternativen und die begründete Entscheidung für eine Lösung sind nachvollziehbar.
Umsetzung: Der eigene oder angepasste lokale Programmcode ist beigefügt und erläutert.
Testdaten: Die verwendeten fiktiven Eingaben sind dokumentiert.
Testnachweise: Erwartete und tatsächliche Ergebnisse sind gegenübergestellt; erkannte Fehler werden nicht verschwiegen.
Integrität: Ein Manifest mit Prüfsummen und das Ergebnis der Integritätsprüfung liegen vor.
Auswertung: Einschränkungen, offene Fragen und der Abnahmestatus sind korrekt beschrieben.
Reflexion: Du erklärst, welche Entscheidungen sinnvoll waren und was Du bei einer Weiterentwicklung ändern würdest.

Mindeststandard: Eine andere Person muss die Unterlagen ohne erfundene Zusatzinformationen prüfen und die Testergebnisse in ihrer eigenen lokalen Lernumgebung nachvollziehen können.

OERs zum Thema

Fachliche Quellen

Die folgenden Quellen dienen zur fachlichen Einordnung. Das Kursprojekt ist eine eigenständige didaktische Simulation.

Bundesinstitut für Berufsbildung: Fachinformatiker/Fachinformatikerin – Umsetzungshilfe für die Ausbildungspraxis.
DIHK-Umsetzungsempfehlungen zu betrieblichen IT-Projektarbeiten – Anforderungen, Planung und Dokumentation.
IHK Region Stuttgart: Informationen zur betrieblichen Projektarbeit – Dokumentation, Entscheidungen, Nachweise und Prüfung.
Python-Dokumentation: CSV – Lesen und Schreiben tabellarischer Daten.
Python-Dokumentation: tempfile – Temporäre lokale Testverzeichnisse.
Python-Dokumentation: hashlib – SHA-256 und andere Hashfunktionen.
Python-Dokumentation: zipfile – Erstellen und Lesen von ZIP-Archiven.

Hinweis zur Ausbildung: Die zuständige IHK kann besondere formale Vorgaben festlegen. Übernimm deshalb nicht ungeprüft den Umfang oder die Struktur dieses Lernfalls für eine echte Prüfungsarbeit.

Wikimedia-Commons-Medien und Lizenznachweise

Alle folgenden Dateien wurden als vorhandene Commons-Dateien recherchiert. Ihre Lizenzangaben beziehen sich auf die jeweiligen Dateibeschreibungsseiten.

Software Development Life cycle.png – Tazlavi, CC BY-SA 4.0.
GANTT Chart.JPG – Chabre, gemeinfrei nach der Commons-Dateibeschreibung.
Abstract Kanban Board.svg – Jennifer Falco, CC BY 4.0.
Testing Pyramid.svg – Abbe98, CC BY-SA 4.0.
Hash function.svg – David Göthberg, gemeinfrei nach der Commons-Dateibeschreibung.
PDCA Cycle.svg – Diagram by Karn Bulsuk (Urheberseite), CC BY 4.0.

Medienrechte: Beachte bei einer Bearbeitung die jeweilige Namensnennung, Lizenzverlinkung und gegebenenfalls Weitergabe unter gleichen Bedingungen. Die eingebundenen Commons-Dateien wurden hier nicht verändert.

YouTube-Lernmedien

Mit Mario: Lerne Git in 60 Minuten – Versionsverwaltung.
Schule goes YouTube: Python – CSV-Dateien lesen und schreiben – Dateiverarbeitung.
Corey Schafer: Python Tutorial – Unit Testing – Automatisierte Softwaretests.

Rechtehinweis: Diese Videos werden als externe Lernmedien eingebettet oder verlinkt. Ihre Einbettung bedeutet nicht, dass sie frei bearbeitet, heruntergeladen oder neu veröffentlicht werden dürfen. Sie werden daher nicht pauschal als OER-lizenzierte Videos ausgewiesen.

Datenschutzhinweis: Externe Videos und iFrames können beim Laden Verbindungen zu Drittanbietern herstellen. Öffne sie nur entsprechend Deiner Einwilligung und den Regeln Deiner Lernumgebung. Übermittle dort keine Projektdaten.