aiMOOC

IT-Service Projekte und Automatisierung – Konfigurationen versioniert verwalten

QR-Code

Einleitung

IT-Service Projekte und Automatisierung – Konfigurationen versioniert verwalten

Zielgruppe: IT-Ausbildung · Dauer: 5 Lerneinheiten à 8–12 Minuten plus Übungen · Lernziel: Änderungen erkennen, dokumentieren, testen und einen funktionierenden Konfigurationsstand wiederherstellen.

Ausbildungsfall (vollständig fiktiv): Die Lernfirma Musterwerk IT betreut den erfundenen Dienst demo-api. Eine Testanfrage braucht in unserer Simulation 5 Sekunden. Der konfigurierte Timeout wird versehentlich von 10 auf 2 Sekunden verkürzt. Du untersuchst den Unterschied und stellst die geprüfte Version wieder her.

Sicherheitsrahmen: Ausschließlich lokale, ausdrücklich erlaubte Übungsrechner und fiktive Konfigurationsdaten. Keine Produktivsysteme, Kundendaten, Passwörter, Tokens, fremden Netze oder ungefragten Übertragungen. Das Python-Labor legt ein neues Git-Repository im temporären lokalen Verzeichnis an und entfernt es danach. Videos und externe iFrames sind optionale Online-Materialien; keine Labordaten dort eingeben.

Git-Logo: Jason Long, Wikimedia Commons, CC BY 3.0.

Lerneinheit 1: Warum versionieren? (8 Minuten)

Versionsverwaltung hält fest, welche Datei wann in welchem Stand gespeichert wurde. Ein Git-Commit ist ein nachvollziehbarer Schnappschuss. Er ersetzt weder einen Funktionstest noch ein unabhängiges Backup.

Ausgangsstand v1       Änderung v2        Wiederherstellung v3
Timeout 10 s     --->  Timeout 2 s  --->   Timeout 10 s
Test: OK               Test: FEHLER        Test: OK

Lokales Mini-Codebeispiel (Python 3): Berechne die Testergebnisse ohne Netzwerkverbindung.

for timeout in (2, 5, 8):
    print(timeout, "OK" if timeout >= 5 else "FEHLER")

Video zur Grundidee: „Was ist GIT? Einfach erklärt!“ – Programmieren lernen. Bei externen Videos gelten die Rechte des jeweiligen Anbieters.

Mini-Auftrag: Erkläre, warum „config-neu-final.json“ ohne Versionshistorie keine sichere Wiederherstellungsstrategie ist.

Lerneinheit 2: Der lokale Git-Kreislauf (10 Minuten)

Du bearbeitest eine Datei im Arbeitsverzeichnis. Mit git diff prüfst Du Änderungen, mit git add merkst Du eine Datei vor, mit git commit speicherst Du einen Stand, mit git log liest Du die Historie.

Arbeitsverzeichnis, Staging und Commit: Daniel Kinzler, Wikimedia Commons, CC BY 3.0. Im Kurs verwendest Du keine dargestellten Netzwerkbefehle wie push oder pull.

Aufgabe	Lokaler Befehl	Ergebnis
Änderung prüfen	`git diff`	veränderte Zeilen
Datei vormerken	`git add service.json`	Staging Area
Stand sichern	`git commit -m "Teststand"`	lokaler Commit
Verlauf prüfen	`git log --oneline`	Commitliste

Vertiefung: „Lerne Git in 30 Minuten“ – Mit Mario; behandelt auch lokale Wiederherstellung.

Lerneinheit 3: Isoliertes interaktives Git-Labor (12 Minuten)

Voraussetzungen: Python 3 und Git ab 2.23, beide bereits lokal installiert. Speichere den folgenden Code als labor.py. Starte ihn im lokalen Terminal mit python labor.py (gegebenenfalls python3 labor.py oder py labor.py). Der Test stellt keine Netzwerkverbindung her.

Deine Eingabe: Wähle einen Timeout von 1 bis 30 Sekunden. Das Programm simuliert eine feste Antwortdauer von 5 Sekunden, erstellt zwei Commits und stellt bei einem Fehler die ältere Datei wieder her. Es schreibt ausschließlich in ein automatisch aufgeräumtes temporäres Verzeichnis.

import json
import shutil
import subprocess
import tempfile
from pathlib import Path

def git(ordner, *argumente):
    return subprocess.run(
        ["git", "-C", str(ordner), *argumente],
        check=True, text=True, capture_output=True
    ).stdout.strip()

def speichern(datei, timeout):
    daten = {"dienst": "demo-api", "timeout_s": timeout}
    datei.write_text(json.dumps(daten, indent=2) + "\n", encoding="utf-8")

def pruefen(datei):
    timeout = json.loads(datei.read_text(encoding="utf-8"))["timeout_s"]
    return "OK" if timeout >= 5 else "FEHLER"

if shutil.which("git") is None:
    raise SystemExit("Bitte Git lokal installieren.")

with tempfile.TemporaryDirectory(prefix="aimooc_git_") as tmp:
    labor = Path(tmp)
    git(labor, "init", "-q")
    git(labor, "config", "user.name", "Lernlabor")
    git(labor, "config", "user.email", "labor@example.invalid")
    git(labor, "config", "commit.gpgsign", "false")
    git(labor, "config", "core.hooksPath", str(labor / "ohne_hooks"))
    datei = labor / "service.json"

    speichern(datei, 10)
    git(labor, "add", "service.json")
    git(labor, "commit", "-qm", "Ausgangsversion")
    print("v1:", pruefen(datei))

    try:
        neu = int(input("Test-Timeout 1 bis 30 Sekunden [2]: ") or "2")
    except ValueError:
        raise SystemExit("Bitte eine ganze Zahl eingeben.")
    if not 1 <= neu <= 30:
        raise SystemExit("Erlaubt sind 1 bis 30 Sekunden.")

    speichern(datei, neu)
    print("Unterschied:\n" + git(labor, "diff", "--", "service.json"))
    git(labor, "add", "service.json")
    git(labor, "commit", "-qm", "Testaenderung")
    print("v2:", pruefen(datei))

    if pruefen(datei) == "FEHLER":
        git(labor, "restore", "--source=HEAD~1", "--", "service.json")
        git(labor, "add", "service.json")
        git(labor, "commit", "-qm", "Ruecknahme nach Fehltest")
        print("Wiederhergestellt:", pruefen(datei))

    print("Verlauf:\n" + git(labor, "log", "-3", "--format=%s"))
    print("Status:", git(labor, "status", "--porcelain") or "sauber")
print("Das temporaere Labor wurde entfernt.")

Getestete Fälle: Bei Eingabe 2 folgt v2: FEHLER und Wiederhergestellt: OK. Bei 8 folgt v2: OK ohne Rücknahme. In beiden Fällen lautet der Git-Status am Ende sauber. Die Zeichen - und + im Diff markieren entfernte und hinzugefügte Zeilen.

Konfiguration	Timeout	Simulierte Antwort	Ergebnis
v1 Ausgangsstand	10 s	5 s	OK
v2 Fehlversuch	2 s	5 s	FEHLER
v3 Rücknahme	10 s	5 s	OK

Benötigte Zeit    █████       5 s
v1 Timeout        ██████████ 10 s    OK
v2 Timeout        ██          2 s    FEHLER
v3 Timeout        ██████████ 10 s    OK

Die Balken zeigen ausschließlich die fiktive Laborsimulation, keine gemessene Serverleistung.

Gestufte Hilfen: Hilfe A – Die Antwort braucht 5 Sekunden: Vergleiche diese Dauer mit dem Timeout. Hilfe B – Lies im Diff die Zeile timeout_s. Hilfe C – HEAD~1 bezeichnet hier den Commit vor dem fehlerhaften Teststand. Mit git restore --source=HEAD~1 -- service.json holst Du die Datei im Übungsrepository zurück; ungesicherte Änderungen an dieser Datei würden überschrieben.

Lerneinheit 4: Historie, Wiederherstellung und Abnahme (8 Minuten)

Ein Repository speichert Commits. Bei unserem Fehlversuch bleibt der fehlerhafte Commit in der Historie; die Wiederherstellung wird als neuer Commit dokumentiert. So kannst Du den Ablauf später begründen.

Commit-Struktur als Vertiefung: Bunyk, Wikimedia Commons, CC BY-SA 4.0.

Abnahmefolge: Änderung ansehen → Test ausführen → Ergebnis dokumentieren → bei Fehler altes Dateibild wiederherstellen → erneut testen → Rücknahme committen.

Wichtige Unterscheidung: git restore setzt eine Dateiversion im Arbeitsverzeichnis zurück. git revert erzeugt dagegen einen Commit, der Änderungen eines anderen Commits rückgängig macht. Das Labor verwendet git restore und einen anschließenden eigenen Commit. Vor jedem Restore ungespeicherte Arbeit prüfen.

Vertiefung: „Lerne Git in 60 Minuten“ – Mit Mario; Kapitel zu Diff, Restore und Rücknahme.

Lerneinheit 5: Teamarbeit, Backup und Sicherheit (8 Minuten)

Vor einer realen Änderung bräuchtest Du einen freigegebenen Änderungsauftrag, einen Test, ein Rückfallverfahren und eine Dokumentation. Dieses Training führt keinen realen Change aus.

Versionszweige als Ausblick: Stannered, Sami Kerola, Moxfyre, Echion2 und Alpenfuchs, Wikimedia Commons, CC BY-SA 3.0.

3-2-1-Backupstrategie: Olaf Pichler, Wikimedia Commons, CC BY-SA 4.0.

Merke: Git ist keine alleinige Backup-Strategie. Sichere Wiederherstellbarkeit braucht zusätzlich geprüfte, getrennte Sicherungen. Niemals Passwörter oder API-Tokens committen; .gitignore entfernt keine bereits versionierten Geheimnisse aus alten Commits.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was ist ein Commit in Git? (Ein gespeicherter Versionsstand) (!Eine automatische Datensicherung außerhalb des Rechners) (!Ein echter Server-Neustart) (!Ein Passwortspeicher)

Welcher Befehl zeigt nicht vorgemerkte Dateiänderungen? (git diff) (!git push) (!git clone) (!git init)

Was macht git add mit einer Datei? (Sie für den nächsten Commit vormerken) (!Sie an einen fremden Server schicken) (!Sie endgültig aus der Historie löschen) (!Ihre Funktion automatisch prüfen)

Welche Eingabe löst im Labor einen Fehler aus? (2 Sekunden) (!5 Sekunden) (!8 Sekunden) (!10 Sekunden)

Warum schlägt der Test bei 2 Sekunden fehl? (Die simulierte Antwort benötigt 5 Sekunden) (!Git benötigt immer 10 Sekunden) (!Der Dienst ist mit dem Internet verbunden) (!Das Repository ist beschädigt)

Wo wird im Kurs das Git-Repository angelegt? (In einem lokalen temporären Verzeichnis) (!In einer Kundendatenbank) (!In einem fremden Cloud-Projekt) (!Auf dem Produktivserver)

Welche Quelle nutzt das Labor beim Restore? (Den vorherigen Commit) (!Eine öffentlich zugängliche Kundendatei) (!Den Webbrowser-Cache) (!Eine externe Test-API)

Was steht nach einem erfolgreichen Rollback-Test im Protokoll? (Wiederhergestellt: OK) (!v2: FEHLER als Endzustand) (!Remote verbunden) (!Passwort gespeichert)

Welche Aussage zu git restore ist richtig? (Nicht gesicherte Dateiänderungen können verloren gehen) (!Git restore erzeugt immer ein Backup auf einem anderen Rechner) (!Git restore lädt immer Daten aus dem Internet) (!Git restore ersetzt jeden Funktionstest)

Was gehört zur sicheren Konfigurationspflege? (Versionierung mit Tests und unabhängigen Backups) (!Zugangsdaten in Commits speichern) (!Änderungen ohne Freigabe produktiv einsetzen) (!Fehlerhafte Konfigurationen ungeprüft verteilen)

Begründetes Quiz-Feedback: Bei Fragen 1–3 zählt der Unterschied zwischen Ansehen, Vormerken und Speichern. Bei Fragen 4–5 ist 2 kleiner als die benötigten 5 Sekunden; bei 5, 8 oder 10 Sekunden besteht die fiktive Simulation. Fragen 6–8 prüfen lokale Isolation, Vorgängerversion und erneute Abnahme. Bei Fragen 9–10 gilt: Restore kann ungesicherte Änderungen überschreiben; Versionshistorie, Funktionstest und getrenntes Backup erfüllen unterschiedliche Aufgaben.

Memory

Arbeitsverzeichnis	Ort der bearbeiteten Dateien
Staging Area	Vorgemerkte Inhalte
Commit	Gespeicherter Schnappschuss
Diff	Sichtbarer Zeilenvergleich
Restore	Rückholen einer Dateiversion
Backup	Unabhängige Sicherungskopie

Drag and Drop

Ordne die richtigen Begriffe zu.	Funktion
git diff	Änderungen vergleichen
git add	Änderungen vormerken
git commit	Versionsstand speichern
git log	Historie anzeigen
git restore	Datei wiederherstellen

Kreuzworträtsel

Commit	Wie heißt ein gespeicherter Git-Schnappschuss?
Repository	Wie heißt das Archiv für Git-Versionen?
Branch	Wie heißt ein unabhängiger Entwicklungszweig?
Rollback	Wie heißt die Rückkehr zu einem vorherigen funktionierenden Stand?
Diff	Wie heißt der Vergleich geänderter Zeilen?
Backup	Wie heißt eine unabhängige Sicherungskopie?

LearningApps

Optionales externes Übungsmaterial; gib dort keine Labordaten oder personenbezogenen Daten ein.

Lückentext

Eine

hält frühere Dateistände nachvollziehbar fest.

Ein Git-Projekt wird in einem

verwaltet.

Ein gespeicherter Stand heißt

.

Bearbeitete Dateien liegen zunächst im

.

Der Befehl git

zeigt Unterschiede an.

Mit git

werden Inhalte für den nächsten Commit vorgemerkt.

Der Befehl git

zeigt den Verlauf.

Die simulierte Anfrage benötigt

Sekunden.

Mit einem Timeout von zwei Sekunden ergibt sich ein

.

Im Labor enthält die Ausgangsversion einen Timeout von

Sekunden.

Die Wiederherstellung einer Datei kann mit git

erfolgen.

Nach der Wiederherstellung wird die Konfiguration erneut

.

Die Historie ersetzt kein unabhängiges

.

Echte Zugangsdaten dürfen nicht in einen Commit

.

Offene Aufgaben

Bewertungshinweis: Zu jeder Aufgabe gehört ein eigener Nachweis sowie eine Begründung. Die Feedback-Sätze helfen Dir, Dein Ergebnis zu prüfen.

Leicht – Basis

Versionsfolge: Zeichne v1 → v2 → v3 und markiere den Fehler. Feedback: v3 braucht einen eigenen Nachweis, weil eine erfolgreiche Rücknahme nicht nur behauptet werden soll.
Begriffskarten: Gestalte vier Bild- oder Textkarten zu Diff, Add, Commit und Log. Feedback: Korrekte Karten trennen Vergleich, Auswahl, Speicherung und Historie.
Konfigurationsvergleich: Schreibe zwei fiktive JSON-Zeilen mit Timeout 10 und 2 und markiere den Unterschied. Feedback: Nur der geänderte Wert ist für diesen Test ursächlich.
Testvorhersage: Sage das Ergebnis für 2, 5 und 8 Sekunden voraus. Feedback: Der Test besteht ab 5 Sekunden, da die simulierte Antwort genau 5 Sekunden braucht.

Standard – Anwendung

Laborversuche: Starte das lokale Programm mit 2 und 8 Sekunden und protokolliere die Terminalausgaben. Feedback: Nur der Fehlversuch braucht den zusätzlichen Wiederherstellungs-Commit.
Änderungsanalyse: Erstelle ein kleines Poster aus der Diff-Ausgabe und erkläre Minus- und Plus-Zeile. Feedback: Der Vergleich belegt den Eingriff, aber nicht dessen fachliche Freigabe.
Commit-Protokoll: Vergleiche die Commit-Meldungen der beiden Laborläufe. Feedback: Die Historie soll Ursache und Behebung nachvollziehbar machen.
Freigabeformular: Entwirf für die fiktive Lernfirma einen einseitigen Änderungsauftrag mit Ziel, Test und Rückfallplan. Feedback: Ohne klaren Rückfallplan bleibt die Änderung unnötig riskant.

Schwer – Transfer

Risikomatrix: Bewerte die Risiken „falscher Timeout“, „fehlendes Backup“ und „ungeprüfte Rücknahme“ auf einem Diagramm. Feedback: Eintrittswahrscheinlichkeit und Auswirkung sind getrennt zu begründen.
Teamablauf: Zeichne zwei parallele Testzweige und eine kontrollierte Zusammenführung. Feedback: Unterschiedliche Experimente dürfen einen freigegebenen Stand nicht unbemerkt verändern.
Test-Erweiterung: Ergänze das lokale Python-Labor um eine zweite fiktive Prüfung, etwa einen erlaubten Portbereich. Feedback: Ein valider JSON-Wert garantiert noch keinen funktionierenden Dienst.
Wiederanlaufkonzept: Entwirf ein Schaubild, wie Git, lokale Tests, Berechtigungen und getrennte Backups zusammenarbeiten. Feedback: Nur ein getestetes Gesamtkonzept behandelt auch Verlust oder Beschädigung des Repositorys.

Lernkontrolle

Änderungsentscheidung: Im lokalen Labor besteht der Test bei Timeout 5, aber nicht bei 4. Begründe die Freigabe anhand der angenommenen Antwortdauer und nenne eine Grenze des Modells.
Fehlerdiagnose: Zwei Commits existieren, aber die Änderung wurde nie getestet. Entwirf einen sicheren Diagnose- und Rückfallablauf.
Ausfallvergleich: Das lokale Repository geht durch einen Defekt verloren. Erkläre, warum Git allein nicht genügt und welche zusätzliche Maßnahme hilft.
Geheimnisschutz: Eine fiktive Konfiguration enthält versehentlich einen API-Schlüssel. Entwickle eine Vorgehensweise zum Stoppen, Melden, Sperren und sicheren Ersetzen statt bloßem Löschen einer Datei.
Abnahmeprotokoll: Formuliere messbare Kriterien für „Rollback erfolgreich“ und unterscheide Dateistand von Dienstfunktion.
Teamkonflikt: Zwei Lernende ändern unterschiedliche Werte derselben Testdatei. Entwickle eine nachvollziehbare Review- und Zusammenführungsstrategie.

Lernnachweis

Gib ausschließlich anonymisierte Ergebnisse aus dem lokalen Labor ab:

Eine beschriftete Grafik mit v1, v2 und v3.
Ein kurzer Diff-Auszug aus der fiktiven Datei.
Die protokollierten Tests für Eingaben 2 und 8.
Die passenden Commit-Meldungen und das Ergebnis Status: sauber.
Eine Erklärung, warum die Rücknahme erfolgreich war und welche Grenzen die Simulation hat.
Ein Rückfall- und Backup-Konzept für die fiktive Lernfirma.

Bewertungsraster (12 Punkte): Versionsfolge und Diff 3 · Testauswertung 3 · nachvollziehbare Rücknahme 3 · Sicherheits- und Backup-Transfer 3. Begründetes Feedback: Volle Punktzahl setzt nicht nur ein korrektes Ergebnis, sondern den erklärten Zusammenhang zwischen Änderung, Wirkung und Wiederherstellung voraus.

OERs zum Thema

Fachquellen (geprüfte Primärdokumentation):

Medienrechte: Die fünf im Lerntext eingebundenen Commons-Grafiken nennen ihre Urheber und jeweilige Creative-Commons-Lizenz samt verlinkter Dateiseite. Die drei YouTube-Videos sind nur als externe Ergänzung eingebettet; daraus folgt keine Freigabe zur Weiterverbreitung als OER. Die lokalen Code- und Beispieldaten sind eigens für diesen Lernfall erstellt. Externe Medien können beim Aufruf Netzwerkverbindungen zu ihren Anbietern herstellen.