Fassung 1.0.3

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Inhalte: Wochen 5 bis 8
2026-10-04 21:53:10 +02:00 · 2026-10-04 21:53:10 +02:00 · 2026-10-04 18:25:04 +02:00 · 2026-10-04 18:25:04 +02:00 · 2026-10-03 00:50:59 +02:00 · 2026-10-03 00:50:59 +02:00
41 changed files with 2186 additions and 24 deletions
@@ -1,6 +1,7 @@
 node_modules/
 .next/
 out/
+build/
 next-env.d.ts
 *.tsbuildinfo

@@ -26,6 +26,73 @@ Vor `npm version` wandert der Abschnitt „Unveröffentlicht" unter eine neue

 ## [Unveröffentlicht]

+## [1.0.3] – 2026-10-04
+
+Vier neue Wochen Lehrgang. Damit ist jede Position des Ausbildungsrahmenplans
+von mindestens einem Inhalt berührt.
+
+### Hinzugefügt
+
+- **Woche 5 · Ausbildung, Betrieb und Zusammenarbeit** – Handouts A4 (Rechte
+  und Pflichten, Aufbau der Abschlussprüfung), A5 (Aufbau- und
+  Ablauforganisation, Mitbestimmung), A6 (Kanalwahl, Ablage, Besprechungen),
+  Praxisaufgabe 5.1 (den Betrieb aus Sicht der IT kartieren),
+  Lernzielkontrolle. Schließt C1, C2 und C5
+- **Woche 6 · IT-Sicherheit und Datenschutz** – Handouts I1 (Schutzziele und
+  Schutzbedarf nach BSI-Standard 200-2), I2 (Passwörter, zweiter Faktor,
+  Phishing), I3 (DSGVO in der Administration), Praxisaufgabe 6.1
+  (Schutzbedarfsfeststellung), Checkliste „Sicherheit eines Arbeitsplatzes
+  prüfen"
+- **Woche 7 · Skripting mit PowerShell** – Handouts P1 (Pipeline und
+  Objekte), P2 (Variablen, Bedingungen, Schleifen), P3 (Skripte, die man
+  betreuen kann), Praxisaufgabe 7.1 (Inventarskript), Lernzielkontrolle.
+  Schließt A4 und A10
+- **Woche 8 · Datensicherung und Speicher** – Handouts S3 (Sicherungsarten,
+  3-2-1, RPO und RTO), S4 (Wiederherstellung testen), S5 (RAID, NAS, SAN),
+  Praxisaufgabe 8.1 (Sicherung eines Bereichs prüfen und zurückspielen),
+  Checkliste „Wiederherstellung testen"
+- Themenblöcke „IT-Sicherheit und Datenschutz" (I) und „Skripting und
+  Automatisierung" (P)
+- 22 Glossareinträge, 38 Merkkarten
+
+Bestehende Installationen: Die neuen Wochen erscheinen im Wochenplan unter
+„noch nicht eingeplant" und werden dort einmal eingeplant.
+
+## [1.0.2] – 2026-10-04
+
+### Hinzugefügt
+
+- **Bremse gegen Passwortraten.** Nach fünf Fehlversuchen wird eine
+  E-Mail-Adresse gesperrt, erst eine Minute, dann doppelt so lang, höchstens
+  15 Minuten. Das gilt auch für Adressen, die es nicht gibt – die Sperre
+  verrät also nicht, welche Konten existieren. Während der Sperre kommt auch
+  das richtige Passwort nicht durch. Ausgesperrt? Ein Neustart des Containers
+  setzt die Zähler zurück. Siehe E42
+- Die Containerabnahme prüft die Sperre im laufenden Abbild
+
+## [1.0.1] – 2026-10-03
+
+Das Docker-Abbild ist jetzt aus dem Nichts aufsetzbar.
+
+### Behoben
+
+- **Im Docker-Abbild ließ sich kein erstes Konto anlegen.** Die README nannte
+  `node werkzeuge/konto.js`, das Abbild enthielt aber nur die Sicherungsskripte,
+  und `tsx` gibt es dort nicht. Ein frisch aufgesetzter Server stand vor einer
+  Anmeldeseite ohne Konto. Das Kontowerkzeug wird jetzt beim Bau mit esbuild zu
+  einer Datei gebündelt (`npm run werkzeuge:bauen`) und liegt unter
+  `/app/werkzeuge/konto.js`
+- **Windows-Pfade in Dateinamen von Anhängen** wurden unter Linux nicht
+  abgetrennt – aus `C:\Users\x\foto.jpg` wurde `C:Usersxfoto.jpg`. Nur die
+  Anzeige war betroffen, gespeichert wird unter der UUID. Der Test dazu war
+  unter Windows grün und unter Linux rot
+
+### Hinzugefügt
+
+- `npm run abnahme:container` – Abnahmelauf gegen das gebaute Docker-Abbild:
+  Lebenszeichen, Betrieb ohne root, erstes Konto, Anmeldung, Passwort neu
+  setzen, Sicherung im Volume
+
 ## [1.0.0] – 2026-09-11

 Die erste abnahmefähige Fassung. Alle zehn Bausteine sind fertig, die
@@ -24,6 +24,9 @@ ENV NEXT_TELEMETRY_DISABLED=1
 COPY --from=abhaengigkeiten /app/node_modules ./node_modules
 COPY . .
 RUN npm run build
+# Das Kontowerkzeug als eine einzige JS-Datei – im Abbild gibt es kein tsx.
+# Die nativen Module bleiben draußen, sie bringt die Standalone-Ausgabe mit.
+RUN npm run werkzeuge:bauen

 # --- Laufzeit -------------------------------------------------------------
 FROM node:${NODE_VERSION} AS laufzeit
@@ -51,8 +54,9 @@ COPY --from=bau /app/public ./public
 COPY --from=bau /app/content ./content
 COPY --from=bau /app/src/lib/db/migrationen ./migrationen

-# Werkzeuge für Sicherung und Wiederherstellung im Container.
+# Werkzeuge für Sicherung, Wiederherstellung und das erste Konto.
 COPY --from=bau /app/scripts/im-container ./werkzeuge
+COPY --from=bau /app/build/werkzeuge/konto.js ./werkzeuge/konto.js
 RUN chmod +x ./werkzeuge/*.sh

 RUN mkdir -p /daten && chown -R node:node /daten /app
@@ -471,3 +471,25 @@ Der Grund ist banal und war ein echter Fehler: Wer die dunkle Fassung
 eingestellt hatte, druckte schwarze Flächen. Eine einzelne Regel für `body`
 genügt nicht, weil die Karten, Ränder und Marken ihre Farben aus Merkmalen
 beziehen.
+
+## E42 · Bremse gegen Passwortraten im Speicher, je E-Mail-Adresse
+
+Nach fünf Fehlversuchen wird eine Adresse gesperrt, erst eine Minute, dann
+jeweils doppelt so lang, höchstens 15 Minuten. Eine Stunde ohne Fehlversuch
+oder eine erfolgreiche Anmeldung setzt den Zähler zurück.
+
+- **Je Adresse, nicht je Konto.** Auch eine Adresse, die es nicht gibt, wird
+  gesperrt. Sonst verriete die Sperre, welche Konten existieren (E6).
+- **Nicht je IP-Adresse.** Hinter dem Reverse Proxy käme die Adresse aus
+  `X-Forwarded-For`, und darauf ist nur Verlass, wenn der Proxy richtig
+  eingestellt ist. Bei einer Handvoll Konten lohnt das Durchprobieren vieler
+  Konten mit wenigen Passwörtern ohnehin nicht.
+- **Obergrenze 15 Minuten.** Wer die Adresse des Ausbilders kennt, soll ihn
+  nicht für Stunden aussperren können.
+- **Im Speicher, nicht in der Datenbank.** Es läuft genau ein Prozess. Ein
+  Neustart setzt die Zähler zurück – das kann ein Angreifer nicht auslösen,
+  der Betreiber aber schon, wenn er sich selbst ausgesperrt hat
+  (`docker compose restart lernbar`).
+- **Gezählt wird vor der Prüfung.** Jeder Versuch gilt sofort als Fehlversuch
+  und wird bei Erfolg zurückgenommen. Zwischen Sperrprüfung und Zählen liegt
+  so kein `await`; sonst kämen gleichzeitige Anfragen alle an der Sperre vorbei.
@@ -39,14 +39,13 @@ Die Anwendung lauscht danach auf `127.0.0.1:3000`. Erstes Ausbilderkonto
 anlegen:

 ```bash
-docker compose exec lernbar node -e "1" >/dev/null   # Container erreichbar?
-docker compose exec lernbar sh -c \
-  'node werkzeuge/konto.js --name "Vorname Nachname" --email ausbilder@betrieb.de --rolle ausbilder'
+docker compose exec lernbar node werkzeuge/konto.js \
+  --name "Vorname Nachname" --email ausbilder@betrieb.de --rolle ausbilder
 ```

-> Solange das Konto-Werkzeug im Abbild noch nicht liegt, geht es vom
-> Entwicklungsrechner aus:
-> `npm run konto:anlegen -- --name "…" --email … --rolle ausbilder`
+Ohne `--passwort` wird eines erzeugt und ausgegeben. Gibt es die Adresse
+schon, setzt derselbe Aufruf das Passwort neu – das ist zugleich der Weg, wenn
+das einzige Ausbilderkonto sein Passwort vergessen hat.

 Danach im Browser anmelden, unter **Verwaltung** das Azubikonto anlegen und
 das Ausbildungsverhältnis mit Beginndatum einrichten.
@@ -244,6 +243,7 @@ npm run typecheck    # TypeScript
 npm run lint         # ESLint
 npm run test         # Vitest – Logik, die wehtut (315 Tests)
 npm run abnahme      # der Abnahmelauf, siehe unten
+npm run abnahme:container   # derselbe Weg gegen das Docker-Abbild
 ```

 ### Der Abnahmelauf
@@ -269,6 +269,17 @@ Voraussetzung: `npm run build` ist gelaufen, und Port 3399 ist frei – sonst
 bricht der Lauf mit einer Meldung ab, statt gegen einen fremden Datenbestand zu
 prüfen.

+### Der Containerlauf
+
+`npm run abnahme` prüft über `next start`, betrieben wird aber der Container.
+`npm run abnahme:container` baut deshalb das Abbild, startet es mit leerem
+Volume und geht den Weg aus dieser README: Lebenszeichen, erstes Konto über
+`werkzeuge/konto.js`, Anmeldung, Passwort neu setzen, Sperre nach
+Fehlversuchen, Sicherung im Container.
+Danach werden Container, Volume und Abbild wieder entfernt.
+
+Voraussetzung: Docker läuft, Port 3398 ist frei (`LERNBAR_CONTAINER_PORT`).
+
 ### Einzelne Zusagen

 ```bash
@@ -0,0 +1,49 @@
+---
+id: "5.1"
+titel: Den Betrieb aus Sicht der IT kartieren
+woche: 5
+block: arbeitsalltag
+ziel: Du erstellst eine Übersicht aller Abteilungen mit Ansprechpartner, wichtigsten Anwendungen und kritischen Zeiten und legst sie so ab, dass das ganze IT-Team damit arbeiten kann.
+zeitrahmen: 6 Stunden, verteilt auf zwei Tage
+rahmenplan: [C2, C5, A1]
+lernfeld: LF1
+material:
+  - Aktuelles Organigramm (bei der Personalabteilung oder im Intranet)
+  - Geräteliste und Ticketsystem (lesend)
+  - Zugang zur gemeinsamen Dokumentation der IT
+kriterien:
+  - Jede Abteilung aus dem Organigramm ist erfasst, keine fehlt
+  - Je Abteilung sind Ansprechpartner, die drei wichtigsten Anwendungen und die kritischen Zeiten benannt
+  - Die Angaben stammen aus Gesprächen mit den Abteilungen, nicht nur aus vorhandenen Unterlagen
+  - Abhängigkeiten zwischen Abteilungen (Datenaustausch, gemeinsame Anwendungen) sind eingezeichnet
+  - Die Übersicht liegt am vereinbarten Ort in der IT-Dokumentation, mit Datum und Verfasser
+  - Mindestens drei Verbesserungsvorschläge aus den Gesprächen sind als Tickets angelegt
+---
+
+## Auftrag
+
+Die IT kennt die Rechner, aber nicht immer die Arbeit, die darauf läuft. Diese Lücke
+schließt du.
+
+1. Besorge dir das aktuelle Organigramm und lege für jede Abteilung einen Abschnitt an.
+2. Vereinbare mit jeder Abteilung ein Gespräch von höchstens 15 Minuten. Stell die Fragen aus
+   der Übersicht im Handout A5 – nicht mehr, sonst wird es ein Verhör.
+3. Halte fest: Ansprechpartner, die drei wichtigsten Anwendungen, Zeiten, in denen nichts
+   ausfallen darf, und mit wem die Abteilung Daten austauscht.
+4. Zeichne die Abhängigkeiten ein: Welche Abteilung bekommt Daten von welcher, über welche
+   Anwendung?
+5. Lege das Ergebnis in der IT-Dokumentation ab. Benenne die Datei nach der Regel aus
+   Handout A6.
+6. Was dir in den Gesprächen an Beschwerden und Wünschen begegnet, legst du als Ticket an.
+
+## Worauf es ankommt
+
+Die Gespräche sind der eigentliche Wert dieser Aufgabe. Eine Übersicht, die nur aus
+vorhandenen Listen abgeschrieben ist, enthält genau die Fehler, die schon in den Listen
+stehen. Und: Nach dieser Woche kennen dich die Abteilungen. Das spart dir in drei Jahren
+Ausbildung viele Erklärungen.
+
+## Zeit
+
+Zwei halbe Tage. Wenn eine Abteilung keine Zeit hat, notiere das und frag nach einem
+Termin in der nächsten Woche – die Aufgabe kann trotzdem zur Abnahme.
@@ -0,0 +1,51 @@
+---
+id: "6.1"
+titel: Den Schutzbedarf eines Arbeitsbereichs feststellen
+woche: 6
+block: sicherheit
+ziel: Du stellst für einen Arbeitsbereich des Betriebs den Schutzbedarf der Informationen, Anwendungen und IT-Systeme fest, begründest jede Einstufung und leitest daraus drei konkrete Maßnahmen ab.
+zeitrahmen: 5 Stunden
+rahmenplan: [A6, A5, B1]
+lernfeld: LF4
+material:
+  - Übersicht der Abteilungen aus Praxisaufgabe 5.1
+  - Geräteliste und Netzplan
+  - Vorlage für die Schutzbedarfsfeststellung (Tabelle beim Ausbilder)
+  - Gesprächstermin mit der Leitung des gewählten Bereichs
+kriterien:
+  - Die wichtigsten Informationen und Geschäftsabläufe des Bereichs sind erfasst
+  - Für jede Anwendung ist der Schutzbedarf je Schutzziel eingestuft
+  - Jede Einstufung ist mit einem konkreten Schadensszenario begründet
+  - Der Schutzbedarf der IT-Systeme ist nachvollziehbar aus den Anwendungen abgeleitet (Maximumprinzip, ggf. Kumulations- oder Verteilungseffekt)
+  - Drei Maßnahmen sind vorgeschlagen, jeweils mit dem Schutzziel, dem sie dienen
+  - Die Einstufung ist mit der Leitung des Bereichs abgestimmt
+---
+
+## Auftrag
+
+Wähle mit dem Ausbilder einen Arbeitsbereich aus, etwa Personal, Buchhaltung, Lager oder
+Vertrieb.
+
+1. **Informationen und Abläufe:** Welche Informationen werden dort verarbeitet, und für
+   welche Abläufe? Nutze dafür deine Gesprächsnotizen aus Aufgabe 5.1.
+2. **Anwendungen:** Welche Programme und Dienste verarbeiten diese Informationen?
+3. **Schutzbedarf der Anwendungen:** Stufe jede Anwendung für Vertraulichkeit, Integrität
+   und Verfügbarkeit ein – normal, hoch oder sehr hoch. Begründe mit einem der sechs
+   Schadensszenarien aus Handout I1.
+4. **IT-Systeme:** Auf welchen Servern, Clients und Verbindungen laufen die Anwendungen?
+   Leite den Schutzbedarf ab und schreib dazu, welches Prinzip du angewandt hast.
+5. **Abstimmung:** Leg die Einstufung der Leitung des Bereichs vor. Sie kennt die Folgen
+   eines Ausfalls besser als die IT.
+6. **Maßnahmen:** Schlage drei Maßnahmen vor, die dort ansetzen, wo der Bedarf hoch ist und
+   der Schutz heute nicht reicht.
+
+## Worauf es ankommt
+
+Die Begründung ist wichtiger als die Einstufung. „Sehr hoch" ohne Szenario ist wertlos;
+„hoch, weil ein Ausfall von mehr als einem Tag die Lohnabrechnung verzögert und damit gegen
+Arbeitsverträge verstößt" ist eine Aussage, mit der man arbeiten kann.
+
+## Zeit
+
+Fünf Stunden einschließlich Abstimmungsgespräch. Den Bereich lieber klein wählen und
+gründlich bearbeiten als groß und oberflächlich.
@@ -0,0 +1,50 @@
+---
+id: "7.1"
+titel: Ein Inventarskript schreiben
+woche: 7
+block: programmierung
+ziel: Du schreibst ein PowerShell-Skript, das die wichtigsten Angaben eines Rechners erfasst und an eine gemeinsame CSV-Datei anhängt, und weist an drei Rechnern nach, dass es zuverlässig funktioniert.
+zeitrahmen: 8 Stunden, verteilt auf zwei Tage
+rahmenplan: [A10, A4, B3, A5]
+lernfeld: LF5
+material:
+  - Drei Testrechner mit Windows, darunter ein Notebook
+  - Eine Netzwerkfreigabe mit Schreibrecht für die CSV-Datei
+  - Zugang zum Git-Repository der IT
+kriterien:
+  - Das Skript erfasst Rechnername, Hersteller, Modell, Seriennummer, Betriebssystem mit Version, Arbeitsspeicher in GB, freien Platz auf C in GB und den Zeitpunkt des letzten Starts
+  - Der Zielpfad der CSV-Datei ist ein Parameter, kein fester Wert im Code
+  - Ein zweiter Lauf auf demselben Rechner erzeugt keine doppelte Zeile, sondern aktualisiert sie
+  - Ist die Freigabe nicht erreichbar, bricht das Skript mit einer verständlichen Meldung ab
+  - Das Skript hat einen Hilfeblock mit Beschreibung und Beispielaufruf
+  - Die Ergebnisse von drei Rechnern liegen in der CSV-Datei und lassen sich in Excel öffnen
+  - Das Skript liegt mit mindestens drei sinnvoll beschriebenen Commits im Repository
+---
+
+## Auftrag
+
+Die Geräteliste der IT wird von Hand gepflegt und ist deshalb nie ganz aktuell. Dein Skript
+soll das ändern.
+
+1. **Angaben finden:** Ermittle mit `Get-CimInstance`, wo die Angaben stecken. Hilfreich
+   sind die Klassen `Win32_ComputerSystem`, `Win32_BIOS`, `Win32_OperatingSystem` und
+   `Win32_LogicalDisk`. Nutze `Get-Member`, um die Eigenschaften zu finden.
+2. **Ein Objekt bauen:** Fasse alles in einem `[PSCustomObject]` zusammen. Rechne Bytes in
+   Gigabyte um und runde auf eine Nachkommastelle.
+3. **Ablegen:** Lies die vorhandene CSV-Datei ein, ersetze die Zeile des eigenen Rechners
+   oder hänge eine neue an, und schreib die Datei zurück.
+4. **Absichern:** Zielpfad als Parameter, Prüfung mit `Test-Path`, Fehlerbehandlung mit
+   `try`/`catch`.
+5. **Dokumentieren:** Hilfeblock oben im Skript, Commits im Repository.
+6. **Nachweisen:** Lauf auf drei Rechnern, darunter ein zweiter Lauf auf demselben Rechner.
+
+## Worauf es ankommt
+
+Das Aktualisieren statt Anhängen ist der Teil, an dem die meisten hängen bleiben – und genau
+der Teil, der das Skript im Alltag brauchbar macht. Überleg dir vorher, woran du einen
+Rechner eindeutig erkennst. Der Rechnername ist es nicht immer; die Seriennummer schon eher.
+
+## Zeit
+
+Zwei Tage. Wenn du nach zwei Stunden nicht weißt, wo eine Angabe steckt, frag nach – das
+Suchen in den Klassen gehört zur Übung, das Verzweifeln daran nicht.
@@ -0,0 +1,53 @@
+---
+id: "8.1"
+titel: Die Sicherung eines Bereichs prüfen und zurückspielen
+woche: 8
+block: system
+ziel: Du prüfst, ob die bestehende Datensicherung zum Schutzbedarf eines Arbeitsbereichs passt, spielst eine Sicherung auf eine Testumgebung zurück und vergleichst die gemessene Zeit mit dem, was der Bereich verkraftet.
+zeitrahmen: 6 Stunden
+rahmenplan: [A9, A5, A4, A8]
+lernfeld: LF4
+material:
+  - Ergebnis der Schutzbedarfsfeststellung aus Praxisaufgabe 6.1
+  - Lesender Zugang zur Sicherungssoftware und ihren Protokollen
+  - Ein Testserver oder eine virtuelle Maschine als Ziel der Wiederherstellung
+  - Checkliste „Wiederherstellung testen"
+kriterien:
+  - RPO und RTO des Bereichs sind mit der Leitung abgestimmt und schriftlich festgehalten
+  - Die bestehende Sicherung ist beschrieben – Art, Häufigkeit, Aufbewahrung, Speicherorte
+  - Der Abgleich mit der 3-2-1-Regel und mit RPO und RTO ist vollständig, Lücken sind benannt
+  - Die Wiederherstellung wurde auf die Testumgebung durchgeführt, nicht auf das laufende System
+  - Die gemessene Dauer ist dokumentiert und dem RTO gegenübergestellt
+  - Das Ergebnis wurde inhaltlich geprüft, nicht nur die Erfolgsmeldung der Software
+  - Die Testumgebung ist anschließend bereinigt
+  - Für jede gefundene Lücke liegt ein konkreter Verbesserungsvorschlag vor
+---
+
+## Auftrag
+
+Nimm den Bereich, den du in Aufgabe 6.1 untersucht hast. Du kennst seinen Schutzbedarf –
+jetzt prüfst du, ob die Sicherung dazu passt.
+
+1. **Anforderungen festhalten:** Wie viel Datenverlust (RPO) und wie viel Ausfallzeit (RTO)
+   verkraftet der Bereich? Stimme beides mit der Leitung ab.
+2. **Bestand aufnehmen:** Was wird gesichert, wie oft, wie lange aufbewahrt, wohin? Lies dazu
+   Einstellungen und Protokolle der Sicherungssoftware.
+3. **Abgleichen:** Erfüllt die Sicherung die 3-2-1-Regel? Gibt es eine Kopie, die offline oder
+   unveränderlich ist? Reicht die Häufigkeit für das RPO?
+4. **Zurückspielen:** Stelle nach der Checkliste die Daten des Bereichs auf der
+   Testumgebung wieder her. Miss die Zeit vom Entschluss bis zur Arbeitsfähigkeit.
+5. **Prüfen:** Öffne Dateien, starte die Anwendung, vergleiche den Stand mit dem
+   Sicherungszeitpunkt.
+6. **Bewerten und vorschlagen:** Wo liegen Lücken? Was schlägst du vor?
+
+## Worauf es ankommt
+
+Die gemessene Zeit ist das wichtigste Ergebnis. Fast jeder Betrieb schätzt die Dauer einer
+Wiederherstellung zu niedrig ein, weil er die Suche nach dem richtigen Sicherungsstand, das
+Bereitstellen der Umgebung und das Prüfen nicht mitrechnet. Wenn deine Messung über dem RTO
+liegt, ist das kein Misserfolg der Aufgabe – sondern genau der Befund, für den sie da ist.
+
+## Zeit
+
+Sechs Stunden. Arbeite in der Testumgebung, und frag vor dem Zurückspielen den Ausbilder,
+ob Ziel und Umfang stimmen.
@@ -0,0 +1,54 @@
+id: 05-arbeitsplatz-sicherheit-pruefen
+titel: Sicherheit eines Arbeitsplatzes prüfen
+block: sicherheit
+worum: >-
+  Ein Rundgang mit der Liste in der Hand findet mehr als jede Richtlinie. Geprüft
+  wird, was tatsächlich eingestellt ist – nicht, was eingestellt sein sollte.
+rahmenplan: [A6, A5]
+lernfeld: LF4
+mit_ticket: false
+
+gruppen:
+  - id: vorbereiten
+    titel: Vorbereiten
+    schritte:
+      - id: v1
+        text: Arbeitsplatz und Nutzer mit Termin angekündigt, Zweck der Prüfung erklärt
+      - id: v2
+        text: Gerät in der Geräteliste nachgeschlagen, Soll-Zustand (Betriebssystem, Verschlüsselung, Schutzsoftware) notiert
+
+  - id: durchfuehren
+    titel: Durchführen
+    schritte:
+      - id: d1
+        text: Bildschirmsperre greift nach spätestens 10 Minuten, Sperren mit Windows-Taste + L ist bekannt
+      - id: d2
+        text: Betriebssystem und Anwendungen auf aktuellem Stand, keine ausstehenden Neustarts für Updates
+      - id: d3
+        text: Schutzsoftware aktiv, Signaturen aktuell, letzte vollständige Prüfung ohne Befund
+      - id: d4
+        text: Festplattenverschlüsselung aktiv (bei Notebooks Pflicht), Wiederherstellungsschlüssel zentral hinterlegt
+      - id: d5
+        text: Der Nutzer arbeitet ohne lokale Administratorrechte
+      - id: d6
+        text: Keine Passwörter auf Zetteln, unter der Tastatur oder in Textdateien auf dem Desktop
+      - id: d7
+        text: Zweiter Faktor für E-Mail und Fernzugang eingerichtet
+      - id: d8
+        text: Keine vertraulichen Ausdrucke offen am Platz oder im Drucker liegen gelassen
+
+  - id: pruefen
+    titel: Prüfen
+    schritte:
+      - id: p1
+        text: Abweichungen vom Soll-Zustand vollständig notiert, je mit Befund und Risiko
+      - id: p2
+        text: Mit dem Nutzer kurz besprochen, was gefunden wurde – ohne Vorwurf
+
+  - id: abschliessen
+    titel: Abschließen
+    schritte:
+      - id: a1
+        text: Für jede Abweichung ein Ticket angelegt oder die Abweichung sofort behoben und dokumentiert
+      - id: a2
+        text: Wiederkehrende Abweichungen an den Ausbilder gemeldet – sie deuten auf eine fehlende Regel hin
@@ -0,0 +1,60 @@
+id: 06-wiederherstellung-testen
+titel: Wiederherstellung testen
+block: system
+worum: >-
+  Der Test findet auf einer Testumgebung statt, wird gemessen und inhaltlich
+  geprüft. Die Erfolgsmeldung der Sicherungssoftware ist kein Ergebnis.
+rahmenplan: [A9, A5]
+lernfeld: LF4
+mit_ticket: true
+
+gruppen:
+  - id: vorbereiten
+    titel: Vorbereiten
+    schritte:
+      - id: v1
+        text: Umfang des Tests festgelegt (Datei, Ordner, Anwendung oder ganzes System)
+      - id: v2
+        text: RPO und RTO des betroffenen Bereichs nachgeschlagen
+      - id: v3
+        text: Testumgebung bereitgestellt und vom Produktivnetz getrennt
+      - id: v4
+        text: Sicherungsstand gewählt und notiert (Datum, Uhrzeit, Art der Sicherung)
+
+  - id: durchfuehren
+    titel: Durchführen
+    schritte:
+      - id: d1
+        text: Startzeit notiert
+      - id: d2
+        text: Wiederherstellung auf die Testumgebung gestartet – nicht auf das laufende System
+      - id: d3
+        text: Auftretende Meldungen und Wartezeiten mitgeschrieben
+      - id: d4
+        text: Endzeit notiert, sobald mit den Daten gearbeitet werden kann
+
+  - id: pruefen
+    titel: Prüfen
+    schritte:
+      - id: p1
+        text: Stichprobe von mindestens fünf Dateien geöffnet, Inhalt lesbar
+      - id: p2
+        text: Stand entspricht dem gewählten Sicherungszeitpunkt
+      - id: p3
+        text: Berechtigungen sind mit zurückgekommen
+      - id: p4
+        text: Anwendung startet und arbeitet mit den zurückgespielten Daten (falls Teil des Tests)
+      - id: p5
+        text: Gemessene Dauer dem RTO gegenübergestellt
+
+  - id: abschliessen
+    titel: Abschließen
+    schritte:
+      - id: a1
+        text: Testprotokoll mit Datum, Umfang, Sicherungsstand, Dauer und Ergebnis abgelegt
+      - id: a2
+        text: Testumgebung bereinigt, zurückgespielte Daten gelöscht
+      - id: a3
+        text: Abweichungen und Auffälligkeiten als Tickets angelegt
+      - id: a4
+        text: Datum des nächsten Tests festgelegt
@@ -182,3 +182,174 @@
    SSDs durch Schreibvorgänge – die Kennzahlen für den Zustand sind deshalb
    unterschiedlich.
  siehe_auch: [SMART]
+
+# --- Woche 5: Ausbildung, Betrieb, Zusammenarbeit -------------------------
+
+- begriff: Probezeit
+  erklaerung: >-
+    Der erste Abschnitt der Ausbildung, mindestens einen und höchstens vier
+    Monate lang. In dieser Zeit können beide Seiten jederzeit ohne Frist und ohne
+    Angabe von Gründen kündigen, schriftlich.
+
+- begriff: Ausbildungsnachweis
+  formen: [Berichtsheft, Ausbildungsnachweise, Ausbildungsnachweises]
+  erklaerung: >-
+    Die schriftliche oder elektronische Aufzeichnung dessen, was in der
+    Ausbildung tatsächlich gelernt und getan wurde. Ein ordnungsgemäß geführter
+    Nachweis ist Voraussetzung für die Zulassung zur Abschlussprüfung.
+
+- begriff: Organigramm
+  erklaerung: >-
+    Die zeichnerische Darstellung der Aufbauorganisation eines Betriebs:
+    Abteilungen, Stellen und wer wem gegenüber weisungsbefugt ist.
+
+- begriff: Betriebsrat
+  erklaerung: >-
+    Die gewählte Vertretung der Beschäftigten. Er hat unter anderem ein
+    Mitbestimmungsrecht, wenn technische Einrichtungen eingeführt werden, die
+    Verhalten oder Leistung überwachen können – also bei vielen IT-Projekten.
+  siehe_auch: [Jugend- und Auszubildendenvertretung]
+
+- begriff: Jugend- und Auszubildendenvertretung
+  steht_fuer: JAV
+  formen: [JAV]
+  erklaerung: >-
+    Die Interessenvertretung der Beschäftigten unter 18 und der Auszubildenden
+    unter 25. Sie kann gewählt werden, wo es einen Betriebsrat und in der Regel
+    mindestens fünf solcher Beschäftigten gibt.
+  siehe_auch: [Betriebsrat]
+
+# --- Woche 6: IT-Sicherheit und Datenschutz -------------------------------
+
+- begriff: Schutzziele
+  formen: [Schutzziel, Schutzzielen]
+  erklaerung: >-
+    Die drei Grundwerte der Informationssicherheit: Vertraulichkeit (nur Befugte
+    sehen die Daten), Integrität (die Daten sind unverfälscht) und Verfügbarkeit
+    (sie stehen bereit, wenn sie gebraucht werden).
+  siehe_auch: [Schutzbedarf]
+
+- begriff: Schutzbedarf
+  formen: [Schutzbedarfs, Schutzbedarfsfeststellung]
+  erklaerung: >-
+    Wie viel Schutz eine Information oder ein System braucht – gemessen am
+    Schaden, der entstünde, wenn ein Schutzziel verletzt würde. Der
+    IT-Grundschutz des BSI unterscheidet normal, hoch und sehr hoch.
+  siehe_auch: [Schutzziele, Maximumprinzip]
+
+- begriff: Maximumprinzip
+  erklaerung: >-
+    Ein IT-System übernimmt den höchsten Schutzbedarf aller Anwendungen, die auf
+    ihm laufen. Eine einzige Anwendung mit sehr hohem Bedarf hebt also das ganze
+    System an.
+  siehe_auch: [Schutzbedarf]
+
+- begriff: Phishing
+  formen: [Phishing-Mail, Phishing-Mails]
+  erklaerung: >-
+    Gefälschte Nachrichten oder Webseiten, die zur Eingabe von Zugangsdaten oder
+    zu einer Zahlung verleiten sollen. Erkennungszeichen sind Zeitdruck, ein
+    unpassender Absender und ein Link, dessen Ziel nicht zum Absender passt.
+
+- begriff: Zwei-Faktor-Authentifizierung
+  steht_fuer: 2FA
+  formen: [2FA, MFA, zweiter Faktor, zweiten Faktor]
+  erklaerung: >-
+    Eine Anmeldung, die neben dem Passwort einen zweiten, unabhängigen Nachweis
+    verlangt – etwa einen Code aus einer App oder einen Sicherheitsschlüssel. Ein
+    gestohlenes Passwort allein genügt dann nicht mehr.
+
+- begriff: DSGVO
+  steht_fuer: Datenschutz-Grundverordnung
+  formen: [Datenschutz-Grundverordnung]
+  erklaerung: >-
+    Die europäische Verordnung, die regelt, wie personenbezogene Daten erhoben,
+    verarbeitet und geschützt werden müssen. Sie gilt unmittelbar in allen
+    Mitgliedstaaten.
+  siehe_auch: [personenbezogene Daten]
+
+- begriff: personenbezogene Daten
+  formen: [personenbezogener Daten, personenbezogenen Daten]
+  erklaerung: >-
+    Alle Angaben, die sich einer bestimmten oder bestimmbaren Person zuordnen
+    lassen – Name, E-Mail-Adresse, Personalnummer, aber auch eine IP-Adresse oder
+    ein Foto.
+  siehe_auch: [DSGVO]
+
+# --- Woche 7: Skripting mit PowerShell ------------------------------------
+
+- begriff: Cmdlet
+  formen: [Cmdlets]
+  erklaerung: >-
+    Ein eingebauter PowerShell-Befehl. Cmdlets heißen immer nach dem Muster
+    Verb-Substantiv, etwa Get-Service, und liefern Objekte statt Text.
+  siehe_auch: [Pipeline]
+
+- begriff: Pipeline
+  erklaerung: >-
+    Die Verkettung von Befehlen mit dem senkrechten Strich. In PowerShell wandern
+    dabei Objekte von Befehl zu Befehl, die sich nach ihren Eigenschaften filtern,
+    sortieren und auswählen lassen.
+  siehe_auch: [Cmdlet]
+
+# --- Woche 8: Datensicherung und Speicher ---------------------------------
+
+- begriff: Vollsicherung
+  formen: [Vollsicherungen]
+  erklaerung: >-
+    Eine Sicherung aller ausgewählten Daten, unabhängig davon, ob sie sich
+    geändert haben. Grundlage für inkrementelle und differenzielle Sicherungen.
+  siehe_auch: [inkrementelle Sicherung, differenzielle Sicherung]
+
+- begriff: inkrementelle Sicherung
+  formen: [inkrementellen Sicherung, inkrementellen Sicherungen, inkrementell]
+  erklaerung: >-
+    Sichert nur, was sich seit der letzten Sicherung gleich welcher Art geändert
+    hat. Schnell und platzsparend; zum Zurückspielen braucht man die
+    Vollsicherung und alle inkrementellen Sicherungen seitdem.
+  siehe_auch: [Vollsicherung, differenzielle Sicherung]
+
+- begriff: differenzielle Sicherung
+  formen: [differenziellen Sicherung, differenziellen Sicherungen, differenziell]
+  erklaerung: >-
+    Sichert alles, was sich seit der letzten Vollsicherung geändert hat. Wächst
+    bis zur nächsten Vollsicherung; zum Zurückspielen genügen die Vollsicherung
+    und die letzte differenzielle Sicherung.
+  siehe_auch: [Vollsicherung, inkrementelle Sicherung]
+
+- begriff: RPO
+  steht_fuer: Recovery Point Objective
+  erklaerung: >-
+    Der größte Datenverlust, den ein Bereich verkraftet, gemessen in Zeit. Ein
+    RPO von vier Stunden heißt: Es muss mindestens alle vier Stunden gesichert
+    werden.
+  siehe_auch: [RTO]
+
+- begriff: RTO
+  steht_fuer: Recovery Time Objective
+  erklaerung: >-
+    Die größte Ausfallzeit, die ein Bereich verkraftet, bis nach einem Schaden
+    wieder gearbeitet werden kann. Ob sie eingehalten wird, zeigt nur ein
+    gemessener Wiederherstellungstest.
+  siehe_auch: [RPO]
+
+- begriff: RAID
+  steht_fuer: Redundant Array of Independent Disks
+  erklaerung: >-
+    Ein Verbund mehrerer Festplatten, der je nach Stufe schneller ist oder den
+    Ausfall einzelner Platten übersteht. Ein RAID schützt nicht vor Löschen,
+    Verschlüsselung oder Beschädigung von Dateien – es ist keine Datensicherung.
+
+- begriff: NAS
+  steht_fuer: Network Attached Storage
+  erklaerung: >-
+    Ein Speichergerät im Netzwerk, das Dateien über Freigaben bereitstellt, etwa
+    per SMB oder NFS.
+  siehe_auch: [SAN, RAID]
+
+- begriff: SAN
+  steht_fuer: Storage Area Network
+  erklaerung: >-
+    Ein Speichernetz, das Servern Speicherblöcke bereitstellt, etwa per iSCSI.
+    Der Server sieht eine Festplatte und legt selbst ein Dateisystem darauf an.
+  siehe_auch: [NAS]
@@ -0,0 +1,69 @@
+---
+id: A4
+titel: Rechte und Pflichten in der Ausbildung
+block: arbeitsalltag
+woche: 5
+worum: Der Ausbildungsvertrag ist kein gewöhnlicher Arbeitsvertrag – das Berufsbildungsgesetz regelt, was beide Seiten einander schulden.
+rahmenplan: [C1]
+lernfeld: LF1
+merksatz: Du schuldest das Lernen, der Betrieb schuldet das Ausbilden. Das Berichtsheft beweist beides.
+karten:
+  - frage: Wie lang darf die Probezeit in der Ausbildung sein, und was gilt in dieser Zeit für die Kündigung?
+    antwort: Mindestens einen, höchstens vier Monate. In der Probezeit können beide Seiten jederzeit ohne Frist und ohne Angabe von Gründen kündigen – schriftlich.
+  - frage: Unter welchen Bedingungen kann ein Azubi nach der Probezeit kündigen?
+    antwort: Aus wichtigem Grund ohne Frist, oder mit vier Wochen Frist, wenn er die Ausbildung aufgeben oder einen anderen Beruf lernen will. Immer schriftlich und mit Angabe des Grundes.
+  - frage: Warum ist das Berichtsheft mehr als eine lästige Pflicht?
+    antwort: Ein ordnungsgemäß geführter Ausbildungsnachweis ist Voraussetzung für die Zulassung zur Abschlussprüfung. Ohne ihn keine Prüfung.
+  - frage: Aus welchen Teilen besteht die Abschlussprüfung zum Fachinformatiker Systemintegration?
+    antwort: Aus Teil 1 nach etwa anderthalb Jahren (Einrichten eines IT-gestützten Arbeitsplatzes, 20 %) und Teil 2 am Ende (Projektarbeit 50 %, zwei schriftliche Fachbereiche je 10 %, Wirtschafts- und Sozialkunde 10 %).
+---
+
+## Das Wesentliche
+
+- **Das Berufsbildungsgesetz (BBiG) geht dem Vertrag vor.** Was dort zugunsten des Azubis
+  geregelt ist, lässt sich im Ausbildungsvertrag nicht wegverhandeln.
+- **Deine Pflichten (§ 13 BBiG)** lassen sich in einem Satz zusammenfassen: dich bemühen,
+  den Beruf zu lernen. Dazu gehören die Berufsschule, die Weisungen im Rahmen der
+  Ausbildung, der pflegliche Umgang mit Geräten, Verschwiegenheit über Betriebs- und
+  Geschäftsgeheimnisse und das Führen des Ausbildungsnachweises.
+- **Die Pflichten des Betriebs (§ 14 BBiG):** dir den Beruf planmäßig beibringen,
+  Ausbildungsmittel kostenlos stellen, dich zur Berufsschule freistellen, dir Zeit für das
+  Berichtsheft während der Arbeitszeit geben und es regelmäßig durchsehen. Und: dir nur
+  Aufgaben geben, die der Ausbildung dienen.
+- **Berufsschule ist Arbeitszeit.** Ein Berufsschultag mit mehr als fünf Unterrichtsstunden
+  wird einmal pro Woche als voller Ausbildungstag angerechnet. Danach musst du nicht mehr in
+  den Betrieb.
+- **Probezeit:** ein bis vier Monate. Danach kann der Betrieb nur noch aus wichtigem Grund
+  kündigen.
+- **Vergütung, Urlaub und Arbeitszeit** stehen im Vertrag. Ob zusätzlich ein Tarifvertrag
+  gilt, hängt davon ab, ob der Betrieb tarifgebunden ist oder der Vertrag darauf verweist –
+  frag nach, statt zu raten.
+- **Bei Problemen** sind Ausbilder, Betriebsrat bzw. Jugend- und Auszubildendenvertretung
+  und die Ausbildungsberatung der IHK die Ansprechpartner. In dieser Reihenfolge, aber nicht
+  zwingend.
+
+## Übersicht
+
+| Prüfungsteil | Zeitpunkt | Inhalt | Gewicht |
+|---|---|---|---|
+| Teil 1 | etwa nach 18 Monaten | Einrichten eines IT-gestützten Arbeitsplatzes (schriftlich, 90 Min.) | 20 % |
+| Teil 2 | Ende der Ausbildung | Betriebliches Projekt der Systemintegration mit Dokumentation, Präsentation und Fachgespräch | 50 % |
+| | | Konzeption und Administration von IT-Systemen (schriftlich) | 10 % |
+| | | Analyse und Entwicklung von Netzwerken (schriftlich) | 10 % |
+| | | Wirtschafts- und Sozialkunde (schriftlich) | 10 % |
+
+Teil 1 zählt also schon zur Endnote – er ist keine Zwischenprüfung zum Üben.
+
+## Prüfungsfrage
+
+**Frage:** Ein Auszubildender wird nach der Probezeit regelmäßig zum Brötchenholen und
+Autowaschen eingeteilt. Beurteilen Sie die Situation und nennen Sie zwei Wege, wie er
+reagieren kann.
+
+**Antwort:** Nach § 14 BBiG dürfen Auszubildenden nur Aufgaben übertragen werden, die dem
+Ausbildungszweck dienen und ihren körperlichen Kräften angemessen sind. Regelmäßige
+ausbildungsfremde Tätigkeiten sind damit unzulässig; gelegentliche Gefälligkeiten, die alle
+im Team gleichermaßen übernehmen, sind dagegen kein Verstoß. Der Auszubildende kann
+(1) das Gespräch mit dem Ausbilder suchen und die Tätigkeiten im Berichtsheft wahrheitsgemäß
+eintragen, (2) sich an Betriebsrat oder Jugend- und Auszubildendenvertretung wenden oder
+(3) die Ausbildungsberatung der zuständigen Kammer einschalten.
@@ -0,0 +1,59 @@
+---
+id: A5
+titel: Den Betrieb verstehen – Aufbau, Abläufe, Ansprechpartner
+block: arbeitsalltag
+woche: 5
+worum: Die IT ist für die anderen da. Wer nicht weiß, was eine Abteilung tut und wann es dort brennt, setzt die falschen Prioritäten.
+rahmenplan: [C2, A1]
+lernfeld: LF1
+merksatz: Das Organigramm sagt, wer entscheidet. Die Abläufe sagen, wer leidet, wenn etwas ausfällt.
+karten:
+  - frage: Was ist der Unterschied zwischen Aufbau- und Ablauforganisation?
+    antwort: Die Aufbauorganisation legt fest, wer wo steht – Abteilungen, Stellen, Weisungswege, sichtbar im Organigramm. Die Ablauforganisation legt fest, wie die Arbeit fließt – Reihenfolge, Zuständigkeiten und Übergaben in einem Prozess.
+  - frage: Warum ist die IT in den meisten Betrieben ein Unterstützungsprozess?
+    antwort: Weil sie nicht selbst das verkauft, womit der Betrieb sein Geld verdient, sondern die Kernprozesse – Fertigung, Vertrieb, Verwaltung – am Laufen hält. Ihre Kunden sind die anderen Abteilungen.
+  - frage: Ab wann kann in einem Betrieb eine Jugend- und Auszubildendenvertretung gewählt werden?
+    antwort: Wenn es einen Betriebsrat gibt und in der Regel mindestens fünf Beschäftigte unter 18 Jahren oder Auszubildende unter 25 Jahren dort arbeiten.
+---
+
+## Das Wesentliche
+
+- **Aufbauorganisation** – wer wo steht. Das Organigramm zeigt Abteilungen, Stellen und
+  Weisungswege. Es beantwortet die Frage: Wer darf das entscheiden?
+- **Ablauforganisation** – wie die Arbeit fließt. Ein Auftrag geht vom Vertrieb über die
+  Arbeitsvorbereitung in die Fertigung und zum Versand. Jede Übergabe ist eine Stelle, an
+  der IT gebraucht wird – und an der ein Ausfall auffällt.
+- **Kernprozesse und Unterstützungsprozesse.** Kernprozesse bringen das Geld herein.
+  Die IT gehört fast immer zu den Unterstützungsprozessen: Ihre Kunden sitzen im selben Haus.
+- **Linie, Stab, Matrix.** In der Linie hat jeder genau einen Vorgesetzten. Eine Stabsstelle
+  berät, entscheidet aber nicht (etwa der Datenschutz). In der Matrix gibt es zwei Richtungen
+  der Weisung, zum Beispiel Abteilung und Projekt.
+- **Die Rechtsform** sagt, wer haftet und wer unterschreiben darf. In einer GmbH haftet die
+  Gesellschaft mit ihrem Vermögen; die Geschäftsführung vertritt sie nach außen.
+- **Mitbestimmung:** Ab fünf ständig Beschäftigten kann ein Betriebsrat gewählt werden. Er
+  redet unter anderem mit, wenn Technik eingeführt wird, die Leistung oder Verhalten
+  überwachen kann – und das ist bei fast jeder neuen Software der Fall.
+- **Für die IT zählt vor allem:** Wann wird wo gearbeitet, was darf wann nicht ausfallen, und
+  wer ist der Ansprechpartner, der für die Abteilung sprechen darf.
+
+## Übersicht
+
+| Frage an eine Abteilung | Warum die IT das wissen muss |
+|---|---|
+| Was ist euer wichtigstes Programm? | Bestimmt, was bei einer Störung zuerst wiederhergestellt wird |
+| Wann darf nichts ausfallen? | Wartungsfenster legt man nicht auf den Monatsabschluss der Buchhaltung |
+| Wer spricht für euch? | Änderungen werden mit einer Person abgestimmt, nicht mit allen |
+| Mit wem tauscht ihr Daten aus? | Schnittstellen sind die häufigste Fehlerquelle nach Updates |
+| Was nervt euch an der IT? | Die ehrlichste Liste für Verbesserungen, die es gibt |
+
+## Prüfungsfrage
+
+**Frage:** Die IT-Abteilung soll eine neue Software zur Zeiterfassung einführen. Welche
+Stellen im Betrieb müssen Sie vor der Einführung einbeziehen, und warum?
+
+**Antwort:** (1) Die Geschäftsführung bzw. die verantwortliche Führungskraft, weil sie über
+Einführung und Budget entscheidet. (2) Den Betriebsrat, weil eine Zeiterfassung geeignet
+ist, Verhalten oder Leistung zu überwachen; er hat dabei ein Mitbestimmungsrecht nach § 87
+Abs. 1 Nr. 6 BetrVG. (3) Den Datenschutzbeauftragten, weil personenbezogene Daten verarbeitet
+werden. (4) Die Personalabteilung bzw. Lohnbuchhaltung als fachlich verantwortliche Stelle,
+die mit den Daten arbeitet und die Schnittstelle zur Abrechnung kennt.
@@ -0,0 +1,57 @@
+---
+id: A6
+titel: Digital zusammenarbeiten – der richtige Kanal, der richtige Ort
+block: arbeitsalltag
+woche: 5
+worum: Chat, E-Mail, Ticket, Wiki – jedes Werkzeug ist für etwas anderes gut. Wer alles überall bespricht, findet nichts wieder.
+rahmenplan: [C5, A5]
+lernfeld: LF1
+merksatz: Aufträge ins Ticket, Wissen ins Wiki, Absprachen in den Chat – und was zählt, schriftlich.
+karten:
+  - frage: Wohin gehört eine Absprache, die in drei Monaten noch nachvollziehbar sein muss – Chat, E-Mail oder Ticket?
+    antwort: Ins Ticket, wenn sie zu einem Auftrag gehört, sonst in die gemeinsame Dokumentation. Chats sind für schnelle Abstimmung gedacht und lassen sich später kaum noch durchsuchen.
+  - frage: Was gehört in ein Besprechungsprotokoll, damit es etwas nützt?
+    antwort: Die getroffenen Entscheidungen und die vereinbarten Aufgaben mit Verantwortlichem und Termin. Wer was gesagt hat, ist meist entbehrlich.
+  - frage: Warum schickt man einen Link auf die Datei statt die Datei als Anhang?
+    antwort: Weil sonst mehrere Fassungen entstehen und niemand mehr weiß, welche gilt. Der Link zeigt immer auf den aktuellen Stand und unterliegt den Zugriffsrechten der Ablage.
+---
+
+## Das Wesentliche
+
+- **Den Kanal nach dem Zweck wählen, nicht nach der Gewohnheit.** Eine Frage, die in zwei
+  Minuten geklärt ist, gehört nicht in eine E-Mail mit fünf Empfängern – und eine Zusage an
+  einen Kunden nicht in den Chat.
+- **Ein Ort der Wahrheit.** Jede Information hat genau einen Ablageort. Kopien per Mail,
+  auf dem Desktop oder im privaten Ordner sind am nächsten Tag veraltet.
+- **Dateinamen, die sich sortieren:** `2026-10-05_Netzplan_Halle2_v3.pdf` statt
+  `Netzplan neu final(2).pdf`. Das Datum vorn in der Form JJJJ-MM-TT ordnet sich von selbst.
+- **Besprechungen** haben eine Tagesordnung vorher und ein Protokoll danach. Im Protokoll
+  stehen Entscheidungen und Aufgaben – wer, was, bis wann.
+- **Was nicht in den Chat gehört:** Passwörter, personenbezogene Daten von Kunden oder
+  Kollegen, Kundendaten aus Tickets. Chats werden mitgelesen, weitergeleitet und abfotografiert.
+- **Erreichbarkeit ehrlich halten.** Status setzen, Abwesenheit eintragen, Vertretung nennen.
+  Wer nicht antwortet, ist für die anderen ein ungelöstes Ticket.
+- **Videokonferenz:** Kamera an, wenn es um Abstimmung geht; Mikrofon aus, wenn man nicht
+  spricht; Bildschirm teilen nur mit geschlossenen privaten Fenstern.
+
+## Übersicht
+
+| Anliegen | Kanal | Warum |
+|---|---|---|
+| Störung oder Auftrag | Ticket | Nachvollziehbar, zuweisbar, messbar |
+| Kurze Rückfrage an einen Kollegen | Chat | Schnell, wird nicht aufbewahrt |
+| Zusage, Angebot, Absprache mit Externen | E-Mail | Nachweisbar und an einen Empfänger gerichtet |
+| Eskalation, Konflikt, eilige Störung | Telefon oder persönlich | Tonfall und sofortige Rückfrage |
+| Anleitung, Konfiguration, Netzplan | Wiki bzw. gemeinsame Dokumentation | Auffindbar für alle, auch in zwei Jahren |
+
+## Prüfungsfrage
+
+**Frage:** In Ihrem Team werden Konfigurationsänderungen bisher per Chat angekündigt und
+dort besprochen. Bewerten Sie dieses Vorgehen und schlagen Sie eine Verbesserung vor.
+
+**Antwort:** Der Chat eignet sich für die schnelle Abstimmung, nicht als Nachweis. Ankündigungen
+gehen in anderen Nachrichten unter, sind später schwer auffindbar und enthalten weder
+Begründung noch Rückfallplan in fester Form. Besser ist eine Änderungsanfrage im
+Ticketsystem mit Beschreibung, Zeitpunkt, betroffenen Systemen, Rückfallplan und
+Freigabe; der Chat dient dann nur noch als Hinweis mit Link auf das Ticket. Nach der Änderung
+wird die Dokumentation im Wiki aktualisiert.
@@ -0,0 +1,60 @@
+---
+id: I1
+titel: Schutzziele und Schutzbedarf – was ist wie viel wert?
+block: sicherheit
+woche: 6
+worum: Nicht alles muss gleich gut geschützt werden. Die Schutzbedarfsfeststellung sagt, wo sich Aufwand lohnt – und begründet ihn.
+rahmenplan: [A6]
+lernfeld: LF4
+merksatz: Erst fragen, was passiert, wenn es schiefgeht. Dann entscheiden, wie viel Schutz es braucht.
+karten:
+  - frage: Welche drei Schutzziele kennt die Informationssicherheit, und was bedeuten sie?
+    antwort: Vertraulichkeit – nur Befugte sehen die Daten. Integrität – die Daten sind vollständig und unverfälscht. Verfügbarkeit – Daten und Systeme stehen bereit, wenn sie gebraucht werden.
+  - frage: Welche drei Schutzbedarfskategorien unterscheidet der IT-Grundschutz des BSI?
+    antwort: Normal – die Schadensauswirkungen sind begrenzt und überschaubar. Hoch – sie können beträchtlich sein. Sehr hoch – sie können existenzbedrohend oder katastrophal sein.
+  - frage: Was besagt das Maximumprinzip bei der Schutzbedarfsfeststellung?
+    antwort: Ein IT-System erbt den höchsten Schutzbedarf aller Anwendungen, die darauf laufen. Läuft eine Anwendung mit hohem Bedarf auf einem Server, hat der Server mindestens hohen Bedarf.
+---
+
+## Das Wesentliche
+
+- **Drei Schutzziele:** Vertraulichkeit, Integrität, Verfügbarkeit. Jede Sicherheitsmaßnahme
+  dient mindestens einem davon. Oft kommt Authentizität hinzu: Man weiß sicher, von wem
+  etwas stammt.
+- **Schutzbedarf ergibt sich aus dem möglichen Schaden**, nicht aus der Technik. Die Frage
+  lautet: Was passiert, wenn diese Information bekannt wird, verfälscht wird oder ausfällt?
+- **Drei Kategorien:** normal, hoch, sehr hoch. Bewertet wird **je Schutzziel** – die
+  Lohnabrechnung hat einen sehr hohen Bedarf an Vertraulichkeit, aber nicht zwingend an
+  Verfügbarkeit in der Stunde.
+- **Sechs Schadensszenarien** helfen beim Einordnen: Verstoß gegen Gesetze oder Verträge,
+  Verletzung von Persönlichkeitsrechten, Gefahr für Leib und Leben, Beeinträchtigung der
+  Aufgabenerfüllung, Ansehensverlust, finanzielle Folgen.
+- **Von oben nach unten:** Erst die Geschäftsprozesse und Informationen bewerten, dann die
+  Anwendungen, dann die IT-Systeme, Räume und Verbindungen, auf denen sie liegen.
+- **Vererbung:** Ein System übernimmt den höchsten Bedarf seiner Anwendungen
+  (Maximumprinzip). Viele kleine Schäden auf einem System können zusammen einen höheren
+  Bedarf ergeben (Kumulationseffekt). Ist eine Anwendung auf mehrere Systeme verteilt,
+  kann der Bedarf des einzelnen Systems niedriger liegen (Verteilungseffekt).
+- **Jede Einstufung braucht eine Begründung.** „Hoch, weil wichtig" ist keine.
+
+## Übersicht
+
+| Kategorie | Bedeutung | Beispiel Verfügbarkeit |
+|---|---|---|
+| normal | begrenzte, überschaubare Auswirkungen | Ausfall des Intranets für einen Tag ist lästig, aber verkraftbar |
+| hoch | beträchtliche Auswirkungen | Ausfall der Warenwirtschaft für einen Tag stoppt Versand und Rechnungen |
+| sehr hoch | existenzbedrohende oder katastrophale Auswirkungen | Ausfall der Produktionssteuerung über Tage mit Vertragsstrafen |
+
+## Prüfungsfrage
+
+**Frage:** Auf einem Server laufen der Dateidienst der Verwaltung (Schutzbedarf
+Vertraulichkeit: normal) und die Personaldatenbank (Vertraulichkeit: sehr hoch). Welchen
+Schutzbedarf hat der Server hinsichtlich der Vertraulichkeit? Begründen Sie und nennen Sie
+eine Alternative.
+
+**Antwort:** Nach dem Maximumprinzip übernimmt der Server den höchsten Schutzbedarf der
+darauf betriebenen Anwendungen, hier also „sehr hoch" für die Vertraulichkeit. Damit
+müssen auch für den Dateidienst die strengeren Maßnahmen gelten – etwa beim Zugriff von
+Administratoren und bei der Sicherung. Alternativ lässt sich die Personaldatenbank auf ein
+eigenes System auslagern; dann kann der Dateiserver mit normalem Schutzbedarf betrieben
+werden, und der hohe Aufwand beschränkt sich auf das System, das ihn wirklich braucht.
@@ -0,0 +1,61 @@
+---
+id: I2
+titel: Konten schützen – Passwörter, zweiter Faktor, Phishing
+block: sicherheit
+woche: 6
+worum: Die meisten Angriffe beginnen nicht mit einer Sicherheitslücke, sondern mit einem Konto, das sich jemand ausgeliehen hat.
+rahmenplan: [A6, B3]
+lernfeld: LF4
+merksatz: Lang statt kompliziert, für jedes Konto ein eigenes, und wo es geht ein zweiter Faktor.
+karten:
+  - frage: Was macht ein Passwort sicher – Länge oder Sonderzeichen?
+    antwort: Vor allem die Länge und dass es nirgends sonst verwendet wird. Eine lange Passphrase aus mehreren Wörtern ist stärker und besser zu merken als ein kurzes Passwort mit Sonderzeichen.
+  - frage: Aus welchen drei Arten von Faktoren kann eine Anmeldung bestehen?
+    antwort: Wissen (Passwort, PIN), Besitz (Smartphone mit App, Sicherheitsschlüssel, Chipkarte) und Sein (Fingerabdruck, Gesicht). Zwei Faktoren müssen aus verschiedenen Arten stammen.
+  - frage: Warum arbeiten Administratoren im Alltag nicht mit ihrem Administratorkonto?
+    antwort: Weil jede Schadsoftware, die sie versehentlich starten, sonst mit vollen Rechten läuft. Für den Alltag dient ein normales Konto, das Administratorkonto nur für die Aufgabe, die es braucht.
+---
+
+## Das Wesentliche
+
+- **Länge schlägt Komplexität.** Eine Passphrase wie `Kaffee-Lager-Gabelstapler-Montag` ist
+  stärker als `K4ff33!` und lässt sich merken.
+- **Für jedes Konto ein eigenes Passwort.** Wird ein Dienst gehackt, probieren Angreifer die
+  erbeuteten Zugangsdaten überall sonst aus. Ein Passwortmanager macht das handhabbar.
+- **Kein Wechsel ohne Anlass.** Regelmäßiger Zwangswechsel führt zu `Sommer2026!`,
+  `Herbst2026!`. Gewechselt wird, wenn ein Verdacht besteht – dann aber sofort.
+- **Zweiter Faktor:** Ein gestohlenes Passwort allein reicht dann nicht mehr. Pflicht für
+  E-Mail, Fernzugang und alle Administratorkonten.
+- **Getrennte Konten für Verwaltungsaufgaben.** Surfen und Mails lesen mit dem normalen
+  Konto, administrieren mit dem Administratorkonto – und nur dafür.
+- **Phishing erkennen:** Zeitdruck, ungewöhnlicher Absender, Link-Ziel passt nicht zum
+  Absender, Aufforderung zur Anmeldung oder Zahlung. Vor dem Klick auf den Link zeigen und
+  die Adresse lesen.
+- **Wer geklickt hat, meldet es sofort.** Nicht schämen, nicht löschen, nicht abwarten. Je
+  früher die IT Bescheid weiß, desto kleiner der Schaden.
+- **Bildschirm sperren**, sobald man den Platz verlässt: Windows-Taste + L.
+
+## Übersicht
+
+| Merkmal einer Phishing-Mail | Beispiel |
+|---|---|
+| Druck und Dringlichkeit | „Ihr Konto wird in 24 Stunden gesperrt" |
+| Absender passt nicht | `support@micros0ft-konto.net` |
+| Link-Ziel weicht ab | Text zeigt `microsoft.com`, Ziel ist eine fremde Adresse |
+| Ungewöhnliche Bitte | Gutscheine kaufen, Kontodaten ändern, Anhang „aktivieren" |
+| Allgemeine Anrede | „Sehr geehrter Kunde" statt des Namens |
+
+## Prüfungsfrage
+
+**Frage:** Eine Mitarbeiterin meldet, dass sie auf einen Link in einer verdächtigen Mail
+geklickt und dort ihr Passwort eingegeben hat. Beschreiben Sie Ihr Vorgehen in der
+richtigen Reihenfolge.
+
+**Antwort:** (1) Sofort das Passwort des betroffenen Kontos ändern und bestehende
+Anmeldesitzungen beenden, damit der Angreifer den Zugang nicht mehr nutzen kann. (2) Prüfen,
+ob der zweite Faktor aktiv ist und ob seit dem Klick ungewöhnliche Anmeldungen,
+Weiterleitungsregeln oder versendete Mails auftreten. (3) Die Mail sichern und andere
+Empfänger warnen bzw. die Mail aus deren Postfächern entfernen. (4) Den Rechner auf
+Schadsoftware prüfen, falls zusätzlich etwas heruntergeladen wurde. (5) Den Vorfall
+dokumentieren und an die Verantwortlichen für Informationssicherheit und Datenschutz
+melden – bei Zugriff auf personenbezogene Daten kann eine Meldepflicht bestehen.
@@ -0,0 +1,64 @@
+---
+id: I3
+titel: Datenschutz in der IT – was du sehen kannst und was du anschauen darfst
+block: sicherheit
+woche: 6
+worum: In der IT hat man Zugriff auf fast alles. Die DSGVO regelt, was man damit tun darf – und das ist deutlich weniger.
+rahmenplan: [A6, C1]
+lernfeld: LF4
+merksatz: Zugriff ist kein Anlass. Hineingeschaut wird nur, wenn der Auftrag es verlangt.
+karten:
+  - frage: Was sind personenbezogene Daten?
+    antwort: Alle Angaben, die sich auf eine bestimmte oder bestimmbare Person beziehen – Name, E-Mail-Adresse, Personalnummer, IP-Adresse, Standortdaten, aber auch ein Foto oder eine Stimmaufnahme.
+  - frage: Innerhalb welcher Frist muss eine Datenschutzverletzung der Aufsichtsbehörde gemeldet werden?
+    antwort: Innerhalb von 72 Stunden, nachdem sie bekannt geworden ist – es sei denn, sie führt voraussichtlich zu keinem Risiko für die Betroffenen. Melden muss der Betrieb; du meldest intern sofort.
+  - frage: Was bedeutet Datenminimierung?
+    antwort: Es werden nur die Daten erhoben und gespeichert, die für den Zweck wirklich nötig sind – und gelöscht, sobald der Zweck erfüllt ist.
+---
+
+## Das Wesentliche
+
+- **Die DSGVO schützt Personen, nicht Daten.** Personenbezogen ist alles, was sich einer
+  bestimmten Person zuordnen lässt – auch eine IP-Adresse oder ein Kennzeichen.
+- **Besonders schützenswert** sind Gesundheitsdaten, religiöse und politische
+  Überzeugungen, Gewerkschaftszugehörigkeit, biometrische Daten und weitere. In der IT
+  begegnen sie dir in Krankmeldungen, Personalakten und Zutrittssystemen.
+- **Die Grundsätze:** rechtmäßig, zweckgebunden, so wenig wie nötig, richtig, nicht länger als
+  nötig gespeichert, sicher verarbeitet. Und der Betrieb muss nachweisen können, dass er sich
+  daran hält.
+- **Technische und organisatorische Maßnahmen (TOM):** Zugriffsrechte, Verschlüsselung,
+  Protokollierung, Datensicherung, Schulungen. Ein großer Teil davon ist IT-Arbeit.
+- **Als Administrator** siehst du Postfächer, Personalordner und Protokolle. Hineinschauen
+  darfst du nur, wenn ein Auftrag es erfordert – und dann nur so weit wie nötig. Was du
+  dabei siehst, bleibt bei dir.
+- **Eine Datenpanne** – verlorenes Notebook, falsch versendete Mail, offener Ordner – meldest
+  du sofort intern. Der Betrieb hat 72 Stunden für die Meldung an die Aufsichtsbehörde, und
+  die Uhr läuft ab dem Moment, in dem jemand im Betrieb davon weiß.
+- **Der Datenschutzbeauftragte** berät und kontrolliert. Er ist Pflicht, sobald in der Regel
+  mindestens 20 Personen ständig mit der automatisierten Verarbeitung personenbezogener
+  Daten beschäftigt sind.
+
+## Übersicht
+
+| Situation | Richtig |
+|---|---|
+| Ein Kollege bittet dich, „mal kurz" ins Postfach seiner Chefin zu schauen | Ablehnen – Zugriff nur mit Auftrag der berechtigten Stelle |
+| Ein Notebook ist im Zug liegen geblieben | Sofort melden, Konto sperren, Verschlüsselung prüfen |
+| Du siehst beim Support eine Krankmeldung auf dem Bildschirm | Nicht lesen, nicht erwähnen, Fenster schließen lassen |
+| Alte Festplatten aus der Personalabteilung | Nachweisbar sicher löschen oder vernichten, Protokoll anlegen |
+| Testdaten für eine neue Software gesucht | Keine echten Personaldaten, sondern erfundene oder unkenntlich gemachte |
+
+## Prüfungsfrage
+
+**Frage:** Ein Außendienstmitarbeiter verliert ein Notebook mit Kundendaten. Die Festplatte
+ist mit BitLocker verschlüsselt. Muss der Vorfall der Aufsichtsbehörde gemeldet werden?
+Begründen Sie.
+
+**Antwort:** Grundsätzlich ist der Verlust eines Geräts mit personenbezogenen Daten eine
+Verletzung des Schutzes dieser Daten und binnen 72 Stunden zu melden. Eine Meldung kann
+entfallen, wenn die Verletzung voraussichtlich nicht zu einem Risiko für die Betroffenen
+führt. Das ist bei einer wirksamen, dem Stand der Technik entsprechenden Verschlüsselung
+regelmäßig der Fall – vorausgesetzt, das Gerät war ausgeschaltet oder gesperrt und der
+Schlüssel ist nicht mit verloren gegangen. Die Entscheidung trifft der Verantwortliche mit
+dem Datenschutzbeauftragten; der Vorfall wird in jedem Fall intern dokumentiert, und das
+Konto des Mitarbeiters wird vorsorglich gesperrt bzw. das Passwort geändert.
@@ -0,0 +1,74 @@
+---
+id: P1
+titel: PowerShell – Befehle, Pipeline und Objekte
+block: programmierung
+woche: 7
+worum: PowerShell reicht keine Texte weiter, sondern Objekte mit Eigenschaften. Wer das verstanden hat, braucht kein Textschnipseln mehr.
+rahmenplan: [A10, B3]
+lernfeld: LF5
+merksatz: Verb-Substantiv finden, Get-Member fragen, filtern, sortieren, auswählen – formatiert wird erst ganz am Ende.
+karten:
+  - frage: Wie sind die Befehle (Cmdlets) in PowerShell benannt, und wie findet man einen unbekannten Befehl?
+    antwort: Nach dem Muster Verb-Substantiv, etwa Get-Service oder Stop-Process. Get-Command mit einem Suchbegriff findet Befehle, Get-Help erklärt sie mit Beispielen.
+  - frage: Was unterscheidet die Pipeline in PowerShell von der in einer klassischen Linux-Shell?
+    antwort: In PowerShell wandern Objekte mit Eigenschaften durch die Pipeline, nicht Textzeilen. Man filtert nach Eigenschaften wie Status oder Name, statt Spalten aus Text herauszuschneiden.
+  - frage: Wozu dient Get-Member?
+    antwort: Es zeigt, welche Eigenschaften und Methoden die Objekte haben, die ein Befehl liefert – also womit man in der Pipeline weiterarbeiten kann.
+---
+
+## Das Wesentliche
+
+- **Verb-Substantiv:** `Get-Service`, `Get-Process`, `Get-ChildItem`, `Stop-Service`. Die
+  Verben sind festgelegt – `Get` liest, `Set` ändert, `New` legt an, `Remove` löscht.
+- **Selbst finden statt googeln:** `Get-Command *service*` findet Befehle,
+  `Get-Help Get-Service -Examples` zeigt Beispiele. Einmal `Update-Help` als Administrator.
+- **Objekte statt Text.** `Get-Service` liefert Dienstobjekte mit Eigenschaften wie `Name`,
+  `Status` und `StartType`. Welche es gibt, verrät `Get-Service | Get-Member`.
+- **Die vier Werkzeuge der Pipeline:**
+  - `Where-Object` filtert: `Where-Object Status -eq 'Stopped'`
+  - `Sort-Object` sortiert: `Sort-Object Name`
+  - `Select-Object` wählt Eigenschaften oder Anzahl: `Select-Object Name, Status -First 10`
+  - `ForEach-Object` tut etwas mit jedem Objekt
+- **Vergleiche** heißen `-eq`, `-ne`, `-gt`, `-lt`, `-like` (mit `*` als Platzhalter) und
+  `-match` (regulärer Ausdruck). Groß- und Kleinschreibung spielt dabei keine Rolle.
+- **Ausgeben und weitergeben:** `Export-Csv` schreibt eine Tabelle für Excel,
+  `Out-File` eine Textdatei. `Format-Table` gehört nur ans Ende – danach sind es keine
+  verwertbaren Objekte mehr.
+- **Erst lesen, dann ändern.** Jeder Befehl, der etwas verändert, kennt `-WhatIf`: Er sagt,
+  was er tun würde, und tut es nicht.
+
+## Übersicht
+
+```powershell
+# Alle beendeten Dienste, die automatisch starten sollten
+Get-Service |
+  Where-Object { $_.Status -eq 'Stopped' -and $_.StartType -eq 'Automatic' } |
+  Sort-Object Name |
+  Select-Object Name, DisplayName
+
+# Die fünf Prozesse mit dem höchsten Speicherverbrauch
+Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 5 Name, Id, WorkingSet
+
+# Dateien im Downloadordner, älter als 90 Tage, als Tabelle für Excel
+Get-ChildItem $HOME\Downloads -File |
+  Where-Object LastWriteTime -lt (Get-Date).AddDays(-90) |
+  Select-Object Name, Length, LastWriteTime |
+  Export-Csv alte-downloads.csv -NoTypeInformation -Encoding UTF8
+```
+
+`$_` steht innerhalb der geschweiften Klammern für das Objekt, das gerade durch die Pipeline
+kommt.
+
+## Prüfungsfrage
+
+**Frage:** Schreiben Sie eine PowerShell-Befehlszeile, die alle laufenden Dienste
+alphabetisch sortiert mit Name und Anzeigename in die Datei `dienste.csv` schreibt, und
+erklären Sie jeden Teil.
+
+**Antwort:**
+`Get-Service | Where-Object Status -eq 'Running' | Sort-Object Name | Select-Object Name, DisplayName | Export-Csv dienste.csv -NoTypeInformation`
+– `Get-Service` liefert alle Dienste als Objekte. `Where-Object` lässt nur die durch, deren
+Eigenschaft `Status` den Wert `Running` hat. `Sort-Object Name` sortiert nach dem Namen.
+`Select-Object` behält nur die beiden gewünschten Eigenschaften. `Export-Csv` schreibt das
+Ergebnis als Tabelle; `-NoTypeInformation` unterdrückt die Typzeile, die ältere
+PowerShell-Fassungen sonst an den Anfang setzen.
@@ -0,0 +1,81 @@
+---
+id: P2
+titel: Variablen, Bedingungen und Schleifen
+block: programmierung
+woche: 7
+worum: Drei Bausteine reichen für fast jedes Verwaltungsskript – sich etwas merken, eine Entscheidung treffen, etwas wiederholen.
+rahmenplan: [A10, A4]
+lernfeld: LF5
+merksatz: Merken mit $, entscheiden mit if, wiederholen mit foreach. Der Rest ist Übung.
+karten:
+  - frage: Was ist der Unterschied zwischen "Hallo $name" und 'Hallo $name' in PowerShell?
+    antwort: In doppelten Anführungszeichen wird die Variable durch ihren Wert ersetzt, also etwa „Hallo Anna". In einfachen Anführungszeichen bleibt der Text genau so stehen, wie er geschrieben ist.
+  - frage: Was gibt dieses Skript aus – $summe = 0; foreach ($z in 1..5) { if ($z % 2 -eq 0) { $summe += $z } }; $summe
+    antwort: 6. Die Schleife läuft über 1 bis 5, die Bedingung lässt nur gerade Zahlen durch (Rest bei Division durch 2 ist 0), also werden 2 und 4 addiert.
+  - frage: Wann nimmt man foreach als Schleife und wann ForEach-Object?
+    antwort: foreach für eine Liste, die schon in einer Variablen liegt – übersichtlich und schnell. ForEach-Object mitten in einer Pipeline, wenn die Objekte direkt aus einem Befehl kommen.
+---
+
+## Das Wesentliche
+
+- **Variablen** beginnen mit `$`: `$pfad = 'D:\Daten'`. Sie können alles aufnehmen – Text,
+  Zahlen, Listen, ganze Objekte aus einem Befehl: `$dienste = Get-Service`.
+- **Text:** In `"…"` werden Variablen eingesetzt, in `'…'` nicht. Für Eigenschaften im Text:
+  `"Freier Platz: $($laufwerk.FreeSpace)"`.
+- **Listen** entstehen mit `@('PC-001', 'PC-002')` oder als Bereich `1..10`. Das erste Element
+  ist `$liste[0]`, die Anzahl `$liste.Count`.
+- **Eigene Objekte** für Berichte: `[PSCustomObject]@{ Name = $n; Status = $s }`. Daraus
+  wird mit `Export-Csv` eine saubere Tabelle.
+- **Bedingungen:** `if (…) { … } elseif (…) { … } else { … }`. In der Klammer steht ein
+  Vergleich mit `-eq`, `-gt`, `-like` usw. – **nicht** mit `=`, das ist eine Zuweisung.
+- **Verknüpfen** mit `-and`, `-or`, `-not`.
+- **Schleifen:** `foreach ($pc in $rechner) { … }` geht jedes Element durch.
+  `while (…) { … }` läuft, solange die Bedingung gilt – und braucht deshalb etwas, das sie
+  irgendwann falsch werden lässt.
+- **Rechnen:** `+ - * /` und `%` für den Rest einer Division. `1GB` ist für PowerShell eine
+  Zahl, `$bytes / 1GB` rechnet also direkt in Gigabyte um.
+
+## Übersicht
+
+```powershell
+$grenze = 15   # Prozent freier Platz, ab dem gewarnt wird
+
+$laufwerke = Get-CimInstance -ClassName Win32_LogicalDisk -Filter 'DriveType = 3'
+
+foreach ($lw in $laufwerke) {
+    $frei = [math]::Round($lw.FreeSpace / $lw.Size * 100, 1)
+
+    if ($frei -lt $grenze) {
+        Write-Warning "$($lw.DeviceID) hat nur noch $frei % frei."
+    }
+    else {
+        Write-Output "$($lw.DeviceID): $frei % frei – in Ordnung."
+    }
+}
+```
+
+`DriveType = 3` sind lokale Festplatten; USB-Sticks (2) und Netzlaufwerke (4) bleiben außen vor.
+
+## Prüfungsfrage
+
+**Frage:** Schreiben Sie ein kurzes PowerShell-Skript, das für eine Liste von drei
+Rechnernamen prüft, ob sie per Ping erreichbar sind, und für jeden Rechner „erreichbar" oder
+„nicht erreichbar" ausgibt.
+
+**Antwort:**
+
+```powershell
+$rechner = @('PC-001', 'PC-002', 'PC-003')
+foreach ($pc in $rechner) {
+    if (Test-Connection -ComputerName $pc -Count 1 -Quiet) {
+        Write-Output "$pc erreichbar"
+    }
+    else {
+        Write-Output "$pc nicht erreichbar"
+    }
+}
+```
+
+Die Liste wird in einer Variablen gehalten, `foreach` geht jeden Namen durch.
+`Test-Connection -Quiet` liefert statt einer ausführlichen Ausgabe nur wahr oder falsch,
+was die `if`-Bedingung direkt auswertet.
@@ -0,0 +1,86 @@
+---
+id: P3
+titel: Ein Skript schreiben, das man in einem Jahr noch versteht
+block: programmierung
+woche: 7
+worum: Ein Skript, das nur sein Verfasser bedienen kann, ist eine Abhängigkeit. Ein gutes Skript erklärt sich, prüft seine Eingaben und meldet Fehler, statt sie zu verschweigen.
+rahmenplan: [A10, A4, A5]
+lernfeld: LF5
+merksatz: Sagen, was es tut. Prüfen, was hineinkommt. Melden, was schiefgeht. Erst mit -WhatIf laufen lassen.
+karten:
+  - frage: Wozu dient ein param-Block am Anfang eines Skripts?
+    antwort: Er legt fest, welche Eingaben das Skript erwartet, mit Typ und ob sie Pflicht sind. Werte stehen dann nicht fest im Code, und PowerShell fragt fehlende Pflichtangaben selbst ab.
+  - frage: Warum fängt ein try-catch-Block manche Fehler nicht ab, und wie behebt man das?
+    antwort: Viele Cmdlets melden Fehler nur und laufen weiter (nicht abbrechende Fehler). Mit -ErrorAction Stop am Befehl wird daraus ein abbrechender Fehler, den catch auffängt.
+  - frage: Was bewirkt die Ausführungsrichtlinie RemoteSigned?
+    antwort: Selbst geschriebene, lokale Skripte laufen; aus dem Internet heruntergeladene Skripte nur, wenn sie signiert sind. Sie schützt vor versehentlichem Ausführen, ist aber keine Sicherheitsgrenze.
+---
+
+## Das Wesentliche
+
+- **Ein Kopf mit Hilfe:** Ein Block `<# .SYNOPSIS … .EXAMPLE … #>` ganz oben macht das
+  Skript für `Get-Help .\skript.ps1` lesbar. Darin steht, was es tut, was es braucht und ein
+  Beispielaufruf.
+- **Eingaben als Parameter**, nicht fest im Code: Pfade, Rechnernamen und Grenzwerte gehören
+  in den `param()`-Block. `[Parameter(Mandatory)]` macht eine Angabe zur Pflicht.
+- **Namen, die etwas sagen:** `$freierPlatzProzent` statt `$x`. Kommentare erklären das
+  **Warum**, nicht das Was – das Was steht im Code.
+- **Fehler nicht verschlucken.** `try { … -ErrorAction Stop } catch { … }` fängt Fehler auf
+  und meldet sie verständlich. Ein leerer `catch`-Block ist schlimmer als gar keiner.
+- **Erst trocken, dann echt.** Mit `[CmdletBinding(SupportsShouldProcess)]` bekommt das eigene
+  Skript `-WhatIf`. Ein Skript, das löscht, ändert oder verschiebt, läuft zuerst so.
+- **Klein anfangen und testen.** Erst an einem Testrechner, dann an einem echten, dann an
+  allen. Jede Stufe mit Blick auf die Ausgabe.
+- **Versionieren.** Skripte gehören in ein Git-Repository der IT, nicht auf den Desktop. So
+  sieht man, wer wann was geändert hat, und kommt zur letzten funktionierenden Fassung zurück.
+- **Ausführungsrichtlinie:** Auf Clients ist meist `RemoteSigned` eingestellt. Sie verhindert
+  versehentliches Ausführen fremder Skripte, ist aber keine Sicherheitsgrenze.
+
+## Übersicht
+
+```powershell
+<#
+.SYNOPSIS
+    Löscht Protokolldateien, die älter als eine bestimmte Anzahl Tage sind.
+.EXAMPLE
+    .\Protokolle-Aufraeumen.ps1 -Pfad D:\Logs -Tage 30 -WhatIf
+#>
+[CmdletBinding(SupportsShouldProcess)]
+param(
+    [Parameter(Mandatory)][string]$Pfad,
+    [int]$Tage = 30
+)
+
+if (-not (Test-Path $Pfad)) {
+    throw "Den Pfad $Pfad gibt es nicht."
+}
+
+$stichtag = (Get-Date).AddDays(-$Tage)
+$alt = Get-ChildItem $Pfad -Filter *.log -File | Where-Object LastWriteTime -lt $stichtag
+
+foreach ($datei in $alt) {
+    if ($PSCmdlet.ShouldProcess($datei.FullName, 'Löschen')) {
+        try {
+            Remove-Item $datei.FullName -ErrorAction Stop
+        }
+        catch {
+            Write-Warning "Konnte $($datei.Name) nicht löschen: $($_.Exception.Message)"
+        }
+    }
+}
+```
+
+## Prüfungsfrage
+
+**Frage:** Ein Kollege hat ein Skript geschrieben, das auf allen Rechnern temporäre Dateien
+löscht. Pfad und Rechnerliste stehen fest im Code, Fehler werden nicht behandelt. Nennen Sie
+vier Verbesserungen und begründen Sie sie.
+
+**Antwort:** (1) Pfad und Rechnerliste als Parameter übergeben – das Skript lässt sich dann
+für andere Fälle nutzen, ohne den Code zu ändern. (2) `-WhatIf` unterstützen und das Skript
+zuerst trocken laufen lassen – bei einem löschenden Skript lässt sich so vorab prüfen, was
+betroffen wäre. (3) Fehlerbehandlung mit `try`/`catch` und `-ErrorAction Stop` – damit nicht
+erreichbare Rechner oder gesperrte Dateien gemeldet und nicht stillschweigend übergangen
+werden. (4) Einen Hilfeblock mit Beschreibung und Beispiel ergänzen und das Skript im
+Repository der IT versionieren – so kann es auch jemand anderes betreuen. Ebenfalls richtig:
+Eingaben prüfen, z. B. mit `Test-Path`, und ein Protokoll der gelöschten Dateien schreiben.
@@ -0,0 +1,63 @@
+---
+id: S3
+titel: Datensicherung planen – voll, differenziell, inkrementell
+block: system
+woche: 8
+worum: Eine Sicherung ist erst dann geplant, wenn feststeht, wie viel Datenverlust und wie viel Ausfallzeit der Betrieb verkraftet.
+rahmenplan: [A9, A6, A8]
+lernfeld: LF4
+merksatz: Drei Kopien, zwei Medien, eine außer Haus – und eine, an die kein Angreifer herankommt.
+karten:
+  - frage: Was ist der Unterschied zwischen einer inkrementellen und einer differenziellen Sicherung?
+    antwort: Die inkrementelle sichert alles, was sich seit der letzten Sicherung gleich welcher Art geändert hat. Die differenzielle sichert alles seit der letzten Vollsicherung – sie wächst also jeden Tag, lässt sich aber schneller zurückspielen.
+  - frage: Was braucht man, um am Donnerstag aus einer Vollsicherung vom Sonntag und täglichen inkrementellen Sicherungen wiederherzustellen?
+    antwort: Die Vollsicherung vom Sonntag und alle inkrementellen Sicherungen von Montag bis Donnerstag, in dieser Reihenfolge. Bei differenziellen Sicherungen genügen die Vollsicherung und die vom Donnerstag.
+  - frage: Was bedeuten RPO und RTO?
+    antwort: RPO (Recovery Point Objective) ist der größte hinnehmbare Datenverlust, gemessen in Zeit – er bestimmt, wie oft gesichert wird. RTO (Recovery Time Objective) ist die größte hinnehmbare Ausfallzeit bis zur Wiederherstellung.
+  - frage: Warum ist ein RAID keine Datensicherung?
+    antwort: Ein RAID schützt nur vor dem Ausfall einer Festplatte. Gelöschte, verschlüsselte oder beschädigte Dateien sind auf allen Platten gleichzeitig weg – das RAID spiegelt den Schaden mit.
+---
+
+## Das Wesentliche
+
+- **Erst die Anforderungen, dann die Technik.** Wie viel Arbeit darf verloren gehen (RPO)?
+  Wie lange darf es dauern, bis wieder gearbeitet werden kann (RTO)? Die Antworten kommen
+  aus der Schutzbedarfsfeststellung, nicht aus dem Datenblatt der Software.
+- **Vollsicherung:** alles, jedes Mal. Einfach zurückzuspielen, aber groß und langsam.
+- **Inkrementell:** nur das Geänderte seit der letzten Sicherung. Klein und schnell beim
+  Sichern, beim Zurückspielen braucht man die ganze Kette.
+- **Differenziell:** das Geänderte seit der letzten Vollsicherung. Wächst bis zur nächsten
+  Vollsicherung, zum Zurückspielen reichen zwei Sicherungen.
+- **3-2-1-Regel:** drei Kopien der Daten, auf zwei verschiedenen Medien, eine davon außer
+  Haus. Gegen Ransomware kommt eine Kopie hinzu, die offline oder unveränderlich ist – sonst
+  verschlüsselt der Angreifer die Sicherung gleich mit.
+- **Generationen:** Tägliche Sicherungen werden einige Tage aufbewahrt, wöchentliche einige
+  Wochen, monatliche länger (Großvater-Vater-Sohn). So findet man auch einen Fehler, der erst
+  nach drei Wochen auffällt.
+- **Keine Sicherung:** ein RAID, eine Synchronisation in die Cloud, ein Papierkorb. Alle drei
+  übernehmen eine Löschung oder Verschlüsselung sofort.
+- **Sicherungen verschlüsseln**, wenn sie den Betrieb verlassen – und den Schlüssel so
+  ablegen, dass man ihn im Notfall findet, ohne die Sicherung zu brauchen.
+
+## Übersicht
+
+| Art | Sichert | Zurückspielen braucht | Platzbedarf |
+|---|---|---|---|
+| Voll | alles | eine Sicherung | hoch |
+| Differenziell | Änderungen seit der letzten Vollsicherung | Vollsicherung + letzte differenzielle | mittel, wächst täglich |
+| Inkrementell | Änderungen seit der letzten Sicherung | Vollsicherung + alle inkrementellen seitdem | gering |
+
+## Prüfungsfrage
+
+**Frage:** Die Buchhaltung verkraftet höchstens vier Stunden Datenverlust und muss nach
+einem Ausfall am selben Arbeitstag wieder arbeiten können. Entwerfen Sie ein passendes
+Sicherungskonzept und begründen Sie es.
+
+**Antwort:** Das RPO von vier Stunden verlangt mindestens alle vier Stunden während der
+Arbeitszeit eine Sicherung, etwa inkrementell um 10, 14 und 18 Uhr, ergänzt durch eine
+nächtliche differenzielle und eine wöchentliche Vollsicherung. Das RTO von einem halben
+Arbeitstag erfordert, dass die Sicherung schnell erreichbar ist – also eine Kopie auf einem
+Sicherungsspeicher im Haus. Nach der 3-2-1-Regel kommt eine Kopie außer Haus hinzu, eine
+davon offline oder unveränderlich gegen Ransomware. Aufbewahrt wird nach Generationen
+(z. B. 14 Tage täglich, 8 Wochen wöchentlich, 12 Monate monatlich). Das Konzept gilt erst als
+umgesetzt, wenn eine Wiederherstellung getestet und die benötigte Zeit gemessen wurde.
@@ -0,0 +1,61 @@
+---
+id: S4
+titel: Wiederherstellen und testen – die Sicherung, die zählt
+block: system
+woche: 8
+worum: Niemand braucht eine Sicherung. Alle brauchen eine Wiederherstellung. Ob sie gelingt, weiß man nur, wenn man sie geübt hat.
+rahmenplan: [A9, A5, A8]
+lernfeld: LF4
+merksatz: Eine Sicherung, die nie zurückgespielt wurde, ist keine Sicherung – sondern eine Hoffnung.
+karten:
+  - frage: Woran erkennt man, ob ein Wiederherstellungstest bestanden ist?
+    antwort: Die Daten sind vollständig, lesbar und auf dem erwarteten Stand, die Anwendung arbeitet damit, und die gemessene Dauer liegt innerhalb des vereinbarten RTO.
+  - frage: Warum gehört der Wiederherstellungsplan auch auf Papier?
+    antwort: Weil er genau dann gebraucht wird, wenn Server, Wiki und Passwortmanager vielleicht nicht erreichbar sind. Ein Plan, der nur auf dem ausgefallenen System liegt, hilft niemandem.
+  - frage: In welcher Reihenfolge stellt man nach einem Totalausfall die Systeme wieder her?
+    antwort: Nach Abhängigkeiten und Schutzbedarf – zuerst die Grundlagen wie Netz, Verzeichnisdienst und Namensauflösung, dann die Systeme mit dem höchsten Verfügbarkeitsbedarf, zuletzt der Rest.
+---
+
+## Das Wesentliche
+
+- **Regelmäßig testen**, nicht erst im Ernstfall. Eine einzelne Datei jeden Monat, eine
+  ganze Anwendung oder ein ganzer Server mindestens einmal im Jahr und nach jeder größeren
+  Änderung an der Sicherung.
+- **Auf eine Testumgebung zurückspielen**, nicht über das laufende System. Sonst wird aus
+  dem Test der Ernstfall.
+- **Messen, nicht schätzen.** Wie lange hat das Zurückspielen gedauert – einschließlich
+  Suchen, Anfordern des Mediums und Prüfen? Das ist die Zahl, die man mit dem RTO vergleicht.
+- **Das Ergebnis prüfen:** Öffnet sich die Datei, startet die Anwendung, stimmt der Stand?
+  Eine fehlerfrei abgeschlossene Wiederherstellung mit leeren Dateien ist ein
+  fehlgeschlagener Test.
+- **Protokollieren:** Datum, was zurückgespielt wurde, von welcher Sicherung, Dauer,
+  Ergebnis, Auffälligkeiten. Das Protokoll ist der Nachweis gegenüber Geschäftsführung,
+  Prüfern und Versicherung.
+- **Der Wiederherstellungsplan** nennt Reihenfolge, Zuständige, Zugangsdaten zum
+  Sicherungssystem und den Ort der Schlüssel. Er liegt ausgedruckt an einem bekannten Ort.
+- **Reihenfolge nach Abhängigkeiten:** Ohne Netz, Verzeichnisdienst und Namensauflösung
+  läuft keine Fachanwendung, egal wie wichtig sie ist.
+
+## Übersicht
+
+| Test | Wie oft | Zeigt |
+|---|---|---|
+| Einzelne Datei oder E-Mail | monatlich | Die Sicherung läuft und ist lesbar |
+| Ganzer Ordner mit Berechtigungen | vierteljährlich | Rechte kommen mit zurück |
+| Ganze Anwendung samt Datenbank | halbjährlich | Die Anwendung arbeitet mit den gesicherten Daten |
+| Ganzer Server bzw. virtuelle Maschine | jährlich | Das RTO ist einzuhalten |
+
+## Prüfungsfrage
+
+**Frage:** Die Sicherungssoftware meldet seit Monaten „erfolgreich". Warum genügt das nicht
+als Nachweis, und wie gehen Sie bei einem Wiederherstellungstest vor?
+
+**Antwort:** Die Meldung bestätigt nur, dass der Sicherungsvorgang ohne Fehler beendet
+wurde – nicht, dass die richtigen Daten gesichert wurden, dass sie lesbar sind und dass sie
+sich in der geforderten Zeit zurückspielen lassen. Vorgehen: (1) Umfang und Ziel des Tests
+festlegen, etwa eine Anwendung samt Datenbank auf einen Testserver. (2) Die Wiederherstellung
+durchführen und die Zeit vom Beginn bis zur Arbeitsfähigkeit messen. (3) Das Ergebnis
+inhaltlich prüfen – Daten vollständig, Anwendung startet, Stand entspricht dem
+Sicherungszeitpunkt. (4) Das Ergebnis mit RPO und RTO vergleichen, protokollieren und
+Abweichungen als Maßnahme erfassen. (5) Die Testumgebung anschließend bereinigen, weil sie
+echte Daten enthält.
@@ -0,0 +1,62 @@
+---
+id: S5
+titel: RAID, NAS und SAN – Speicher, der einen Ausfall übersteht
+block: system
+woche: 8
+worum: Festplatten fallen aus, das ist sicher. Ein RAID sorgt dafür, dass man es erst an der Warnmeldung merkt und nicht am Stillstand.
+rahmenplan: [A9, B1, A3]
+lernfeld: LF2
+merksatz: RAID gegen Plattenausfall, Sicherung gegen alles andere. Das eine ersetzt das andere nie.
+karten:
+  - frage: Wie viel Speicher ist nutzbar, und wie viele Platten dürfen ausfallen – bei RAID 1, RAID 5 und RAID 6?
+    antwort: RAID 1 – die Hälfte, eine Platte je Spiegel. RAID 5 – alle Platten bis auf eine, eine darf ausfallen. RAID 6 – alle Platten bis auf zwei, zwei dürfen ausfallen.
+  - frage: Ein RAID 5 aus fünf Platten mit je 4 TB – wie viel ist nutzbar?
+    antwort: 16 TB. Eine Platte entfällt auf die Paritätsinformation, also (5 − 1) × 4 TB.
+  - frage: Worin unterscheiden sich NAS und SAN?
+    antwort: Ein NAS stellt Dateien über das Netzwerk bereit, etwa per SMB oder NFS – die Clients sehen Freigaben. Ein SAN stellt Speicherblöcke bereit, etwa per iSCSI oder Fibre Channel – der Server sieht eine Festplatte und legt selbst ein Dateisystem an.
+---
+
+## Das Wesentliche
+
+- **RAID 0** verteilt die Daten auf mehrere Platten (Striping). Schnell, aber ohne jede
+  Ausfallsicherheit: Fällt eine Platte aus, ist alles weg. Kein Einsatz für wichtige Daten.
+- **RAID 1** spiegelt zwei Platten. Halbe Kapazität, eine Platte darf ausfallen. Typisch für
+  das Betriebssystem eines Servers.
+- **RAID 5** verteilt Daten und Paritätsinformation über mindestens drei Platten. Eine Platte
+  darf ausfallen. Bei großen Platten ist der Wiederaufbau lang und belastet die übrigen
+  Platten – fällt währenddessen eine zweite aus, sind die Daten verloren.
+- **RAID 6** wie RAID 5 mit doppelter Parität, mindestens vier Platten. Zwei Platten dürfen
+  ausfallen. Heute die bessere Wahl für große Datenspeicher.
+- **RAID 10** ist ein Verbund aus Spiegeln (mindestens vier Platten). Halbe Kapazität, schnell
+  beim Schreiben, je Spiegelpaar darf eine Platte ausfallen. Gut für Datenbanken.
+- **Hot-Spare:** eine Reserveplatte, die bei einem Ausfall sofort einspringt. Der
+  Wiederaufbau beginnt, bevor jemand den Ausfall bemerkt.
+- **Überwachen:** Ein RAID mit ausgefallener Platte läuft weiter und sieht gesund aus.
+  Ohne Benachrichtigung merkt man den ersten Ausfall erst am zweiten.
+- **NAS, SAN, DAS:** NAS liefert Dateien übers Netz, SAN liefert Speicherblöcke an Server, DAS
+  hängt direkt an einem einzigen Server.
+
+## Übersicht
+
+| Stufe | Mindestens | Nutzbar bei n Platten | Darf ausfallen | Typischer Einsatz |
+|---|---|---|---|---|
+| RAID 0 | 2 | n | keine | Zwischenspeicher, Videoschnitt |
+| RAID 1 | 2 | n / 2 | eine | Systemplatten |
+| RAID 5 | 3 | n − 1 | eine | kleinere Datenspeicher |
+| RAID 6 | 4 | n − 2 | zwei | große Datenspeicher, NAS |
+| RAID 10 | 4 | n / 2 | eine je Spiegel | Datenbanken, virtuelle Maschinen |
+
+## Prüfungsfrage
+
+**Frage:** Für ein NAS stehen sechs Festplatten mit je 8 TB zur Verfügung. Vergleichen Sie
+RAID 5, RAID 6 und RAID 10 hinsichtlich nutzbarer Kapazität und Ausfallsicherheit und
+geben Sie eine Empfehlung.
+
+**Antwort:** RAID 5: (6 − 1) × 8 TB = 40 TB nutzbar, eine Platte darf ausfallen. RAID 6:
+(6 − 2) × 8 TB = 32 TB, zwei beliebige Platten dürfen ausfallen. RAID 10: 6 / 2 × 8 TB = 24 TB,
+je Spiegelpaar darf eine Platte ausfallen – fallen beide Platten eines Paares aus, sind die
+Daten verloren. Empfehlung: RAID 6. Bei 8-TB-Platten dauert der Wiederaufbau viele Stunden;
+in dieser Zeit verträgt RAID 5 keinen weiteren Fehler, RAID 6 schon. RAID 10 wäre schneller
+beim Schreiben, kostet aber deutlich mehr Kapazität, und für ein NAS mit Dateiablagen ist
+die Schreibleistung meist nicht entscheidend. Unabhängig davon ersetzt keine RAID-Stufe die
+Datensicherung.
@@ -0,0 +1,94 @@
+id: woche-05
+woche: 5
+titel: Lernzielkontrolle Woche 5 – Ausbildung, Betrieb und Zusammenarbeit
+dauer_minuten: 40
+hinweis: >-
+  Offene Fragen. Antworten in ganzen Sätzen; bei Rechtsfragen genügt die
+  sinngemäße Regel, die Paragrafennummer ist nicht gefordert.
+
+fragen:
+  - id: f1
+    frage: >-
+      Ein Auszubildender ist seit sechs Wochen im Betrieb und möchte die
+      Ausbildung beenden, weil er doch studieren will. Was muss er beachten?
+      Wie wäre es nach acht Monaten?
+    punkte: 6
+    musterloesung: >-
+      Nach sechs Wochen liegt er in der Probezeit (ein bis vier Monate). Er kann
+      jederzeit ohne Einhaltung einer Frist und ohne Angabe von Gründen kündigen,
+      die Kündigung muss aber schriftlich erfolgen. Nach acht Monaten ist die
+      Probezeit vorbei: Er kann dann mit einer Frist von vier Wochen kündigen,
+      weil er die Berufsausbildung aufgeben will; die Kündigung muss schriftlich
+      und unter Angabe des Grundes erfolgen. (Probezeit 2 P., Kündigung darin 1 P.,
+      Frist danach 2 P., Schriftform mit Grund 1 P.)
+
+  - id: f2
+    frage: >-
+      Nennen Sie je drei Pflichten des Auszubildenden und des Ausbildungsbetriebs.
+    punkte: 6
+    musterloesung: >-
+      Auszubildender (drei aus): sich bemühen, die berufliche Handlungsfähigkeit
+      zu erwerben; übertragene Aufgaben sorgfältig ausführen; an
+      Ausbildungsmaßnahmen und der Berufsschule teilnehmen; Weisungen im Rahmen
+      der Ausbildung befolgen; die Betriebsordnung beachten; Geräte und
+      Werkzeuge pfleglich behandeln; über Betriebs- und Geschäftsgeheimnisse
+      Stillschweigen wahren; den Ausbildungsnachweis führen.
+      Betrieb (drei aus): die Ausbildung planmäßig durchführen; Ausbildungsmittel
+      kostenlos zur Verfügung stellen; zum Besuch der Berufsschule freistellen
+      und anhalten; Zeit zum Führen des Ausbildungsnachweises geben und ihn
+      regelmäßig durchsehen; nur ausbildungsbezogene Aufgaben übertragen; eine
+      angemessene Vergütung zahlen. (Je Pflicht 1 P.)
+
+  - id: f3
+    frage: >-
+      Warum lohnt es sich, das Berichtsheft gewissenhaft zu führen? Nennen Sie
+      zwei Gründe.
+    punkte: 4
+    musterloesung: >-
+      (1) Ein ordnungsgemäß geführter Ausbildungsnachweis ist Voraussetzung für
+      die Zulassung zur Abschlussprüfung. (2) Er belegt gegenüber Betrieb und
+      Kammer, was tatsächlich vermittelt wurde – bei Streit über ausbildungsfremde
+      Tätigkeiten oder Lücken ist er das wichtigste Beweismittel. Ebenfalls
+      richtig: Er hilft bei der Prüfungsvorbereitung, weil er zeigt, welche Themen
+      schon behandelt wurden. (Je Grund 2 P.)
+
+  - id: f4
+    frage: >-
+      Erklären Sie den Unterschied zwischen Aufbau- und Ablauforganisation an
+      einem Beispiel aus Ihrem Betrieb.
+    punkte: 6
+    musterloesung: >-
+      Die Aufbauorganisation beschreibt die Struktur: Abteilungen, Stellen und
+      Weisungsbeziehungen, dargestellt im Organigramm – etwa dass die IT der
+      kaufmännischen Leitung unterstellt ist. Die Ablauforganisation beschreibt,
+      wie Arbeit über die Stellen hinweg fließt – etwa der Weg einer
+      Kundenbestellung vom Vertrieb über die Arbeitsvorbereitung und Fertigung
+      bis zum Versand und zur Rechnung. (Definition je 2 P., stimmiges Beispiel 2 P.)
+
+  - id: f5
+    frage: >-
+      Ein Kollege schreibt Ihnen im Chat das Passwort für einen Serverzugang,
+      damit Sie eine Störung beheben können. Wie bewerten Sie das, und wie wäre
+      es richtig gewesen?
+    punkte: 5
+    musterloesung: >-
+      Passwörter gehören nicht in den Chat: Nachrichten werden gespeichert,
+      lassen sich weiterleiten, sind auf mehreren Geräten sichtbar und oft auch
+      für Administratoren der Plattform lesbar. Richtig wäre, den Zugang über den
+      Passwortmanager des Teams zu teilen oder ein persönliches Konto mit den
+      nötigen Rechten einzurichten. Ist das Passwort bereits im Chat gelandet,
+      wird es nach der Störung geändert. (Bewertung mit Begründung 3 P.,
+      richtiger Weg 2 P.)
+
+  - id: f6
+    frage: >-
+      Ordnen Sie jedem Anliegen den passenden Kommunikationsweg zu und begründen
+      Sie kurz: (a) Der Drucker im Lager druckt nicht. (b) Sie möchten wissen,
+      ob ein Kollege um 14 Uhr Zeit hat. (c) Sie sagen einem Lieferanten einen
+      Liefertermin zu.
+    punkte: 6
+    musterloesung: >-
+      (a) Ticket – die Störung muss erfasst, zugewiesen und nachvollziehbar
+      abgeschlossen werden. (b) Chat oder kurzer Anruf – eine schnelle Absprache
+      ohne Nachweisbedarf. (c) E-Mail – eine Zusage an Externe muss nachweisbar
+      sein und an einen bestimmten Empfänger gehen. (Je Zuordnung mit Begründung 2 P.)
@@ -0,0 +1,86 @@
+id: woche-07
+woche: 7
+titel: Lernzielkontrolle Woche 7 – Skripting mit PowerShell
+dauer_minuten: 45
+hinweis: >-
+  Offene Fragen. Bei Code zählt, dass er funktionieren würde – Schreibweise von
+  Groß- und Kleinbuchstaben und kleine Tippfehler werden nicht abgezogen.
+
+fragen:
+  - id: f1
+    frage: >-
+      Erklären Sie, was in der PowerShell-Pipeline von Befehl zu Befehl
+      weitergereicht wird, und welchen Vorteil das gegenüber einer Shell hat,
+      die Text weiterreicht.
+    punkte: 5
+    musterloesung: >-
+      Weitergereicht werden Objekte mit Eigenschaften und Methoden, keine
+      Textzeilen. Der nächste Befehl kann direkt auf Eigenschaften wie Status,
+      Name oder Größe zugreifen, nach ihnen filtern und sortieren. Bei einer
+      Textshell müsste man die gewünschte Angabe erst aus der Zeile
+      herausschneiden; ändert sich das Ausgabeformat, bricht das Skript.
+      (Objekte 2 P., Vorteil mit Begründung 3 P.)
+
+  - id: f2
+    frage: >-
+      Schreiben Sie eine Befehlszeile, die die zehn größten Dateien im Ordner
+      D:\Daten (ohne Unterordner) mit Name und Größe anzeigt, die größte zuerst.
+    punkte: 6
+    musterloesung: >-
+      Get-ChildItem D:\Daten -File | Sort-Object Length -Descending |
+      Select-Object -First 10 Name, Length. Bewertung: Dateien des Ordners
+      abrufen (2 P.), absteigend nach Length sortieren (2 P.), auf zehn
+      begrenzen und die Eigenschaften auswählen (2 P.). Der Schalter -File ist
+      wünschenswert, aber nicht gefordert.
+
+  - id: f3
+    frage: >-
+      Was gibt das folgende Skript aus? Begründen Sie.
+      $liste = @(3, 8, 12, 5);
+      $treffer = 0;
+      foreach ($zahl in $liste) { if ($zahl -gt 4) { $treffer++ } };
+      $treffer
+    punkte: 4
+    musterloesung: >-
+      Ausgabe: 3. Die Schleife geht alle vier Zahlen durch; die Bedingung ist
+      bei 8, 12 und 5 erfüllt, nicht bei 3. Bei jedem Treffer wird der Zähler
+      um eins erhöht. (Ergebnis 2 P., Begründung 2 P.)
+
+  - id: f4
+    frage: >-
+      Erklären Sie den Unterschied zwischen -eq, -like und -match an je einem
+      Beispiel.
+    punkte: 6
+    musterloesung: >-
+      -eq vergleicht auf Gleichheit: 'PC-001' -eq 'pc-001' ist wahr, weil
+      Groß- und Kleinschreibung keine Rolle spielt. -like vergleicht mit
+      Platzhaltern: 'PC-001' -like 'PC-*' ist wahr. -match prüft gegen einen
+      regulären Ausdruck: 'PC-001' -match '^PC-\d{3}$' ist wahr, weil auf
+      "PC-" genau drei Ziffern folgen. (Je Operator mit Beispiel 2 P.)
+
+  - id: f5
+    frage: >-
+      Ein Skript soll alte Benutzerprofile löschen. Was tun Sie, bevor Sie es
+      auf allen Rechnern ausführen? Nennen Sie drei Schritte.
+    punkte: 6
+    musterloesung: >-
+      (1) Mit -WhatIf laufen lassen und prüfen, welche Profile betroffen wären.
+      (2) Zuerst an einem Testrechner, dann an einem einzelnen echten Rechner
+      ausführen und das Ergebnis kontrollieren. (3) Sicherstellen, dass eine
+      aktuelle Sicherung der betroffenen Daten vorliegt. Ebenfalls richtig:
+      Änderung ankündigen bzw. als Änderungsanfrage freigeben lassen, Protokoll
+      der gelöschten Profile schreiben, Ausschlussliste für Dienst- und
+      Administratorkonten einbauen. (Je Schritt 2 P.)
+
+  - id: f6
+    frage: >-
+      Im folgenden Ausschnitt wird ein Fehler beim Kopieren nicht vom
+      catch-Block aufgefangen. Warum, und wie beheben Sie das?
+      try { Copy-Item \\server\vorlagen\*.docx C:\Vorlagen } catch { Write-Warning 'Kopieren fehlgeschlagen' }
+    punkte: 5
+    musterloesung: >-
+      Copy-Item meldet die meisten Fehler als nicht abbrechende Fehler: Er gibt
+      eine Fehlermeldung aus und läuft weiter, der catch-Block wird nicht
+      erreicht. Abhilfe: -ErrorAction Stop an den Befehl anhängen, dann wird der
+      Fehler zu einem abbrechenden Fehler und vom catch-Block aufgefangen.
+      (Ursache 3 P., Behebung 2 P.)
@@ -203,3 +203,11 @@ bloecke:
    kuerzel: S
    titel: Betriebssysteme und Dienste
    farbe: petrol
+  - id: sicherheit
+    kuerzel: I
+    titel: IT-Sicherheit und Datenschutz
+    farbe: petrol
+  - id: programmierung
+    kuerzel: P
+    titel: Skripting und Automatisierung
+    farbe: petrol
@@ -0,0 +1,30 @@
+nummer: 5
+titel: Ausbildung, Betrieb und Zusammenarbeit
+block: arbeitsalltag
+leitfrage: Für wen arbeitet die IT – und woher weißt du, was diese Leute brauchen?
+ziel: >-
+  Du kennst deine Rechte und Pflichten in der Ausbildung, kannst den Aufbau des
+  Betriebs aus Sicht der IT beschreiben und wählst für jede Absprache den
+  passenden Kanal.
+
+handouts: [A4, A5, A6]
+aufgaben: ["5.1"]
+checklisten: []
+lernzielkontrolle: woche-05
+
+tage:
+  - tag: Montag
+    theorie: [A4]
+    praxis: Den eigenen Ausbildungsvertrag und den betrieblichen Ausbildungsplan durchlesen, Fragen notieren und mit dem Ausbilder klären.
+  - tag: Dienstag
+    theorie: [A5]
+    praxis: Praxisaufgabe 5.1 beginnen – Organigramm besorgen, Gesprächstermine mit allen Abteilungen vereinbaren, erste Gespräche führen.
+  - tag: Mittwoch
+    theorie: [A6]
+    praxis: Ablage der IT-Dokumentation sichten, drei veraltete oder doppelte Dokumente finden und einen Vorschlag zur Bereinigung machen.
+  - tag: Donnerstag
+    theorie: []
+    praxis: Praxisaufgabe 5.1 abschließen – restliche Gespräche, Abhängigkeiten einzeichnen, Übersicht ablegen, Tickets anlegen.
+  - tag: Freitag
+    theorie: []
+    praxis: Lernzielkontrolle, danach Berichtsheft schreiben.
@@ -0,0 +1,30 @@
+nummer: 6
+titel: IT-Sicherheit und Datenschutz
+block: sicherheit
+leitfrage: Was ist hier eigentlich wie viel wert – und wer würde es vermissen?
+ziel: >-
+  Du kannst den Schutzbedarf eines Arbeitsbereichs feststellen und begründen,
+  einen Arbeitsplatz auf typische Schwachstellen prüfen und richtig reagieren,
+  wenn ein Konto oder Daten in falsche Hände geraten sind.
+
+handouts: [I1, I2, I3]
+aufgaben: ["6.1"]
+checklisten: [05-arbeitsplatz-sicherheit-pruefen]
+lernzielkontrolle: null
+
+tage:
+  - tag: Montag
+    theorie: [I1]
+    praxis: Drei Anwendungen des Betriebs gemeinsam mit dem Ausbilder einstufen, je Schutzziel mit Begründung.
+  - tag: Dienstag
+    theorie: [I2]
+    praxis: Fünf Arbeitsplätze nach Checkliste prüfen, Abweichungen als Tickets anlegen.
+  - tag: Mittwoch
+    theorie: [I3]
+    praxis: Praxisaufgabe 6.1 beginnen – Bereich wählen, Informationen und Anwendungen erfassen, Gespräch mit der Leitung vereinbaren.
+  - tag: Donnerstag
+    theorie: []
+    praxis: Praxisaufgabe 6.1 abschließen – Systeme ableiten, Einstufung abstimmen, Maßnahmen vorschlagen.
+  - tag: Freitag
+    theorie: []
+    praxis: Ergebnis der Schutzbedarfsfeststellung dem Ausbilder vorstellen, Berichtsheft schreiben.
@@ -0,0 +1,30 @@
+nummer: 7
+titel: Skripting mit PowerShell
+block: programmierung
+leitfrage: Welche Arbeit machst du jede Woche von Hand, obwohl ein Rechner sie besser könnte?
+ziel: >-
+  Du kannst mit der PowerShell-Pipeline Informationen abfragen und filtern,
+  ein Skript mit Variablen, Bedingungen und Schleifen schreiben und es so
+  gestalten, dass andere es sicher benutzen können.
+
+handouts: [P1, P2, P3]
+aufgaben: ["7.1"]
+checklisten: []
+lernzielkontrolle: woche-07
+
+tage:
+  - tag: Montag
+    theorie: [P1]
+    praxis: Zehn Fragen an das eigene System mit der Pipeline beantworten – etwa welche Dienste beendet sind, die automatisch starten sollten.
+  - tag: Dienstag
+    theorie: [P2]
+    praxis: Ein Skript schreiben, das vor knappem Speicherplatz warnt, und an drei Rechnern testen.
+  - tag: Mittwoch
+    theorie: [P3]
+    praxis: Praxisaufgabe 7.1 beginnen – Angaben in den CIM-Klassen finden, Objekt bauen, erster Lauf.
+  - tag: Donnerstag
+    theorie: []
+    praxis: Praxisaufgabe 7.1 abschließen – Aktualisieren statt Anhängen, Fehlerbehandlung, Hilfeblock, Lauf auf drei Rechnern.
+  - tag: Freitag
+    theorie: []
+    praxis: Lernzielkontrolle, danach Berichtsheft schreiben.
@@ -0,0 +1,30 @@
+nummer: 8
+titel: Datensicherung und Speicher
+block: system
+leitfrage: Wie lange dauert es wirklich, bis nach einem Ausfall wieder gearbeitet werden kann?
+ziel: >-
+  Du kannst ein Sicherungskonzept aus dem Schutzbedarf ableiten, eine
+  Wiederherstellung durchführen und messen und die passende RAID-Stufe für
+  einen Datenspeicher begründen.
+
+handouts: [S3, S4, S5]
+aufgaben: ["8.1"]
+checklisten: [06-wiederherstellung-testen]
+lernzielkontrolle: null
+
+tage:
+  - tag: Montag
+    theorie: [S3]
+    praxis: Die Sicherungsaufträge des Betriebs gemeinsam mit dem Ausbilder durchgehen und je Auftrag Art, Häufigkeit und Aufbewahrung notieren.
+  - tag: Dienstag
+    theorie: [S5]
+    praxis: RAID-Zustand und Plattenüberwachung von Server und NAS prüfen, Kapazitäten für drei Ausbaustufen durchrechnen.
+  - tag: Mittwoch
+    theorie: [S4]
+    praxis: Eine einzelne Datei und einen Ordner mit Berechtigungen nach Checkliste zurückspielen.
+  - tag: Donnerstag
+    theorie: []
+    praxis: Praxisaufgabe 8.1 – Sicherung des Bereichs prüfen, auf die Testumgebung zurückspielen, Zeit messen, Vorschläge schreiben.
+  - tag: Freitag
+    theorie: []
+    praxis: Monatliches Feedbackgespräch, danach Berichtsheft schreiben.
@@ -1,6 +1,6 @@
 # Abnahmeprotokoll

-Erzeugt am 2026-09-11 17:16 Uhr
+Erzeugt am 2026-10-04 16:24 Uhr

 Erzeugt von `scripts/pruefungen/abnahme.mjs` gegen eine **frische, leere Datenbank**.

@@ -54,15 +54,15 @@ Erzeugt von `scripts/pruefungen/abnahme.mjs` gegen eine **frische, leere Datenba

 - ✓ Der Azubi legt das Wochenblatt der laufenden Woche an
 - ✓ Ein Wochenblatt lässt sich öffnen
- ✓ Das Wochenblatt kommt als PDF heraus — HTTP 200, 2646 Bytes
+- ✓ Das Wochenblatt kommt als PDF heraus — HTTP 200, 2649 Bytes

 ## A8 · Sicherung zurückspielen

- ✓ Die Sicherung läuft durch — lernbar-20260911-171627.tar.gz
+- ✓ Die Sicherung läuft durch — lernbar-20261004-182433.tar.gz
 - ✓ Zum Beweis wird der Datenbestand beschädigt — 2 → 1 Konten
 - ✓ Die Rückspielung läuft durch — ohne Fehler
 - ✓ Der gelöschte Azubi ist wieder da — Tim Vogt
 - ✓ Auch der Lernverlauf kam mit zurück — 1 Einträge
- ✓ Der überschriebene Stand wurde zur Seite gelegt, nicht gelöscht — verdraengt-20260911-171632
+- ✓ Der überschriebene Stand wurde zur Seite gelegt, nicht gelöscht — verdraengt-20261004-182436

 **36 von 36 Prüfungen erfüllt.**
@@ -401,6 +401,7 @@ mitten durchgeschnitten, aufklappbare Abschnitte drucken aufgeklappt.

 | Beobachtung | Woran es liegt |
 |---|---|
+| „Zu viele Fehlversuche" bei der Anmeldung | Nach fünf falschen Passwörtern wird die Adresse für eine Minute gesperrt, bei weiteren Fehlversuchen länger, höchstens 15 Minuten. Abwarten – oder Passwort vom Ausbilder neu setzen lassen. Hat sich das einzige Ausbilderkonto ausgesperrt: `docker compose restart lernbar` setzt die Sperre zurück. |
 | „Diese Seite gibt es nicht" bei fremden Daten | Kein Fehler, sondern die Rechteprüfung. Ob es zu einer Kennung überhaupt Daten gibt, geht Unbefugte nichts an – deshalb 404 und nicht „kein Zugriff". |
 | Die Anwendung startet nicht, nennt aber Datei und Zeile | Ein Inhaltsfehler unter `content/`. Die Meldung sagt genau, wo. `npm run inhalte:pruefen` prüft ohne Start. |
 | Ein Anhang lässt sich nicht hochladen | Über 25 MB. Bei einem Reverse Proxy zusätzlich `client_max_body_size 30m` setzen (siehe README). |
@@ -1,12 +1,12 @@
 {
  "name": "lernbar",
-  "version": "0.1.0",
+  "version": "1.0.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "lernbar",
-      "version": "0.1.0",
+      "version": "1.0.3",
      "dependencies": {
        "@node-rs/argon2": "^2.0.2",
        "better-sqlite3": "^12.11.1",
@@ -1,6 +1,6 @@
 {
  "name": "lernbar",
-  "version": "1.0.0",
+  "version": "1.0.3",
  "private": true,
  "description": "Lern-Bar – betriebliche Ausbildung Fachinformatiker Systemintegration",
  "engines": {
@@ -17,11 +17,13 @@
    "e2e": "playwright test",
    "inhalte:pruefen": "tsx scripts/inhalte-pruefen.ts",
    "konto:anlegen": "tsx scripts/konto-anlegen.ts",
+    "werkzeuge:bauen": "esbuild scripts/konto-anlegen.ts --bundle --platform=node --target=node22 --format=cjs --external:better-sqlite3 --external:@node-rs/argon2 --outfile=build/werkzeuge/konto.js",
    "backup": "bash scripts/im-container/sicherung.sh",
    "restore": "bash scripts/im-container/wiederherstellen.sh",
    "screenshots": "tsx scripts/screenshots.ts",
    "symbole": "tsx scripts/symbole.ts",
-    "abnahme": "node scripts/pruefungen/abnahme.mjs"
+    "abnahme": "node scripts/pruefungen/abnahme.mjs",
+    "abnahme:container": "node scripts/pruefungen/container.mjs"
  },
  "dependencies": {
    "@node-rs/argon2": "^2.0.2",
@@ -0,0 +1,199 @@
+import { chromium } from '@playwright/test';
+import { spawnSync } from 'node:child_process';
+
+/**
+ * Der Abnahmelauf gegen das Docker-Abbild.
+ *
+ * `abnahme.mjs` prüft die Anwendung über `next start`. Betrieben wird sie aber
+ * als Container – und was dort fehlt, fällt dabei nicht auf. So war es mit dem
+ * Kontowerkzeug: Die README beschrieb `node werkzeuge/konto.js`, im Abbild lag
+ * es nie, und ein frisch aufgesetzter Server stand ohne jedes Konto da.
+ *
+ * Dieser Lauf baut das Abbild, startet es mit leerem Volume und geht den Weg
+ * aus der README: Lebenszeichen, erstes Konto, Anmeldung, Sperre bei
+ * Fehlversuchen, Sicherung.
+ *
+ *   node scripts/pruefungen/container.mjs
+ *
+ * Voraussetzung: Docker läuft, Port 3398 ist frei (LERNBAR_CONTAINER_PORT).
+ */
+
+const PORT = Number(process.env.LERNBAR_CONTAINER_PORT ?? 3398);
+const BASIS = `http://localhost:${PORT}`;
+const ABBILD = 'lernbar:abnahme';
+const NAME = `lernbar-abnahme-${Date.now()}`;
+
+const AUSBILDER = { name: 'Petra Kessler', email: 'petra.kessler@betrieb.test', pw: 'container-ausbilder' };
+
+let fehler = 0;
+
+function pruefe(bedingung, text, zusatz = '') {
+  console.log(`   ${bedingung ? '✓' : '✗'} ${text}${zusatz ? ` – ${zusatz}` : ''}`);
+  if (!bedingung) fehler += 1;
+}
+
+function abschnitt(titel) {
+  console.log(`\n${titel}`);
+}
+
+function docker(argumente, zusatz = {}) {
+  return spawnSync('docker', argumente, { encoding: 'utf8', ...zusatz });
+}
+
+function imContainer(...argumente) {
+  const ergebnis = docker(['exec', NAME, ...argumente]);
+  return { ende: ergebnis.status, ausgabe: `${ergebnis.stdout}${ergebnis.stderr}` };
+}
+
+let browser = null;
+
+function aufraeumen() {
+  // -v nimmt das namenlose Volume mit – sonst bleibt bei jedem Lauf eins liegen.
+  docker(['rm', '-fv', NAME], { stdio: 'ignore' });
+  docker(['rmi', ABBILD], { stdio: 'ignore' });
+}
+
+async function portBelegt() {
+  try {
+    await fetch(`${BASIS}/api/gesundheit`, { signal: AbortSignal.timeout(1000) });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function gesund(sekunden = 60) {
+  for (let i = 0; i < sekunden; i += 1) {
+    try {
+      const antwort = await fetch(`${BASIS}/api/gesundheit`);
+      if (antwort.ok) return true;
+    } catch {
+      /* noch nicht da */
+    }
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+  return false;
+}
+
+async function anmelden(email, passwort) {
+  const kontext = await browser.newContext({ locale: 'de-DE' });
+  const seite = await kontext.newPage();
+  seite.setDefaultTimeout(30000);
+  await seite.goto(`${BASIS}/anmelden`);
+  await seite.fill('#email', email);
+  await seite.fill('#passwort', passwort);
+  await seite.click('button[type=submit]');
+  const angekommen = await seite
+    .waitForURL(`${BASIS}/`, { timeout: 15000 })
+    .then(() => true)
+    .catch(() => false);
+  await kontext.close();
+  return angekommen;
+}
+
+/** Ein Anmeldeversuch, der die angezeigte Meldung zurückgibt. */
+async function meldungNachAnmeldung(email, passwort) {
+  const kontext = await browser.newContext({ locale: 'de-DE' });
+  const seite = await kontext.newPage();
+  seite.setDefaultTimeout(30000);
+  await seite.goto(`${BASIS}/anmelden`);
+  await seite.fill('#email', email);
+  await seite.fill('#passwort', passwort);
+  await seite.click('button[type=submit]');
+  const text = await seite
+    .locator('.hinweis-fehler')
+    .innerText({ timeout: 15000 })
+    .catch(() => '');
+  await kontext.close();
+  return text;
+}
+
+async function main() {
+  if (docker(['info'], { stdio: 'ignore' }).status !== 0) {
+    console.error('Docker ist nicht erreichbar.');
+    process.exit(2);
+  }
+  if (await portBelegt()) {
+    console.error(`Auf Port ${PORT} antwortet schon etwas. Anderen Port über LERNBAR_CONTAINER_PORT setzen.`);
+    process.exit(2);
+  }
+
+  // --- C1 Das Abbild entsteht ----------------------------------------------
+
+  abschnitt('C1 · Das Abbild entsteht und startet');
+
+  console.log('   … baue das Abbild, das dauert beim ersten Mal einige Minuten');
+  const bau = docker(['build', '-t', ABBILD, '.'], { stdio: ['ignore', 'ignore', 'pipe'] });
+  pruefe(bau.status === 0, 'Das Abbild lässt sich bauen', bau.status === 0 ? '' : bau.stderr.split('\n').slice(-5).join(' '));
+  if (bau.status !== 0) return;
+
+  const start = docker(['run', '-d', '--name', NAME, '-p', `127.0.0.1:${PORT}:3000`, ABBILD]);
+  pruefe(start.status === 0, 'Der Container startet');
+  if (start.status !== 0) return;
+
+  pruefe(await gesund(), 'Die Anwendung meldet sich gesund');
+  pruefe(imContainer('id', '-un').ausgabe.trim() === 'node', 'Sie läuft nicht als root');
+
+  // --- C2 Das erste Konto ---------------------------------------------------
+
+  abschnitt('C2 · Das erste Konto entsteht im Container');
+
+  const werkzeuge = imContainer('ls', '/app/werkzeuge').ausgabe;
+  pruefe(werkzeuge.includes('konto.js'), 'Das Kontowerkzeug liegt im Abbild');
+
+  const anlegen = imContainer(
+    'node', 'werkzeuge/konto.js',
+    '--name', AUSBILDER.name, '--email', AUSBILDER.email, '--rolle', 'ausbilder', '--passwort', AUSBILDER.pw,
+  );
+  pruefe(anlegen.ende === 0 && anlegen.ausgabe.includes('Konto angelegt'), 'Der Aufruf aus der README legt das Konto an', anlegen.ausgabe.split('\n')[0]);
+
+  browser = await chromium.launch();
+  pruefe(await anmelden(AUSBILDER.email, AUSBILDER.pw), 'Der Ausbilder meldet sich mit diesem Konto an');
+  pruefe(!(await anmelden(AUSBILDER.email, 'falsch-falsch')), 'Ein falsches Passwort wird abgewiesen');
+
+  // Derselbe Aufruf ist der Rettungsweg, wenn das einzige Ausbilderkonto sein
+  // Passwort vergessen hat.
+  const neu = imContainer('node', 'werkzeuge/konto.js', '--name', AUSBILDER.name, '--email', AUSBILDER.email);
+  const neuesPw = neu.ausgabe.match(/Passwort: (\S+)/)?.[1];
+  pruefe(neu.ende === 0 && neu.ausgabe.includes('gab es schon') && neuesPw, 'Ein zweiter Aufruf setzt das Passwort neu');
+  pruefe(neuesPw && (await anmelden(AUSBILDER.email, neuesPw)), 'Mit dem neuen Passwort geht die Anmeldung');
+  pruefe(!(await anmelden(AUSBILDER.email, AUSBILDER.pw)), 'Das alte Passwort gilt nicht mehr');
+
+  // --- C3 Bremse gegen Passwortraten ----------------------------------------
+
+  abschnitt('C3 · Bremse gegen Passwortraten');
+
+  // Eine Adresse, die es nicht gibt: Die Sperre muss genauso greifen, sonst
+  // verriete sie, welche Konten existieren.
+  const unbekannt = 'niemand@betrieb.test';
+  for (let i = 0; i < 5; i += 1) await meldungNachAnmeldung(unbekannt, `geraten-${i}`);
+  const gesperrt = await meldungNachAnmeldung(unbekannt, 'geraten-6');
+  pruefe(gesperrt.includes('Zu viele Fehlversuche'), 'Nach fünf Fehlversuchen wird gesperrt – auch für eine unbekannte Adresse', gesperrt);
+
+  pruefe(neuesPw && (await anmelden(AUSBILDER.email, neuesPw)), 'Ein anderes Konto ist davon nicht betroffen');
+
+  for (let i = 0; i < 5; i += 1) await meldungNachAnmeldung(AUSBILDER.email, `geraten-${i}`);
+  pruefe(!(await anmelden(AUSBILDER.email, neuesPw)), 'Während der Sperre kommt auch das richtige Passwort nicht durch');
+
+  // --- C4 Sicherung im Container -------------------------------------------
+
+  abschnitt('C4 · Sicherung im Container');
+
+  const sicherung = imContainer('/app/werkzeuge/sicherung.sh', '/daten/sicherungen');
+  pruefe(sicherung.ende === 0, 'Die Sicherung läuft im Container durch', sicherung.ausgabe.trim().split('\n').at(-1));
+  const archive = imContainer('sh', '-c', 'ls /daten/sicherungen/lernbar-*.tar.gz').ausgabe;
+  pruefe(/lernbar-\d{8}-\d{6}\.tar\.gz/.test(archive), 'Das Archiv liegt im Volume');
+}
+
+try {
+  await main();
+} catch (e) {
+  console.error(e);
+  fehler += 1;
+} finally {
+  if (browser) await browser.close();
+  aufraeumen();
+}
+
+console.log(fehler === 0 ? '\n✓ Containerabnahme bestanden.' : `\n✗ ${fehler} Prüfung(en) nicht erfüllt.`);
+process.exit(fehler === 0 ? 0 : 1);
@@ -11,7 +11,7 @@ import path from 'node:path';
 * im sichtbaren Text.
 */

-const BASIS = 'http://localhost:3311';
+const BASIS = process.env.LERNBAR_BASIS ?? 'http://localhost:3000';
 const AZUBI = { email: 'jonas.berger@betrieb.de', pw: 'azubi-start-2026' };
 const AUSBILDER = { email: 'fw@wildeflorian.de', pw: 'ausbilder-start' };

@@ -26,6 +26,29 @@ const bruchstuecke = loesungen.map((l) => l.slice(40, 110)).filter((b) => b.leng
 console.log(`${loesungen.length} Musterlösungen aus woche-01.yaml gelesen.`);
 console.log('Geprüft wird auf Bruchstücke wie:', JSON.stringify(bruchstuecke[0]?.slice(0, 60)));

+// --- Ausgangslage herstellen ----------------------------------------------
+//
+// Der entscheidende Fall ist „freigegeben, aber noch nicht abgegeben". Den gibt
+// es nur einmal je Kontrolle. Damit die Prüfung wiederholbar bleibt, wird die
+// Kontrolle „woche-01" vorher zurückgesetzt – das ist ein Testaufbau, kein Teil
+// der Anwendung, und greift deshalb ausdrücklich nur auf die lokale
+// Beispieldatenbank zu.
+const { default: Datenbank } = await import('better-sqlite3');
+const dbPfad = process.env.LERNBAR_DB ?? path.join(process.cwd(), 'daten', 'lernbar.sqlite');
+
+if (fs.existsSync(dbPfad)) {
+  const db = new Datenbank(dbPfad);
+  const betroffen = db.prepare("select id from kontrolle where kontrolle_id = 'woche-01'").all();
+  for (const eintrag of betroffen) {
+    db.prepare('delete from kontroll_antwort where kontrolle_id = ?').run(eintrag.id);
+    db.prepare('delete from kontrolle where id = ?').run(eintrag.id);
+  }
+  db.close();
+  console.log(`Ausgangslage hergestellt: ${betroffen.length} frühere Bearbeitung(en) von woche-01 entfernt.`);
+} else {
+  console.log(`Keine Datenbank unter ${dbPfad} – die Ausgangslage wird nicht zurückgesetzt.`);
+}
+
 const browser = await chromium.launch();
 const seite = await (await browser.newContext({ locale: 'de-DE' })).newPage();

@@ -41,13 +64,19 @@ async function abmelden() {
  await seite.waitForURL(/anmelden/);
 }

-/** Sucht im rohen HTML **und** in der RSC-Nutzlast. */
+/** Sucht im rohen HTML **und** in der Server-Nutzlast. */
 async function lecksuche(beschriftung) {
  const html = await seite.content();
+
+  // Die Nutzlast steht in eingebetteten Skripten, die `self.__next_f` füllen.
+  // Dort **nachträglich** nachzusehen bringt nichts: Next leert das Feld, sobald
+  // es verarbeitet ist – es wäre immer leer, und die Prüfung liefe ins Leere,
+  // ohne dass es auffällt. Deshalb wird der Quelltext der Skripte gelesen.
  const rsc = await seite.evaluate(() =>
-    // Next legt die Server-Nutzlast in self.__next_f ab – dort steht alles,
-    // was der Server an den Browser geschickt hat.
-    (globalThis.self?.__next_f ?? []).map((t) => (Array.isArray(t) ? String(t[1] ?? '') : '')).join(''),
+    [...document.querySelectorAll('script:not([src])')]
+      .map((element) => element.textContent ?? '')
+      .filter((text) => text.includes('__next_f'))
+      .join(''),
  );

  const treffer = bruchstuecke.filter((b) => html.includes(b) || rsc.includes(b));
@@ -55,7 +84,7 @@ async function lecksuche(beschriftung) {

  console.log(
    `   ${beschriftung.padEnd(34)} Leck: ${treffer.length === 0 ? 'nein' : `JA (${treffer.length})`}` +
-      ` | RSC-Größe ${rsc.length} | "musterloesung":null ${nullFelder}x`,
+      ` | Nutzlast ${rsc.length} Zeichen | "musterloesung":null ${nullFelder}x`,
  );
  return treffer;
 }
@@ -71,8 +100,17 @@ await abmelden();
 await anmelden(AUSBILDER);
 await seite.goto(`${BASIS}/kontrollen`);
 await seite.waitForSelector('.kontrollzeile');
-await seite.locator('.kontrollzeile', { hasText: 'Woche 1' }).locator('button:has-text("Freigeben")').click();
-await seite.waitForTimeout(1500);
+const freigeben = seite
+  .locator('.kontrollzeile', { hasText: 'Woche 1' })
+  .locator('button:has-text("Freigeben")');
+if ((await freigeben.count()) > 0) {
+  await freigeben.click();
+  await seite.waitForTimeout(1500);
+} else {
+  // Bei einem wiederholten Lauf ist sie schon freigegeben. Das ist kein
+  // Grund abzubrechen – der entscheidende Fall kommt erst danach.
+  console.log('   (war bereits freigegeben)');
+}

 console.log('\n3) Nach der Freigabe, vor der Abgabe – der entscheidende Fall');
 await abmelden();
@@ -3,6 +3,7 @@
 import { eq } from 'drizzle-orm';
 import { redirect } from 'next/navigation';
 import { datenbank, schema } from '@/lib/db';
+import { anmeldeDrossel, wartezeitText } from '@/lib/auth/drossel';
 import { passwortPruefen } from '@/lib/auth/passwort';
 import { sitzungAnlegen, sitzungBeenden } from '@/lib/auth/sitzung';
 import { jetzt } from '@/lib/zeit';
@@ -19,6 +20,18 @@ export async function anmelden(_vorher: Anmeldezustand, formular: FormData): Pro
    return { fehler: 'Bitte E-Mail-Adresse und Passwort eingeben.', email };
  }

+  // Während einer Sperre wird gar nicht erst geprüft – auch ein richtiges
+  // Passwort kommt dann nicht durch, sonst wäre die Sperre wertlos.
+  const drossel = anmeldeDrossel();
+  const wartezeit = drossel.wartezeit(email);
+  if (wartezeit > 0) {
+    return { fehler: `Zu viele Fehlversuche. Bitte ${wartezeitText(wartezeit)} noch einmal versuchen.`, email };
+  }
+  // Jeder Versuch zählt sofort als Fehlversuch und wird erst bei Erfolg
+  // zurückgenommen. Zwischen Prüfen und Zählen liegt so kein await – sonst
+  // kämen hundert gleichzeitige Anfragen alle an der Sperre vorbei.
+  drossel.fehlversuch(email);
+
  const db = datenbank();
  const benutzer = db.select().from(schema.benutzer).where(eq(schema.benutzer.email, email)).get();

@@ -34,6 +47,8 @@ export async function anmelden(_vorher: Anmeldezustand, formular: FormData): Pro
  const stimmt = await passwortPruefen(benutzer.passwortHash, passwort);
  if (!stimmt) return abweisung;

+  drossel.erfolg(email);
+
  db.update(schema.benutzer).set({ letzteAnmeldungAm: jetzt() }).where(eq(schema.benutzer.id, benutzer.id)).run();
  await sitzungAnlegen(benutzer.id);

@@ -67,7 +67,9 @@ export function megabyte(bytes: number): string {
 * etwas verloren.
 */
 export function saubererName(name: string): string {
-  return path
+  // win32.basename trennt an / und \ – der Name kommt vom Browser, nicht vom
+  // Server, und ein Windows-Pfad darf auch unter Linux nicht durchrutschen.
+  return path.win32
    .basename(name)
    .replace(/[\u0000-\u001f\u007f]/g, '')
    .replace(/["\\]/g, '')
@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'vitest';
+import {
+  Drossel,
+  FREIE_VERSUCHE,
+  GRUNDSPERRE_MS,
+  HOECHSTSPERRE_MS,
+  VERGESSEN_NACH_MS,
+  sperreFuer,
+  wartezeitText,
+} from './drossel';
+
+/** Eine Uhr, die nur weiterläuft, wenn man sie stellt. */
+function stehendeUhr(start = 1_000_000) {
+  let zeit = start;
+  return {
+    uhr: () => zeit,
+    vor: (ms: number) => {
+      zeit += ms;
+    },
+  };
+}
+
+function scheitern(drossel: Drossel, schluessel: string, mal: number) {
+  for (let i = 0; i < mal; i += 1) drossel.fehlversuch(schluessel);
+}
+
+describe('sperreFuer', () => {
+  it('lässt die ersten Fehlversuche frei', () => {
+    for (let n = 1; n < FREIE_VERSUCHE; n += 1) expect(sperreFuer(n)).toBe(0);
+  });
+
+  it('sperrt ab dem fünften Fehlversuch und verdoppelt dann', () => {
+    expect(sperreFuer(FREIE_VERSUCHE)).toBe(GRUNDSPERRE_MS);
+    expect(sperreFuer(FREIE_VERSUCHE + 1)).toBe(2 * GRUNDSPERRE_MS);
+    expect(sperreFuer(FREIE_VERSUCHE + 2)).toBe(4 * GRUNDSPERRE_MS);
+  });
+
+  it('bleibt bei der Obergrenze stehen', () => {
+    expect(sperreFuer(FREIE_VERSUCHE + 20)).toBe(HOECHSTSPERRE_MS);
+  });
+});
+
+describe('Drossel', () => {
+  it('sperrt nach fünf Fehlversuchen, nicht vorher', () => {
+    const { uhr } = stehendeUhr();
+    const drossel = new Drossel(uhr);
+    scheitern(drossel, 'a@x.de', FREIE_VERSUCHE - 1);
+    expect(drossel.wartezeit('a@x.de')).toBe(0);
+    drossel.fehlversuch('a@x.de');
+    expect(drossel.wartezeit('a@x.de')).toBe(GRUNDSPERRE_MS);
+  });
+
+  it('gibt nach Ablauf der Sperre wieder frei', () => {
+    const { uhr, vor } = stehendeUhr();
+    const drossel = new Drossel(uhr);
+    scheitern(drossel, 'a@x.de', FREIE_VERSUCHE);
+    vor(GRUNDSPERRE_MS);
+    expect(drossel.wartezeit('a@x.de')).toBe(0);
+  });
+
+  it('verlängert beim nächsten Fehlversuch nach der Sperre', () => {
+    const { uhr, vor } = stehendeUhr();
+    const drossel = new Drossel(uhr);
+    scheitern(drossel, 'a@x.de', FREIE_VERSUCHE);
+    vor(GRUNDSPERRE_MS);
+    drossel.fehlversuch('a@x.de');
+    expect(drossel.wartezeit('a@x.de')).toBe(2 * GRUNDSPERRE_MS);
+  });
+
+  it('setzt nach erfolgreicher Anmeldung zurück', () => {
+    const { uhr } = stehendeUhr();
+    const drossel = new Drossel(uhr);
+    scheitern(drossel, 'a@x.de', FREIE_VERSUCHE - 1);
+    drossel.erfolg('a@x.de');
+    scheitern(drossel, 'a@x.de', FREIE_VERSUCHE - 1);
+    expect(drossel.wartezeit('a@x.de')).toBe(0);
+  });
+
+  it('vergisst Fehlversuche nach einer Stunde Ruhe', () => {
+    const { uhr, vor } = stehendeUhr();
+    const drossel = new Drossel(uhr);
+    scheitern(drossel, 'a@x.de', FREIE_VERSUCHE - 1);
+    vor(VERGESSEN_NACH_MS);
+    drossel.fehlversuch('a@x.de');
+    expect(drossel.wartezeit('a@x.de')).toBe(0);
+  });
+
+  it('zählt jede Adresse für sich', () => {
+    const { uhr } = stehendeUhr();
+    const drossel = new Drossel(uhr);
+    scheitern(drossel, 'a@x.de', FREIE_VERSUCHE);
+    expect(drossel.wartezeit('a@x.de')).toBeGreaterThan(0);
+    expect(drossel.wartezeit('b@x.de')).toBe(0);
+  });
+
+  it('räumt auf, lässt eine laufende Sperre aber nicht verdrängen', () => {
+    const { uhr } = stehendeUhr();
+    const drossel = new Drossel(uhr);
+    scheitern(drossel, 'opfer@x.de', FREIE_VERSUCHE);
+    for (let i = 0; i < 10_050; i += 1) drossel.fehlversuch(`erfunden-${i}@x.de`);
+    expect(drossel.groesse).toBeLessThanOrEqual(10_001);
+    expect(drossel.wartezeit('opfer@x.de')).toBe(GRUNDSPERRE_MS);
+  });
+});
+
+describe('wartezeitText', () => {
+  it('rundet auf ganze Minuten auf', () => {
+    expect(wartezeitText(1)).toBe('in einer Minute');
+    expect(wartezeitText(60_000)).toBe('in einer Minute');
+    expect(wartezeitText(60_001)).toBe('in 2 Minuten');
+    expect(wartezeitText(HOECHSTSPERRE_MS)).toBe('in 15 Minuten');
+  });
+});
@@ -0,0 +1,94 @@
+/**
+ * Bremse gegen Passwortraten.
+ *
+ * Gezählt wird je E-Mail-Adresse – auch für Adressen, die es nicht gibt.
+ * Sonst verriete die Sperre, welche Konten existieren (siehe E6).
+ *
+ * Die ersten Fehlversuche sind frei, danach verdoppelt sich die Sperre bis
+ * zu einer Obergrenze. Die Obergrenze ist Absicht: Wer fremde Adressen
+ * eintippt, soll den Ausbilder nicht für Stunden aussperren können.
+ *
+ * Der Zähler liegt im Speicher des einen Serverprozesses. Ein Neustart setzt
+ * ihn zurück – das ist zugleich der Notausgang, falls man sich selbst
+ * ausgesperrt hat. Siehe E42.
+ */
+
+export const FREIE_VERSUCHE = 5;
+export const GRUNDSPERRE_MS = 60_000;
+export const HOECHSTSPERRE_MS = 15 * 60_000;
+export const VERGESSEN_NACH_MS = 60 * 60_000;
+const HOECHSTZAHL_EINTRAEGE = 10_000;
+
+export type Stand = { fehlversuche: number; zuletzt: number; gesperrtBis: number };
+
+/** Wie lange nach dem n-ten Fehlversuch gesperrt wird. */
+export function sperreFuer(fehlversuche: number): number {
+  if (fehlversuche < FREIE_VERSUCHE) return 0;
+  return Math.min(GRUNDSPERRE_MS * 2 ** (fehlversuche - FREIE_VERSUCHE), HOECHSTSPERRE_MS);
+}
+
+export function nachFehlversuch(stand: Stand | undefined, jetzt: number): Stand {
+  const bisher = stand && jetzt - stand.zuletzt < VERGESSEN_NACH_MS ? stand.fehlversuche : 0;
+  const fehlversuche = bisher + 1;
+  return { fehlversuche, zuletzt: jetzt, gesperrtBis: jetzt + sperreFuer(fehlversuche) };
+}
+
+export function restsperre(stand: Stand | undefined, jetzt: number): number {
+  return stand ? Math.max(0, stand.gesperrtBis - jetzt) : 0;
+}
+
+/** „in 3 Minuten" – aufgerundet, damit niemand zu früh wiederkommt. */
+export function wartezeitText(ms: number): string {
+  const minuten = Math.max(1, Math.ceil(ms / 60_000));
+  return minuten === 1 ? 'in einer Minute' : `in ${minuten} Minuten`;
+}
+
+export class Drossel {
+  private staende = new Map<string, Stand>();
+
+  constructor(private uhr: () => number = Date.now) {}
+
+  /** Restliche Sperre in Millisekunden, 0 heißt: darf versuchen. */
+  wartezeit(schluessel: string): number {
+    return restsperre(this.staende.get(schluessel), this.uhr());
+  }
+
+  fehlversuch(schluessel: string): void {
+    const jetzt = this.uhr();
+    this.staende.set(schluessel, nachFehlversuch(this.staende.get(schluessel), jetzt));
+    if (this.staende.size > HOECHSTZAHL_EINTRAEGE) this.aufraeumen(jetzt);
+  }
+
+  erfolg(schluessel: string): void {
+    this.staende.delete(schluessel);
+  }
+
+  get groesse(): number {
+    return this.staende.size;
+  }
+
+  /**
+   * Wer massenhaft ausgedachte Adressen schickt, soll den Speicher nicht
+   * füllen. Erst fällt weg, was ohnehin vergessen ist, dann das Älteste.
+   * Eine laufende Sperre wird nie weggeräumt – sonst ließe sie sich mit
+   * genug ausgedachten Adressen aus dem Speicher drängen.
+   */
+  private aufraeumen(jetzt: number): void {
+    for (const [schluessel, stand] of this.staende) {
+      if (jetzt - stand.zuletzt >= VERGESSEN_NACH_MS) this.staende.delete(schluessel);
+    }
+    for (const [schluessel, stand] of this.staende) {
+      if (this.staende.size <= HOECHSTZAHL_EINTRAEGE) break;
+      if (stand.gesperrtBis <= jetzt) this.staende.delete(schluessel);
+    }
+  }
+}
+
+// Eine Drossel pro Prozess, am globalThis wie die Datenbankverbindung, damit
+// das Neuladen im Entwicklungsbetrieb die Zähler nicht verdoppelt.
+const halter = globalThis as unknown as { __lernbarDrossel?: Drossel };
+
+export function anmeldeDrossel(): Drossel {
+  halter.__lernbarDrossel ??= new Drossel();
+  return halter.__lernbarDrossel;
+}
Author	SHA1	Message	Date
Florian WildeandClaude Opus 5.5	4611974494	Fassung 1.0.3 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-04 21:53:10 +02:00
Florian WildeandClaude Opus 5.5	7d171f149d	Inhalte: Wochen 5 bis 8 Vier neue Wochen nach Rahmenplan, im bestehenden Format: - Woche 5 Ausbildung, Betrieb und Zusammenarbeit (C1, C2, C5) - Woche 6 IT-Sicherheit und Datenschutz (A6, LF4) - Woche 7 Skripting mit PowerShell (A10, A4) - Woche 8 Datensicherung und Speicher (A9) 12 Handouts, 38 Merkkarten, 4 Praxisaufgaben, 2 Checklisten, 2 Lernzielkontrollen, 22 Glossareintraege, zwei neue Themenbloecke. Jede Berufsbildposition ist jetzt von mindestens einem Inhalt beruehrt. Die Praxisaufgaben bauen aufeinander auf: Die Abteilungsuebersicht aus 5.1 ist Grundlage der Schutzbedarfsfeststellung in 6.1, und deren Ergebnis ist Massstab fuer die Sicherungspruefung in 8.1. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-04 21:53:10 +02:00
Florian WildeandClaude Opus 5.5	052419dd43	Fassung 1.0.2 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-04 18:25:04 +02:00
Florian WildeandClaude Opus 5.5	31d7779f45	Bremse gegen Passwortraten Nach fuenf Fehlversuchen wird eine E-Mail-Adresse gesperrt, erst eine Minute, dann doppelt so lang, hoechstens 15 Minuten. Gezaehlt wird je Adresse, auch fuer unbekannte - sonst verriete die Sperre, welche Konten es gibt. Waehrend der Sperre kommt auch das richtige Passwort nicht durch. Jeder Versuch zaehlt sofort und wird bei Erfolg zurueckgenommen. Zwischen Sperrpruefung und Zaehlen liegt damit kein await; gleichzeitige Anfragen kommen so nicht alle an der Sperre vorbei. Der Zaehler liegt im Speicher des einen Prozesses. Ein Neustart setzt ihn zurueck - der Notausgang, falls sich das einzige Ausbilderkonto aussperrt. Beim Aufraeumen wird eine laufende Sperre nie verdraengt. Die Containerabnahme prueft die Sperre im laufenden Abbild. Das Abnahmeprotokoll ist gegen diesen Stand neu erzeugt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-04 18:25:04 +02:00
Florian WildeandClaude Opus 5.5	5fbf1ac4de	Fassung 1.0.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-03 00:50:59 +02:00
Florian WildeandClaude Opus 5.5	adb93a722f	Kontowerkzeug ins Abbild, Containerabnahme Die README nannte `node werkzeuge/konto.js`, im Abbild lag aber nur das Sicherungswerkzeug, und tsx gibt es dort nicht. Ein frisch aufgesetzter Server stand ohne jedes Konto da. Das Kontoskript wird jetzt beim Bau mit esbuild zu einer Datei gebuendelt; die nativen Module bleiben aussen vor, sie bringt die Standalone-Ausgabe mit. Aufgefallen ist das nicht, weil der Abnahmelauf gegen `next start` prueft. Neu ist deshalb `npm run abnahme:container`: Abbild bauen, mit leerem Volume starten, erstes Konto anlegen, anmelden, Passwort neu setzen, sichern. Ausserdem trennt saubererName Windows-Pfade jetzt auch unter Linux ab (path.win32.basename). Der Test dazu war nur unter Windows gruen. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-03 00:50:59 +02:00
Florian WildeandClaude Opus 5	6181ec4bd7	Pruefskripte: wiederholbar und ehrlich machen Die Dichtheitspruefung der Musterloesungen las die Server-Nutzlast aus self.__next_f - das Feld leert Next nach der Verarbeitung, es war also immer leer. Die Pruefung lief an dieser Stelle ins Leere, ohne dass es auffiel; nur der HTML-Quelltext wurde wirklich geprueft. Gelesen wird jetzt der Quelltext der eingebetteten Skripte. Damit zeigt die Ausgabe, was sie zeigen soll: vor der Abgabe steht fuenfmal "musterloesung":null in der Nutzlast, danach stehen dort die Loesungen. Ausserdem stellt das Skript seine Ausgangslage selbst her und laeuft gegen den Port, der ueber LERNBAR_BASIS eingestellt ist - vorher war 3311 fest eingetragen und ein zweiter Lauf scheiterte daran, dass die Kontrolle schon abgegeben war. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-11 19:36:29 +02:00