jleibl/ihk-ausbildung
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: IHK Ausbildung materials

Browse Source
This commit is contained in:
Jan-Marlon Leibl
2026-03-13 11:46:08 +01:00
commit eb4a13ef7c
67 changed files with 11361 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
00-Inhaltsverzeichnis.md Normal file
View File

@@ -0,0 +1,159 @@
# IHK Ausbildung - Fachinformatiker Anwendungsentwicklung
> Index für die Ausbildungsunterlagen | [[00-Inhaltsverzeichnis|🔗 Direkt zum Inhaltsverzeichnis]]
## Überblick
Diese Vault enthält alle Lernunterlagen für die 3-jährige Ausbildung zum/zur Fachinformatiker/in Anwendungsentwicklung gemäß Rahmenlehrplan KMK (13.12.2019) und Ausbildungsverordnung FIAusbV (28.02.2020).
### Zeitlicher Ablauf
| Jahr | Lernfelder | Gesamtstunden |
| ------------------ | ---------- | ------------- |
| 1. Ausbildungsjahr | LF 1-5 | 320 Stunden |
| 2. Ausbildungsjahr | LF 6-9 | 280 Stunden |
| 3. Ausbildungsjahr | LF 10a-12a | 280 Stunden |
| | | |
### Prüfungsübersicht
- **Teil 1 der Abschlussprüfung**: Nach dem 4. Ausbildungshalbjahr (nach LF 1-6)
- **Teil 2 der Abschlussprüfung**: Am Ende der Ausbildung
---
## Ordnerstruktur
```
IHK-Ausbildung/
├── 📚 1-Ausbildungsjahr/
│ ├── 📖 LF1-Unternehmen-Rolle/
│ ├── 📖 LF2-Arbeitsplätze-ausstatten/
│ ├── 📖 LF3-Datenbanken/
│ ├── 📖 LF4-IT-Sicherheit/
│ └── 📖 LF5-Analyse-Design/
│
├── 📚 2-Ausbildungsjahr/
│ ├── 📖 LF6-Webanwendungen/
│ ├── 📖 LF7-Service/
│ ├── 📖 LF8-Daten-integration/
│ └── 📖 LF9-Netzwerke-Dienste/
│
├── 📚 3-Ausbildungsjahr/
│ ├── 📖 LF10a-Benutzeroberflächen/
│ ├── 📖 LF11a-Funktionalität-realisiren/
│ └── 📖 LF12a-Kundenspezifische-Entwicklung/
│
├── 📝 Prüfungsvorbereitung/
│ ├── 📖 Teil1-Prüfung/
│ ├── 📖 Teil2-Projekt/
│ └── 📖 Wirtschafts-Sozialkunde/
│
├── 🏢 Betriebliche-Ausbildung/
│ ├── 📖 Ausbildungsnachweis/
│ ├── 📖 Projekt-doku-Vorlagen/
│ └── 📖 Betriebliche-Themen/
│
├── 📚 Wissen/
│ ├── 📖 Programmiersprachen/
│ ├── 📖 Datenbanken/
│ ├── 📖 Netzwerk-Technik/
│ ├── 📖 IT-Sicherheit/
│ └── 📖 Projektmanagement/
│
└── 📋 Notizen/
```
---
## Lernfeld-Übersicht mit Kompetenzen
### 1. Ausbildungsjahr
#### LF 1: Das Unternehmen und die eigene Rolle im Betrieb beschreiben
- **Zeitrichtwert**: 40 Stunden
- **Kernkompetenz**: Unternehmen hinsichtlich Wertschöpfungskette präsentieren und eigene Rolle beschreiben
- **Themen**: Unternehmensleitbild, Marktstruktur, Rechtsform, Wertschöpfungskette, Organisationsstruktur
#### LF 2: Arbeitsplätze nach Kundenwunsch ausstatten
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Ausstattung eines Arbeitsplatzes nach Kundenwunsch dimensionieren, anzubieten, zu beschaffen und zu übergeben
- **Themen**: Hard-/Software-Auswahl, Nutzwertanalyse, Angebotserstellung, Beschaffung, Inbetriebnahme
#### LF 3: Clients in Netzwerke einbinden
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Netzwerkinfrastruktur analysieren und Clients integrieren
- **Themen**: Netzwerkkomponenten, IP-Konfiguration, DHCP, DNS, WLAN, Netzwerkprotokolle
#### LF 4: Schutzbedarfsanalyse im eigenen Arbeitsbereich durchführen
- **Zeitrichtwert**: 40 Stunden
- **Kernkompetenz**: Schutzbedarfsanalyse zur Ermittlung der Informationssicherheit auf Grundschutzniveau
- **Themen**: Schutzziele (Vertraulichkeit, Integrität, Verfügbarkeit), Bedrohungen, Sicherheitsleitlinie, BSI-Grundschutz
#### LF 5: Software zur Verwaltung von Daten anpassen
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Informationen mittels Daten abbilden, Daten verwalten und Software anpassen
- **Themen**: Datenbankmodelle, ER-Diagramme, SQL, Datenformate, Softwareanpassung
---
### 2. Ausbildungsjahr
#### LF 6: Serviceanfragen bearbeiten
- **Zeitrichtwert**: 40 Stunden
- **Kernkompetenz**: Serviceanfragen einordnen, Fehlerursachen ermitteln und beheben
- **Themen**: ITIL-Grundlagen, Ticket-Systeme, Support-Levels, Kommunikation, Dokumentation
#### LF 7: Cyber-physische Systeme ergänzen
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Physische Welt und IT-Systeme funktional zu einem CPS zusammenführen
- **Themen**: Sensoren, Aktoren, Mikrocontroller, IoT-Kommunikation, MQTT
#### LF 8: Daten systemübergreifend bereitstellen
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Daten aus dezentralen Quellen zusammenführen, aufbereiten und zur Verfügung stellen
- **Themen**: Datenbanken, APIs, Schnittstellen, Datenformate, Datenintegration
#### LF 9: Netzwerke und Dienste bereitstellen
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Netzwerke und Dienste planen, konfigurieren und erweitern
- **Themen**: Serverdienste, VPN, Firewall, Netzwerksicherheit, Dienste (HTTP, DNS, DHCP, etc.)
---
### 3. Ausbildungsjahr (Fachrichtung Anwendungsentwicklung)
#### LF 10a: Benutzerschnittstellen gestalten und entwickeln
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Benutzeroberflächen für softwarebasierte Arbeitsabläufe und Geschäftsprozesse gestalten und entwickeln
- **Themen**: UI/UX-Design, Responsive Design, Benutzerfreundlichkeit, agile Methoden
#### LF 11a: Funktionalität in Anwendungen realisieren
- **Zeitrichtwert**: 80 Stunden
- **Kernkompetenz**: Modulare Komponenten zur informationstechnischen Verarbeitung entwickeln und Qualität sichern
- **Themen**: OOP, Modularisierung, Schnittstellen, Tests, Qualitätssicherung
#### LF 12a: Kundenspezifische Anwendungsentwicklung durchführen
- **Zeitrichtwert**: 120 Stunden
- **Kernkompetenz**: Kundenauftrag zur Anwendungsentwicklung vollständig durchführen und bewerten
- **Themen**: Projektmanagement, Anforderungsanalyse, Implementierung, Tests, Dokumentation, Übergabe
---
## Wichtige Ressourcen
### Gesetzliche Grundlagen
- [[Rahmenlehrplan-KMK|Fachinformatiker Rahmenlehrplan KMK]]
- [[Ausbildungsverordnung|FIAusbV - Verordnung über die Berufsausbildung]]
- [[Liste-der-Entsprechungen|KMK/BIBB Liste der Entsprechungen]]
### Externe Links
- [KMK Rahmenlehrpläne](http://www.kmk.org)
- [BIBB Ausbildungsprofile](http://www.bibb.de)
- [Fachinformatiker Prüfungsvorbereitung](https://fachinformatikerpruefungsvorbereitung.de)
---
*Zuletzt aktualisiert: 2024*
*Ausbildung: Fachinformatiker Anwendungsentwicklung | IHK Bremen*

79
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-00-Übersicht.md Normal file
View File

@@ -0,0 +1,79 @@
# LF 1: Das Unternehmen und die eigene Rolle im Betrieb beschreiben
> **1. Ausbildungsjahr** | Zeitrichtwert: **40 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, ihr Unternehmen hinsichtlich seiner Wertschöpfungskette zu präsentieren und ihre eigene Rolle im Betrieb zu beschreiben.
---
## Themenübersicht
1. [[LF1-01-Unternehmensziele|Unternehmensziele und Leitbild]]
2. [[LF1-02-Marktstruktur|Marktstruktur und Wettbewerb]]
3. [[LF1-03-Rechtsformen|Rechtsformen]]
4. [[LF1-04-Organisation|Organisationsstruktur]]
5. [[LF1-05-Wertschoepfungskette|Wertschöpfungskette]]
6. [[LF1-06-Eigene-Rolle|Eigene Rolle im Betrieb]]
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Die ökonomischen, ökologischen und sozialen Zielsetzungen deines Unternehmens erläutern
- [ ] Die Marktstruktur in deiner Branche analysieren
- [ ] Das Unternehmen als komplexes System mit Markt- und Kundenbeziehungen einordnen
- [ ] Die Wertschöpfungskette beschreiben und die eigene Rolle darin darstellen
- [ ] Die Organisationsstruktur und Rechtsform des Unternehmens erklären
- [ ] Den eigenen Handlungs- und Entscheidungsspielraum (Vollmachten) beschreiben
---
## Kompetenzbereiche
### Fachkompetenz
- Unternehmensziele und Leitbild verstehen
- Wertschöpfungskette analysieren
- Rechtsformen unterscheiden (GmbH, UG, OHAG, KG, AG, etc.)
- Organisationsstrukturen interpretieren
### Selbstkompetenz
- Eigene Rolle reflektieren
- Stärken und Entwicklungsbereiche identifizieren
- Perspektiven für die berufliche Entwicklung aufzeigen
### Sozialkompetenz
- Im Team präsentieren
- Kommunikationsregeln anwenden
- Feedback geben und annehmen
---
## Handlungsphasen (vollständige Handlung)
1. **Informieren**: Unternehmensleitbild, Ziele, Struktur erkunden
2. **Planen**: Präsentation vorbereiten, Inhalte strukturieren
3. **Durchführen**: Präsentation erstellen und vortragen
4. **Überprüfen**: Qualität des Produkts bewerten
5. **Reflektieren**: Eigene Rolle und Handeln bewerten
---
## Prüfungsrelevanz
- Basis für die gesamte Ausbildung
- Wird in Teil 1 der Abschlussprüfung vorausgesetzt
- Grundlagen für WISO-Prüfung
---
## Querverweise
- [[LF2-Arbeitsplätze-ausstatten|Nachher: LF 2 - Arbeitsplätze nach Kundenwunsch ausstatten]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO - Wirtschaft und Soziales]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

85
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-01-Unternehmensziele.md Normal file
View File

@@ -0,0 +1,85 @@
# 1.1 Unternehmensziele und Leitbild
## Ökonomische Ziele
| Ziel | Beschreibung | Beispiel |
|------|-------------|----------|
| Gewinnmaximierung | Erzielung maximalen Gewinns | 10% Umsatzrendite |
| Umsatzwachstum | Steigerung des Umsatzes | +15% jährlich |
| Marktanteil | Vergrößerung des Marktanteils | 25% Marktanteil |
| Liquidität | Sicherstellung der Zahlungsfähigkeit | positiver Cashflow |
## Ökologische Ziele
- **Umweltschutz**: Reduktion von CO2-Emissionen
- **Nachhaltigkeit**: Nutzung erneuerbarer Energien
- **Ressourceneffizienz**: Weniger Verbrauch pro Einheit
- **Recycling**: Kreislaufwirtschaft fördern
## Soziale Ziele
- **Mitarbeiterzufriedenheit**: Gutes Betriebsklima
- **Work-Life-Balance**: Flexible Arbeitszeiten
- **Ausbildung**: Ausbildungsplätze anbieten
- **Gesellschaftliches Engagement**: CSR-Projekte
---
## Unternehmensleitbild
### Was ist ein Leitbild?
Das Leitbild ist eine schriftliche Grundsatzerklärung, die die **Identität** und **philosophie** des Unternehmens darstellt.
### Elemente eines Leitbildes
```
Leitbild-Komponenten
├── Vision (langfristiges Ziel)
├── Mission (Auftrag/Zweck)
├── Werte (Grundsätze)
└── Ziele (konkret, messbar)
```
### Beispiel-Leitbild
> *"Unser Unternehmen bietet innovative IT-Lösungen, die das Leben unserer Kunden vereinfachen. Wir stehen für Qualität, Nachhaltigkeit und partnerschaftliche Zusammenarbeit."*
---
## SMART-Ziele
Ziele sollten nach der SMART-Formel formuliert werden:
| Buchstabe | Bedeutung | Beispiel |
|-----------|----------|----------|
| **S**pezifisch | Klar definiert | "Umsatz steigern" |
| **M**essbar | Quantifizierbar | "um 20%" |
| **A**ttraktiv | Erstrebenswert | für alle Beteiligten |
| **R**ealistisch | Erreichbar | im Rahmen der Möglichkeiten |
| **T**erminiert | Mit Zeitpunkt | "bis 31.12.2025" |
---
## Übung
Formuliere ein SMART-Ziel für deinen Ausbildungsbetrieb:
```markdown
Spezifisch: _______________
Messbar: _______________
Attraktiv: _______________
Realistisch: _______________
Terminiert: _______________
```
---
## Querverweise
- [[LF1-02-Marktstruktur|Nächstes Thema: Marktstruktur]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Unternehmensziele]]
---
*Stand: 2024*

98
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-02-Marktstruktur.md Normal file
View File

@@ -0,0 +1,98 @@
# 1.2 Marktstruktur und Wettbewerb
## Marktanalyse
### Marktsegmente
Ein Markt besteht aus verschiedenen Segmenten:
```
Markt
├── Geografische Segmente
│ ├── Regional
│ ├── National
│ └── International
├── Produktbezogene Segmente
│ ├── Premium
│ ├── Standard
│ └── Discount
└── Kundenbezogene Segmente
├── B2B (Business to Business)
├── B2C (Business to Consumer)
└── B2G (Business to Government)
```
### Wettbewerbsanalyse (5-Kräfte-Modell nach Porter)
```
┌─────────────────────┐
│ Verhandlungsmacht │
│ der Lieferanten │
└──────────┬──────────┘
│
┌──────────────┼──────────────┐
│ │ │
▼ ▼ ▼
┌─────────┐ ┌──────────┐ ┌─────────┐
│ Bedrohung│ │ STATUS │ │ Bedrohung│
│ durch │ │ QUO │ │ durch │
│ neue │ │ │ │ Substit- │
│ Konkurrenz│ │ Konkurrenz│ │ ute │
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │
└──────────────┼──────────────┘
│
┌────────┴────────┐
│ Verhandlungsmacht│
│ der Kunden │
└─────────────────┘
```
## Wettbewerbsstrategien
| Strategie | Beschreibung | Beispiel |
|----------|-------------|----------|
| **Kostenführerschaft** | Günstigstes Angebot | Aldi, Lidl |
| **Differenzierung** | Einzigartiges Produkt | Apple |
| **Fokussierung** | Nische bedienen | Luxusmarken |
---
## Kundenbeziehungen
### Kundensegmente
```
Kunden
├── Bestandskunden (treu, regelmäßig)
├── Neukunden (gewinnen)
├── Potenzielle Kunden (ansprechen)
└── Verlorene Kunden (zurückgewinnen)
```
### Kundenbindung
- **Qualität**: Hohe Produktqualität
- **Service**: Guter Kundenservice
- **Preis**: Faire Preise
- **Kommunikation**: Regelmäßiger Kontakt
---
## Übung: Marktanalyse für deinen Betrieb
1. Wer sind die Hauptwettbewerber?
2. Welche Produkte/Dienstleistungen bieten sie?
3. Was sind deren Stärken und Schwächen?
4. Wie positioniert sich dein Unternehmen?
---
## Querverweise
- [[LF1-03-Rechtsformen|Nächstes Thema: Rechtsformen]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Marketing]]
---
*Stand: 2024*

109
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-03-Rechtsformen.md Normal file
View File

@@ -0,0 +1,109 @@
# 1.3 Rechtsformen
## Übersicht der Rechtsformen
### Privatrechtliche Rechtsformen
```
Rechtsformen
├── Einzelunternehmen
│
├── Personengesellschaften
│ ├── OHG (Offene Handelsgesellschaft)
│ ├── KG (Kommanditgesellschaft)
│ └── GbR (Gesellschaft bürgerlichen Rechts)
│
└── Kapitalgesellschaften
├── GmbH (Gesellschaft mit beschränkter Haftung)
├── UG (haftungsbeschränkt)
├── AG (Aktiengesellschaft)
└── GmbH & Co. KG
```
## Im Detail
### Einzelunternehmen
| Merkmal | Beschreibung |
|---------|--------------|
| Gründer | Natürliche Person |
| Haftung | Unbegrenzt, persönlich |
| Mindestkapital | Keines |
| Gewinn | Einkommensteuer |
### GmbH (Gesellschaft mit beschränkter Haftung)
| Merkmal | Beschreibung |
|---------|--------------|
| Gründer | 1+ Personen (natürlich/juristisch) |
| Haftung | Auf Gesellschaftsvermögen beschränkt |
| Mindestkapital | 25.000€ (bei Gründung) |
| Organe | Geschäftsführer, Gesellschafterversammlung |
### UG (haftungsbeschränkt)
| Merkmal | Beschreibung |
|---------|--------------|
| Besonderheit | "Mini-GmbH" |
| Mindestkapital | 1€ |
| Pflicht | 25% Gewinn in Rücklage bis 25.000€ |
### AG (Aktiengesellschaft)
| Merkmal | Beschreibung |
|---------|--------------|
| Mindestkapital | 50.000€ |
| Organe | Vorstand, Aufsichtsrat, Hauptversammlung |
| Aktien | Anteile frei handelbar |
### OHG (Offene Handelsgesellschaft)
| Merkmal | Beschreibung |
|---------|--------------|
| Gründer | 2+ Personen |
| Haftung | Alle Gesellschafter unbegrenzt |
| Vertretung | Jeder Gesellschafter vertritt |
### GbR (Gesellschaft bürgerlichen Rechts)
| Merkmal | Beschreibung |
|---------|--------------|
| Gründer | 2+ Personen |
| Zweck | Beliebig (nicht gewerblich) |
| Haftung | Alle Gesellschafter persönlich |
---
## Vergleichstabelle
| Rechtsform | Mindestkapital | Haftung | Steuer |
|-----------|----------------|---------|--------|
| Einzelunternehmen | - | Unbegrenzt | ESt |
| OHG | - | Persönlich | ESt |
| KG | - | KG: unbegrenzt, K: begrenzt | ESt |
| GmbH | 25.000€ | Begrenzt | KSt + GewSt |
| UG | 1€ | Begrenzt | KSt + GewSt |
| AG | 50.000€ | Begrenzt | KSt + GewSt |
---
## Wahl der Rechtsform
### Kriterien
1. **Haftung**: Persönliche Haftung vermeiden?
2. **Kapital**: Wie viel Geld ist verfügbar?
3. **Steuern**: Welche Steuerbelastung?
4. **Flexibilität**: Wie einfach Änderungen?
5. **Image**: Welche Rechtsform passt?
---
## Querverweise
- [[LF1-04-Organisation|Nächstes Thema: Organisationsstruktur]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Rechtsformen]]
---
*Stand: 2024*

113
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-04-Organisation.md Normal file
View File

@@ -0,0 +1,113 @@
# 1.4 Organisationsstruktur
## Aufbauorganisation
### Organigramm
```
Organigramm - Beispiel IT-Unternehmen
┌─────────────────┐
│ Geschäftsführer │
└────────┬────────┘
│
┌────────────┼────────────┐
│ │ │
┌───▼───┐ ┌────▼────┐ ┌───▼───┐
│ Leiter│ │ Leiter │ │ Leiter│
│Vertrieb│ │Entwickl.│ │Support│
└───┬───┘ └────┬───┘ └───┬───┘
│ │ │
┌───▼───┐ ┌────▼────┐ ┌───▼───┐
│Team 1 │ │Team 2 │ │Team 3 │
│ │ │ │ │ │
└───────┘ └─────────┘ └───────┘
```
## Organisationsformen
### Funktionale Organisation
```
┌──────────┐
│ CEO │
└────┬─────┘
┌──────┴──────┬──────┐
│ │ │
┌────▼────┐ ┌────▼──┐ ┌─▼─────┐
│Produktion│ │Vertrieb│ │Finanzen│
└─────────┘ └───────┘ └───────┘
```
### Hierarchische Ebenen
| Ebene | Titel | Aufgabe |
|-------|-------|----------|
| 1 | Geschäftsführung | Strategie, Führung |
| 2 | Abteilungsleitung | Operative Führung |
| 3 | Teamleitung | Teamkoordination |
| 4 | Mitarbeiter | Aufgabenerfüllung |
---
## Ablauforganisation
### Geschäftsprozesse
```
Prozessmodell
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Input │ → │ Aktivität│ → │ Aktivität│ → │ Output │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
│
▼
┌─────────────┐
│ Entscheidung │
└─────────────┘
```
### Prozessarten
| Prozess | Beschreibung |
|---------|-------------|
| ** Kernprozesse** | Wertschöpfend (z.B. Produktion) |
| **Supportprozesse** | Unterstützend (z.B. IT) |
| **Managementprozesse** | Steuernd (z.B. Controlling) |
---
## Schnittstellen
### Horizontale Schnittstellen
- Zwischen Abteilungen
- Gleiche Hierarchieebene
### Vertikale Schnittstellen
- Zwischen Hierarchieebenen
- Vorgesetzte ↔ Mitarbeiter
---
## Organigramm erstellen
### Schritte
1. Alle Mitarbeiter erfassen
2. Hierarchieebenen definieren
3. Abteilungen bilden
4. Zuständigkeiten zuweisen
5. Visualisieren
---
## Querverweise
- [[LF1-05-Wertschoepfungskette|Nächstes Thema: Wertschöpfungskette]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Unternehmen]]
---
*Stand: 2024*

118
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-05-Wertschoepfungskette.md Normal file
View File

@@ -0,0 +1,118 @@
# 1.5 Wertschöpfungskette
## Definition
Die Wertschöpfungskette beschreibt alle Aktivitäten, die ein Unternehmen durchführt, um aus **Input** (Rohstoffe, Informationen) ein **Output** (Produkt/Dienstleistung) zu erstellen.
## Klassische Wertschöpfungskette (Porter)
```
┌─────────────────────────────────────────────────────────────┐
│ WERTSCHÖPFUNGSKETTE │
├───────────────────────┬─────────────────────────────────────┤
│ UNTERSTÜTZUNG │ HAUPTAKTIVITÄTEN │
├───────────────────────┼─────────────────────────────────────┤
│ │ │
│ 1. Beschaffung │ 5. Marketing & Vertrieb │
│ (Einkauf) │ (Kunden gewinnen) │
│ │ │
├───────────────────────┼─────────────────────────────────────┤
│ 2. Personal- │ 4. Absatz / Vertrieb │
│ verwaltung │ (verkaufen) │
│ │ │
├───────────────────────┼─────────────────────────────────────┤
│ 3. Technologie │ 6. Service │
│ (IT, F&E) │ (Kundendienst) │
│ │ │
├───────────────────────┴─────────────────────────────────────┤
│ │
│ 7. Produktion / Leistungserstellung │
│ (Herstellung der Produkte/Dienstleistungen) │
│ │
└─────────────────────────────────────────────────────────────┘
```
## Wertschöpfung im IT-Bereich
```
IT-Wertschöpfungskette
┌─────────────┐
│ ANALYSE │ ← Kundenanforderungen verstehen
└──────┬──────┘
│
▼
┌─────────────┐
│ DESIGN │ ← Lösungskonzepte entwickeln
└──────┬──────┘
│
▼
┌─────────────┐
│ ENTWICKLUNG │ ← Software programmieren
└──────┬──────┘
│
▼
┌─────────────┐
│ TESTING │ ← Qualität sichern
└──────┬──────┘
│
▼
┌─────────────┐
│ ROLLOUT │ ← Auslieferung & Installation
└──────┬──────┘
│
▼
┌─────────────┐
│ SUPPORT │ ← Wartung & Betreuung
└─────────────┘
```
---
## Wertschöpfungskette analysieren
### Fragen zur Analyse
1. Welche Aktivitäten erzeugen den größten Wert?
2. Welche Aktivitäten kosten am meisten?
3. Wo können wir effizienter werden?
4. Welche Aktivitäten können wir auslagern?
---
## Eigene Rolle in der Wertschöpfung
### Einordnung
| Position | Beitrag zur Wertschöpfung |
|----------|---------------------------|
| Support | Hilft Kunden, Produkt zu nutzen |
| Entwicklung | Erstellt das Produkt |
| Vertrieb | Bringt Produkt zum Kunden |
| Beratung | Schafft Mehrwert |
---
## Übung
Zeichne die Wertschöpfungskette deines Ausbildungsbetriebes:
```
1. _______________
2. _______________
3. _______________
4. _______________
5. _______________
6. _______________
```
---
## Querverweise
- [[LF1-06-Eigene-Rolle|Nächstes Thema: Eigene Rolle]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Wertschöpfung]]
---
*Stand: 2024*

105
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-06-Eigene-Rolle.md Normal file
View File

@@ -0,0 +1,105 @@
# 1.6 Eigene Rolle im Betrieb
## Ausbildungsvertrag
### Rechte und Pfflichten
**Auszubildende/r hat Recht auf:**
- Ausbildung nach Ausbildungsplan
- Vergütung (Ausbildungsentgelt)
- Urlaub (mindestens 24 Werktage/Jahr)
- Berufsschulunterricht
- Nachhilfe bei Problemen
**Auszubildende/r ist verpflichtet:**
- Lernpflicht (Berufsschule, Betrieb)
- Sorgfaltspflicht
- Schweigepflicht
- Betriebsordnung einhalten
---
## Handlungsspielraum
### Vollmachten
| Bereich | Typische Grenzen |
|---------|------------------|
| Einkauf | Bis 100€ ohne Genehmigung |
| Support | Grundlegende Supporttätigkeiten |
| Konfiguration | Standardkonfigurationen |
| Kundenkontakt | Nur unter Aufsicht |
### Entscheidungsspielraum
```
Entscheidungsspielraum
├── Kein Spielraum
│ └── Kritische Entscheidungen (immer Rücksprache)
│
├── Begrenzter Spielraum
│ └── Standardentscheidungen (innerhalb von Regeln)
│
└── Freier Spielraum
└── Eigenverantwortliche Entscheidungen
```
---
## Kommunikation
### Ansprechpartner
| Rolle | Aufgabe |
|-------|---------|
| Ausbilder | Betreuung im Betrieb |
| Berufsschullehrer | Unterricht |
| Azubi-Vertreter | Interessenvertretung |
| Betriebsrat | Mitarbeitervertretung |
### Kommunikationswege
- **Formell**: Meetings, E-Mail, Tickets
- **Informell**: Pausengespräch, Slack, Teams
---
## Fort- und Weiterbildung
### Während der Ausbildung
- Berufsschule
- Überbetriebliche Lehrgänge
- innerbetriebliche Schulungen
### Nach der Ausbildung
- Weiterbildung zum/zur:
- Fachwirt/in
- Techniker/in
- Meister/in
- Bachelor/Master
---
## Reflexion
### Selbsteinschätzung
Beantworte für dich:
1. Was sind meine Stärken?
2. Was muss ich noch lernen?
3. Welche Ziele habe ich für die Ausbildung?
4. Wo sehe ich mich nach der Ausbildung?
---
## Querverweise
- [[LF2-Arbeitsplätze-ausstatten|Nächstes Lernfeld: LF 2]]
- [[Prüfungsübersicht|Prüfungsvorbereitung]]
---
*Stand: 2024*

121
1-Ausbildungsjahr/LF1-Unternehmen-Rolle/LF1-Notizen.md Normal file
View File

@@ -0,0 +1,121 @@
# LF 1: Das Unternehmen und die eigene Rolle im Betrieb beschreiben
> **1. Ausbildungsjahr** | Zeitrichtwert: **40 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, ihr Unternehmen hinsichtlich seiner Wertschöpfungskette zu präsentieren und ihre eigene Rolle im Betrieb zu beschreiben.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Die ökonomischen, ökologischen und sozialen Zielsetzungen deines Unternehmens erläutern
- [ ] Die Marktstruktur in deiner Branche analysieren
- [ ] Das Unternehmen als komplexes System mit Markt- und Kundenbeziehungen einordnen
- [ ] Die Wertschöpfungskette beschreiben und die eigene Rolle darin darstellen
- [ ] Die Organisationsstruktur und Rechtsform des Unternehmens erklären
- [ ] Den eigenen Handlungs- und Entscheidungsspielraum (Vollmachten) beschreiben
- [ ] Fort- und Weiterbildungsmaßnahmen im Unternehmen darstellen
- [ ] Adressatengerechte multimediale Präsentationen erstellen
---
## Kompetenzbereiche
### Fachkompetenz
- Unternehmensziele und Leitbild verstehen
- Wertschöpfungskette analysieren
- Rechtsformen unterscheiden (GmbH, UG, OHG, KG, AG, etc.)
- Organisationsstrukturen interpretieren
### Selbstkompetenz
- Eigene Rolle reflektieren
- Stärken und Entwicklungsbereiche identifizieren
- Perspektiven für die berufliche Entwicklung aufzeigen
### Sozialkompetenz
- Im Team präsentieren
- Kommunikationsregeln anwenden
- Feedback geben und annehmen
---
## Zentrale Themen
### 1. Das Unternehmen kennenlernen
```
Unternehmensleitbild → Marktstruktur → Rechtsform →
Organisationsstruktur → Wertschöpfungskette → Rolle im Betrieb
```
### 2. Unternehmensziele
- **Ökonomische Ziele**: Gewinn, Umsatz, Marktanteil
- **Ökologische Ziele**: Umweltschutz, Nachhaltigkeit, Ressourceneffizienz
- **Soziale Ziele**: Mitarbeiterzufriedenheit, Ausbildung, Gesellschaftliches Engagement
### 3. Rechtsformen (Überblick)
| Rechtsform | Merkmale | Haftung |
|------------|----------|---------|
| GmbH | Juristische Person, min. 25.000€ Stammkapital | Gesellschaftsvermögen |
| UG (haftungsbeschränkt) | Juristische Person, min. 1€ Stammkapital | Gesellschaftsvermögen |
| OHG | Natürliche Personen | Persönlich, unbegrenzt |
| KG | Mind. ein Komplementär, min. ein Kommanditist | Komplementär: unbegrenzt |
| AG | Juristische Person, min. 50.000€ Grundkapital | Gesellschaftsvermögen |
| Einzelunternehmen | Natürliche Person | Persönlich, unbegrenzt |
### 4. Organisationsstruktur
- **Aufbauorganisation**: Hierarchie, Abteilungen, Zuständigkeiten
- **Ablauforganisation**: Prozesse, Workflows, Schnittstellen
- **Organigramme**: Visualisierung der Struktur
### 5. Wertschöpfungskette
```
Beschaffung → Produktion → Vertrieb → Marketing →
Kundenservice → Buchhaltung/Controlling
```
### 6. Eigene Rolle im Betrieb
- Ausbildungsvertrag und Rechte/Pflichten
- Handlungsspielraum und Vollmachten
- Kommunikationswege
- Ansprechpartner und Hierarchie
---
## Handlungsphasen (vollständige Handlung)
1. **Informieren**: Unternehmensleitbild, Ziele, Struktur erkunden
2. **Planen**: Präsentation vorbereiten, Inhalte strukturieren
3. **Durchführen**: Präsentation erstellen und vortragen
4. **Überprüfen**: Qualität des Produkts bewerten
5. **Reflektieren**: Eigene Rolle und Handeln bewerten
---
## Prüfungsrelevanz
- Basis für die gesamte Ausbildung
- Wird in Teil 1 der Abschlussprüfung vorausgesetzt
- Grundlagen für WISO-Prüfung
---
## Tipps für die Prüfung
1. **Mündliche Prüfung**: Übe Präsentationen vorzustellen
2. **Unternehmensanalyse**: Kenntnisse über deinen eigenen Ausbildungsbetrieb
3. **Rechtsformen**: Unterschiede können in WISO abgefragt werden
4. **Wertschöpfung**: Verstehe die Prozesse im Unternehmen
---
## Querverweise
- [[LF2-Arbeitsplätze-ausstatten|Anschließend: LF 2 - Arbeitsplätze nach Kundenwunsch ausstatten]]
- [[Wirtschafts-Sozialkunde|WISO - Wirtschaft und Soziales]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

66
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-00-Übersicht.md Normal file
View File

@@ -0,0 +1,66 @@
# LF 2: Arbeitsplätze nach Kundenwunsch ausstatten
> **1. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, die Ausstattung eines Arbeitsplatzes nach Kundenwunsch zu dimensionieren, anzubieten, zu beschaffen und den Arbeitsplatz an die Kunden zu übergeben.
---
## Themenübersicht
1. [[LF2-01-Kundenanforderungen|Kundenanforderungen aufnehmen]]
2. [[LF2-02-Hardwareauswahl|Hardware auswählen]]
3. [[LF2-03-Softwareauswahl|Software auswählen]]
4. [[LF2-04-Nutzwertanalyse|Nutzwertanalyse durchführen]]
5. [[LF2-05-Angebot|Kalkulation und Angebot]]
6. [[LF2-06-Beschaffung|Beschaffung und Inbetriebnahme]]
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Kundenwünsche für Arbeitsplatz-Ausstattung aufnehmen und Anforderungen ermitteln
- [ ] Auswahlkriterien für Hard- und Software ableiten
- [ ] Technische Merkmale von Produkten vergleichen (Nutzwertanalyse)
- [ ] Angebote erstellen und Preise kalkulieren
- [ ] Beschaffungsprozess organisieren
- [ ] IT-Arbeitsplatz konfigurieren und in Betrieb nehmen
---
## Handlungsphasen
```
1. Kundenwunsch aufnehmen
↓
2. Anforderungen analysieren
↓
3. Produkte vergleichen
↓
4. Angebot erstellen
↓
5. Beschaffen und konfigurieren
↓
6. Übergeben und dokumentieren
```
---
## Prüfungsrelevanz
- **Teil 1 der Abschlussprüfung** (Gewichtung: 20%)
- Schwerpunktthema für den praktischen Teil
---
## Querverweise
- [[LF1-Unternehmen-Rolle|Vorher: LF 1]]
- [[LF3-Datenbanken|Nachher: LF 3]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

111
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-01-Kundenanforderungen.md Normal file
View File

@@ -0,0 +1,111 @@
# 2.1 Kundenanforderungen aufnehmen
## Kundengespräch
### Vorbereitung
```
Gesprächsvorbereitung
├── Termin vereinbaren
├── Unterlagen vorbereiten (Firmenpräsentation, Produktkataloge)
├── Fragen formulieren
└── Gesprächsziel definieren
```
### Fragetechniken
| Fragentyp | Beispiel | Zweck |
|-----------|---------|-------|
| **Offen** | "Was sind Ihre Wünsche?" | Informationen sammeln |
| **Geschlossen** | "Brauchen Sie Windows?" | Bestätigung |
| **Zurückfragend** | "Warum ist das wichtig?" | Tiefes Verständnis |
| **Zusammenfassend** | "Also benötigen Sie..." | Verständnis sichern |
---
## Anforderungen erfassen
### Lastenheft (vom Kunden)
Das Lastenheft enthält alle Anforderungen des Kunden:
```markdown
# Lastenheft - Arbeitsplatzausstattung
## 1. Anlass
Neueinstellung von 5 Mitarbeitern
## 2. Nutzerprofil
- Büroarbeit
- E-Mail, Office-Anwendungen
- Videokonferenzen
- gelegentlich Bildbearbeitung
## 3. Anforderungen Hardware
- Leistungsstarker PC (Office + Bildbearbeitung)
- 2 Monitore (24")
- Headset für Videokonferenzen
## 4. Anforderungen Software
- Windows 11 Pro
- Microsoft 365 Business
- Adobe Photoshop (Lizenz vorhanden)
## 5. Budget
max. 2.000€ pro Arbeitsplatz
## 6. Zeitrahmen
Lieferung bis zum 15. des Folgemonats
```
---
## Anforderungskategorien
### Funktionale Anforderungen
| Kategorie | Beispiele |
|-----------|-----------|
| Leistung | Schnell genug für alle Anwendungen |
| Speicher | Ausreichend für Projektdaten |
| Display | Für Videokonferenzen geeignet |
### Nicht-funktionale Anfordermen
| Kategorie | Beispiele |
|-----------|-----------|
| Zuverlässigkeit | 3 Jahre Garantie |
| Ergonomie | TÜV-zertifiziert |
| Nachhaltigkeit | Energy Star |
---
## Übung: Anforderungen aufnehmen
Führe ein Rollenspiel durch:
- Person A: Kunde (beschreibt Wünsche)
- Person B: Azubi (notiert Anforderungen)
Dokumentiere die Ergebnisse:
```
Kundenwunsch: _________________
Ermittelte Anforderungen:
- Hardware: _______________
- Software: _______________
- Budget: _______________
- Zeitrahmen: _______________
```
---
## Querverweise
- [[LF2-02-Hardwareauswahl|Nächstes Thema: Hardware auswählen]]
- [[LF1-06-Eigene-Rolle|Kommunikation]]
---
*Stand: 2024*

102
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-02-Hardwareauswahl.md Normal file
View File

@@ -0,0 +1,102 @@
# 2.2 Hardware auswählen
## PC-Komponenten
### Prozessor (CPU)
| Kriterium | Bedeutung |
|-----------|-----------|
| Kerne | Mehr Kerne = parallel arbeiten |
| Taktfrequenz | Höher = schneller |
| Cache | Mehr = schnellerer Datenzugriff |
| Generation | Aktueller = effizienter |
**Aktuelle Generationen (2024):**
- Intel: Core i3/i5/i7/i9 (14. Gen)
- AMD: Ryzen 3/5/7/9 (5000-7000er)
### Arbeitsspeicher (RAM)
| Typ | Geschwindigkeit |
|-----|----------------|
| DDR4 | 2133-3200 MT/s |
| DDR5 | 4800-7200 MT/s |
**Empfehlung:**
- Office: 8-16 GB
- Bildbearbeitung: 32 GB
- Video/3D: 64+ GB
### Speicher
| Typ | Geschwindigkeit | Einsatz |
|-----|----------------|----------|
| SSD NVMe | Sehr schnell (3000+ MB/s) | System |
| SSD SATA | Schnell (500 MB/s) | Programme |
| HDD | Langsam (100 MB/s) | Datenarchiv |
### Grafikkarte (GPU)
| Typ | Einsatz |
|-----|---------|
| Integriert | Office, Surfen |
| Dediziert (GTX/RTX) | Bildbearbeitung, Gaming |
| Professionell (Quadro) | CAD, 3D |
---
## Peripherie
### Monitor
| Kriterium | Empfehlung |
|-----------|-------------|
| Größe | 24-27" |
| Auflösung | Full HD (1920x1080) oder mehr |
| Panel | IPS (betroffene Farben) |
| Ergonomie | Höhenverstellbar, Pivot |
### Tastatur/Maus
- **Tastatur**: Tastatur-Layout (QWERTZ), mechanisch/sch Membrane
- **Maus**: Ergonomisch, Kabel/Wireless
### Headset
- Für Videokonferenzen: Mit Mikrofon
- Aktive Geräuschunterdrückung (ANC)
---
## Checkliste Hardware
```
☐ Prozessor: _______________
☐ RAM: _______________
☐ Speicher (SSD): _______________
☐ Grafikkarte: _______________
☐ Monitor: _______________
☐ Tastatur: _______________
☐ Maus: _______________
☐ Headset: _______________
☐ Gesamtpreis: _______________
```
---
## Normen und Vorschriften
- **CE-Kennzeichnung**: EU-Sicherheitsstandard
- **RoHS**: Beschränkung gefährlicher Stoffe
- **Energy Star**: Energieeffizienz
---
## Querverweise
- [[LF2-03-Softwareauswahl|Nächstes Thema: Software auswählen]]
- [[LF4-IT-Sicherheit|IT-Sicherheit]]
---
*Stand: 2024*

96
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-03-Softwareauswahl.md Normal file
View File

@@ -0,0 +1,96 @@
# 2.3 Software auswählen
## Betriebssysteme
### Optionen
| OS | Vorteile | Nachteile | Einsatz |
|----|----------|-----------|----------|
| **Windows 11** | Kompatibel, weit verbreitet | Lizenzkosten | Büro, privat |
| **Linux (Ubuntu)** | Kostenlos, sicher | Weniger Software | Server, Developer |
| **macOS** | Design, Ökosystem | Teuer, Apple-Hardware | Design, Media |
### Lizenzierung
```
Lizenzmodelle
├── Kauf (perpetual)
├── Subscription (Mietmodell)
├── Open Source (kostenlos)
└── OEM (an Hardware gebunden)
```
---
## Anwendungssoftware
### Office-Pakete
| Produkt | Kosten | Features |
|---------|--------|----------|
| Microsoft 365 | ~12-15€/Monat | Word, Excel, PowerPoint, Teams |
| LibreOffice | Kostenlos | Word, Calc, Impress |
| Google Workspace | ~6-12€/Monat | Docs, Sheets, Drive |
### Branchensoftware
- ERP-Systeme (SAP, Lexware)
- CRM-Systeme (Salesforce)
- Buchhaltung (DATEV)
---
## Softwarekriterien
### Auswahlkriterien
| Kriterium | Gewichtung | Beispiel |
|-----------|------------|-----------|
| Funktionalität | Hoch | Alle benötigten Features |
| Kompatibilität | Hoch | Mit bestehender IT |
| Benutzerfreundlichkeit | Mittel | Einfache Bedienung |
| Support | Mittel |Deutscher Ansprechpartner |
| Kosten | Mittel | Budget einhalten |
| Datenschutz | Hoch | DSGVO-Konformität |
---
## Lizenzmanagement
### Lizenzarten
```
Lizenzarten
├── Einzelplatzlizenz
├── Volumenlizenz (Site License)
├── OEM-Lizenz (an Hardware gebunden)
├── Subscription (zeitlich begrenzt)
└── Concurrent License (gleiche Nutzer)
```
### Compliance
- Lizenzen dokumentieren
- Audit-Fähigkeit sicherstellen
- Schulung der Nutzer
---
## Datenschutz (DSGVO)
### Anforderungen
- **Auftragsverarbeitung**: Vertrag mit Anbieter
- **Datenspeicherung**: Wo werden Daten gespeichert?
- **Löschkonzept**: Was passiert bei Vertragsende?
---
## Querverweise
- [[LF2-04-Nutzwertanalyse|Nächstes Thema: Nutzwertanalyse]]
- [[LF4-IT-Sicherheit|DSGVO]]
---
*Stand: 2024*

113
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-04-Nutzwertanalyse.md Normal file
View File

@@ -0,0 +1,113 @@
# 2.4 Nutzwertanalyse durchführen
## Definition
Die Nutzwertanalyse (NWA) ist ein **systematisches Bewertungsverfahren** zur Auswahl zwischen verschiedenen Alternativen.
## Schritte
```
Nutzwertanalyse - Ablauf
1. Kriterien festlegen
↓
2. Gewichtung definieren
↓
3. Bewertung durchführen
↓
4. Nutzwert berechnen
↓
5. Entscheidung treffen
```
---
## Schritt-für-Schritt
### 1. Kriterien definieren
| Nr. | Kriterium | Beispiel |
|-----|----------|----------|
| 1 | Preis | günstigster Preis |
| 2 | Leistung | Prozessor-Rating |
| 3 | Qualität | Garantiezeit |
| 4 | Design | Optik |
| 5 | Service | Support-Qualität |
### 2. Gewichtung (Summe = 100%)
| Kriterium | Gewichtung |
|-----------|-------------|
| Preis | 25% |
| Leistung | 30% |
| Qualität | 20% |
| Design | 10% |
| Service | 15% |
| **Summe** | **100%** |
### 3. Bewertung (1-10 Punkte)
| Kriterium | Gewichtung | Laptop A | Laptop B |
|-----------|------------|----------|----------|
| Preis | 25% | 7 (70%) | 8 (80%) |
| Leistung | 30% | 8 (80%) | 9 (90%) |
| Qualität | 20% | 8 (80%) | 7 (70%) |
| Design | 10% | 6 (60%) | 9 (90%) |
| Service | 15% | 7 (70%) | 8 (80%) |
### 4. Nutzwert berechnen
```
Nutzwert = Σ (Bewertung × Gewichtung)
Laptop A:
= 0,25 × 7 + 0,30 × 8 + 0,20 × 8 + 0,10 × 6 + 0,15 × 7
= 1,75 + 2,40 + 1,60 + 0,60 + 1,05
= 7,40
Laptop B:
= 0,25 × 8 + 0,30 × 9 + 0,20 × 7 + 0,10 × 9 + 0,15 × 8
= 2,00 + 2,70 + 1,40 + 0,90 + 1,20
= 8,20
```
### 5. Ergebnis
| Laptop | Nutzwert | Rang |
|--------|----------|------|
| Laptop B | 8,20 | 1 |
| Laptop A | 7,40 | 2 |
---
## Vorlage
### Nutzwertanalyse - Vorlage
| Kriterium | Gewichtung (%) | Lösung A | Lösung B | Lösung C |
|-----------|-----------------|----------|----------|----------|
| Kriterium 1 | | | | |
| Kriterium 2 | | | | |
| Kriterium 3 | | | | |
| Kriterium 4 | | | | |
| Kriterium 5 | | | | |
| **Summe** | **100%** | | | |
---
## Tipps
- **Objektiv bewerten**: Nicht von persönlichen Präferenzen leiten lassen
- **Kriterien dokumentieren**: Warum wurde welches Kriterium gewichtet?
- **Alternativen vergleichen**: Mindestens 2-3 Optionen
---
## Querverweise
- [[LF2-05-Angebot|Nächstes Thema: Kalkulation und Angebot]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Entscheidungsfindung]]
---
*Stand: 2024*

131
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-05-Angebot.md Normal file
View File

@@ -0,0 +1,131 @@
# 2.5 Kalkulation und Angebot
## Angebotskalkulation
### Handelskalkulation
```
Listeneinkaufspreis (LEP)
+ Bezugskosten (Fracht, Verpackung)
= Einstandspreis (EP)
+ Handlungskosten (Gemeinkosten, z.B. 30%)
= Selbstkosten (SK)
+ Gewinnmarge (z.B. 15%)
= Netto-Angebotspreis
+ Umsatzsteuer (19%)
= Brutto-Angebotspreis
```
### Beispielrechnung
```
Hardware:
- PC-System: 800,00 €
- Monitor: 300,00 €
- Peripherie: 150,00 €
---------------------------------
Summe Hardware: 1.250,00 €
Bezugskosten (2%): 25,00 €
---------------------------------
Einstandspreis: 1.275,00 €
+ Gemeinkosten (30%): 382,50 €
---------------------------------
Selbstkosten: 1.657,50 €
+ Gewinn (15%): 248,63 €
---------------------------------
Netto-Angebotspreis: 1.906,13 €
+ Umsatzsteuer (19%): 362,16 €
---------------------------------
Brutto-Angebotspreis: 2.268,29 €
```
---
## Angebotsstruktur
### Angebotsvorlage
```
Angebot Nr.: [Nummer]
Datum: [Datum]
An:
[Firmenname]
[Ansprechpartner]
[Adresse]
Angebot für: [Projektname/Beschreibung]
Sehr geehrte/r [Name],
wir bieten Ihnen如下:
Position | Beschreibung | Menge | Einzelpreis | Gesamtpreis
---------|--------------|-------|-------------|-------------
1 | [Produkt 1] | 1 | [Preis] | [Preis]
2 | [Produkt 2] | 1 | [Preis] | [Preis]
... | | | |
Zwischensumme (netto) | [Summe]
+ Umsatzsteuer 19% | [MwSt]
---------------------------------
Gesamtbetrag (brutto) | [Gesamt]
Lieferzeit: [Zeit]
Zahlungsbedingungen: [sofort/30 Tage/etc.]
Gültigkeit: [Datum]
Mit freundlichen Grüßen,
[Name]
[Firma]
```
---
## Angebotsvergleich
### Quantitative Kriterien
| Kriterium | Angebot A | Angebot B |
|-----------|------------|------------|
| Gesamtpreis | 2.268€ | 2.350€ |
| Lieferzeit | 5 Tage | 3 Tage |
| Garantie | 2 Jahre | 3 Jahre |
### Qualitative Kriterien
| Kriterium | Angebot A | Angebot B |
|-----------|------------|------------|
| Support | Deutsch | Deutsch + Englisch |
| Referenzen | 5 | 10 |
---
## Wichtige Begriffe
| Begriff | Erklärung |
|---------|-----------|
| **LEP** | Listeneinkaufspreis |
| **EP** | Einstandspreis |
| **SK** | Selbstkosten |
| **Anfrage** | Anforderung des Kunden |
| **Angebot** | Verbindliches Angebot des Lieferanten |
| **Auftragsbestätigung** | Annahme des Angebots |
---
## Querverweise
- [[LF2-06-Beschaffung|Nächstes Thema: Beschaffung und Inbetriebnahme]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Kalkulation]]
---
*Stand: 2024*

169
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-06-Beschaffung.md Normal file
View File

@@ -0,0 +1,169 @@
# 2.6 Beschaffung und Inbetriebnahme
## Beschaffungsprozess
### Bestellung
```
Beschaffungsablauf
├── Bedarfsanalyse
├── Lieferantenauswahl
├── Bestellung auslösen
├── Lieferung prüfen
└── Einbuchen
```
### Lieferantenmanagement
| Kriterium | Bedeutung |
|-----------|-----------|
| Lieferzeit | Schnelle Verfügbarkeit |
| Preis | Wettbewerbsfähig |
| Support | Technische Hilfe |
| Zuverlässigkeit | Pünktliche Lieferung |
---
## Konfiguration
### Hardware
```
Konfigurationsschritte
├── BIOS/UEFI Einstellungen
├── RAID-Konfiguration
├── Boot-Reihenfolge
├── Energieeinstellungen
└── Hardwaretests
```
### Software
```
Installationsreihenfolge
├── Betriebssystem
├── Updates und Patches
├── Treiber
├── Anwendungssoftware
└── Virenschutz
```
### Imaging
```
Systemabbild erstellen
├── Referenzsystem aufsetzen
├── Treiber sammeln
├── Sysprep durchführen
├── Image erstellen (z.B. Clonezilla)
└── Auf Clients verteilen
```
---
## Inbetriebnahme
### Prüfungen
| Prüfung | Beschreibung |
|---------|-------------|
| Sichtprüfung | Keine Transportschäden |
| Funktionstest | Alle Komponenten funktionieren |
| Performance | Benchmark durchführen |
| Sicherheit | Virenschutz, Updates |
### Dokumentation
```
Konfigurationsdokumentation
├── Seriennummern
├── IP-Adressen
├── Installierte Software
├── Benutzerkonten
└── Passwörter (sicher gespeichert)
```
---
## Übergabe an Kunden
### Abnahme
```
Übergabeprozedur
├── Installation beim Kunden
├── Funktionsprüfung
├── Einweisung des Kunden
├── Übergabedokumentation
└── Abnahme durch Kunden
```
### Einweisung
| Thema | Inhalt |
|-------|--------|
| Grundfunktionen | System starten/herunterfahren |
| Software | Wichtige Programme erklären |
| Support | Ansprechpartner nennen |
| Support | Notfallkontakte |
### Übergabedokumentation
```markdown
# Übergabeprotokoll
## Auftraggeber
Name: _______________
Datum: _______________
## Gelieferte Hardware
- Gerät 1: _______________
- Gerät 2: _______________
## Installierte Software
- _______________
## Übergabeprüfung
- [ ] Alle Geräte funktionieren
- [ ] Software installiert
- [ ] Kunde eingewiesen
## Unterschriften
Kunde: _______________
Techniker: _______________
```
---
## Garantie und Support
### Garantiebedingungen
| Typ | Dauer |
|-----|-------|
| Herstellergarantie | 2-3 Jahre |
| Bring-in | Kunde sendet ein |
| Vor-Ort | Techniker kommt vorbei |
| Pick-up & Return | Abholung durch Hersteller |
### Supportstufen
```
Support-Level
├── Level 1: First-Level (Hotline)
├── Level 2: Technischer Support
├── Level 3: Entwicklung/Hersteller
└── Eskalation bei Bedarf
```
---
## Querverweise
- [[LF2-05-Angebot|Zurück: Kalkulation und Angebot]]
- [[LF3-Datenbanken|Nächstes Lernfeld: Datenbanken]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Vertragsrecht]]
---
*Stand: 2024*

165
1-Ausbildungsjahr/LF2-Arbeitsplätze-ausstatten/LF2-Notizen.md Normal file
View File

@@ -0,0 +1,165 @@
# LF 2: Arbeitsplätze nach Kundenwunsch ausstatten
> **1. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, die Ausstattung eines Arbeitsplatzes nach Kundenwunsch zu dimensionieren, anzubieten, zu beschaffen und den Arbeitsplatz an die Kunden zu übergeben.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Kundenwünsche für Arbeitsplatz-Ausstattung aufnehmen und Anforderungen ermitteln
- [ ] Auswahlkriterien für Hard- und Software ableiten
- [ ] Technische Merkmale von Produkten vergleichen (Nutzwertanalyse)
- [ ] Angebote erstellen und Preise kalkulieren
- [ ] Beschaffungsprozess organisieren
- [ ] IT-Arbeitsplatz konfigurieren und in Betrieb nehmen
- [ ] Übergabeprotokoll erstellen
- [ ] Den gesamten Prozess reflektieren und bewerten
---
## Handlungsphasen
### 1. Kundenwunsch aufnehmen
```
Kundengespräch → Anforderungen ermitteln → Dokumentation → Auswahlkriterien
```
**Wichtige Fragen:**
- Welche Software wird benötigt?
- Welche Leistungsanforderungen bestehen?
- Ergonomische Anforderungen?
- Budgetvorstellungen?
### 2. Produkte vergleichen
**Kriterien für Hardware:**
| Kriterium | Beschreibung |
|-----------|-------------|
| Prozessor | Kerne, Taktfrequenz, Cache |
| Arbeitsspeicher | Kapazität, Typ (DDR4/DDR5) |
| Festplatte | SSD/HDD, Kapazität |
| Grafikkarte | Dediziert/integriert, Speicher |
| Display | Auflösung, Größe, Paneltyp |
| Anschlüsse | USB, HDMI, etc. |
**Kriterien für Software:**
- Lizenzmodell (Kauf, Subscription, Open Source)
- Kompatibilität mit bestehender Infrastruktur
- Benutzerfreundlichkeit
- Support/Updates
- Datenschutz (DSGVO)
### 3. Nutzwertanalyse
**Beispiel-Matrix:**
| Kriterium | Gewichtung | Laptop A | Laptop B |
|-----------|------------|----------|----------|
| Performance | 25% | 8 (80%) | 9 (90%) |
| Preis | 20% | 7 (70%) | 6 (60%) |
| Akkulaufzeit | 15% | 9 (90%) | 7 (70%) |
| Display | 15% | 8 (80%) | 9 (90%) |
| Ergonomie | 15% | 7 (70%) | 8 (80%) |
| Support | 10% | 8 (80%) | 7 (70%) |
| **Gesamt** | **100%** | **7,9** | **7,8** |
**Berechnung:**
```
Nutzwert = Σ (Bewertung × Gewichtung)
```
### 4. Angebotskalkulation
```
Listeneinkaufspreis
+ Bezugskosten (Versand, Zoll)
= Einstandspreis
+ Gemeinkosten/Zuschlag (z.B. 30%)
+ Gewinnmarge (z.B. 15%)
= Angebotspreis
+ MwSt. (19%)
= Brutto-Angebotspreis
```
### 5. Beschaffung und Inbetriebnahme
**Ablauf:**
1. Bestellung auslösen
2. Lieferung prüfen (Mängel dokumentieren!)
3. Komponenten installieren
4. Software konfigurieren
5. Funktion testen
6. Kunden einweisen
7. Übergabeprotokoll erstellen
---
## Zentrale Inhalte
### Hard- und Software
- Desktop-PC, Laptop, Workstation
- Peripherie (Monitor, Tastatur, Maus, Drucker)
- Betriebssysteme (Windows, Linux, macOS)
- Anwendungssoftware (Office, Branchensoftware)
- Cloud-Lösungen (SaaS, IaaS)
### Normen und Vorschriften
- CE-Kennzeichnung
- Ergonomie (Bildschirmarbeitsplätze)
- Datenschutz (DSGVO)
- IT-Sicherheit
- Nachhaltigkeit (Green IT, Recycling)
### Elektrotechnik (Grundlagen)
- Spannung, Strom, Leistung
- Schutzmaßnahmen
- Energieeffizienz
---
## Wichtige Begriffe
| Begriff | Erklärung |
|---------|-----------|
| **Lastenheft** | Vom Kunden erstellte Anforderungsbeschreibung |
| **Pflichtenheft** | Vom Anbieter erstellte Umsetzungsbeschreibung |
| **Nutzwertanalyse** | Systematisches Bewertungsverfahren für Alternativen |
| **Angebotsvergleich** | Quantitative und qualitative Gegenüberstellung von Angeboten |
| **Übergabeprotokoll** | Dokumentation der übergebenen Leistungen |
---
## Prüfungsrelevanz
- **Teil 1 der Abschlussprüfung** (Gewichtung: 20%)
- Schwerpunktthema für den praktischen Teil
- Projektarbeit: "Einrichten eines IT-gestützten Arbeitsplatzes"
---
## Typische Prüfungsaufgaben
1. Anforderungen aus Kundenwunsch ableiten
2. Hardwarekomponenten auswählen und begründen
3. Nutzwertanalyse durchführen
4. Angebotskalkulation erstellen
5. Konfiguration dokumentieren
6. Störungen beheben
---
## Querverweise
- [[LF1-Unternehmen-Rolle|Vorher: LF 1 - Das Unternehmen]]
- [[LF3-Netzwerke-einbinden|Nachher: LF 3 - Clients in Netzwerke einbinden]]
- [[IT-Sicherheit|IT-Sicherheit und Datenschutz]]
- [[Wirtschafts-Sozialkunde|WISO - Kalkulation]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

43
1-Ausbildungsjahr/LF3-Datenbanken/LF3-00-Übersicht.md Normal file
View File

@@ -0,0 +1,43 @@
# Lernfeld 3: Datenbanken entwickeln
## Übersicht
Dieses Lernfeld behandelt die Entwicklung und Verwaltung von Datenbanken.
## Themen
| Nr. | Thema | Beschreibung |
|-----|-------|-------------|
| 3.1 | [[LF3-01-Datenbankgrundlagen|Datenbankgrundlagen]] | Grundbegriffe, DBMS, Datenmodelle |
| 3.2 | [[LF3-02-Datenmodellierung|Datenmodellierung]] | ER-Modell, Normalisierung |
| 3.3 | [[LF3-03-SQL-Grundlagen|SQL-Grundlagen]] | SELECT, INSERT, UPDATE, DELETE |
| 3.4 | [[LF3-04-SQL-Abfragen|SQL-Abfragen]] | JOINs, Aggregatfunktionen, Unterabfragen |
| 3.5 | [[LF3-05-Datenbankmanagement|Datenbankmanagement]] | Rechte, Sicherheit, Backup |
## Lernziele
- Datenbanken konzipieren und modellieren
- SQL-Abfragen erstellen
- Datenbanken verwalten und absichern
## Voraussetzungen
- LF1: Unternehmen und Rolle
- LF2: Arbeitsplätze ausstatten
## Prüfungsrelevanz
- Teil 1 Abschlussprüfung (schriftlich)
- Teil 2 Abschlussprüfung (praktisch)
---
## Querverweise
- [[LF2-06-Beschaffung|Zurück: Beschaffung und Inbetriebnahme]]
- [[LF4-IT-Sicherheit|Nächstes Lernfeld: IT-Sicherheit]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Datenschutz]]
---
*Stand: 2024*

127
1-Ausbildungsjahr/LF3-Datenbanken/LF3-01-Datenbankgrundlagen.md Normal file
View File

@@ -0,0 +1,127 @@
# 3.1 Datenbankgrundlagen
## Was ist eine Datenbank?
Eine Datenbank ist eine **strukturierte Sammlung von Daten**, die elektronisch gespeichert und verwaltet werden.
### Vorteile gegenüber Dateisystem
| Dateisystem | Datenbank |
|-------------|-----------|
| Redundanz | Keine/reduzierte Redundanz |
| Inkonsistenzen | Datenkonsistenz |
| Zugriffskontrollle | Integrierte Rechteverwaltung |
| Parallelzugriff | Concurrent Access |
| Datensicherung | Backup/Recovery |
---
## Datenbankmanagementsystem (DBMS)
### Funktionen
```
DBMS - Kernfunktionen
├── Datendefinition (DDL)
├── Datenmanipulation (DML)
├── Zugriffskontrolle
├── Transaktionsmanagement
├── Datenintegrität
└── Datensicherung
```
### DBMS-Typen
| Typ | Beispiele | Einsatz |
|-----|-----------|----------|
| Relational | MySQL, PostgreSQL, Oracle | Standard |
| Dokumentenorientiert | MongoDB | Unstrukturierte Daten |
| Key-Value | Redis | Caching |
| Graph | Neo4j | Netzwerke |
### Relationale Datenbanken
```
Relationales Modell
├── Tabelle (Relation)
├── Zeile (Tupel/Datensatz)
├── Spalte (Attribut)
├── Primärschlüssel
└── Fremdschlüssel
```
---
## Datenbankarchitektur
### Dreischichtenarchitektur
```
Architektur
├── Externe Ebene (Benutzersicht)
├── Konzeptionelle Ebene (logisches Modell)
└── Interne Ebene (physikalische Speicherung)
```
### ANSI-SPARC-Architektur
| Ebene | Beschreibung |
|-------|-------------|
| Extern | Benutzeransichten |
| Konzeptuell | Gesamtsicht der DB |
| Intern | Speicherstrukturen |
---
## Datenmodelle
### Hierarchisches Modell
```
Baumstruktur
Root
├── Kind1
│ └── Enkel1
└── Kind2
```
### Netzwerkmodell
```
Netzstruktur
Knoten1 ←→ Knoten2 ←→ Knoten3
```
### Relationales Modell
```
Tabellenmodell
Kunde (ID, Name, Adresse)
↓
Bestellung (ID, Kunde_ID, Datum)
```
---
## Wichtige Begriffe
| Begriff | Erklärung |
|---------|-----------|
| **Tabelle** | Sammlung von Datensätzen |
| **Datensatz** | Eine Zeile in einer Tabelle |
| **Attribut** | Eine Spalte in einer Tabelle |
| **Primärschlüssel** | Eindeutige ID eines Datensatzes |
| **Fremdschlüssel** | Verweis auf andere Tabelle |
| **Index** | Beschleunigt den Zugriff |
| **Sicht (View)** | Gespeicherte Abfrage |
---
## Querverweise
- [[LF3-02-Datenmodellierung|Nächstes Thema: Datenmodellierung]]
- [[LF5-03-Programmierung|Programmierung]]
---
*Stand: 2024*

174
1-Ausbildungsjahr/LF3-Datenbanken/LF3-02-Datenmodellierung.md Normal file
View File

@@ -0,0 +1,174 @@
# 3.2 Datenmodellierung
## ER-Modell (Entity-Relationship)
Das ER-Modell ist ein **konzeptionelles Datenmodell** zur Beschreibung von Datenstrukturen.
### Grundbegriffe
```
ER-Modell - Komponenten
├── Entitäten (Entities)
├── Beziehungen (Relationships)
└── Attribute (Eigenschaften)
```
### Entitäten
Eine Entität ist ein **Objekt der realen Welt**, das eindeutig identifizierbar ist.
| Entität | Beispiel |
|---------|----------|
| Person | Kunde, Mitarbeiter |
| Ding | Produkt, Auto |
| Konzept | Bestellung, Rechnung |
### Attribute
Attribute beschreiben **Eigenschaften** von Entitäten.
```
Attribute - Typen
├── Einfachwertig
├── Mehrwertig (z.B. Telefonnummern)
├── Zusammengesetzt (z.B. Adresse)
└── Abgeleitet (z.B. Alter aus Geburtsdatum)
```
### Beziehungen (Relationships)
Beziehungen verknüpfen Entitäten miteinander.
```
Beziehungsgrade
├── 1:1 (One-to-One)
├── 1:n (One-to-Many)
└── n:m (Many-to-Many)
```
---
## ER-Diagramm
### Symbole
```
Notation (Chen-Notation)
Rechteck → Entität
Raute → Beziehung
Ellipse → Attribut
Unterstrich → Primärschlüssel
Doppel ellipse → Mehrwertiges Attribut
```
### Kardinalitäten
| Symbol | Bedeutung |
|--------|-----------|
| 1 | Genau eins |
| N | Eins bis viele |
| 0..1 | Null bis eins |
| 0..N | Null bis viele |
### Beispiel: Webshop
```
ER-Diagramm - Webshop
Kunde ──────── Bestellung ──────── Produkt
(1) (1..n) (1) (1..n) (1) (1..n)
Kunde: {Kunden_ID (PK), Name, E-Mail, Adresse}
Bestellung: {Bestell_ID (PK), Kunden_ID (FK), Datum, Status}
Produkt: {Produkt_ID (PK), Name, Preis, Kategorie}
BestellPosition: {Bestell_ID (FK), Produkt_ID (FK), Menge}
```
---
## Normalisierung
Normalisierung reduziert **Redundanz** und vermeidet **Anomalien**.
### Normalformen
```
Normalisierungsstufen
├── 1. Normalform (1NF)
├── 2. Normalform (2NF)
├── 3. Normalform (3NF)
└── Boyce-Codd-Normalform (BCNF)
```
### 1. Normalform (1NF)
**Bedingung**: Jedes Attribut enthält nur atomare (unteilbare) Werte.
```
Nicht 1NF:
Bestellung | Produkte
-----------|------------------
1 | A, B, C
1NF:
Bestellung | Produkt
-----------|----------
1 | A
1 | B
1 | C
```
### 2. Normalform (2NF)
**Bedingung**: 1NF erfüllt + jedes Nicht-Schlüssel-Attribut ist vom gesamten Primärschlüssel abhängig.
### 3. Normalform (3NF)
**Bedingung**: 2NF erfüllt + keine transitiven Abhängigkeiten.
```
Nicht 3NF:
{Student_ID, Kurs_ID} → {Note} → {Bewertungstext}
3NF:
{Student_ID, Kurs_ID} → {Note}
{Note} → {Bewertungstext}
```
---
## Übung: Datenmodell erstellen
### Aufgabenstellung
Erstelle ein ER-Diagramm für eine Bibliothek:
- Bücher können ausgeliehen werden
- Kunden leihen Bücher aus
- Ein Buch hat mehrere Exemplare
### Lösung
```
Entitäten:
- Kunde (Kunden_ID, Name, Adresse)
- Buch (ISBN, Titel, Autor, Verlag)
- Exemplar (Exemplar_ID, ISBN, Status)
- Ausleihe (Ausleihe_ID, Kunden_ID, Exemplar_ID, Datum)
Beziehungen:
- Kunde (1) ─── (0..n) Ausleihe
- Exemplar (1) ─── (0..1) Ausleihe
- Buch (1) ─── (1..n) Exemplar
```
---
## Querverweise
- [[LF3-01-Datenbankgrundlagen|Zurück: Datenbankgrundlagen]]
- [[LF3-03-SQL-Grundlagen|Nächstes Thema: SQL-Grundlagen]]
---
*Stand: 2024*

235
1-Ausbildungsjahr/LF3-Datenbanken/LF3-03-SQL-Grundlagen.md Normal file
View File

@@ -0,0 +1,235 @@
# 3.3 SQL-Grundlagen
## Was ist SQL?
**SQL** (Structured Query Language) ist die Standardsprache für die Kommunikation mit relationalen Datenbanken.
### SQL-Teilsprachen
```
SQL - Kategorien
├── DDL (Data Definition Language)
│ ├── CREATE → Objekte erstellen
│ ├── ALTER → Objekte ändern
│ └── DROP → Objekte löschen
├── DML (Data Manipulation Language)
│ ├── SELECT → Daten abfragen
│ ├── INSERT → Daten einfügen
│ ├── UPDATE → Daten ändern
│ └── DELETE → Daten löschen
├── DCL (Data Control Language)
│ ├── GRANT → Rechte vergeben
│ └── REVOKE → Rechte entziehen
└── TCL (Transaction Control Language)
├── COMMIT → Transaktion abschließen
├── ROLLBACK → Transaktion zurücksetzen
└── SAVEPOINT → Speicherpunkt
```
---
## Datentypen
### Numerisch
| Datentyp | Beschreibung | Bereich |
|----------|-------------|---------|
| INT | Ganzzahl | -2 Mrd. bis 2 Mrd. |
| DECIMAL(p,s) | Dezimalzahl | p= Stellen, s= Nachkommastellen |
| FLOAT | Gleitkommazahl | ~7 Stellen |
| DOUBLE | Doppelte Präzision | ~15 Stellen |
### Zeichenketten
| Datentyp | Beschreibung | max. Länge |
|----------|-------------|-------------|
| CHAR(n) | Festlänge | 255 |
| VARCHAR(n) | Variable Länge | 65.535 |
| TEXT | Langer Text | 65.535+ |
| LONGTEXT | Sehr langer Text | 4 GB |
### Datum/Zeit
| Datentyp | Beschreibung |
|----------|-------------|
| DATE | Datum (JJJJ-MM-TT) |
| TIME | Zeit (HH:MM:SS) |
| DATETIME | Datum + Zeit |
| TIMESTAMP | Unix-Zeitstempel |
---
## DDL - Datenbankobjekte erstellen
### Tabelle erstellen (CREATE TABLE)
```sql
CREATE TABLE Kunde (
Kunden_ID INT PRIMARY KEY,
Vorname VARCHAR(50) NOT NULL,
Nachname VARCHAR(50) NOT NULL,
E-Mail VARCHAR(100) UNIQUE,
Geburtsdatum DATE,
Erstellt_AM TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```
### Tabelle ändern (ALTER TABLE)
```sql
-- Spalte hinzufügen
ALTER TABLE Kunde ADD Telefon VARCHAR(20);
-- Spalte ändern
ALTER TABLE Kunde MODIFY E-Mail VARCHAR(150);
-- Spalte löschen
ALTER TABLE Kunde DROP COLUMN Telefon;
```
### Tabelle löschen (DROP TABLE)
```sql
DROP TABLE Kunde;
```
---
## DML - Daten bearbeiten
### Daten einfügen (INSERT)
```sql
-- Einzelne Zeile
INSERT INTO Kunde (Kunden_ID, Vorname, Nachname, E-Mail)
VALUES (1, 'Max', 'Mustermann', 'max@example.com');
-- Mehrere Zeilen
INSERT INTO Kunde (Kunden_ID, Vorname, Nachname)
VALUES
(2, 'Anna', 'Schmidt'),
(3, 'Peter', 'Müller');
```
### Daten ändern (UPDATE)
```sql
-- Ein Datensatz
UPDATE Kunde
SET E-Mail = 'max.neu@example.com'
WHERE Kunden_ID = 1;
-- Mehrere Datensätze
UPDATE Kunde
SET Nachname = 'Meier'
WHERE Nachname = 'Müller';
```
### Daten löschen (DELETE)
```sql
-- Bestimmte Zeilen
DELETE FROM Kunde WHERE Kunden_ID = 1;
-- Alle Zeilen (Tabelle bleibt)
DELETE FROM Kunde;
```
---
## SELECT - Daten abfragen
### Grundstruktur
```sql
SELECT -- Was?
Spalten
FROM -- Woher?
Tabelle
WHERE -- Filter
Bedingung
ORDER BY -- Sortierung
Spalte;
```
### Einfache Abfragen
```sql
-- Alle Spalten
SELECT * FROM Kunde;
-- Bestimmte Spalten
SELECT Vorname, Nachname FROM Kunde;
-- Mit Alias
SELECT Vorname AS 'Vorname', Nachname AS 'Nachname' FROM Kunde;
```
### WHERE-Klausel
```sql
-- Einfache Bedingung
SELECT * FROM Kunde WHERE Nachname = 'Mustermann';
-- Vergleichsoperatoren
SELECT * FROM Kunde WHERE Alter >= 18;
SELECT * FROM Produkt WHERE Preis > 100 AND Preis < 500;
-- LIKE (Mustervergleich)
SELECT * FROM Kunde WHERE Name LIKE 'M%'; -- beginnt mit M
SELECT * FROM Kunde WHERE Name LIKE '%er%'; -- enthält 'er'
SELECT * FROM Kunde WHERE Name LIKE '___'; -- genau 3 Zeichen
-- IN (in Liste)
SELECT * FROM Kunde WHERE Stadt IN ('Berlin', 'Hamburg', 'München');
-- BETWEEN (Bereich)
SELECT * FROM Produkt WHERE Preis BETWEEN 100 AND 500;
```
---
## Übung: SQL-Grundlagen
### Aufgaben
1. Erstelle eine Tabelle "Produkt" mit ID, Name, Preis, Kategorie
2. Füge 3 Produkte ein
3. Ändere den Preis des ersten Produkts auf 99,99
4. Lösche das teuerste Produkt
### Lösung
```sql
-- 1. Tabelle erstellen
CREATE TABLE Produkt (
Produkt_ID INT PRIMARY KEY,
Name VARCHAR(100),
Preis DECIMAL(10,2),
Kategorie VARCHAR(50)
);
-- 2. Daten einfügen
INSERT INTO Produkt VALUES
(1, 'Laptop', 1299.99, 'Elektronik'),
(2, 'Maus', 29.99, 'Zubehör'),
(3, 'Tastatur', 79.99, 'Zubehör');
-- 3. Preis ändern
UPDATE Produkt SET Preis = 99.99 WHERE Produkt_ID = 1;
-- 4. Teuerstes löschen
DELETE FROM Produkt WHERE Preis = (SELECT MAX(Preis) FROM Produkt);
```
---
## Querverweise
- [[LF3-02-Datenmodellierung|Zurück: Datenmodellierung]]
- [[LF3-04-SQL-Abfragen|Nächstes Thema: SQL-Abfragen]]
- [[LF6-04-Sicherheit-Web|Sicherheit: SQL-Injection]]
---
*Stand: 2024*

263
1-Ausbildungsjahr/LF3-Datenbanken/LF3-04-SQL-Abfragen.md Normal file
View File

@@ -0,0 +1,263 @@
# 3.4 SQL-Abfragen
## JOINs - Tabellen verknüpfen
JOINs verbinden Daten aus mehreren Tabellen.
### Arten von JOINs
```
JOIN-Typen
├── INNER JOIN
├── LEFT OUTER JOIN
├── RIGHT OUTER JOIN
├── FULL OUTER JOIN
└── CROSS JOIN
```
### INNER JOIN
Gibt nur übereinstimmende Zeilen zurück.
```sql
-- Syntax
SELECT spalten
FROM tabelle1
INNER JOIN tabelle2 ON tabelle1.spalte = tabelle2.spalte;
-- Beispiel: Kunden mit Bestellungen
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
INNER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
-- Kurzschreibweise (impliziter Join)
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde, Bestellung
WHERE Kunde.Kunden_ID = Bestellung.Kunden_ID;
```
### LEFT OUTER JOIN
Gibt alle Zeilen der linken Tabelle zurück.
```sql
-- Alle Kunden, auch ohne Bestellung
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
LEFT OUTER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
```
### RIGHT OUTER JOIN
Gibt alle Zeilen der rechten Tabelle zurück.
```sql
-- Alle Bestellungen, auch ohne Kunden
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
RIGHT OUTER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
```
### Mehrere JOINs
```sql
SELECT
Kunde.Name,
Bestellung.Datum,
Produkt.Name AS Produkt
FROM Kunde
INNER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID
INNER JOIN BestellPosition ON Bestellung.Bestell_ID = BestellPosition.Bestell_ID
INNER JOIN Produkt ON BestellPosition.Produkt_ID = Produkt.Produkt_ID;
```
---
## Aggregatfunktionen
Aggregatfunktionen fassen mehrere Zeilen zu einem Ergebnis zusammen.
| Funktion | Beschreibung | Beispiel |
|----------|-------------|----------|
| COUNT() | Anzahl der Zeilen | COUNT(*) |
| SUM() | Summe | SUM(Preis) |
| AVG() | Durchschnitt | AVG(Preis) |
| MIN() | Minimum | MIN(Preis) |
| MAX() | Maximum | MAX(Preis) |
### Beispiele
```sql
-- Anzahl der Kunden
SELECT COUNT(*) AS AnzahlKunden FROM Kunde;
-- Summe aller Bestellungen
SELECT SUM(Gesamtbetrag) AS Gesamtumsatz FROM Bestellung;
-- Durchschnittspreis
SELECT AVG(Preis) AS Durchschnittspreis FROM Produkt;
-- Minimale/Maximale Bestellung
SELECT MIN(Gesamtbetrag) AS KleinsteBestellung,
MAX(Gesamtbetrag) AS GrößteBestellung
FROM Bestellung;
```
---
## GROUP BY - Gruppierung
Gruppiert Ergebnisse nach bestimmten Kriterien.
```sql
-- Umsatz pro Kunde
SELECT Kunden_ID, SUM(Gesamtbetrag) AS Umsatz
FROM Bestellung
GROUP BY Kunden_ID;
-- Anzahl Bestellungen pro Kunde
SELECT Kunden_ID, COUNT(*) AS AnzahlBestellungen
FROM Bestellung
GROUP BY Kunden_ID;
-- Umsatz pro Kategorie
SELECT Kategorie, SUM(Preis) AS Gesamtumsatz
FROM Produkt
GROUP BY Kategorie;
```
### HAVING - Filter nach Aggregation
```sql
-- Kunden mit mehr als 3 Bestellungen
SELECT Kunden_ID, COUNT(*) AS Anzahl
FROM Bestellung
GROUP BY Kunden_ID
HAVING COUNT(*) > 3;
```
---
## Unterabfragen (Subqueries)
Unterabfragen sind verschachtelte SELECT-Anweisungen.
### Skalar-Unterabfrage
Gibt einen einzelnen Wert zurück.
```sql
-- Alle Produkte, die teurer als der Durchschnitt sind
SELECT Name, Preis
FROM Produkt
WHERE Preis > (SELECT AVG(Preis) FROM Produkt);
```
### Unterabfrage mit IN
```sql
-- Kunden, die mindestens eine Bestellung haben
SELECT Name
FROM Kunde
WHERE Kunden_ID IN (SELECT Kunden_ID FROM Bestellung);
```
### Korrelierte Unterabfrage
Referenziert Spalten der äußeren Abfrage.
```sql
-- Produkte mit dem höchsten Preis pro Kategorie
SELECT Name, Preis, Kategorie
FROM Produkt p1
WHERE Preis = (
SELECT MAX(Preis)
FROM Produkt p2
WHERE p1.Kategorie = p2.Kategorie
);
```
---
## ORDER BY - Sortierung
```sql
-- Aufsteigend (Standard)
SELECT * FROM Produkt ORDER BY Preis;
-- Absteigend
SELECT * FROM Produkt ORDER BY Preis DESC;
-- Mehrere Sortierspalten
SELECT * FROM Bestellung
ORDER BY Datum DESC, Gesamtbetrag DESC;
```
---
## LIMIT / TOP - Ergebnismenge begrenzen
```sql
-- MySQL/MariaDB
SELECT * FROM Produkt ORDER BY Preis DESC LIMIT 10;
-- SQL Server
SELECT TOP 10 * FROM Produkt ORDER BY Preis DESC;
-- PostgreSQL
SELECT * FROM Produkt ORDER BY Preis DESC LIMIT 10;
```
---
## Übung: Komplexe Abfragen
### Ausgangsdaten
```sql
-- Kunden (ID, Name, Stadt)
-- Bestellungen (ID, Kunden_ID, Datum, Gesamtbetrag)
-- BestellPositionen (Bestell_ID, Produkt_ID, Menge, Preis)
```
### Aufgaben
1. Finde die 5 umsatzstärksten Kunden
2. Liste alle Bestellungen mit Kundenname
3. Zeige den durchschnittlichen Bestellwert pro Stadt
### Lösungen
```sql
-- 1. Top 5 Kunden
SELECT K.Name, SUM(B.Gesamtbetrag) AS Umsatz
FROM Kunde K
JOIN Bestellung B ON K.Kunden_ID = B.Kunden_ID
GROUP BY K.Kunden_ID, K.Name
ORDER BY Umsatz DESC
LIMIT 5;
-- 2. Bestellungen mit Kundenname
SELECT B.Bestell_ID, K.Name, B.Datum, B.Gesamtbetrag
FROM Bestellung B
JOIN Kunde K ON B.Kunden_ID = K.Kunden_ID
ORDER BY B.Datum DESC;
-- 3. Durchschnittsbestellwert pro Stadt
SELECT K.Stadt, AVG(B.Gesamtbetrag) AS Durchschnitt
FROM Kunde K
JOIN Bestellung B ON K.Kunden_ID = B.Kunden_ID
GROUP BY K.Stadt;
```
---
## Querverweise
- [[LF3-03-SQL-Grundlagen|Zurück: SQL-Grundlagen]]
- [[LF3-05-Datenbankmanagement|Nächstes Thema: Datenbankmanagement]]
- [[LF5-03-Programmierung|Programmierung]]
---
*Stand: 2024*

245
1-Ausbildungsjahr/LF3-Datenbanken/LF3-05-Datenbankmanagement.md Normal file
View File

@@ -0,0 +1,245 @@
# 3.5 Datenbankmanagement
## Benutzerverwaltung
### Benutzer erstellen
```sql
-- MySQL/MariaDB
CREATE USER 'benutzer'@'localhost' IDENTIFIED BY 'passwort';
-- PostgreSQL
CREATE USER benutzer WITH PASSWORD 'passwort';
```
### Rechte vergeben (GRANT)
```sql
-- Alle Rechte auf eine Datenbank
GRANT ALL PRIVILEGES ON datenbank.* TO 'benutzer'@'localhost';
-- Nur Leserechte
GRANT SELECT ON datenbank.tabelle TO 'benutzer'@'localhost';
-- Mehrere Rechte
GRANT SELECT, INSERT, UPDATE ON datenbank.tabelle TO 'benutzer'@'localhost';
```
### Rechte entziehen (REVOKE)
```sql
REVOKE INSERT ON datenbank.tabelle FROM 'benutzer'@'localhost';
```
### Rollen (PostgreSQL)
```sql
-- Rolle erstellen
CREATE ROLE leser;
-- Rechte zuweisen
GRANT SELECT ON tabelle TO leser;
-- Rolle zu Benutzer
GRANT leser TO benutzer;
```
---
## Transaktionen
Transaktionen garantieren die **ACID-Eigenschaften**.
```
ACID - Eigenschaften
├── Atomicity (Atomarität)
├── Consistency (Konsistenz)
├── Isolation (Isolierung)
└── Durability (Dauerhaftigkeit)
```
### Transaktionssteuerung
```sql
-- Transaktion starten (implizit bei vielen DBMS)
START TRANSACTION;
-- Änderungen speichern
COMMIT;
-- Änderungen zurücknehmen
ROLLBACK;
-- Sicherungspunkt setzen
SAVEPOINT speicherpunkt1;
```
### Beispiel: Überweisung
```sql
START TRANSaktion;
-- Geld abbuchen
UPDATE Konto SET Kontostand = Kontostand - 100
WHERE Konto_ID = 1;
-- Geld gutschreiben
UPDATE Konto SET Kontostand = Kontostand + 100
WHERE Konto_ID = 2;
-- Wenn alles OK, speichern
COMMIT;
-- Bei Fehler: alles zurücksetzen
ROLLBACK;
```
---
## Datensicherung (Backup)
### Backup-Typen
| Typ | Beschreibung |
|-----|-------------|
| Vollbackup | Alle Daten sichern |
| Inkrementell | Nur Änderungen seit letztem Backup |
| Differentiell | Änderungen seit Vollbackup |
### MySQL/MariaDB
```bash
# Vollbackup
mysqldump -u root -p datenbank > backup.sql
# Mehrere Datenbanken
mysqldump -u root -p --databases db1 db2 > backup.sql
# Wiederherstellen
mysql -u root -p datenbank < backup.sql
```
### PostgreSQL
```bash
# Vollbackup
pg_dump -U benutzer datenbank > backup.sql
# Wiederherstellen
psql -U benutzer datenbank < backup.sql
```
### Backup-Strategie
```
Backup-Plan
├── Täglich: Inkrementelles Backup
├── Wöchentlich: Vollbackup
├── Monatlich: Archivierung
└── Offsite: Externe Speicherung
```
---
## Datenbankoptimierung
### Indizes
Indizes beschleunigen den Zugriff auf Daten.
```sql
-- Index erstellen
CREATE INDEX idx_name ON tabelle (spalte);
-- Zusammengesetzter Index
CREATE INDEX idx_name ON tabelle (spalte1, spalte2);
-- Eindeutiger Index
CREATE UNIQUE INDEX idx_email ON tabelle (email);
-- Index löschen
DROP INDEX idx_name ON tabelle;
```
### EXPLAIN - Abfrage analysieren
```sql
-- Ausführungsplan anzeigen
EXPLAIN SELECT * FROM tabelle WHERE spalte = 'wert';
-- MySQL
EXPLAIN FORMAT=JSON SELECT * FROM tabelle WHERE spalte = 'wert';
```
### Optimierungstipps
| Tipp | Beschreibung |
|------|-------------|
| INDEX verwenden | Für WHERE-Joins und -Spalten |
| SELECT * vermeiden | Nur benötigte Spalten |
| JOINs minimieren | Nicht mehr als nötig |
| Wildcards vermeiden | `LIKE '%wert'` ist langsam |
---
## Datensicherheit
### SQL Injection verhindern
```sql
-- NICHT SO: Direkte Eingabe
SELECT * FROM benutzer WHERE name = '" + eingabe + "'
-- BESSER: Prepared Statements
PREPARE stmt FROM 'SELECT * FROM benutzer WHERE name = ?';
SET @name = eingabe;
EXECUTE stmt USING @name;
```
### Verschlüsselung
```
Verschlüsselungsebenen
├── Transport Layer Security (TLS)
├── Transparent Data Encryption (TDE)
└── Spaltenweise Verschlüsselung
```
---
## Monitoring
### MySQL/MariaDB
```sql
-- Aktuelle Verbindungen
SHOW PROCESSLIST;
-- Statusvariablen
SHOW STATUS LIKE 'Connections';
SHOW STATUS LIKE 'Threads%';
-- Langsame Abfragen
SHOW VARIABLES LIKE 'slow_query_log';
```
### Wichtige Metriken
| Metrik | Beschreibung |
|--------|-------------|
| Connection Usage | Aktive Verbindungen |
| Query Cache | Cache-Trefferquote |
| Lock Waits | Warteschlangen |
| Buffer Pool | Speicherauslastung |
---
## Querverweise
- [[LF3-04-SQL-Abfragen|Zurück: SQL-Abfragen]]
- [[LF4-IT-Sicherheit|Sicherheit: Zugriffskontrolle]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Datenschutz]]
---
*Stand: 2024*

226
1-Ausbildungsjahr/LF3-Netzwerke-einbinden/LF3-Notizen.md Normal file
View File

@@ -0,0 +1,226 @@
# LF 3: Clients in Netzwerke einbinden
> **1. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, eine Netzwerkinfrastruktur zu analysieren sowie Clients zu integrieren.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Anforderungen an die Client-Integration im Kundengespräch erfassen
- [ ] Netzwerkkomponenten und deren Eigenschaften beschreiben
- [ ] Physische und logische Netzwerkpläne lesen und erstellen
- [ ] Clients für Netzwerke konfigurieren (IP, DNS, DHCP, etc.)
- [ ] Clients in bestehende Netzwerke einbinden
- [ ] Funktionstests durchführen und dokumentieren
- [ ] Wirtschaftlichkeit und Ökologie berücksichtigen
---
## Netzwerk-Grundlagen
### OSI-Schichtenmodell (7 Layer)
| Layer | Name | Beispiele | Protokolle |
|-------|------|-----------|-------------|
| 7 | Application | HTTP, FTP, SMTP | DNS, DHCP |
| 6 | Presentation | SSL/TLS | JPEG, GIF |
| 5 | Session | RPC, NetBIOS | - |
| 4 | Transport | TCP, UDP | - |
| 3 | Network | IP, ICMP | Router |
| 2 | Data Link | Ethernet, Wi-Fi | Switch |
| 1 | Physical | Kabel, Glasfaser | Hub |
### TCP/IP-Modell (4 Layer)
```
+------------------------+
| Application Layer | ← HTTP, FTP, SMTP, DNS, DHCP
+------------------------+
| Transport Layer | ← TCP, UDP
+------------------------+
| Internet Layer | ← IP, ICMP, ARP
+------------------------+
| Network Access Layer | ← Ethernet, Wi-Fi
+------------------------+
```
---
## Netzwerkkomponenten
### Aktive Komponenten
| Komponente | OSI-Layer | Funktion |
|-----------|-----------|----------|
| **Hub** | Layer 1 | Signal verstärken, Broadcast |
| **Switch** | Layer 2 | MAC-Adressen lernen, VLANs |
| **Router** | Layer 3 | IP-Routing zwischen Netzen |
| **Gateway** | Layer 3-7 | Protokollübersetzung |
| **Access Point** | Layer 1-2 | WLAN-Verbindung |
### Kabeltypen
| Typ | max. Länge | max. Geschwindigkeit |
|-----|------------|---------------------|
| CAT5e | 100m | 1 Gbit/s |
| CAT6 | 100m | 10 Gbit/s (55m) |
| CAT6a | 100m | 10 Gbit/s |
| CAT7/7a | 100m | 10+ Gbit/s |
---
## IP-Konfiguration
### IPv4
**Aufbau:** 4 Oktette (0-255), maximal 32 Bit
**IP-Adresse Beispiel:** `192.168.1.100`
**Subnetzmaske:** `255.255.255.0` (/24)
**私有 IP-Bereiche (RFC 1918):**
- 10.0.0.0/8
- 172.16.0.0/12
- 192.168.0.0/16
### IPv6
**Aufbau:** 8 Gruppen à 16 Bit, Hexadezimal
**Beispiel:** `2001:0db8:85a3:0000:0000:8a2e:0370:7334`
**Abkürzung:**
- Führende Nullen können weggelassen werden
- Doppelter Doppelpunkt (::) für aufeinanderfolgende Nullgruppen
---
## DHCP (Dynamic Host Configuration Protocol)
### Ablauf (DORA)
```
Client Server
| 1. DISCOVER |
|------------------>|
| 2. OFFER |
|<------------------|
| 3. REQUEST |
|------------------>|
| 4. ACK |
|<------------------|
```
### DHCP-Pool Beispiel
```
Network: 192.168.1.0/24
Range: 192.168.1.100 - 192.168.1.200
Gateway: 192.168.1.1
DNS: 192.168.1.1, 8.8.8.8
Lease Time: 24 hours
```
---
## DNS (Domain Name System)
### Aufbau
```
Beispiel: www.example.com
│ │
│ └─> TLD (Top Level Domain)
└──────────> Domain
```
### DNS-Einträge
| Typ | Verwendung |
|-----|------------|
| A | IPv4-Adresse |
| AAAA | IPv6-Adresse |
| CNAME | Alias |
| MX | Mailserver |
| NS | Nameserver |
| TXT | Textinfo |
---
## Netzwerkplanung
### Logischer Netzwerkplan
- IP-Adressierung
- Subnetze
- Routing
- Dienste
### Physischer Netzwerkplan
- Kabelwege
- Rack-Belegung
- Port-Belegung
- Switch-Ports
---
## Sicherheit
### Netzwerksicherheit
- Firewall-Regeln
- VLAN-Trennung
- Port-Security
- VPN für Remote-Zugriff
### Energiesparen
- Energy Efficient Ethernet (EEE)
- Wake-on-LAN
- Zeitschaltuhren
---
## Handlungsphasen
1. **Informieren**: Anforderungen erfassen, Netzwerk analysieren
2. **Planen**: Konzept erstellen, Komponenten auswählen
3. **Durchführen**: Konfiguration durchführen, Clients einbinden
4. **Überprüfen**: Funktionstests, Dokumentation
5. **Reflektieren**: Wirtschaftlichkeit, Optimierung
---
## Prüfungsrelevanz
- **Teil 1 der Abschlussprüfung**
- Praktische Netzwerkkonfiguration
- IP-Planung und Subnetting
---
## Übungsaufgaben
1. IP-Adresse für Client konfigurieren (statisch/DHCP)
2. Kleinen Netzwerkplan erstellen (max. 10 Clients)
3. DHCP-Server konfigurieren
4. DNS-Auflösung testen
---
## Querverweise
- [[LF2-Arbeitsplätze-ausstatten|Vorher: LF 2]]
- [[LF4-Schutzbedarfsanalyse|Nachher: LF 4 - Schutzbedarfsanalyse]]
- [[Netzwerk-Technik|Netzwerktechnik]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

43
1-Ausbildungsjahr/LF4-IT-Sicherheit/LF4-00-Übersicht.md Normal file
View File

@@ -0,0 +1,43 @@
# Lernfeld 4: IT-Sicherheit gewährleisten
## Übersicht
Dieses Lernfeld behandelt die Grundlagen der IT-Sicherheit und des Datenschutzes.
## Themen
| Nr. | Thema | Beschreibung |
|-----|-------|-------------|
| 4.1 | [[LF4-01-Gefahren-Analyse|Gefahren und Bedrohungen]] | Malware, Hacker, Social Engineering |
| 4.2 | [[LF4-02-Schutzmassnahmen|Schutzmaßnahmen]] | Virenschutz, Firewall, Verschlüsselung |
| 4.3 | [[LF4-03-Sicherheitskonzepte|Sicherheitskonzepte]] | BSI, ISO 27001 |
| 4.4 | [[LF4-04-Datenschutz|Datenschutz (DSGVO)]] | Rechtliche Anforderungen |
## Lernziele
- Bedrohungen für IT-Systeme erkennen
- Schutzmaßnahmen implementieren
- Datenschutzanforderungen umsetzen
## Voraussetzungen
- LF1: Unternehmen und Rolle
- LF2: Arbeitsplätze ausstatten
- LF3: Datenbanken entwickeln
## Prüfungsrelevanz
- Teil 1 Abschlussprüfung (schriftlich)
- Teil 2 Abschlussprüfung (praktisch)
---
## Querverweise
- [[LF3-05-Datenbankmanagement|Zurück: Datenbankmanagement]]
- [[LF5-Analyse-Design|Nächstes Lernfeld: Analyse und Design]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Datenschutz]]
---
*Stand: 2024*

197
1-Ausbildungsjahr/LF4-IT-Sicherheit/LF4-01-Gefahren-Analyse.md Normal file
View File

@@ -0,0 +1,197 @@
# 4.1 Gefahren und Bedrohungen
## Bedrohungskategorien
```
Bedrohungen - Übersicht
├── Malware (Schadsoftware)
├── Hacker-Angriffe
├── Social Engineering
├── Physische Bedrohungen
└── Insider-Bedrohungen
```
---
## Malware (Schadsoftware)
### Arten von Malware
| Typ | Beschreibung | Beispiel |
|-----|-------------|----------|
| **Virus** | Benötigt Wirt, verbreitet sich | Dateivirus |
| **Wurm** | Selbstständig, Netzwerk | Conficker |
| **Trojaner** | Tarnung als nützliches Programm | Emotet |
| **Ransomware** | Verschlüsselt Daten | WannaCry |
| **Spyware** | Spioniert Nutzer aus | Keylogger |
| **Adware** | Werbung anzeigen | Browser-Hijacker |
| **Rootkit** | Versteckt Eindringlinge | Kernel-Rootkit |
### Schadfunktionen
```
Malware-Funktionen
├── Datenspionage
├── Datenzerstörung
├── Systemübernahme
├── Botnetz-Erstellung
├── Erpressung
└── Kryptomining
```
### Angriffsvektoren
| Vektor | Beschreibung |
|--------|-------------|
| E-Mail | Phishing, infizierte Anhänge |
| Web | Drive-by-Downloads |
| USB | Infizierte Wechselmedien |
| Netzwerk | Exploits, Schwachstellen |
| Social Engineering | Benutzer täuschen |
---
## Hacker-Angriffe
### Angriffsarten
```
Angriffstechniken
├── Denial of Service (DoS)
├── Distributed DoS (DDoS)
├── Man-in-the-Middle
├── SQL Injection
├── Cross-Site Scripting (XSS)
├── Buffer Overflow
└── Brute Force
```
### DoS/DDoS
```
DoS - Denial of Service
Ziel: Dienst unerreichbar machen
Methoden:
├── Überlastung (Traffic-Flood)
├── Ausnutzung von Schwachstellen
└── Ressourcenerschöpfung
```
### SQL Injection
```sql
-- Bösartige Eingabe
' OR '1'='1
-- Resultat (alle Daten werden zurückgegeben)
SELECT * FROM benutzer WHERE name = '' OR '1'='1'
```
### Brute-Force
```
Brute-Force - Ausprobieren aller Möglichkeiten
Schutz:
├── Sperrung nach X Versuchen
├── Captcha
├── Zwei-Faktor-Authentifizierung
└── Starke Passwörter
```
---
## Social Engineering
### Psychologische Angriffe
| Technik | Beschreibung | Beispiel |
|---------|-------------|----------|
| **Phishing** | Gefäuschte E-Mails | Bank-Fake-Mails |
| **Spear Phishing** | Gezielt auf Opfer | CEO-Fraud |
| **Vishing** | Telefon-Phishing | Support-Anruf |
| **Pretexting** | Erfundene Szenarien | Polizei-Anruf |
| **Baiting** | Köder | USB-Stick liegen lassen |
### Erkennung
```
Phishing-Merkmale
├── Absender-Adresse verdächtig
├── Dringlichkeit / Drohungen
├── Rechtschreibfehler
├── Unerwartete Anhänge
├── Fehlerhafte Links
└── Ungewöhnliche Anfragen
```
---
## Physische Bedrohungen
### Risiken
```
Physische Bedrohungen
├── Diebstahl (Laptop, Handy)
├── Hardware-Beschädigung
├── Umgebungseinflüsse (Feuer, Wasser)
├── Stromausfall
└── unbefugter Zutritt
```
### Gegenmaßnahmen
| Maßnahme | Beschreibung |
|----------|-------------|
| Zutrittskontrolle | Türschlüssel, Chipkarte |
| Alarmanlagen | Bewegungsmelder |
| Brandschutz | Rauchmelder, Löschgeräte |
| USV | Unterbrechungsfreie Stromversorgung |
| Datensicherung | Regelmäßige Backups |
---
## Schadensarten
### Vertraulichkeit
```
Vertraulichkeitsverletzung
├── Unbefugter Datenzugriff
├── Datenklau
├── Spionage
└── Veröffentlichung
```
### Integrität
```
Integritätsverletzung
├── Datenänderung
├── Manipulation
├── Sabotage
└── Fälschung
```
### Verfügbarkeit
```
Verfügbarkeitsverletzung
├── Systemausfall
├── Datenverlust
├── DDoS-Angriff
└── Ransomware
```
---
## Querverweise
- [[LF4-02-Schutzmassnahmen|Nächstes Thema: Schutzmaßnahmen]]
- [[LF5-03-Programmierung|Programmierung: Sichere Softwareentwicklung]]
---
*Stand: 2024*

235
1-Ausbildungsjahr/LF4-IT-Sicherheit/LF4-02-Schutzmassnahmen.md Normal file
View File

@@ -0,0 +1,235 @@
# 4.2 Schutzmaßnahmen
## Sicherheitsmaßnahmen - Überblick
```
Sicherheitsebenen (Defense in Depth)
├── Physische Sicherheit
├── Netzwerksicherheit
├── System­sicherheit
├── Anwendungs­sicherheit
└── Datensicherheit
```
---
## Virenschutz
### Antivirus-Software
| Komponente | Funktion |
|------------|----------|
| Echtzeitschutz | Scannt Dateien beim Zugriff |
| On-Demand-Scan | Manuelle Prüfung |
| Signatur-Erkennung | Bekannte Schadsoftware |
| Heuristik | Verdachtsverhalten erkennen |
| Sandbox | Ausführung in isolierter Umgebung |
### Antiviren-Programme
| Produkt | Typ | Eigenschaften |
|---------|-----|---------------|
| Windows Defender | Integriert | Kostenlos, gut |
| Bitdefender | Kommerziell | Top-Schutz |
| Kaspersky | Kommerziell | Umfassend |
| ClamAV | Open Source | Linux-Server |
### Konfiguration
```
Antivirus-Einstellungen
├── Echtzeitschutz aktiviert
├── Automatische Updates
├── Geplante Vollscans
├── Quarantäne bei Fund
└── Reporting aktivieren
```
---
## Firewall
### Firewall-Typen
| Typ | Ebene | Beschreibung |
|-----|-------|-------------|
| Paketfilter | Netzwerk | Nach IP/Port filtern |
| Stateful Inspection | Netzwerk | Verbindungsstatus prüfen |
| Application Layer | Netzwerk | Anwendungsprotokolle |
| Host-Based | System | Einzelner PC |
| Web Application (WAF) | Anwendung | HTTP/HTTPS |
### Windows Firewall
```powershell
# Status abfragen
Get-NetFirewallProfile
# Regel erstellen (PowerShell)
New-NetFirewallRule -DisplayName "HTTP-Allow" -Direction Inbound -Protocol TCP -LocalPort 80 -Action Allow
# Regel deaktivieren
Set-NetFirewallRule -DisplayName "HTTP-Allow" -Enabled False
```
### Firewall-Regeln
```
Regelstruktur
├── Aktion: Erlauben/Blockieren
├── Richtung: Eingehend/Ausgehend
├── Protokoll: TCP/UDP/ICMP
├── Port: Nummer oder Bereich
├── IP-Adresse: Quelle/Ziel
└── Programm: Pfad zur Anwendung
```
---
## Verschlüsselung
### Verschlüsselungsarten
| Art | Verwendung | Beispiele |
|-----|------------|----------|
| **Symmetrisch** | Gleicher Schlüssel | AES, 3DES |
| **Asymmetrisch** | Schlüsselpaar | RSA, ECC |
| **Hashing** | Einwegfunktion | SHA-256, MD5 |
### Symmetrische Verschlüsselung
```
Verschlüsselung mit AES
Klartext → AES (Schlüssel) → Chiffretext
Chiffretext → AES (Schlüssel) → Klartext
```
### Asymmetrische Verschlüsselung
```
Schlüsselpaar
├── Öffentlicher Schlüssel (Public Key)
│ └── Verschlüsselung, Verifizierung
└── Privater Schlüssel (Private Key)
└── Entschlüsselung, Signatur
```
### Verschlüsselungsbereiche
| Bereich | Technologie | Beispiel |
|---------|-------------|----------|
| Festplatte | Full Disk Encryption (FDE) | BitLocker, FileVault |
| Datei | Transparent Encryption | EFS, VeraCrypt |
| E-Mail | S/MIME, PGP | Gpg4win |
| Web | TLS/SSL | HTTPS |
| Datenbank | Transparent Data Encryption | TDE |
---
## Authentifizierung
### Authentifizierungsfaktoren
```
Authentifizierungsfaktoren
├── Wissen (Something you know)
│ └── Passwort, PIN
├── Besitz (Something you have)
│ └── Chipkarte, Token, Handy
└── Eigenschaft (Something you are)
└── Fingerabdruck, Face ID
```
### Starke Authentifizierung (2FA/MFA)
| Typ | Beschreibung |
|-----|-------------|
| **2FA** | Zwei Faktoren |
| **MFA** | Mehrere Faktoren |
| **TOTP** | Zeitbasiert (Google Authenticator) |
| **SMS** | Einmalcode per SMS (unsicherer) |
| **Hardware-Token** | Physischer Schlüssel (YubiKey) |
### Passwort-Richtlinien
```
Sichere Passwörter
├── Mindestens 12 Zeichen
├── Groß- und Kleinbuchstaben
├── Zahlen und Sonderzeichen
├── Keine Wörterbuchwörter
├── Keine Wiederverwendung
└── Regelmäßig ändern
```
### Passwort-Manager
| Produkt | Plattform | Typ |
|---------|----------|-----|
| Bitwarden | Alle | Open Source |
| 1Password | Alle | Kommerziell |
| KeePass | Windows/Linux | Open Source |
| iCloud Keychain | Apple | Integriert |
---
## Updates und Patches
### Patch-Management
```
Patch-Prozess
├── Identifikation → Sicherheitslücken melden
├── Bewertung → Schweregrad prüfen
├── Entwicklung → Patch erstellen
├── Test → In Testumgebung prüfen
├── Verteilung → Rollout planen
└── Dokumentation → Änderungen festhalten
```
### Patch-Stufen
| Stufe | Priorität | Zeitrahmen |
|-------|----------|------------|
| Kritisch | Sofort | 24-72 Stunden |
| Hoch | Bald | 1 Woche |
| Mittel | Geplant | 1 Monat |
| Niedrig | Bei Gelegenheit | Quartal |
---
## Netzwerksicherheit
### VPNs (Virtual Private Network)
```
VPN - Tunnel durch unsicheres Netzwerk
Lokaler PC → Verschlüsselter Tunnel → Unternehmensnetzwerk
```
| VPN-Typ | Beschreibung |
|---------|-------------|
| Site-to-Site | Netzwerk-zu-Netzwerk |
| Remote Access | Einzelner Benutzer |
| SSL-VPN | Browser-basiert |
| IPsec | Standard-basiert |
### WLAN-Sicherheit
| Standard | Sicherheit | Empfehlung |
|----------|------------|-------------|
| WEP | Unsicher | Nicht nutzen |
| WPA | Schwach | Nicht nutzen |
| **WPA2** | Sicher | Empfohlen |
| WPA3 | Sehr sicher | Neuinstallation |
---
## Querverweise
- [[LF4-01-Gefahren-Analyse|Zurück: Gefahren und Bedrohungen]]
- [[LF4-03-Sicherheitskonzepte|Nächstes Thema: Sicherheitskonzepte]]
---
*Stand: 2024*

236
1-Ausbildungsjahr/LF4-IT-Sicherheit/LF4-03-Sicherheitskonzepte.md Normal file
View File

@@ -0,0 +1,236 @@
# 4.3 Sicherheitskonzepte
## IT-Sicherheitsstandards
### BSI-Grundschutz
Das **BSI (Bundesamt für Sicherheit in der Informationstechnik)** definiert den **IT-Grundschutz**.
```
BSI-Grundschutz - Bausteine
├── SYS
│ ├── SYS.1.1 Allgemeiner Server
│ ├── SYS.1.2 Windows Server
│ ├── SYS.1.3 Linux Server
│ ├── SYS.2.1 Client
│ └── ...
├── APP
├── NET
├── INF
├── ORG
└── OPS
```
### ISO 27001
Internationaler Standard für **Informationssicherheits-Managementsysteme (ISMS)**.
```
ISO 27001 - PDCA-Zyklus
├── Plan (Planen)
├── Do (Umsetzen)
├── Check (Prüfen)
└── Act (Verbessern)
```
---
## Schutzbedarfsanalyse
### Schutzziele
```
Schutzziele - CIA
├── Vertraulichkeit (Confidentiality)
├── Integrität (Integrity)
└── Verfügbarkeit (Availability)
```
### Schutzbedarfsfeststellung
```
Schutzbedarfsanalyse - Schritte
1. Assets identifizieren
2. Bedrohungen analysieren
3. Schwachstellen identifizieren
4. Schadensszenarien bewerten
5. Schutzbedarf festlegen
```
### Schutzbedarfskategorien
| Kategorie | Beschreibung | Beispiel |
|----------|-------------|----------|
| **Normal** | Geringe Auswirkungen | Internes Wiki |
| **Hoch** | Erhebliche Auswirkungen | Kunden-Daten |
| **Sehr hoch** | Existenzielle Auswirkungen | Passwörter, Finanzen |
### Beispiel: Schutzbedarfsanalyse
```
Beispiel: Online-Shop
Asset: Kunden-Datenbank
- Vertraulichkeit: Hoch (personenbezogene Daten)
- Integrität: Hoch (keine Manipulation)
- Verfügbarkeit: Hoch (24/7 Betrieb)
Schutzmaßnahmen:
- TLS-Verschlüsselung
- Regelmäßige Backups
- Redundante Systeme
```
---
## Risikomanagement
### Risikobewertung
```
Risiko = Wahrscheinlichkeit × Schadensausmaß
Matrix:
| gering | mittel | hoch
----------|--------|--------|------
gering | niedrig| niedrig| mittel
mittel | niedrig| mittel | hoch
hoch | mittel| hoch | kritisch
```
### Risikobehandlung
```
Risikobehandlung - Optionen
├── Vermeiden → Risiko eliminieren
├── Reduzieren → Maßnahmen implementieren
├── Versichern → Risiko übertragen
└── Akzeptieren → Risiko bewusst hinnehmen
```
---
## Sicherheitsrichtlinien
### Informationssicherheitsrichtlinie
```markdown
# Informationssicherheitsrichtlinie
## 1. Zweck
Diese Richtlinie definiert die Grundsätze...
## 2. Geltungsbereich
Diese Richtlinie gilt für alle Mitarbeiter...
## 3. Verantwortlichkeiten
- CISO: Gesamtverantwortung
- IT-Abteilung: Technische Umsetzung
- Mitarbeiter: Einhaltung
## 4. Regelungen
- Passwortrichtlinie
- Datensicherungsrichtlinie
- Zugangsberechtigungen
- Nutzung von IT-Systemen
```
### Berechtigungskonzept
```
Berechtigungskonzept - Grundsätze
├── Need-to-know → Nur was nötig ist
├── Least Privilege → Minimale Rechte
├── Segregation of Duties → Aufgabentrennung
└── Regelmäßige Prüfung → Rechte überprüfen
```
---
## Business Continuity Management (BCM)
### Notfallplanung
```
Notfallmanagement-Prozess
├── Prävention → Risiken minimieren
├── Detektion → Störung erkennen
├── Reaktion → Sofortmaßnahmen
├── Wiederherstellung → Systeme wiederherstellen
└── Nachbereitung → Lessons Learned
```
### Notfalltypen
| Typ | Beispiel | Reaktionszeit |
|-----|----------|---------------|
| Kritisch | Ransomware | Sofort |
| Hoch | Server-Ausfall | 4 Stunden |
| Mittel | E-Mail-Probleme | 24 Stunden |
| Niedrig | Druckerdefekt | 1 Woche |
---
## Datensicherungskonzept
### Backup-Strategie
```
Backup-Regel 3-2-1
├── 3 Kopien der Daten
├── 2 verschiedene Medien
└── 1 Kopie extern (offsite)
```
### Backup-Typen
| Typ | Zeitpunkt | Wiederherstellung |
|-----|-----------|-------------------|
| Vollbackup | Wöchentlich | Schnell |
| Differentiell | Täglich | Mittel |
| Inkrementell | Stündlich | Langsam |
### Aufbewahrung
```
Aufbewahrungsfristen
├── Täglich: 7 Tage
├── Wöchentlich: 4 Wochen
├── Monatlich: 12 Monate
└── Jährlich: 10 Jahre (gesetzlich)
```
---
## Schulung und Sensibilisierung
### Security-Awareness
```
Schulungsprogramm
├── Neue Mitarbeiter: Grundlagen
├── Jährlich: Auffrischung
├── Bei Bedarf: Spezialthemen
└── Phishing-Simulationen
```
### Themen
| Bereich | Inhalt |
|---------|--------|
| Passwörter | Starke Passwörter, 2FA |
| E-Mail | Phishing erkennen |
| Social Engineering | Betrugsversuche |
| Datenschutz | DSGVO-Grundlagen |
| Mobile Geräte | Sicherheitsrichtlinien |
---
## Querverweise
- [[LF4-02-Schutzmassnahmen|Zurück: Schutzmaßnahmen]]
- [[LF4-04-Datenschutz|Nächstes Thema: Datenschutz (DSGVO)]]
---
*Stand: 2024*

245
1-Ausbildungsjahr/LF4-IT-Sicherheit/LF4-04-Datenschutz.md Normal file
View File

@@ -0,0 +1,245 @@
# 4.4 Datenschutz (DSGVO)
## DSGVO - Grundlagen
Die **Datenschutz-Grundverordnung (DSGVO)** ist seit dem 25. Mai 2018 EU-weit gültig.
### Grundprinzipien
```
DSGVO - Grundsätze (Art. 5)
├── Rechtmäßigkeit, Transparenz
├── Zweckbindung
├── Datenminimierung
├── Richtigkeit
├── Speicherbegrenzung
└── Integrität und Vertraulichkeit
```
### Anwendungsbereich
| Bereich | Geltung |
|---------|---------|
| EU-Bürger | Weltweit |
| EU-Unternehmen | Weltweit |
| Drittland-Unternehmen | Bei Angebot in EU |
---
## Personenbezogene Daten
### Definition
> Alle Informationen, die sich auf eine **identifizierte** oder **identifizierbare** natürliche Person beziehen.
### Kategorien
| Kategorie | Beispiele |
|-----------|----------|
| Stammdaten | Name, Adresse, Geburtsdatum |
| Kontaktdaten | Telefon, E-Mail |
| Vertragsdaten | Kunden-Nr., Vertragsinhalt |
| Nutzungsdaten | Logfiles, Cookies |
| Gesundheitsdaten | Krankheit, Behinderung |
| Biometrische Daten | Fingerabdruck, Face ID |
| Politische Meinungen | Parteizugehörigkeit |
| Religiöse Überzeugung | Konfession |
### Besondere Kategorien
```
Art. 9 DSGVO - Besondere personenbezogene Daten
├── Gesundheitsdaten
├── Biometrische Daten
├── Politische Meinungen
├── Religiöse Überzeugung
├── Gewerkschaftszugehörigkeit
├── Ethnische Herkunft
├── Sexualleben
└── Strafrechtliche Verurteilungen
```
---
## Betroffenenrechte
### Rechte der Betroffenen
| Recht | Beschreibung |
|-------|-------------|
| **Auskunft** (Art. 15) | Informationen über verarbeitete Daten |
| **Berichtigung** (Art. 16) | Falsche Daten korrigieren |
| **Löschung** (Art. 17) | "Recht auf Vergessenwerden" |
| **Einschränkung** (Art. 18) | Verarbeitung sperren |
| **Datenübertragung** (Art. 20) | Daten in maschinenlesbarem Format |
| **Widerspruch** (Art. 21) | Widerspruch gegen Verarbeitung |
| **Automatisierte Entscheidungen** (Art. 22) | Keine rein automatisierten Entscheidungen |
### Informationspflichten
```
Art. 13, 14 DSGVO - Bei Erhebung mitzuteilen
├── Verantwortlicher
├── Datenschutzbeauftragter
├── Zweck der Verarbeitung
├── Rechtsgrundlage
├── Empfänger oder Kategorien
├── Speicherdauer
├── Betroffenenrechte
└── Beschwerderecht bei Behörde
```
---
## Verantwortliche
### Verantwortlicher
> Natürliche oder juristische Person, die über die **Zwecke und Mittel** der Verarbeitung entscheidet.
### Auftragsverarbeitung (Art. 28)
```
Auftragsverarbeiter (AV)
├── Externe Dienstleister (Cloud, Hosting)
├── Weisungsgebunden
├── Auftragsverarbeitungsvertrag (AVV) erforderlich
└── Kontroll- und Überwachungspflichten
```
### Datenschutzbeauftragter (DSB)
| Unternehmen | Pflicht |
|-------------|----------|
| > 20 Mitarbeiter | Pflicht |
| Verarbeitung besonderer Daten | Pflicht |
| Öffentliche Stelle | Immer |
---
## Technische und organisatorische Maßnahmen (TOM)
### Mindestanforderungen
```
Art. 32 DSGVO - Sicherheit der Verarbeitung
├── Pseudonymisierung
├── Verschlüsselung
├── Vertraulichkeit
├── Integrität
├── Verfügbarkeit
└── Rasche Wiederherstellbarkeit
```
### Beispiele für TOM
| Maßnahme | Beschreibung |
|----------|-------------|
| Zutrittskontrolle | Zugang zum Serverraum |
| Zugriffskontrolle | Berechtigungskonzept |
| Weitergabekontrolle | TLS-Verschlüsselung |
| Eingabekontrolle | Protokollierung |
| Verfügbarkeitskonzept | Backup, USV |
| Trennungsgebot | Test-/Produktivumgebung |
---
## Datenschutz-Folgenabschätzung (DSFA)
### Wann erforderlich?
```
Art. 35 DSGVO - Pflicht zur DSFA
├── Verarbeitung besonderer Kategorien
├── Umfangreiches Profiling
├── Systematisches Monitoring
├── Neue Technologien
└── Risikoreiche Verarbeitung
```
### Durchführung
```
DSFA-Schritte
1. Beschreibung der Verarbeitung
2. Bewertung der Erforderlichkeit
3. Risiken für Betroffene identifizieren
4. Maßnahmen zur Risikominimierung
5. Stellungnahme DSB
6. Dokumentation
```
---
## Datenschutzverletzungen
### Meldepflicht
```
Art. 33 DSGVO - Meldung an Behörde
├── Innerhalb von 72 Stunden
├── Beschreibung der Verletzung
├── Kategorien betroffener Daten
├── Anzahl Betroffener
├── Wahrscheinliche Folgen
└── Ergriffene Maßnahmen
```
### Benachrichtigungspflicht
```
Art. 34 DSGVO - Benachrichtigung Betroffener
├── Wenn hohe Risiken für Rechte
├── Sofortige Benachrich­tigung
└── In verständlicher Sprache
```
---
## Bußgeld und Strafen
### DSGVO-Bußgelder
```
Art. 83 DSGVO - Geldbußen
├── Bis zu 20 Mio. EUR oder
├── Bis zu 4% des weltweiten Jahresumsatzes
└── Je nach Schwere des Verstoßes
```
### Bußgeld-Kategorien
| Verstoß | Maximales Bußgeld |
|----------|-------------------|
| Grundprinzipien | 10 Mio. oder 2% |
| Rechte der Betroffenen | 10 Mio. oder 2% |
| Übermittlung in Drittland | 20 Mio. oder 4% |
| Sonstige Verstöße | 20 Mio. oder 4% |
---
## Checkliste Datenschutz
```
□ Verarbeitungsverzeichnis (Art. 30)
□ Datenschutzbeauftragter benannt (falls nötig)
□ Auftragsverarbeitungsverträge (Art. 28)
□ Technische Maßnahmen implementiert
□ Mitarbeiter geschult
□ Datenschutz-Folgenabschätzung (falls nötig)
□ Prozesse für Betroffenenrechte
□ Datenschutzerklärung auf Website
□ Verletzungsmanagement dokumentiert
```
---
## Querverweise
- [[LF4-03-Sicherheitskonzepte|Zurück: Sicherheitskonzepte]]
- [[LF3-Datenbanken|Datenbanken: Datensicherheit]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Rechtliche Grundlagen]]
---
*Stand: 2024*

183
1-Ausbildungsjahr/LF4-Schutzbedarfsanalyse/LF4-Notizen.md Normal file
View File

@@ -0,0 +1,183 @@
# LF 4: Schutzbedarfsanalyse im eigenen Arbeitsbereich durchführen
> **1. Ausbildungsjahr** | Zeitrichtwert: **40 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, mit Hilfe einer bestehenden Sicherheitsleitlinie eine Schutzbedarfsanalyse zur Ermittlung der Informationssicherheit auf Grundschutzniveau in ihrem Arbeitsbereich durchzuführen.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Die Schutzziele der Informationssicherheit erklären
- [ ] Rechtliche Regelungen zum Datenschutz anwenden (DSGVO, BDSG)
- [ ] Bedrohungen für IT-Systeme identifizieren
- [ ] Eine Schutzbedarfsanalyse durchführen
- [ ] Schutzmaßnahmen vorschlagen und umsetzen
- [ ] Den IT-Sicherheitsprozess reflektieren
---
## Schutzziele (CIA)
```
┌─────────────────────────────────────────────────────────────┐
│ SCHUTZZIELE │
├─────────────────┬─────────────────┬─────────────────────┤
│ VERTRAULICHKEIT │ INTEGRITÄT │ VERFÜGBARKEIT │
│ (Confidentiality)│ (Integrity) │ (Availability) │
├─────────────────┼─────────────────┼─────────────────────┤
│ Nur befugte │ Daten müssen │ Systeme und Daten │
│ Personen können │ korrekt und │ sind bei Bedarf │
│ Daten lesen │ unverändert │ verfügbar │
│ │ sein │ │
├─────────────────┴─────────────────┴─────────────────────┤
│ Weitere Schutzziele: │
│ - Authentizität (Echtheit nachweisen) │
│ - Verbindlichkeit (Nicht-Abstreitbarkeit) │
│ - Zurechenbarkeit (Rückverfolgbarkeit) │
└─────────────────────────────────────────────────────────────┘
```
---
## Bedrohungen
### Kategorien
| Kategorie | Beispiele |
|-----------|-----------|
| **Technisch** | Hardware-Ausfall, Software-Fehler, Malware |
| **Natürlich** | Hochwasser, Feuer, Blitzschlag |
| **Menschlich** | Fahrlässigkeit, Vorsatz, Social Engineering |
| **Organisatorisch** | Prozessfehler, Personalmangel |
### Häufige Angriffe
```
Angriffsvektoren:
├── Phishing
├── Ransomware
├── DDoS
├── SQL Injection
├── Cross-Site Scripting (XSS)
├── Man-in-the-Middle
├── Brute Force
└── Zero-Day-Exploits
```
---
## Schutzmaßnahmen
### Organisatorisch
- Sicherheitsrichtlinien
- Schulungen/Awareness
- Zugriffskontrollen
- Incident-Response-Prozess
### Technisch
- Firewall
- Antivirensoftware
- Verschlüsselung
- Backup/Recovery
- Updates/Patches
### Physisch
- Zutrittskontrolle
- Brandschutz
- USV (unterbrechungsfreie Stromversorgung)
---
## Rechtliche Grundlagen
### DSGVO (Datenschutz-Grundverordnung)
- seit 25.05.2018 wirksam
- Personenbezogene Daten schützen
- Betroffenenrechte stärken
- Bußgelder bis 20 Mio. € oder 4% des Jahresumsatzes
### BDSG (Bundesdatenschutzgesetz)
- Ergänzt DSGVO für Deutschland
- Regelungen für öffentliche Stellen
### Wichtige Begriffe
| Begriff | Erklärung |
|---------|-----------|
| **Personenbezogene Daten** | Alle Informationen, die sich auf eine identifizierte Person beziehen |
| **Verarbeitung** | Speichern, Übermitteln, Löschen, etc. |
| **Einwilligung** | Freiwillige, informierte Zustimmung |
| **Datenschutzbeauftragter** | Pflicht bei >20 Mitarbeitern mit Datenverarbeitung |
---
## BSI-Grundschutz
### Vorgehen
1. **Strukturanalyse**: IT-Systeme erfassen
2. **Schutzbedarfsfeststellung**: Schutzniveau bestimmen
3. **Modellierung**: Geeignete Bausteine auswählen
4. **Umsetzung**: Maßnahmen umsetzen
5. **Erprobung**: Basis-Check durchführen
### Schutzbedarfskategorien
| Kategorie | Normal | Hoch | Sehr Hoch |
|-----------|--------|------|-----------|
| Vertraulichkeit | begrenzt | erheblich | existenzbedrohend |
| Integrität | begrenzt | erheblich | existenzbedrohend |
| Verfügbarkeit | begrenzt | erheblich | existenzbedrohend |
---
## Verschlüsselung
### Symmetrisch
- Ein Schlüssel für Ver- und Entschlüsselung
- Bsp.: AES, DES, 3DES
- Schnell, aber Schlüsselaustausch problematisch
### Asymmetrisch
- Schlüsselpaar: öffentlich + privat
- Bsp.: RSA, ECC
- Langsamer, sicherer Schlüsselaustausch
### Hybride Verfahren
- Asymmetrisch für Schlüsselaustausch
- Symmetrisch für Datenverschlüsselung
- Bsp.: TLS/SSL, PGP
---
## Handlungsphasen
1. **Informieren**: Sicherheitsleitlinie, Schutzziele
2. **Planen**: Schutzbedarfsanalyse vorbereiten
3. **Durchführen**: Analyse durchführen, Maßnahmen ableiten
4. **Überprüfen**: Ergebnisse bewerten
5. **Reflektieren**: Prozess bewerten
---
## Prüfungsrelevanz
- Wichtiges Grundlagen-Lernfeld für IT-Sicherheit
- Wird in Teil 1 und Teil 2 der Prüfung vorausgesetzt
- Basis für LF 11b/d (Betrieb und Sicherheit vernetzter Systeme)
---
## Querverweise
- [[LF3-Netzwerke-einbinden|Vorher: LF 3]]
- [[LF5-Datenbanken-anpassen|Nachher: LF 5]]
- [[IT-Sicherheit|Vertiefung IT-Sicherheit]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

45
1-Ausbildungsjahr/LF5-Analyse-Design/LF5-00-Übersicht.md Normal file
View File

@@ -0,0 +1,45 @@
# Lernfeld 5: Softwareentwicklung analysieren und planen
## Übersicht
Dieses Lernfeld behandelt die Analyse und Planung von Softwareprojekten.
## Themen
| Nr. | Thema | Beschreibung |
|-----|-------|-------------|
| 5.1 | [[LF5-01-Anforderungsanalyse|Anforderungsanalyse]] | Anforderungen erheben und dokumentieren |
| 5.2 | [[LF5-02-Softwaremodellierung|Softwaremodellierung]] | UML, Struktogramme, Flussdiagramme |
| 5.3 | [[LF5-03-Programmierung|Programmierung]] | Algorithmen, Datenstrukturen |
| 5.4 | [[LF5-04-Testverfahren|Testverfahren]] | Unit Tests, Integrationstests |
## Lernziele
- Anforderungen analysieren und dokumentieren
- Softwaremodelle erstellen
- Algorithmen entwickeln
- Tests planen und durchführen
## Voraussetzungen
- LF1: Unternehmen und Rolle
- LF2: Arbeitsplätze ausstatten
- LF3: Datenbanken entwickeln
- LF4: IT-Sicherheit
## Prüfungsrelevanz
- Teil 1 Abschlussprüfung (schriftlich)
- Teil 2 Abschlussprüfung (praktisch)
---
## Querverweise
- [[LF4-04-Datenschutz|Zurück: Datenschutz (DSGVO)]]
- [[LF6-Webanwendungen|Nächstes Lernfeld: Webanwendungen entwickeln]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Projektmanagement]]
---
*Stand: 2024*

220
1-Ausbildungsjahr/LF5-Analyse-Design/LF5-01-Anforderungsanalyse.md Normal file
View File

@@ -0,0 +1,220 @@
# 5.1 Anforderungsanalyse
## Anforderungsmanagement
### Was sind Anforderungen?
```
Anforderungen - Definition
Anforderung = Bedürfnis oder Erwartung eines Stakeholders
```
### Arten von Anforderungen
```
Anforderungstypen
├── Funktionale Anforderungen
│ └── Was das System tun muss
└── Nicht-funktionale Anforderungen
└── Qualitätsanforderungen (Performance, Sicherheit, etc.)
```
---
## Funktionale Anforderungen
### Beispiele
| Anforderung | Beschreibung |
|-------------|-------------|
| F01 | Das System muss Benutzer anmelden können |
| F02 | Das System muss Daten speichern können |
| F03 | Das System muss Berichte erstellen können |
### Anforderungskategorien
```
Funktionale Anforderungen
├── Geschäftsregeln
├── Schnittstellen
├── Datenverarbeitung
├── Reporting
└── Administrationsfunktionen
```
---
## Nicht-funktionale Anforderungen
### Kategorien
| Kategorie | Beschreibung | Beispiele |
|-----------|-------------|----------|
| **Performance** | Geschwindigkeit | < 2 Sek. Ladezeit |
| **Skalierbarkeit** | Wachstum | 1000 Benutzer |
| **Verfügbarkeit** | Laufzeit | 99,9% |
| **Sicherheit** | Schutz | TLS-Verschlüsselung |
| **Benutzerfreundlichkeit** | Bedienung | Intuitiv |
| **Wartbarkeit** | Änderungen | Modulare Struktur |
| **Kompatibilität** | Plattformen | Windows, macOS, Linux |
---
## Anforderungen erheben
### Methoden
```
Erhebungsmethoden
├── Interviews
├── Workshops
├── Beobachtung
├── Dokumentenanalyse
├── Fragebögen
└── Prototyping
```
### Interview-Leitfaden
```
Interview-Vorbereitung
├── Ziele definieren
├── Fragen vorbereiten
├── Teilnehmer auswählen
├── Zeitrahmen planen
└── Dokumentation vorbereiten
```
### Fragetechniken
| Fragetyp | Beispiel | Zweck |
|----------|---------|-------|
| Offen | "Wie arbeiten Sie heute?" | Verständnis |
| Geschlossen | "Welches System nutzen Sie?" | Fakten |
| Zurückfragend | "Warum ist das wichtig?" | Tiefe |
| Hypothetisch | "Was würde passieren, wenn...?" | Szenarien |
---
## Anforderungen dokumentieren
### Lastenheft (Requirements Specification)
```markdown
# Lastenheft - Projekt [Name]
## 1. Zielsetzung
[Beschreibung des Projekts]
## 2. Funktionale Anforderungen
- F01: [Beschreibung]
- F02: [Beschreibung]
## 3. Nicht-funktionale Anforderungen
- NF01: [Beschreibung]
- NF02: [Beschreibung]
## 4. Schnittstellen
- [Externe Systeme]
## 5. Abnahmekriterien
- [Testfälle]
```
### User Stories
```
User Story - Format
Als [Rolle] möchte ich [Ziel], um [Nutzen].
Beispiel:
Als Kunde möchte ich mein Passwort zurücksetzen,
um wieder Zugriff auf mein Konto zu haben.
```
### User Story - Akzeptanzkriterien
```markdown
User Story: Passwort zurücksetzen
Akzeptanzkriterien:
- [ ] E-Mail-Adresse wird validiert
- [ ] Link ist 24 Stunden gültig
- [ ] Neues Passwort muss Mindestlänge haben
- [ ] Bestätigungs-E-Mail wird gesendet
- [ ] Nach Reset ist Login möglich
```
---
## Anforderungen priorisieren
### Priorisierungsmethoden
```
Priorisierungs-Methoden
├── MoSCoW-Methode
├── Kano-Modell
├── WSJF (Weighted Shortest Job First)
└── Stack Ranking
```
### MoSCoW-Methode
| Priorität | Bedeutung | Beispiel |
|-----------|-----------|----------|
| **Must have** | Unbedingt erforderlich | Login |
| **Should have** | Sehr wichtig | Passwort vergessen |
| **Could have** | Wünschenswert | Dark Mode |
| **Won't have** | Dieses Release nicht | Export PDF |
---
## Anforderungen validieren
### Prüfkriterien
```
Anforderungsprüfung - Checkliste
├── Vollständig?
├── Konsistent?
├── Realisierbar?
├── Testbar?
├── Verständlich?
└── Abgestimmt?
```
### Review-Prozess
```
Anforderungsreview
├── Peer-Review
├── Stakeholder-Abnahme
├── Änderungsmanagement
└── Versionierung
```
---
## Werkzeuge
### Anforderungsmanagement-Tools
| Tool | Typ | Einsatz |
|------|-----|---------|
| Jira | Professionell | Große Projekte |
| Azure DevOps | Professionell | Microsoft-Umgebung |
| YouTrack | Professionell | Flexible Projekte |
| Trello | Einfach | Kanban-Boards |
| Markdown | Einfach | Dokumentation |
---
## Querverweise
- [[LF5-02-Softwaremodellierung|Nächstes Thema: Softwaremodellierung]]
- [[LF2-01-Kundenanforderungen|Kundengespräch]]
---
*Stand: 2024*

335
1-Ausbildungsjahr/LF5-Analyse-Design/LF5-02-Softwaremodellierung.md Normal file
View File

@@ -0,0 +1,335 @@
# 5.2 Softwaremodellierung
## Modellierungssprachen
### Übersicht
```
Modellierung - Sprachen
├── UML (Unified Modeling Language)
├── Struktogramme (Nassi-Shneiderman)
├── Flussdiagramme (Flowcharts)
├── Entity-Relationship (ER)
└── Aktivitätsdiagramme
```
---
## UML - Unified Modeling Language
### UML-Diagrammtypen
```
UML 2.5 - Diagrammübersicht
├── Strukturdiagramme
│ ├── Klassendiagramm
│ ├── Objektdiagramm
│ ├── Komponentendiagramm
│ ├── Verteilungsdiagramm
│ └── Paketdiagramm
└── Verhaltensdiagramme
├── Anwendungsfalldiagramm
├── Aktivitätsdiagramm
├── Zustandsdiagramm
└── Sequenzdiagramm
```
---
## Klassendiagramm
### Elemente
```
Klassendiagramm - Symbole
┌─────────────────────────┐
│ Klassenname │
├─────────────────────────┤
│ - attribut: Typ │ ← Eigenschaften
├─────────────────────────┤
│ + methode(): Rückgabetyp│ ← Methoden
└─────────────────────────┘
Sichtbarkeit:
+ public (öffentlich)
- private (privat)
# protected (geschützt)
~ package (Paket)
```
### Beziehungen
```
Beziehungsarten
├── Assoziation ───────
├── Aggregation ◇─────── (hat ein, kann auch ohne existieren)
├── Komposition ◆────── (hat ein, existiert nicht ohne)
├── Vererbung △───────
└── Implementierung ▷───
```
### Beispiel
```
┌─────────────┐ ┌─────────────┐
│ Kunde │ 1 * │ Bestellung │
├─────────────┤─────────│─────────────┤
│ -name │* │ -datum │
│ -adresse │ │ -status │
├─────────────┤ ├─────────────┤
│ +bestellen()│ │ +erstellen()│
└─────────────┘ └─────────────┘
```
---
## Anwendungsfalldiagramm (Use Case)
### Elemente
```
Anwendungsfall-Diagramm
┌─────────────┐
│ Akteur │
└──────┬──────┘
│
│ (Verbindung)
▼
┌─────────────────┐
│ Anwendungsfall │
└─────────────────┘
```
### Beispiel
```
┌────────┐
│ Kunde │
└────┬───┘
│
┌────┴────┐
│ │
▼ ▼
┌─────────┐ ┌─────────────────┐
│ Suchen │ │ Bestellen │
└─────────┘ └─────────────────┘
│
┌───┴───┐
│ │
▼ ▼
┌────────┐ ┌──────────┐
│ Bezahlen│ │ Zurückgeben│
└────────┘ └──────────┘
```
---
## Aktivitätsdiagramm
### Elemente
```
Aktivitätsdiagramm - Symbole
┌─────────┐ ◇──────►
│ Start │ (Objekt)
└─────────┘
▭ Entscheidung ▢ Parallel
┌─────────┐ ╱ ╲
│ Aktion │ ╱ Merge ╲
└─────────┘ ╲ ╱
┌─────────┐
│ Ende │
└─────────┘
```
### Beispiel
```
▭
▼
┌───────────┐
│ Bestellung │
│ starten │
└─────┬─────┘
│
▼
┌───────────┐
│ Ware │
│ verfügbar?│
└─────┬─────┘
│
╱ ╲
Ja Nein
╲ ╱
▼ ▼
┌────────┐ ┌──────────┐
│Liefern │ │Benachrich-│
│ │ │tigen │
└───┬────┘ └────┬─────┘
│ │
└─────┬─────┘
▼
┌────────┐
│ Ende │
└────────┘
```
---
## Sequenzdiagramm
### Elemente
```
Sequenzdiagramm - Elemente
┌──────┐ ┌──────┐
│ Actor│ │ System│
└──┬───┘ └──┬───┘
│ │
│ Nachricht ──►
│ │
│ ◄─────── Rückmeldung
│ │
```
### Beispiel
```
┌────────┐ ┌────────┐ ┌────────┐
│ Client │ │ Server │ │ Daten- │
│ │ │ │ │ bank │
└───┬────┘ └───┬────┘ └───┬────┘
│ │ │
│──Login()───►│ │
│ │──Query()───►│
│ │◄─────────── │
│◄─────────── │ │
│ │ │
```
---
## Struktogramme (Nassi-Shneiderman)
### Grundelemente
```
Struktogramme
┌──────────────────┐
│ Anweisung │ ← einfache Anweisung
└──────────────────┘
┌──────────────────┐
│ Verzweigung │
│ │
│ Wenn Bedingung │
│ dann Anweisung │
│ sonst Anweisung│
└──────────────────┘
┌──────────────────┐
│ Schleife │
│ │
│ solange Bed. │
│ Anweisung │
└──────────────────┘
```
### Beispiel
```
┌──────────────────────────────────────┐
│ Eingegebene Zahl ist negativ? │
├──────────────────────────────────────┤
│ JA NEIN │
│ │ │ │
│ ┌─────┴─────┐ ┌────┴────┐ │
│ │ "Zahl ist │ │ "Zahl │ │
│ │ negativ" │ │ ist pos.│ │
│ └───────────┘ └─────────┘ │
└──────────────────────────────────────┘
```
---
## Flussdiagramme (Flowchart)
### Symbole
```
Flussdiagramm - Symbole
┌─────────┐
│ Oval │ → Start/Ende
└─────────┘
┌─────────┐
│ Rechteck│ → Aktion/Prozess
└─────────┘
┌────┐
│Raute│ → Entscheidung
└────┘
→ → Verbindungslinie
```
### Beispiel
```
┌───────┐
│ Start │
└───┬───┘
│
▼
┌────────┐
│ Zahl │
│ einlesen│
└───┬────┘
│
▼
┌───────────┐
│negativ? │
└─────┬─────┘
╱ ╲
Ja Nein
╲ ╱
▼ ▼
┌─────────┐ ┌─────────┐
│ negativ │ │ positiv │
└────┬────┘ └────┬────┘
│ │
└─────┬──────┘
▼
┌───────┐
│ Ende │
└───────┘
```
---
## Werkzeuge
### Modellierungs-Tools
| Tool | Typ | Plattform |
|------|-----|----------|
| PlantUML | Text-basiert | Alle |
| Mermaid | Text-basiert | Alle |
| draw.io | Visuell | Web |
| Lucidchart | Professionell | Web |
| Enterprise Architect | Professionell | Windows |
| Visual Paradigm | Professionell | Alle |
---
## Querverweise
- [[LF5-01-Anforderungsanalyse|Zurück: Anforderungsanalyse]]
- [[LF5-03-Programmierung|Nächstes Thema: Programmierung]]
---
*Stand: 2024*

302
1-Ausbildungsjahr/LF5-Analyse-Design/LF5-03-Programmierung.md Normal file
View File

@@ -0,0 +1,302 @@
# 5.3 Programmierung
## Algorithmen
### Was ist ein Algorithmus?
> Ein **Algorithmus** ist eine endliche Folge von eindeutigen Anweisungen zur Lösung eines Problems.
### Eigenschaften
```
Algorithmus-Eigenschaften
├── Endlichkeit → Endlich viele Schritte
├── Eindeutigkeit → Jeder Schritt klar definiert
├── Ausführbarkeit → Jeder Schritt ausführbar
├── Terminiertheit → Algorithmus endet
└── Korrektheit → Liefert richtiges Ergebnis
```
---
## Grundlegende Programmstrukturen
### Sequenz
```
Anweisungen werden nacheinander ausgeführt
Schritt 1
↓
Schritt 2
↓
Schritt 3
```
### Selektion (Verzweigung)
```
Wenn-Dann-Sonst
┌───────────────┐
│ Bed. erfüllt? │
└───────┬───────┘
╱ ╲
Ja Nein
╲ ╱
▼ ▼
┌────────┐ ┌────────┐
│ Block A│ │ Block B│
└────────┘ └────────┘
```
### Iteration (Schleife)
```
Wiederholung
┌───────────────┐
│ Bedingung │
└───────┬───────┘
╱ ╲
wahr falsch
╲ ╱
▼ ▼
┌─────────┐ ┌──────┐
│ Block │──►│ Ende │
│ ausführen│ └──────┘
└─────────┘
```
---
## Datenstrukturen
### Grundlegende Datentypen
| Typ | Beispiel | Speicher |
|-----|----------|----------|
| Integer | 42 | 4 Byte |
| Float | 3.14 | 8 Byte |
| Boolean | true/false | 1 Byte |
| Char | 'A' | 1 Byte |
| String | "Hallo" | variabel |
### Arrays
```
Array - eindimensional
[0] [1] [2] [3] [4]
10 20 30 40 50
Zugriff: array[2] → 30
```
### Listen
```
Liste - dynamisch
Liste<String> namen = ["Max", "Anna", "Peter"]
Operationen:
- add(Element) → Hinzufügen
- remove(Index) → Entfernen
- get(Index) → Abrufen
- size() → Größe
```
### Schlüssel-Wert-Paare (Dictionary/Map)
```
Map - Schlüssel-Wert
{
"Name": "Max",
"Alter": 25,
"Stadt": "Berlin"
}
```
---
## Algorithmen
### Suchen
#### Lineare Suche
```
Suche in ungeordneter Liste
Schleife durch alle Elemente
→ O(n) Zeitkomplexität
```
#### Binäre Suche
```
Suche in sortierter Liste
Teile und Herrsche
→ O(log n) Zeitkomplexität
```
### Sortieren
#### Bubble Sort
```
Vergleiche benachbarte Elemente
Tausche wenn in falscher Reihenfolge
Beispiel:
[5, 3, 8, 1] → [3, 5, 1, 8] → [3, 1, 5, 8] → ...
→ O(n²) Zeitkomplexität
```
#### Quick Sort
```
Pivot-Element wählen
Kleine links, große rechts
Rekursiv wiederholen
→ O(n log n) Durchschnitt
```
---
## Komplexität
### Big O Notation
| Notation | Name | Beispiel |
|----------|------|----------|
| O(1) | Konstant | Array-Zugriff |
| O(log n) | Logarithmisch | Binäre Suche |
| O(n) | Linear | Lineare Suche |
| O(n log n) | Linearithmisch | Quick Sort |
| O(n²) | Quadratisch | Bubble Sort |
| O(2^n) | Exponentiell | Brute Force |
---
## Programmiersprachen
### Übersicht
| Sprache | Typ | Einsatz |
|---------|-----|----------|
| **Python** | Interpretiert | Data Science, Web |
| **Java** | Kompiliert | Enterprise |
| **JavaScript** | Interpretiert | Web, Frontend |
| **C#** | Kompiliert | Windows, .NET |
| **C/C++** | Kompiliert | Systemnah |
### Sprachkonzepte
```
Programmierparadigmen
├── Imperativ → Anweisungen
├── Prozedural → Funktionen
├── Objektorientiert → Klassen/Objekte
├── Funktional → Funktionen ohne Zustand
└── Logisch → Regeln und Fakten
```
---
## Objektorientierte Programmierung (OOP)
### Grundkonzepte
```
OOP - Prinzipien
├── Kapselung (Encapsulation)
├── Vererbung (Inheritance)
├── Polymorphie
└── Abstraktion
```
### Klasse und Objekt
```python
# Klasse (Bauplan)
class Auto:
# Konstruktor
def __init__(self, marke, farbe):
self.marke = marke
self.farbe = farbe
self.geschwindigkeit = 0
# Methode
def beschleunigen(self, wert):
self.geschwindigkeit += wert
def __str__(self):
return f"{self.marke}, {self.farbe}"
# Objekt (Instanz)
mein_auto = Auto("BMW", "rot")
mein_auto.beschleunigen(50)
```
### Vererbung
```python
class Tier:
def __init__(self, name):
self.name = name
def essen(self):
print("Tier isst")
class Hund(Tier): # Vererbung
def bellen(self):
print("Wuff!")
hund = Hund("Bello")
hund.essen() # Von Tier geerbt
hund.bellen() # Eigene Methode
```
---
## Qualitätskriterien
### Clean Code Prinzipien
```
Gute Software
├── Lesbarkeit → Gut verständlich
├── Wartbarkeit → Einfach zu ändern
├── Effizienz → Schnell genug
├── Zuverlässigkeit → Keine Fehler
└── Sicherheit → Vor Angriffen geschützt
```
### Namenskonventionen
```
Variablen: camelCase
meinName = "Max"
Konstanten: UPPER_CASE
MAX_ALTER = 100
Funktionen: camelCase
def holeDaten():
Klassen: PascalCase
class Benutzer:
```
---
## Querverweise
- [[LF5-02-Softwaremodellierung|Zurück: Softwaremodellierung]]
- [[LF5-04-Testverfahren|Nächstes Thema: Testverfahren]]
- [[LF4-01-Gefahren-Analyse|Sicherheit: Sichere Programmierung]]
---
*Stand: 2024*

274
1-Ausbildungsjahr/LF5-Analyse-Design/LF5-04-Testverfahren.md Normal file
View File

@@ -0,0 +1,274 @@
# 5.4 Testverfahren
## Softwaretests - Grundlagen
### Warum testen?
```
Testziele
├── Fehler finden
├── Qualität sichern
├── Vertrauen schaffen
├── Risiken minimieren
└── Dokumentation
```
### Testprinzipien
```
Grundsätze des Testens
├── Vollständig unmöglich → 100% Test nicht möglich
├── Frühzeitig → Tests von Anfang an
├── Defektclustering → Fehler häufen sich
├── Pestizid-Paradox → Tests wiederholen
├── Fehlerfreiheitsirrtum → Keine Fehler ≠ Qualität
└── Kontextabhängig → Projektabhängig
```
---
## Testarten
### Nach Sichtweise
| Testart | Beschreibung |
|---------|-------------|
| **White Box** | Inneres bekannt, strukturbasiert |
| **Black Box** | Inneres unbekannt, funktional |
| **Gray Box** | Teilweise bekannt |
### Nach Zeitpunkt
```
Testphasen
├── Statische Tests (vor Ausführung)
│ └── Code-Review, Analyse
└── Dynamische Tests (bei Ausführung)
└── Unit, Integration, System, Abnahme
```
---
## Teststufen
### Pyramide
```
Testpyramide
╱╲
╱ ╲ End-to-End (wenige)
╱────╲
╱ ╲ Integration (mittel)
╱────────╲
╱ ╲ Unit-Tests (viele)
╱────────────╲
```
### Unit Tests
> Test einzelner Funktionen/Klassen
```python
import unittest
class TestRechner(unittest.TestCase):
def test_addition(self):
ergebnis = addieren(2, 3)
self.assertEqual(ergebnis, 5)
def test_division_durch_null(self):
with self.assertRaises(ZeroDivisionError):
dividieren(10, 0)
if __name__ == '__main__':
unittest.main()
```
### Integrationstests
> Test der Zusammenarbeit von Komponenten
```
Integration - Strategien
├── Big Bang → Alles gleichzeitig
├── Top-Down → Oberste Ebene zuerst
├── Bottom-Up → Unterste Ebene zuerst
└── Sandwich → Beide Richtungen
```
### Systemtests
> Test des gesamten Systems
```
Systemtest - Prüfbereiche
├── Funktionale Anforderungen
├── Nicht-funktionale Anforderungen
├── Schnittstellen
├── Datenintegration
└── Performance
```
### Abnahmetests
> Test durch den Kunden
```
Abnahmetest - Arten
├── Alpha (beim Hersteller)
├── Beta (bei Anwendern)
└── Operational (im Echtbetrieb)
```
---
## Testmethoden
### Black-Box-Tests
```
Techniken
├── Äquivalenzklassen
├── Grenzwertanalyse
├── Entscheidungstabellen
├── Zustandsübergänge
└── Anwendungsfall-basiert
```
### Äquivalenzklassen
```
Beispiel: Alterseingabe (0-120)
Gültige Klasse: 0 bis 120
Ungültige Klassen: < 0, > 120
Testfälle:
- 25 (gültig)
- 0 (Grenzwert)
- 120 (Grenzwert)
- -1 (ungültig)
- 121 (ungültig)
```
### White-Box-Tests
```
Techniken
├── Anweisungsabdeckung
├── Zweigabdeckung
├── Pfadabdeckung
└── Bedingungsabdeckung
```
---
## Testmanagement
### Testplan
```markdown
# Testplan - [Projekt]
## 1. Testobjekt
[Was wird getestet]
## 2. Testumgebung
[System, Tools]
## 3. Testfälle
| ID | Beschreibung | Erwartung |
|----|--------------|-----------|
| T1 | Login gültig | Erfolg |
| T2 | Login ungültig | Fehler |
## 4. Zeitplan
[Termine]
## 5. Kriterien
[Abnahme]
```
### Testfall-Struktur
```
Testfall - Elemente
├── Testfall-ID
├── Titel/Beschreibung
├── Vorbedingungen
├── Testschritte
├── Erwartetes Ergebnis
├── Tatsächliches Ergebnis
├── Status (Pass/Fail)
└── Tester
```
---
## Testautomatisierung
### Werkzeuge
| Zweck | Tools |
|-------|-------|
| Unit Tests | JUnit (Java), pytest (Python), NUnit (.NET) |
| UI Tests | Selenium, Playwright, Cypress |
| API Tests | Postman, RestAssured |
| Lasttests | JMeter, k6 |
### Beispiel: pytest
```python
# test_calculator.py
import pytest
def test_addition():
assert add(2, 3) == 5
def test_subtraktion():
assert sub(5, 3) == 2
@pytest.mark.parametrize("a,b,expected", [
(1, 1, 2),
(0, 0, 0),
(-1, 1, 0),
])
def test_add_param(a, b, expected):
assert add(a, b) == expected
```
---
## Fehlermanagement
### Fehlerverfolgung
```
Fehlerlebenszyklus
Neu → Bestätigt → In Bearbeitung → Gelöst → Geschlossen
↓
Abgelehnt
```
### Fehlerprioritäten
| Priorität | Beschreibung | Reaktionszeit |
|-----------|-------------|---------------|
| Kritisch | System nicht nutzbar | Sofort |
| Hoch | Wichtige Funktion | 24h |
| Mittel | Kleinere Probleme | 1 Woche |
| Niedrig | kosmetisch | Bei Zeit |
---
## Querverweise
- [[LF5-03-Programmierung|Zurück: Programmierung]]
- [[LF6-Webanwendungen|Nächstes Lernfeld: Webanwendungen]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Qualitätsmanagement]]
---
*Stand: 2024*

253
1-Ausbildungsjahr/LF5-Datenbanken-anpassen/LF5-Notizen.md Normal file
View File

@@ -0,0 +1,253 @@
# LF 5: Software zur Verwaltung von Daten anpassen
> **1. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, Informationen mittels Daten abzubilden, diese Daten zu verwalten und dazu Software anzupassen.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Informationen als Daten abbilden und strukturieren
- [ ] Datenbankmodelle unterscheiden und anwenden
- [ ] ER-Diagramme erstellen
- [ ] SQL-Abfragen erstellen und ausführen
- [ ] Datenformate unterscheiden
- [ ] Software zur Datenverwaltung anpassen
- [ ] Testfälle entwickeln und Tests durchführen
---
## Datenbank-Grundlagen
### Datenbankmodelle
```
Datenbankmodelle
├── Hierarchisch
├── Netzwerkartig
├── Relational (am häufigsten)
├── Objektorientiert
└── NoSQL
```
### Relationales Datenbankmodell
**Grundbegriffe:**
| Begriff | Erklärung |
|---------|-----------|
| **Tabelle (Relation)** | Sammlung von Datensätzen |
| **Spalte (Attribut)** | Eigenschaft eines Datensatzes |
| **Zeile (Tupel)** | Ein Datensatz |
| **Primärschlüssel** | Eindeutige Identifikation |
| **Fremdschlüssel** | Verweis auf andere Tabelle |
---
## ER-Diagramm (Entity-Relationship)
### Elemente
```
┌─────────────┐ ┌─────────────┐
│ Entity │ │ Entity │
│ (Typ) │ │ (Typ) │
├─────────────┤ ├─────────────┤
│ Attribute │ │ Attribute │
│ PK: id │ │ PK: id │
└─────┬───────┘ └──────┬──────┘
│ N │ M
│ │
└──────────┬───────────┘
│
┌──────┴──────┐
│ Relationship │
│ (Beziehung) │
└──────────────┘
```
### Beziehungsgrade
- **1:1** (One-to-One)
- **1:N** (One-to-Many) - am häufigsten
- **M:N** (Many-to-Many)
---
## Normalisierung
### Normalformen
| NF | Regel | Ziel |
|----|-------|------|
| 1NF | Atomare Werte | Keine wiederholenden Gruppen |
| 2NF | Keine partielle Abhängigkeit | Vollständige funktionale Abhängigkeit vom PK |
| 3NF | Keine transitiven Abhängigkeiten | Keine Abhängigkeiten zwischen Nicht-Schlüsselattributen |
### Beispiel: 1NF → 2NF
**Nicht normalisiert:**
```
Bestellung(BestellID, Kunde, {Artikel, Menge})
```
**Normalisiert (1NF/2NF):**
```
Bestellung(BestellID, Kunde)
Bestellposition(BestellID, Artikel, Menge)
```
---
## SQL (Structured Query Language)
### DDL (Data Definition Language)
```sql
-- Tabelle erstellen
CREATE TABLE Kunde (
KundenID INT PRIMARY KEY,
Name VARCHAR(100) NOT NULL,
Email VARCHAR(255) UNIQUE,
ErstelltAm DATETIME DEFAULT CURRENT_TIMESTAMP
);
-- Tabelle ändern
ALTER TABLE Kunde ADD Telefon VARCHAR(20);
-- Tabelle löschen
DROP TABLE Kunde;
```
### DML (Data Manipulation Language)
```sql
-- Daten einfügen
INSERT INTO Kunde (Name, Email)
VALUES ('Max Mustermann', 'max@example.com');
-- Daten aktualisieren
UPDATE Kunde
SET Email = 'neue@email.de'
WHERE KundenID = 1;
-- Daten löschen
DELETE FROM Kunde WHERE KundenID = 1;
-- Daten abfragen
SELECT * FROM Kunde;
```
### DQL (Data Query Language)
```sql
-- Einfache Abfrage
SELECT Name, Email FROM Kunde;
-- Mit Bedingung
SELECT * FROM Kunde
WHERE Name LIKE 'M%'
ORDER BY Name ASC;
-- Mit JOIN
SELECT b.BestellID, k.Name, a.Artikelname
FROM Bestellung b
JOIN Kunde k ON b.KundenID = k.KundenID
JOIN Bestellposition bp ON b.BestellID = bp.BestellID
JOIN Artikel a ON bp.ArtikelID = a.ArtikelID;
-- Aggregatfunktionen
SELECT COUNT(*) AS Anzahl,
SUM(Betrag) AS Gesamt
FROM Bestellung
WHERE YEAR(Datum) = 2024;
```
---
## Datenformate
### Strukturierte Daten
| Format | Beschreibung |
|--------|--------------|
| CSV | Komma-separierte Werte |
| JSON | JavaScript Object Notation |
| XML | eXtensible Markup Language |
| YAML | YAML Ain't Markup Language |
### Beispiel: CSV
```csv
ID;Name;Email
1;Max Mustermann;max@example.com
2;Anna Schmidt;anna@example.com
```
### Beispiel: JSON
```json
{
"kunden": [
{
"id": 1,
"name": "Max Mustermann",
"email": "max@example.com"
}
]
}
```
---
## Software-Anpassung
### Vorgehen
1. **Anforderungen analysieren**
2. **Datenmodell erweitern**
3. **SQL-Skripte erstellen**
4. **Anwendung anpassen**
5. **Testfälle definieren**
6. **Testen und dokumentieren**
### Testmethoden
- **Unit-Tests**: Einzelne Komponenten testen
- **Integrationstests**: Zusammenspiel testen
- **Systemtests**: Gesamtsystem testen
- **Abnahmetests**: Mit Kunden testen
---
## Handlungsphasen
1. **Informieren**: Daten analysieren, Anforderungen erheben
2. **Planen**: Datenmodell entwerfen, Testfälle definieren
3. **Durchführen**: Software anpassen, Tests durchführen
4. **Überprüfen**: Funktion prüfen, Qualität sichern
5. **Reflektieren**: Prozess evaluieren
---
## Prüfungsrelevanz
- Fundament für LF 8 (Daten bereitstellen)
- Wichtig für Teil 1 der Abschlussprüfung
- SQL-Kenntnisse werden vorausgesetzt
---
## Querverweise
- [[LF4-Schutzbedarfsanalyse|Vorher: LF 4]]
- [[LF8-Daten-bereitstellen|Nachher: LF 8]]
- [[Datenbanken|Datenbanken-Vertiefung]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

42
1-Ausbildungsjahr/LF6-Webanwendungen/LF6-00-Übersicht.md Normal file
View File

@@ -0,0 +1,42 @@
# Lernfeld 6: Webanwendungen entwickeln
## Übersicht
Dieses Lernfeld behandelt die Entwicklung von Webanwendungen.
## Themen
| Nr. | Thema | Beschreibung |
| --- | --- | --- |
| 6.1 | [[LF6-01-Web-Grundlagen]] | HTTP, HTML, CSS |
| 6.2 | [[LF6-02-Frontend]] | JavaScript, Frameworks |
| 6.3 | [[LF6-03-Backend]] | Server, APIs, Datenbanken |
| 6.4 | [[LF6-04-Sicherheit-Web]] | XSS, CSRF, SQL Injection |
## Lernziele
- Webanwendungen entwickeln
- Frontend und Backend verbinden
- Sicherheitslücken erkennen und vermeiden
## Voraussetzungen
- LF3: Datenbanken
- LF4: IT-Sicherheit
- LF5: Analyse und Design
## Prüfungsrelevanz
- Teil 2 Abschlussprüfung (praktisch)
---
## Querverweise
- [[LF5-04-Testverfahren|Zurück: Testverfahren]]
- [[LF9-Netzwerke-Dienste|Nächstes Lernfeld: Netzwerke]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: E-Commerce]]
---
*Stand: 2024*

225
1-Ausbildungsjahr/LF6-Webanwendungen/LF6-01-Web-Grundlagen.md Normal file
View File

@@ -0,0 +1,225 @@
# 6.1 Web-Grundlagen
## Internet und WWW
### Grundbegriffe
```
Internet - Netzwerk der Netzwerke
WWW (World Wide Web) - Dienst im Internet
```
### Funktionsweise
```
Client-Server-Modell
┌─────────┐ ┌─────────┐
│ Browser │ ───────►│ Server │
│ (Client)│ ◄───────│ │
└─────────┘ └─────────┘
```
---
## HTTP - Hypertext Transfer Protocol
### HTTP-Ablauf
```
HTTP - Kommunikation
1. Client sendet Request
2. Server verarbeitet
3. Server sendet Response
```
### HTTP-Methoden
| Methode | Beschreibung | idempotent |
|---------|-------------|------------|
| **GET** | Daten abrufen | Ja |
| **POST** | Daten senden | Nein |
| **PUT** | Daten ersetzen | Ja |
| **PATCH** | Daten teilweise ändern | Nein |
| **DELETE** | Daten löschen | Ja |
### HTTP-Statuscodes
| Code | Bedeutung | Beispiel |
|------|-----------|----------|
| **200** | OK | Erfolgreich |
| **201** | Created | Erstellt |
| **301** | Moved Permanently | Umleitung |
| **400** | Bad Request | Fehlerhafte Anfrage |
| **401** | Unauthorized | Nicht angemeldet |
| **403** | Forbidden | Keine Berechtigung |
| **404** | Not Found | Nicht gefunden |
| **500** | Internal Server Error | Serverfehler |
### HTTPS
```
HTTPS = HTTP + TLS-Verschlüsselung
Vorteile:
├── Vertraulichkeit
├── Integrität
└── Authentifizierung
```
---
## HTML - HyperText Markup Language
### Grundstruktur
```html
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8">
<title>Titel</title>
</head>
<body>
<!-- Inhalt -->
</body>
</html>
```
### HTML-Elemente
| Element | Bedeutung |
|---------|----------|
| `<h1>` bis `<h6>` | Überschriften |
| `<p>` | Absatz |
| `<a>` | Link |
| `<img>` | Bild |
| `<ul>`, `<ol>` | Liste |
| `<table>` | Tabelle |
| `<form>` | Formular |
| `<div>`, `<span>` | Container |
### Semantisches HTML
```html
<header>Kopfbereich</header>
<nav>Navigation</nav>
<main>
<article>
<section>Inhalt</section>
</article>
<aside>Seitenleiste</aside>
</main>
<footer>Fußbereich</footer>
```
---
## CSS - Cascading Style Sheets
### Einbindung
```html
<!-- Extern -->
<link rel="stylesheet" href="style.css">
<!-- Intern -->
<style>
body { background: white; }
</style>
<!-- Inline -->
<p style="color: red;">Text</p>
```
### CSS-Selektoren
```css
/* Element */
p { color: blue; }
/* Klasse */
.klasse { font-size: 16px; }
/* ID */
#id { background: gray; }
/* Attribut */
[type="text"] { border: 1px solid; }
/* Pseudoklasse */
:hover { cursor: pointer; }
/* Nachfahre */
div p { margin: 10px; }
```
### Flexbox
```css
.container {
display: flex;
justify-content: space-between;
align-items: center;
}
```
### Grid
```css
.grid {
display: grid;
grid-template-columns: repeat(3, 1fr);
gap: 20px;
}
```
---
## Responsive Design
### Viewport
```html
<meta name="viewport"
content="width=device-width, initial-scale=1.0">
```
### Media Queries
```css
/* Mobile zuerst */
.container {
width: 100%;
}
@media (min-width: 768px) {
.container {
width: 750px;
}
}
@media (min-width: 1024px) {
.container {
width: 970px;
}
}
```
### Breakpoints
| Gerät | Breite |
|-------|--------|
| Mobile | < 768px |
| Tablet | 768px - 1023px |
| Desktop | >= 1024px |
---
## Querverweise
- [[LF6-02-Frontend|Nächstes Thema: Frontend-Entwicklung]]
- [[LF4-02-Schutzmassnahmen|IT-Sicherheit: HTTPS]]
---
*Stand: 2024*

268
1-Ausbildungsjahr/LF6-Webanwendungen/LF6-02-Frontend.md Normal file
View File

@@ -0,0 +1,268 @@
# 6.2 Frontend-Entwicklung
## JavaScript
### Grundlagen
```javascript
// Variablen
let name = "Max"; // veränderbar
const alter = 25; // konstant
// Datentypen
let text = "Hallo"; // String
letzahl = 42; // Number
let wahr = true; // Boolean
let array = [1, 2, 3]; // Array
let objekt = { // Object
name: "Max",
alter: 25
};
```
### Kontrollstrukturen
```javascript
// Bedingung
if (alter >= 18) {
console.log("Volljährig");
} else {
console.log("Minderjährig");
}
// Switch
switch (tag) {
case "Mo":
case "Di":
console.log("Arbeitstag");
break;
default:
console.log("Wochenende");
}
// Schleifen
for (let i = 0; i < 5; i++) {
console.log(i);
}
array.forEach(item => {
console.log(item);
});
```
### Funktionen
```javascript
// Funktionsdeklaration
function gruss(name) {
return "Hallo " + name;
}
// Arrow Function
const gruss = (name) => "Hallo " + name;
// Mit Standardwert
function gruss(name = "Gast") {
return "Hallo " + name;
}
```
---
## DOM - Document Object Model
### Element auswählen
```javascript
// Nach ID
const element = document.getElementById("meine-id");
// Nach Klasse
const elemente = document.getElementsByClassName("klasse");
// Nach Selektor
const element = document.querySelector(".klasse");
const elemente = document.querySelectorAll("p");
```
### Inhalt ändern
```javascript
// Text ändern
element.textContent = "Neuer Text";
// HTML ändern
element.innerHTML = "<strong>Fett</strong>";
// Attribute
element.setAttribute("class", "neu");
element.getAttribute("href");
```
### Events
```javascript
// Event Listener
element.addEventListener("click", function() {
console.log("Geklickt!");
});
// Arrow Function
element.addEventListener("click", () => {
alert("Geklickt!");
});
```
---
## Formulare
### HTML-Formular
```html
<form id="login-form">
<label for="email">E-Mail:</label>
<input type="email" id="email" name="email" required>
<label for="password">Passwort:</label>
<input type="password" id="password" name="password" required>
<button type="submit">Anmelden</button>
</form>
```
### Formulardaten auslesen
```javascript
const formular = document.getElementById("login-form");
formular.addEventListener("submit", function(e) {
e.preventDefault(); // Verhindert Seitenreload
const formData = new FormData(formular);
const daten = Object.fromEntries(formData);
console.log(daten);
// { email: "...", password: "..." }
});
```
---
## Frameworks
### React
```jsx
import React, { useState } from 'react';
function Counter() {
const [count, setCount] = useState(0);
return (
<div>
<p>Zähler: {count}</p>
<button onClick={() => setCount(count + 1)}>
Erhöhen
</button>
</div>
);
}
```
### Vue
```html
<script setup>
import { ref } from 'vue';
const count = ref(0);
</script>
<template>
<p>Zähler: {{ count }}</p>
<button @click="count++">Erhöhen</button>
</template>
```
### Vergleich
| Framework | Typ |特点 |
|-----------|-----|-----|
| React | Library | Flexibel, große Community |
| Vue | Framework | Einfach zu lernen |
| Angular | Framework | Enterprise, TypeScript |
---
## Asynchrone Programmierung
### Promises
```javascript
// Promise erstellen
const promise = new Promise((resolve, reject) => {
// Async Operation
if (erfolg) {
resolve("Erfolg!");
} else {
reject("Fehler!");
}
});
// Nutzen
promise
.then(ergebnis => console.log(ergebnis))
.catch(fehler => console.error(fehler));
```
### Async/Await
```javascript
async function datenLaden() {
try {
const response = await fetch('/api/daten');
const daten = await response.json();
console.log(daten);
} catch (error) {
console.error("Fehler:", error);
}
}
```
---
## Fetch API
```javascript
// GET
fetch('/api/benutzer')
.then(response => response.json())
.then(data => console.log(data));
// POST
fetch('/api/benutzer', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
name: "Max",
email: "max@example.com"
})
})
.then(response => response.json())
.then(data => console.log(data));
```
---
## Querverweise
- [[LF6-01-Web-Grundlagen|Zurück: Web-Grundlagen]]
- [[LF6-03-Backend|Nächstes Thema: Backend-Entwicklung]]
- [[LF6-04-Sicherheit-Web|Web-Sicherheit]]
---
*Stand: 2024*

272
1-Ausbildungsjahr/LF6-Webanwendungen/LF6-03-Backend.md Normal file
View File

@@ -0,0 +1,272 @@
# 6.3 Backend-Entwicklung
## Server-Grundlagen
### Client-Server-Architektur
```
Webanwendung - Architektur
┌─────────────┐ HTTP ┌─────────────┐
│ Browser │ ◄──────────────►│ Server │
│ (Frontend) │ │ (Backend) │
└─────────────┘ └──────┬──────┘
│
┌─────┴─────┐
│ Datenbank │
└───────────┘
```
---
## Node.js
### Grundlagen
```javascript
// Einfacher Server
const http = require('http');
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/html' });
res.end('<h1>Hallo Welt!</h1>');
});
server.listen(3000, () => {
console.log('Server läuft auf Port 3000');
});
```
### Express.js
```javascript
const express = require('express');
const app = express();
// Middleware
app.use(express.json());
// GET-Route
app.get('/api/benutzer', (req, res) => {
res.json([
{ id: 1, name: 'Max' },
{ id: 2, name: 'Anna' }
]);
});
// POST-Route
app.post('/api/benutzer', (req, res) => {
const neuerBenutzer = req.body;
// Speichern...
res.status(201).json(neuerBenutzer);
});
app.listen(3000);
```
---
## REST-API
### REST-Prinzipien
```
REST - Grundsätze
├── Ressourcen-orientiert (Nomen)
├── Stateless (keine Session)
├── Einheitliche Schnittstelle
├── Client-Server-Trennung
└── Cache-fähig
```
### HTTP-Methoden
| Methode | CRUD | Beschreibung |
|---------|-----|-------------|
| GET | Read | Daten abrufen |
| POST | Create | Daten erstellen |
| PUT | Update | Daten vollständig ersetzen |
| PATCH | Update | Daten teilweise ändern |
| DELETE | Delete | Daten löschen |
### API-Endpunkte
```
Beispiel: Benutzer-Ressource
GET /api/benutzer → Alle Benutzer
GET /api/benutzer/:id → Ein Benutzer
POST /api/benutzer → Benutzer erstellen
PUT /api/benutzer/:id → Benutzer ersetzen
PATCH /api/benutzer/:id → Benutzer ändern
DELETE /api/benutzer/:id → Benutzer löschen
```
### Response-Format
```json
// Erfolgreich (200 OK)
{
"status": "success",
"data": {
"id": 1,
"name": "Max"
}
}
// Erfolg (201 Created)
{
"status": "success",
"message": "Benutzer erstellt",
"data": {
"id": 2
}
}
// Fehler (400 Bad Request)
{
"status": "error",
"message": "Ungültige E-Mail-Adresse"
}
```
---
## Datenbank-Zugriff
### MySQL mit Node.js
```javascript
const mysql = require('mysql2/promise');
async function main() {
const connection = await mysql.createConnection({
host: 'localhost',
user: 'root',
password: 'passwort',
database: 'webshop'
});
// Daten abfragen
const [rows] = await connection.execute(
'SELECT * FROM benutzer WHERE id = ?',
[1]
);
console.log(rows);
await connection.end();
}
main();
```
### MongoDB mit Node.js
```javascript
const mongoose = require('mongoose');
// Verbindung
mongoose.connect('mongodb://localhost:27017/webshop');
// Schema
const benutzerSchema = new mongoose.Schema({
name: String,
email: { type: String, unique: true },
alter: Number
});
const Benutzer = mongoose.model('Benutzer', benutzerSchema);
// Daten speichern
const neuerBenutzer = new Benutzer({
name: 'Max',
email: 'max@example.com'
});
await neuerBenutzer.save();
```
---
## Session und Authentifizierung
### JWT (JSON Web Token)
```javascript
const jwt = require('jsonwebtoken');
// Token erstellen
function createToken(user) {
return jwt.sign(
{ id: user.id, email: user.email },
'geheimer-schluessel',
{ expiresIn: '24h' }
);
}
// Token prüfen
function verifyToken(token) {
try {
return jwt.verify(token, 'geheimer-schluessel');
} catch (err) {
return null;
}
}
// Middleware
function authenticate(req, res, next) {
const token = req.headers.authorization?.split(' ')[1];
const decoded = verifyToken(token);
if (!decoded) {
return res.status(401).json({ error: 'Nicht autorisiert' });
}
req.user = decoded;
next();
}
```
### Passwort-Hashing
```javascript
const bcrypt = require('bcrypt');
// Passwort hashen
async function hashPassword(password) {
const salt = await bcrypt.genSalt(10);
return await bcrypt.hash(password, salt);
}
// Passwort prüfen
async function checkPassword(password, hash) {
return await bcrypt.compare(password, hash);
}
```
---
## RESTful Best Practices
### Tipps
```
API-Design - Empfehlungen
├── Versionierung: /api/v1/...
├── Plural: /benutzer nicht /benutzer
├── Filter: /benutzer?alter=25
├── Sortierung: /benutzer?sort=name
├── Paginierung: /benutzer?page=1&limit=10
├── Fehlercodes: HTTP-Statuscodes nutzen
└── Dokumentation: OpenAPI/Swagger
```
---
## Querverweise
- [[LF6-02-Frontend|Zurück: Frontend-Entwicklung]]
- [[LF6-04-Sicherheit-Web|Nächstes Thema: Web-Sicherheit]]
- [[LF3-Datenbanken|Datenbanken]]
---
*Stand: 2024*

257
1-Ausbildungsjahr/LF6-Webanwendungen/LF6-04-Sicherheit-Web.md Normal file
View File

@@ -0,0 +1,257 @@
# 6.4 Web-Sicherheit
## OWASP Top 10
### Die wichtigsten Sicherheitsrisiken
```
OWASP Top 10 (2021)
├── A01: Broken Access Control
├── A02: Cryptographic Failures
├── A03: Injection
├── A04: Insecure Design
├── A05: Security Misconfiguration
├── A06: Vulnerable Components
├── A07: Authentification Failures
├── A08: Software and Data Integrity Failures
├── A09: Security Logging Failures
└── A10: Server-Side Request Forgery
```
---
## Injection
### SQL Injection
**Problem:** Benutzereingaben werden direkt in SQL-Abfragen eingebaut.
```sql
-- Gefährlich
SELECT * FROM benutzer WHERE name = '" + name + "'
-- Bei name = "' OR '1'='1"
SELECT * FROM benutzer WHERE name = '' OR '1'='1'
-- → Alle Benutzer werden zurückgegeben!
```
**Schutz: Prepared Statements**
```javascript
// Gefährlich
db.query("SELECT * FROM users WHERE name = '" + name + "'");
// Sicher - Parameterized Query
db.query("SELECT * FROM users WHERE name = ?", [name]);
```
### XSS (Cross-Site Scripting)
**Problem:** Schadcode wird in Webseiten eingeschleust.
```html
<!-- Gefährlich: Benutzereingabe direkt ausgeben -->
<div>{{ benutzereingabe }}</div>
<!-- Bei eingabe = <script>alert('XSS')</script> -->
```
**Schutz: Output Encoding**
```javascript
// HTML-Escaping
function escapeHtml(text) {
const map = {
'&': '&amp;',
'<': '&lt;',
'>': '&gt;',
'"': '&quot;',
"'": '&#039;'
};
return text.replace(/[&<>"']/g, m => map[m]);
}
// React macht das automatisch
<div>{benutzereingabe}</div>
```
### Content Security Policy (CSP)
```http
Content-Security-Policy: default-src 'self'; script-src 'self'
```
---
## CSRF (Cross-Site Request Forgery)
### Das Problem
```
CSRF-Angriff
1. Opfer ist eingeloggt bei bank.com
2. Opfer besucht bösartige Seite
3. Bösartige Seite sendet Request an bank.com
4. Browser sendet automatisch Session-Cookie
5. Überweisung wird ausgeführt
```
### Schutz: CSRF-Token
```javascript
// Server: Token generieren
app.get('/form', (req, res) => {
const csrfToken = crypto.randomBytes(32).toString('hex');
req.session.csrfToken = csrfToken;
res.render('form', { csrfToken });
});
// Server: Token prüfen
app.post('/transfer', (req, res) => {
if (req.body.csrfToken !== req.session.csrfToken) {
return res.status(403).send('CSRF-Angriff erkannt');
}
// Weiter mit Überweisung...
});
```
---
## Authentifizierung
### Unsichere Praktiken
```
Vermeiden
├── Passwörter im Klartext speichern
├── Schwache Passwörter erlauben
├── Keine Zwei-Faktor-Authentifizierung
├── Session-IDs in URL
└── Unbegrenzte Login-Versuche
```
### Sichere Authentifizierung
```javascript
// 1. Passwörter hashen
const hash = await bcrypt.hash(passwort, 12);
// 2. Rate Limiting
const rateLimit = require('express-rate-limit');
app.use('/login', rateLimit({
windowMs: 15 * 60 * 1000,
max: 5 // 5 Versuche
}));
// 3. Sichere Session
app.use(session({
secret: 'geheimer-schluessel',
httpOnly: true,
secure: true, // HTTPS
sameSite: 'strict'
}));
```
---
## Sicherheits-Header
### Wichtige Header
```http
# HSTS - HTTPS erzwingen
Strict-Transport-Security: max-age=31536000; includeSubDomains
# X-Content-Type-Options
X-Content-Type-Options: nosniff
# X-Frame-Options - Clickjacking
X-Frame-Options: DENY
# Content Security Policy
Content-Security-Policy: default-src 'self'
# Referrer Policy
Referrer-Policy: strict-origin-when-cross-origin
```
### Implementierung in Express
```javascript
const helmet = require('helmet');
app.use(helmet());
```
---
## Eingabevalidierung
### Grundprinzip
```
Validierung - Regeln
├── Nie Benutzereingaben vertrauen
├── Client-seitige Validierung reicht nicht
├── Whitelist statt Blacklist
├── Länge und Format prüfen
└── Alle Eingaben validieren
```
### Validierungsbeispiel
```javascript
const Joi = require('joi');
const benutzerSchema = Joi.object({
name: Joi.string()
.alphanum()
.min(3)
.max(30)
.required(),
email: Joi.string()
.email()
.required(),
alter: Joi.number()
.integer()
.min(18)
.max(150)
});
// Validierung
const { error, value } = benutzerSchema.validate(req.body);
if (error) {
return res.status(400).json({ error: error.details });
}
```
---
## Checkliste Web-Sicherheit
```
Sicherheits-Checkliste
□ HTTPS erzwingen
□ Sicherheits-Header setzen
□ SQL Injection verhindern (Prepared Statements)
□ XSS verhindern (Escaping)
□ CSRF-Token verwenden
□ Passwörter hashen (bcrypt)
□ Rate Limiting
□ Eingaben validieren
□ Fehlermeldungen nicht zu detailliert
□ Regelmäßige Updates
□ Sicherheitstests durchführen
```
---
## Querverweise
- [[LF6-03-Backend|Zurück: Backend-Entwicklung]]
- [[LF4-IT-Sicherheit|IT-Sicherheit allgemein]]
- [[LF3-05-Datenbankmanagement|Datenbank: SQL Injection]]
---
*Stand: 2024*

181
2-Ausbildungsjahr/LF6-Serviceanfragen/LF6-Notizen.md Normal file
View File

@@ -0,0 +1,181 @@
# LF 6: Serviceanfragen bearbeiten
> **2. Ausbildungsjahr** | Zeitrichtwert: **40 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, Serviceanfragen einzuordnen, Fehlerursachen zu ermitteln und zu beheben.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Serviceanfragen analysieren und einordnen
- [ ] Service-Level-Agreements (SLA) prüfen
- [ ] Ticket-Systeme bedienen
- [ ] Fehlerursachen systematisch ermitteln
- [ ] Lösungen im Rahmen des Support-Levels erarbeiten
- [ ] Mit Kunden situationsgerecht kommunizieren
- [ ] Den Bearbeitungsprozess reflektieren
---
## ITIL-Grundlagen
### Service-Struktur
```
ITIL-Prozesse
├── Service Strategy
├── Service Design
├── Service Transition
├── Service Operation
│ ├── Incident Management
│ ├── Problem Management
│ └── Request Fulfillment
└── Continual Service Improvement
```
### Support-Level
| Level | Beschreibung | Beispiel |
|-------|--------------|----------|
| **1st Level** | Erste Ebene, einfache Probleme | Passwort zurücksetzen |
| **2nd Level** | Technischer Support | Hard- und Softwareprobleme |
| **3rd Level** | Entwicklung/Hersteller | Komplexe Fehler |
---
## Ticket-Systeme
### Ticket-Lebenszyklus
```
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ New │───>│ Open │───>│ Pending │───>│ Closed │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
│ │
v v
┌─────────┐ ┌─────────┐
│ In │ │ Resolved│
│ Progress │ └─────────┘
└─────────┘
```
### Prioritäten
| Priorität | Beschreibung | Reaktionszeit |
|-----------|--------------|---------------|
| **P1 - Kritisch** | Geschäftskritisch | < 1 Stunde |
| **P2 - Hoch** | Große Auswirkung | < 4 Stunden |
| **P3 - Mittel** | Begrenzte Auswirkung | < 1 Arbeitstag |
| **P4 - Niedrig** | Minimaler Impact | < 1 Woche |
---
## SLA (Service Level Agreement)
### Bestandteile
```
SLA-Inhalte
├── Verfügbarkeit (z.B. 99,9%)
├── Reaktionszeiten
├── Wiederherstellungszeiten
├── Support-Zeiten (24/7, 9-17 Uhr)
├── Eskalationsprozeduren
├── Reporting
└── Kosten
```
### Berechnung Verfügbarkeit
```
Beispiel: 99,9% Verfügbarkeit
Jährlich: 365 Tage × 24h = 8760h
Erlaubte Ausfallzeit: 8760 × 0,001 = 8,76h
Monatlich: 720h × 0,001 = 0,72h
```
---
## Fehleranalyse
### Methoden
| Methode | Beschreibung |
|---------|--------------|
| **5 Whys** | Warum-Fragen stellen (Root Cause) |
| **Ishikawa** | Fischgräten-Diagramm |
| **Kepner-Tregoe** | Situationsanalyse |
### 5-Why-Beispiel
```
Problem: Drucker druckt nicht
1. Warum? → Kein Toner
2. Warum? → Toner wurde nie gewechselt
3. Warum? → Keine Warnung bei niedrigem Tonerstand
4. Warum? → Einstellungen nicht konfiguriert
5. Warum? → Schulung nicht erfolgt
→ Lösung: Schulung durchführen
```
---
## Kommunikation
### Vier-Seiten-Modell (Schulz von Thun)
```
Nachricht hat 4 Seiten:
┌─────────────────────────────────────┐
│ Sachinhalt │ ← Was wurde mitgeteilt?
├─────────────────────────────────────┤
│ Selbstoffenbarung │ ← Was sagt das über mich aus?
├─────────────────────────────────────┤
│ Beziehung │ ← Wie stehe ich zum Empfänger?
├─────────────────────────────────────┤
│ Appelle │ ← Was will ich erreichen?
└─────────────────────────────────────┘
```
### Deeskalation
- **Aktives Zuhören**
- **Empathie zeigen**
- **Sachlich bleiben**
- **Lösungen anbieten**
- **Rückmeldung geben**
---
## Handlungsphasen
1. **Aufnehmen**: Ticket erstellen, Kunden kontaktieren
2. **Analysieren**: SLA prüfen, Fehler eingrenzen
3. **Lösen**: Lösung erarbeiten, umsetzen
4. **Dokumentieren**: Ticket aktualisieren, dokumentieren
5. **Abschließen**: Kunden informieren, Feedback einholen
---
## Prüfungsrelevanz
- Wichtig für Support-Tätigkeiten
- Kommunikationskompetenz wird geprüft
---
## Querverweise
- [[1-Ausbildungsjahr/LF5-Datenbanken-anpassen|Vorher: LF 5]]
- [[2-Ausbildungsjahr/LF7-Cyber-physische-Systeme|Nachher: LF 7]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

225
2-Ausbildungsjahr/LF7-Cyber-physische-Systeme/LF7-Notizen.md Normal file
View File

@@ -0,0 +1,225 @@
# LF 7: Cyber-physische Systeme ergänzen
> **2. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, die physische Welt und IT-Systeme funktional zu einem cyber-physischen System zusammenzuführen.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Ein CPS analysieren und dessen Komponenten beschreiben
- [ ] Datenfluss an Schnittstellen verstehen
- [ ] Sensoren und Aktoren auswählen und integrieren
- [ ] IoT-Kommunikationsprotokolle anwenden
- [ ] Energiebedarf berechnen
- [ ] System testen und dokumentieren
- [ ] Sicherheitsaspekte berücksichtigen
---
## Was ist ein CPS?
```
Cyber-Physical System (CPS)
│
├── PHYSISCHE WELT
│ ├── Sensoren (Messdaten erfassen)
│ └── Aktoren (physikalische Aktionen)
│
├── IT-SYSTEM
│ ├── Steuerung/Regelung
│ ├── Datenverarbeitung
│ └── Speicherung
│
└── KOMMUNIKATION
├── Netzwerkverbindung
└── Protokolle (MQTT, REST, etc.)
```
### CPS vs. IoT
| Merkmal | CPS | IoT |
|---------|-----|-----|
| Fokus | Steuerung + Regelung | Vernetzung + Daten |
| Bereich | Produktion, Auto | Consumer, Gebäude |
| Echtzeit | Oft kritisch | Meist weniger |
---
## Sensoren
### Typen
| Sensortyp | Messgröße | Anwendung |
|-----------|-----------|------------|
| Temperatursensor | °C/°F | Klimaanlage |
| Feuchtigkeitssensor | %rH | Gewächshaus |
| Drucksensor | bar/Pa | Hydraulik |
| Lichtsensor | Lux | Beleuchtung |
| Abstandssensor | cm/mm | Automatisierung |
| Füllstandssensor | % | Tank |
| Bewegungssensor | bool | Sicherheit |
### Schnittstellen
```
Sensor-Schnittstellen
├── Analog
│ ├── 0-10V
│ └── 4-20mA (Stromschleife)
├── Digital
│ ├── I2C (Two-Wire)
│ ├── SPI
│ ├── 1-Wire
│ └── UART
└── Funk
├── Zigbee
├── Bluetooth LE
└── LoRa
```
---
## Aktoren
### Typen
| Aktortyp | Funktion | Beispiel |
|---------|---------|---------|
| Relais | Schalten | Licht, Motor |
| Motor | Drehung | Roboterarm |
| Ventil | Durchfluss | Hydraulik |
| Heizelement | Wärme | 3D-Drucker |
| LED | Lichtsignal | Statusanzeige |
| Piezo | Tonalarm | Signalton |
---
## Mikrocontroller & Einplatinencomputer
### Vergleich
| Plattform | Prozessor | RAM | GPIO | OS |
|-----------|-----------|-----|------|-----|
| **Arduino Uno** | ATmega328P | 2KB | 14 | Nein |
| **Raspberry Pi 4** | ARM Cortex-A72 | 8GB | 40 | Linux |
| **ESP32** | Xtensa | 520KB | 34 | FreeRTOS |
| **BBC micro:bit** | ARM Cortex-M4 | 256KB | 19 | Keins |
### Programmierung
```python
# Raspberry Pi / Python Beispiel
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
try:
while True:
GPIO.output(18, True) # LED an
time.sleep(1)
GPIO.output(18, False) # LED aus
time.sleep(1)
except KeyboardInterrupt:
GPIO.cleanup()
```
---
## IoT-Kommunikationsprotokolle
### MQTT
**Publish/Subscribe-Prinzip:**
```
Publisher Broker Subscriber
│ │ │
│──Topic: temp───>│ │
│ │──temp───> │
│ │ │
│──Topic: temp───>│ │
│ │ │
```
**Beispiel (Python):**
```python
import paho.mqtt.client as mqtt
def on_connect(client, userdata, flags, rc):
client.subscribe("sensor/temperature")
def on_message(client, userdata, msg):
print(f"Temperatur: {msg.payload.decode()}")
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect("broker.example.com", 1883)
client.loop_forever()
```
### REST API
```
HTTP-Methoden:
GET → Daten abrufen
POST → Daten erstellen
PUT → Daten vollständig ersetzen
PATCH → Daten teilweise ändern
DELETE → Daten löschen
```
---
## Energiebedarf
### Berechnung
```
P = U × I (Leistung = Spannung × Strom)
Beispiel:
Mikrocontroller: 5V × 0,5A = 2,5W
Stunden pro Tag: 24h
Verbrauch/Tag: 2,5W × 24h = 60Wh = 0,06kWh
Jahr: 0,06kWh × 365 = 21,9kWh
```
---
## Handlungsphasen
1. **Analysieren**: Bestehendes System verstehen
2. **Informieren**: Technische Dokumentation studieren
3. **Planen**: Komponentenauswahl, Konzept erstellen
4. **Implementieren**: Software, Hardware integrieren
5. **Testen**: Funktion prüfen, dokumentieren
6. **Reflektieren**: Optimierungsmöglichkeiten finden
---
## Prüfungsrelevanz
- Wichtig für Anwendungsentwicklung
- Projektion in LF 10a-12a
- Praxisbezug für Abschlussprojekt
---
## Querverweise
- [[2-Ausbildungsjahr/LF6-Serviceanfragen|Vorher: LF 6]]
- [[2-Ausbildungsjahr/LF8-Daten-bereitstellen|Nachher: LF 8]]
- [[IoT-Programmierung|IoT-Programmierung Vertiefung]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

32
2-Ausbildungsjahr/LF7-Service/LF7-00-Übersicht.md Normal file
View File

@@ -0,0 +1,32 @@
# Lernfeld 7: Service und Support
## Übersicht
Dieses Lernfeld behandelt die Bearbeitung von Serviceanfragen und den IT-Support.
## Themen
| Nr. | Thema | Beschreibung |
| --- | --- | --- |
| 7.1 | [[LF7-01-ITIL-Grundlagen]] | IT Service Management |
| 7.2 | [[LF7-02-Ticketmanagement]] | Ticketsysteme, Prozesse |
| 7.3 | [[LF7-03-Support-Stufen]] | 1st/2nd/3rd Level |
| 7.4 | [[LF7-04-Kommunikation]] | Kundenkommunikation |
## Lernziele
- Serviceanfragen professionell bearbeiten
- ITIL-Prozesse anwenden
- Support-Stufen unterscheiden
- Kundenorientiert kommunizieren
---
## Querverweise
- [[LF6-04-Sicherheit-Web|Zurück: Web-Sicherheit]]
- [[LF8-Datenintegration|Nächstes Lernfeld: Datenintegration]]
---
*Stand: 2024*

150
2-Ausbildungsjahr/LF7-Service/LF7-01-ITIL-Grundlagen.md Normal file
View File

@@ -0,0 +1,150 @@
# 7.1 ITIL-Grundlagen
## Was ist ITIL?
**ITIL** (Information Technology Infrastructure Library) ist ein Framework für **IT Service Management (ITSM)**.
### Geschichte
```
ITIL-Versionen
├── ITIL v1 (1989) → 1990er
├── ITIL v2 (2001) → Best Practices
├── ITIL v3 (2007) → Service Lifecycle
└── ITIL 4 (2019) → Aktuell, flexibler
```
---
## ITIL Service Value System (SVS)
```
ITIL 4 - Überblick
┌────────────────────────────────────────┐
│ Organisation │
├────────────────────────────────────────┤
│ Service Value Chain │
│ Plan → Improve → Engage → Design → │
│ Transition → Operation │
├────────────────────────────────────────
│ ITIL Practices │
└────────────────────────────────────────┘
```
---
## ITIL Service Value Chain
```
Value Chain - Aktivitäten
├── Plan (Planen)
│ └── Strategie festlegen
├── Improve (Verbessern)
│ └── Kontinuierliche Verbesserung
├── Engage (Einbeziehen)
│ └── Kommunikation mit Stakeholdern
├── Design & Transition (Gestalten)
│ └── Services entwickeln
├── Obtain/Build (Beschaffen)
│ └── Komponenten bereitstellen
└── Deliver & Operate (Liefern/Betreiben)
└── Services bereitstellen
```
---
## ITIL Practices
### Service Practices
| Practice | Beschreibung |
|----------|-------------|
| Service Desk | Single Point of Contact |
| Incident Management | Störungsbearbeitung |
| Problem Management | Grundursachenanalyse |
| Change Management | Änderungsprozess |
| Release Management | Bereitstellung |
### Technical Practices
| Practice | Beschreibung |
|----------|-------------|
| Monitoring | Systemüberwachung |
| Event Management | Ereignisverarbeitung |
| Incident Response | Reaktionsfähigkeit |
|Continual Improvement | KVP |
---
## Kernkonzepte
### Service
```
Service - Definition
Ein Service ermöglicht es Kunden,
Wert zu erreichen, ohne spezifische
Kosten und Risiken zu tragen.
```
### Value
```
Wert - Komponenten
├── Nutzen (Utility)
│ └── Funktionen, die Kunde braucht
└── Ertrag (Warranty)
└── Qualität, Verfügbarkeit
```
### Customer Experience
```
Service Relationship
┌─────────┐ Service ┌─────────┐
│ Service │◄───────────────►│ Kunde │
│ Provider│ │ │
└─────────┘ └─────────┘
```
---
## ITIL-Prozesse im Detail
### Incident Management
```
Incident Lifecycle
1. Detect → Erkennen
2. Record → Erfassen
3. Categorize → Kategorisieren
4. Prioritize → Priorisieren
5. Diagnose → Diagnostizieren
6. Resolve → Beheben
7. Close → Abschließen
```
### Problem Management
```
Problem - Ablauf
Problem erkannt
↓
Analyse der Grundursache
↓
Lösung entwickeln
↓
Change Request erstellen
↓
Problem gelöst
```
---
## Querverweise
- [[LF7-02-Ticketmanagement|Nächstes Thema: Ticketmanagement]]
---
*Stand: 2024*

178
2-Ausbildungsjahr/LF7-Service/LF7-02-Ticketmanagement.md Normal file
View File

@@ -0,0 +1,178 @@
# 7.2 Ticketmanagement
## Ticketsysteme
### Was ist ein Ticket?
```
Ticket = Strukturierten Erfassung
einer Serviceanfrage oder Störung
```
### Lebenszyklus
```
Ticket-Lebenszyklus
┌──────────┐
│ Neu │ ← Created
└────┬─────┘
│
▼
┌──────────┐
│ In Bearb.│ ← Assigned
└────┬─────┘
│
▼
┌──────────┐
│ Gelöst │ ← Resolved
└────┬─────┘
│
▼
┌──────────┐
│ Geschlos.│ ← Closed
└──────────┘
```
---
## Ticket-Kategorien
### Kategorisierung
| Kategorie | Beschreibung |
|-----------|-------------|
| Incident | Störung, Serviceausfall |
| Request | Anfrage, Wunsch |
| Change | Änderungsanfrage |
| Problem | Wiederkehrendes Problem |
### Prioritäten
| Priorität | Beschreibung | Reaktionszeit |
|-----------|-------------|---------------|
| **P1 - Kritisch** | Geschäftskritisch | < 1 Stunde |
| **P2 - Hoch** | Wichtige Funktion | < 4 Stunden |
| **P3 - Mittel** | Normale Priorität | < 1 Arbeitstag |
| **P4 - Niedrig** | Kleinere Probleme | < 1 Woche |
### Auswirkung (Impact)
| Level | Beschreibung |
|-------|-------------|
| 1 - Global | Alle Benutzer betroffen |
| 2 - Abteilung | Mehrere Abteilungen |
| 3 - Einzelner | Ein Benutzer |
---
## Ticketfelder
### Standardfelder
```
Ticket-Daten
├── ID (eindeutig)
├── Titel/Zusammenfassung
├── Beschreibung
├── Kategorie
├── Priorität
├── Status
├── Bearbeiter
├── Lösung
├── Erstellungsdatum
├── Fälligkeitsdatum
└── Anhang/Bilder
```
### Beispiel-Ticket
```markdown
# Ticket #12345
Titel: Drucker druckt nicht
Kategorie: Hardware
Priorität: P3
Status: In Bearbeitung
Beschreibung:
Der Drucker im 2. OG zeigt Fehlermeldung
"Papierstau" obwohl kein Papier vorhanden.
Lösung:
Wartung durchgeführt, Walzen gereinigt.
```
---
## Ticketwerkzeuge
### Tools
| Tool | Typ | Eigenschaften |
|------|-----|---------------|
| Jira Service Management | Cloud | Umfangreich |
| OTRS | Open Source | Deutsch |
| GLPI | Open Source | Asset-Management |
| Zendesk | Cloud | Support-fokussiert |
| Freshservice | Cloud | Einfach |
---
## SLA (Service Level Agreement)
### SLA-Komponenten
```
SLA - Inhalt
├── Reaktionszeiten
├── Lösungszeiten
├── Verfügbarkeit
├── Support-Zeiten (Business Hours)
├── Eskalationsprozeduren
└── Kommunikationswege
```
### Eskalation
```
Eskalation - Stufen
├── 1. Stufe: Bearbeiter
├── 2. Stufe: Teamleiter
├── 3. Stufe: Manager
└── 4. Stufe: Geschäftsführung
```
---
## Kennzahlen (KPIs)
### Wichtige Metriken
| KPI | Beschreibung | Zielwert |
|-----|-------------|----------|
| MTTR | Mean Time To Resolve | < 8h |
| MTTF | Mean Time To Failure | > 720h |
| FCR | First Contact Resolution | > 70% |
| CSAT | Customer Satisfaction | > 4.5/5 |
### Reporting
```
Ticket-Report
├── Anzahl offener Tickets
├── Durchschnittliche Lösungszeit
├── Tickets pro Kategorie
├── SLA-Einhaltung
└── Kundenfeedback
```
---
## Querverweise
- [[LF7-01-ITIL-Grundlagen|Zurück: ITIL-Grundlagen]]
- [[LF7-03-Support-Stufen|Nächstes Thema: Support-Stufen]]
---
*Stand: 2024*

194
2-Ausbildungsjahr/LF7-Service/LF7-03-Support-Stufen.md Normal file
View File

@@ -0,0 +1,194 @@
# 7.3 Support-Stufen
## Support-Struktur
### Eskalationsmodell
```
Support-Level
┌─────────────────────────────────┐
│ Service Desk │ ← 1st Level
│ (First Line / Front Office) │
└───────────────┬─────────────────┘
│
▼
┌─────────────────────────────────┐
│ Technical Support │ ← 2nd Level
│ (2nd Line / Backend) │
└───────────────┬─────────────────┘
│
▼
┌─────────────────────────────────┐
│ Expert Support │ ← 3rd Level
│ (3rd Line / Specialists) │
└───────────────┬─────────────────┘
│
▼
┌─────────────────────────────────┐
│ External Vendors/Developers │ ← 4th Level
└─────────────────────────────────┘
```
---
## Level 1 - First Level Support
### Aufgaben
| Aufgabe | Beschreibung |
|---------|-------------|
| Annahme | Tickets entgegennehmen |
| Kategorisierung | Richtige Kategorie zuweisen |
| Grunddiagnose | Einfache Probleme lösen |
| Lösungswissen | Bekannte Lösungen anwenden |
| Eskalation | Komplexe Fälle weitergeben |
### Fähigkeiten
```
First Level - Anforderungen
├── Produktwissen
├── Kommunikationsfähigkeit
├── Grundlegende Technik
├── Dokumentation
└── Zeitmanagement
```
### Typische Lösungsquote
```
First Contact Resolution (FCR)
Ziel: 60-70% direkt gelöst
```
---
## Level 2 - Second Level Support
### Aufgaben
| Aufgabe | Beschreibung |
|---------|-------------|
| Tiefendiagnose | Komplexe Probleme analysieren |
| Technische Lösung | Fachliche Probleme beheben |
| Workarounds | Temporäre Lösungen finden |
| Dokumentation | Wissensdatenbank pflegen |
| Schulung | Level 1 unterstützen |
### Fähigkeiten
```
Second Level - Anforderungen
├── Vertieftes Technikwissen
├── Erfahrung mit Systemen
├── Analysefähigkeit
├── Eigenständigkeit
└── Mentoring
```
---
## Level 3 - Third Level Support
### Aufgaben
| Aufgabe | Beschreibung |
|---------|-------------|
| Expertenwissen | Spezialisten-Know-how |
| Grundursachenanalyse | Komplexe Fehler finden |
| Entwicklung | Fixes entwickeln |
| Architektur | Systemänderungen planen |
|Vendor-Kontakt | Hersteller einbinden |
### Fähigkeiten
```
Third Level - Anforderungen
├── Sehr tiefes Fachwissen
├── Programmierkenntnisse
├── Architekturverständnis
├── Innovationskraft
└── Dokumentation
```
---
## Eskalation
### Wann eskalieren?
```
Eskalations-Kriterien
├── Zeitüberschreitung
├── Fehlende Kompetenz
├── Benutzer-Escalation
├── Qualitätsprobleme
└── Neue Sachverhalte
```
### Vertikale vs. Horizontale Eskalation
| Typ | Beschreibung |
|-----|-------------|
| **Vertikal** | An Vorgesetzte/ höhere Level |
| **Horizontal** | An anderes Team/ Thema |
---
## Remote Support
### Tools
| Tool | Beschreibung |
|------|-------------|
| AnyDesk | Fernwartung |
| TeamViewer | Universell |
| Windows Remote Desktop | Windows |
| VNC | Plattformübergreifend |
### Best Practices
```
Fernwartung - Regeln
├── Genehmigung einholen
├── Bildschirm freigeben lassen
├── Nur auf Abfrage handeln
├── Keine privaten Daten ansehen
└── Session dokumentieren
```
---
## Wissensdatenbank
### Knowledge Base (KB)
```
KB - Inhalte
├── Lösungsschritte (How-To)
├── FAQ
├── Bekannte Probleme (Known Errors)
├── Produktdokumentation
└── Anleitungen
```
### Ticket-to-Knowledge
```
Aus Ticket wird Artikel
1. Problem reproduziert
2. Lösung gefunden
3. KB-Artikel erstellen
4. Auf Kunden-Ticket verlinken
```
---
## Querverweise
- [[LF7-02-Ticketmanagement|Zurück: Ticketmanagement]]
- [[LF7-04-Kommunikation|Nächstes Thema: Kommunikation]]
---
*Stand: 2024*

161
2-Ausbildungsjahr/LF7-Service/LF7-04-Kommunikation.md Normal file
View File

@@ -0,0 +1,161 @@
# 7.4 Kundenkommunikation
## Kommunikationsgrundlagen
### Grundsätze
```
Gute Kommunikation
├── Zuhören
├── Verständlich erklären
├── Geduldig sein
├── Freundlich bleiben
└── Nicht überfordern
```
### Aktives Zuhören
```
Aktives Zuhören - Techniken
├── Augenkontakt
├── Nicken
├── Nachfragen
├── Zusammenfassen
└── Nicht unterbrechen
```
---
## Gesprächsführung
### Am Telefon
```
Telefon - Checkliste
├── Begrüßung (Name, Firma)
├── Problem aufnehmen
├── Fragen stellen
├── Lösung anbieten
├── Zusammenfassung
├── Verabschiedung
```
### Gesprächsphasen
| Phase | Inhalt |
|-------|--------|
| Eröffnung | Begrüßung, Vorstellung |
| Ermittlung | Problem verstehen |
| Lösung | Lösung anbieten |
| Abschluss | Zusammenfassung, Nächste Schritte |
---
## Technische Erklärungen
### Kunden verständlich
```
Komplexität reduzieren
├── Fachbegriffe vermeiden oder erklären
├── Analogien verwenden
├── Visuelle Hilfen einsetzen
├── Schritt für Schritt arbeiten
└── Nachfragen ob verstanden
```
### Analogien
```
Beispiele für Erklärungen
Netzwerk → Straßennetz
Server → Bibliothek
Firewall → Sicherheitskontrolle
Backup → Sicherheitskopie
```
---
## schwierige Situationen
### Umgang mit Ärger
```
Ärgerlicher Kunde - Verhalten
├── Ruhig bleiben
├── Nicht persönlich nehmen
├── Verständnis zeigen
├── Nicht unterbrechen
└── Lösung anbieten
```
### Formulierungen
| Vermeiden | Besser |
|-----------|--------|
| Das ist unmöglich | Ich schaue mir das an |
| Das ist nicht mein Problem | Ich verbinde Sie mit... |
| Das müssen Sie | Hier ist die Lösung |
| Keine Ahnung | Das finde ich für Sie heraus |
---
## Dokumentation
### Ticket-Kommunikation
```
Dokumentation - Tipps
├── Wichtige Punkte notieren
├── Vereinbarungen festhalten
├── Nächste Schritte klären
├── Zeit notieren
└── Professionell bleiben
```
### E-Mail-Kommunikation
```
E-Mail - Struktur
├── Aussagekräftiger Betreff
├── Höfliche Anrede
├── Klare Beschreibung
├── Erwartete Antwort
├── Signatur
```
---
## Feedback und Zufriedenheit
### Kundenzufriedenheit messen
```
CSAT - Customer Satisfaction
└── Nach Ticket-Abschluss:
"Wie zufrieden sind Sie?"
(Skala 1-5)
```
### NPS - Net Promoter Score
```
Frage: "Wie wahrscheinlich empfehlen Sie uns?"
(0-10)
Berechnung:
Promoters (9-10) - Detractors (0-6)
= NPS (-100 bis +100)
```
---
## Querverweise
- [[LF7-03-Support-Stufen|Zurück: Support-Stufen]]
- [[LF1-06-Eigene-Rolle|Eigene Rolle im Betrieb]]
---
*Stand: 2024*

182
2-Ausbildungsjahr/LF8-Daten-bereitstellen/LF8-Notizen.md Normal file
View File

@@ -0,0 +1,182 @@
# LF 8: Daten systemübergreifend bereitstellen
> **2. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler besitzen die Kompetenz, Daten aus dezentralen Quellen zusammenzuführen, aufzubereiten und zur weiteren Nutzung zur Verfügung zu stellen.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Datenquellen analysieren und bewerten
- [ ] Heterogene Datenquellen integrieren
- [ ] Daten für die Weiterverarbeitung aufbereiten
- [ ] APIs und Schnittstellen nutzen
- [ ] Datenbanksysteme anbinden
- [ ] Dokumentation erstellen
---
## Datenquellen
### Typen
```
DATENQUELLEN
├── Relationale Datenbanken
│ ├── MySQL/MariaDB
│ ├── PostgreSQL
│ └── MS SQL Server
├── NoSQL-Datenbanken
│ ├── MongoDB (Dokument)
│ ├── Redis (Key-Value)
│ └── Cassandra (Spaltenorientiert)
├── Dateien
│ ├── CSV, JSON, XML
│ └── Excel, PDF
├── Web-Services
│ ├── REST-APIs
│ └── SOAP
└── Cloud-Dienste
└── AWS S3, Azure Blob, etc.
```
---
## Datenintegration
### ETL-Prozess
```
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Extract │ → │ Transform│ → │ Load │ → │ Target │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
│ │
│ Bereinigung │
│ Konvertierung │
│ Aggregation │
```
### Herausforderungen
- **Datenqualität**: Vollständigkeit, Konsistenz
- **Formate**: Unterschiedliche Strukturen
- **Latenz**: Echtzeit vs. Batch
- **Security**: Authentifizierung, Autorisierung
---
## APIs (Application Programming Interface)
### REST-Prinzipien
```
REST-Konventionen:
├── Ressourcenorientiert (Nomen)
├── HTTP-Methoden nutzen
│ ├── GET → Lesen
│ ├── POST → Erstellen
│ ├── PUT → Ersetzen
│ ├── PATCH → Teilaktualisierung
│ └── DELETE → Löschen
├── Statuscodes
│ ├── 200 OK
│ ├── 201 Created
│ ├── 400 Bad Request
│ ├── 401 Unauthorized
│ └── 404 Not Found
└── Stateless (zustandslos)
```
### API-Beispiel
```python
# Python REST-API mit Flask
from flask import Flask, jsonify, request
app = Flask(__name__)
# GET - Daten abrufen
@app.route('/api/kunden', methods=['GET'])
def get_kunden():
return jsonify(kunden_liste)
# POST - Daten erstellen
@app.route('/api/kunden', methods=['POST'])
def create_kunde():
daten = request.json
kunden_liste.append(daten)
return jsonify(daten), 201
# PUT - Daten aktualisieren
@app.route('/api/kunden/<int:id>', methods=['PUT'])
def update_kunde(id):
daten = request.json
for i, k in enumerate(kunden_liste):
if k['id'] == id:
kunden_liste[i] = daten
return jsonify(daten)
return jsonify({'error': 'Not found'}), 404
```
---
## Datenbank-Anbindung
### Python mit SQLAlchemy
```python
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class Kunde(Base):
__tablename__ = 'kunden'
id = Column(Integer, primary_key=True)
name = Column(String(100))
email = Column(String(255))
# Verbindung herstellen
engine = create_engine('sqlite:///kunden.db')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
# Daten abfragen
for kunde in session.query(Kunde).all():
print(f"{kunde.id}: {kunde.name}")
```
---
## Handlungsphasen
1. **Analysieren**: Datenquellen identifizieren, Strukturen verstehen
2. **Planen**: Integrationskonzept erstellen
3. **Entwickeln**: Schnittstellen implementieren
4. **Testen**: Datenfluss prüfen
5. **Dokumentieren**: Handhabung beschreiben
---
## Prüfungsrelevanz
- Wichtig für LF 12a (Abschlussprojekt)
- Datenintegration in Projekten
---
## Querverweise
- [[2-Ausbildungsjahr/LF7-Cyber-physische-Systeme|Vorher: LF 7]]
- [[2-Ausbildungsjahr/LF9-Netzwerke-Dienste|Nachher: LF 9]]
- [[Programmiersprachen/Python|Python Vertiefung]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

32
2-Ausbildungsjahr/LF8-Datenintegration/LF8-00-Übersicht.md Normal file
View File

@@ -0,0 +1,32 @@
# Lernfeld 8: Daten systemübergreifend bereitstellen
## Übersicht
Dieses Lernfeld behandelt die Integration von Daten aus verschiedenen Quellen.
## Themen
| Nr. | Thema | Beschreibung |
|-----|-------|-------------|
| 8.1 | [[LF8-01-Datenquellen|Datenquellen]] | Datenbanken, APIs, Dateien |
| 8.2 | [[LF8-02-Schnittstellen|Schnittstellen]] | REST, SOAP, GraphQL |
| 8.3 | [[LF8-03-Datenformate|Datenformate]] | JSON, XML, CSV |
| 8.4 | [[LF8-04-ETL-Prozesse|ETL-Prozesse]] | Extrahieren, Transformieren, Laden |
## Lernziele
- Daten aus verschiedenen Quellen integrieren
- Schnittstellen entwickeln und nutzen
- Datenformate konvertieren
- ETL-Prozesse implementieren
---
## Querverweise
- [[LF7-04-Kommunikation|Zurück: Kommunikation]]
- [[LF9-Netzwerke-Dienste|Nächstes Lernfeld: Netzwerke und Dienste]]
---
*Stand: 2024*

130
2-Ausbildungsjahr/LF8-Datenintegration/LF8-01-Datenquellen.md Normal file
View File

@@ -0,0 +1,130 @@
# 8.1 Datenquellen
## Arten von Datenquellen
### Datenbanken
```
Datenbank-Typen
├── Relational (MySQL, PostgreSQL, Oracle)
├── NoSQL (MongoDB, Cassandra)
├── Graph (Neo4j)
└── Zeitreihen (InfluxDB)
```
### Dateisysteme
| Format | Typ | Einsatz |
|--------|-----|----------|
| CSV | Text | Tabellarische Daten |
| JSON | Text | Strukturierte Daten |
| XML | Text | Konfiguration, Austausch |
| Excel | Binär | Tabellenkalkulation |
| PDF | Binär | Dokumente |
### Externe Quellen
```
Externe Datenquellen
├── APIs (REST, SOAP)
├── Webservices
├── Cloud-Speicher
├── Stream-Daten (IoT)
└── Drittanbieter
```
---
## Datenbank-Anbindung
### JDBC (Java)
```java
// Verbindung zu Datenbank
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/datenbank",
"benutzer",
"passwort"
);
// Abfrage
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM tabelle");
```
### Python (SQLAlchemy)
```python
from sqlalchemy import create_engine
engine = create_engine(
'postgresql://user:password@localhost:5432/database'
)
# Daten lesen
df = pd.read_sql("SELECT * FROM tabelle", engine)
```
---
## Dateien einlesen
### CSV
```python
import pandas as pd
# CSV einlesen
df = pd.read_csv('daten.csv')
# Mit Trennzeichen
df = pd.read_csv('daten.txt', sep='\t')
```
### JSON
```python
import json
# JSON laden
with open('daten.json') as f:
daten = json.load(f)
# Zu DataFrame
df = pd.json_normalize(daten)
```
### Excel
```python
import pandas as pd
# Excel einlesen
df = pd.read_excel('daten.xlsx')
# Bestimmtes Sheet
df = pd.read_excel('daten.xlsx', sheet_name='Tabelle1')
```
---
## Datenbanktypen im Vergleich
| Kriterium | Relational | NoSQL |
|-----------|-----------|-------|
| Schema | Fest | Flexibel |
| Skalierung | Vertikal | Horizontal |
| Transaktionen | ACID | Eventual Consistency |
| Komplexität | Mittel | Niedrig |
| Beispiele | MySQL, PostgreSQL | MongoDB, Redis |
---
## Querverweise
- [[LF8-02-Schnittstellen|Nächstes Thema: Schnittstellen]]
- [[LF3-Datenbanken|Datenbanken]]
---
*Stand: 2024*

185
2-Ausbildungsjahr/LF8-Datenintegration/LF8-02-Schnittstellen.md Normal file
View File

@@ -0,0 +1,185 @@
# 8.2 Schnittstellen
## API-Typen
### REST (Representational State Transfer)
```
REST-Prinzipien
├── Ressourcen-orientiert
├── Stateless
├── Einheitliche Schnittstelle
├── Client-Server
└── Cache-fähig
```
### REST-Endpunkte
```
Beispiel: Benutzer-API
GET /api/benutzer → Alle Benutzer
GET /api/benutzer/123 → Ein Benutzer
POST /api/benutzer → Erstellen
PUT /api/benutzer/123 → Aktualisieren
DELETE /api/benutzer/123 → Löschen
```
### REST-Beispiel
```javascript
// Express.js Server
const express = require('express');
const app = express();
app.get('/api/benutzer/:id', async (req, res) => {
const benutzer = await findBenutzer(req.params.id);
res.json(benutzer);
});
app.post('/api/benutzer', async (req, res) => {
const neuerBenutzer = await createBenutzer(req.body);
res.status(201).json(neuerBenutzer);
});
```
---
## SOAP (Simple Object Access Protocol)
### Unterschiede zu REST
| Kriterium | REST | SOAP |
|-----------|------|------|
| Format | JSON, XML | Nur XML |
| Transport | HTTP | HTTP, SMTP |
| Stateless | Ja | Optional |
| Größe | Klein | Groß |
### SOAP-Beispiel
```xml
<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
<soap:Header/>
<soap:Body>
<GetUserRequest xmlns="http://beispiel.de/api">
<UserId>123</UserId>
</GetUserRequest>
</soap:Body>
</soap:Envelope>
```
---
## GraphQL
### Konzepte
```
GraphQL - Besonderheiten
├── Eine Anfrage, viele Daten
├── Client definiert benötigte Felder
├── Stark typisiert (Schema)
└── Keine Over- oder Underfetching
```
### GraphQL-Beispiel
```graphql
# Anfrage
query {
user(id: "123") {
name
email
orders {
id
total
}
}
}
# Antwort
{
"data": {
"user": {
"name": "Max",
"email": "max@example.com",
"orders": [
{ "id": "1", "total": 99.99 }
]
}
}
}
```
---
## API-Design Best Practices
### URL-Design
```
Richtlinien
├── Ressourcen plural (benutzer nicht benutzer)
├── Bindestrich für Wörter (benutzer-profil)
├── Kleinbuchstaben
├── Keine Verben im Pfad
└── Query-Parameter für Filter
```
### HTTP-Statuscodes
| Code | Bedeutung | Verwendung |
|------|-----------|------------|
| 200 | OK | Erfolgreich |
| 201 | Created | Erstellt |
| 400 | Bad Request | Ungültige Anfrage |
| 401 | Unauthorized | Nicht angemeldet |
| 404 | Not Found | Nicht gefunden |
| 500 | Server Error | Fehler |
---
## API-Dokumentation
### OpenAPI (Swagger)
```yaml
openapi: 3.0.0
info:
title: Meine API
version: 1.0.0
paths:
/benutzer:
get:
summary: Alle Benutzer
responses:
'200':
description: Erfolgreich
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/Benutzer'
```
### Tools
| Tool | Beschreibung |
|------|-------------|
| Swagger UI | Interaktive Dokumentation |
| Postman | API-Testing |
| Insomnia | API-Client |
---
## Querverweise
- [[LF8-01-Datenquellen|Zurück: Datenquellen]]
- [[LF8-03-Datenformate|Nächstes Thema: Datenformate]]
---
*Stand: 2024*

199
2-Ausbildungsjahr/LF8-Datenintegration/LF8-03-Datenformate.md Normal file
View File

@@ -0,0 +1,199 @@
# 8.3 Datenformate
## JSON (JavaScript Object Notation)
### Grundstruktur
```json
{
"name": "Max Mustermann",
"alter": 25,
"adresse": {
"stadt": "Berlin",
"plz": "10115"
},
"hobbys": ["Lesen", "Programmieren"],
"aktiv": true
}
```
### Datentypen
| Typ | Beispiel |
|-----|----------|
| String | "Hallo" |
| Number | 42, 3.14 |
| Boolean | true, false |
| Array | [1, 2, 3] |
| Object | {"key": "value"} |
| Null | null |
### JSON in Python
```python
import json
# String zu Dictionary
daten = json.loads('{"name": "Max"}')
# Dictionary zu String
text = json.dumps(daten, indent=2)
# Mit Datei
with open('daten.json', 'w') as f:
json.dump(daten, f, indent=2)
```
---
## XML (eXtensible Markup Language)
### Grundstruktur
```xml
<?xml version="1.0" encoding="UTF-8"?>
<benutzer>
<name>Max Mustermann</name>
<alter>25</alter>
<adresse>
<stadt>Berlin</stadt>
</adresse>
</benutzer>
```
### XML-Attribute
```xml
<benutzer id="123" typ="admin">
<name>Max</name>
</benutzer>
```
### XML in Python
```python
import xml.etree.ElementTree as ET
# Parsen
baum = ET.parse('daten.xml')
wurzel = baum.getroot()
# Element finden
for kind in wurzel.findall('.//kind'):
print(kind.text)
# Erstellen
root = ET.Element('daten')
ET.SubElement(root, 'wert').text = 'test'
baum = ET.ElementTree(root)
baum.write('ausgabe.xml')
```
---
## CSV (Comma Separated Values)
### Grundstruktur
```csv
Name,Alter,Stadt
Max,25,Berlin
Anna,30,Hamburg
Peter,28,München
```
### Mit Python
```python
import pandas as pd
# Lesen
df = pd.read_csv('daten.csv', sep=',')
# Schreiben
df.to_csv('ausgabe.csv', index=False)
# Mit Header überspringen
df = pd.read_csv('daten.csv', skiprows=1)
```
---
## Vergleich
| Kriterium | JSON | XML | CSV |
|-----------|------|-----|-----|
| Lesbarkeit | Gut | Gut | Gut |
| Datentypen | Ja | Ja | Nein |
| Komplexität | Niedrig | Mittel | Niedrig |
| Dateigröße | Klein | Groß | Kleinest |
| Einsatz | APIs | Konfiguration | Tabellarisch |
---
## Datenkonvertierung
### CSV zu JSON
```python
import pandas as pd
import json
# CSV lesen
df = pd.read_csv('daten.csv')
# Zu JSON
json_string = df.to_json(orient='records', indent=2)
# In Datei schreiben
with open('daten.json', 'w') as f:
f.write(json_string)
```
### XML zu JSON
```python
import xmltodict
import json
# XML zu Dictionary
with open('daten.xml') as f:
daten = xmltodict.parse(f)
# Zu JSON
json_string = json.dumps(daten, indent=2)
```
---
## Datenvalidierung
### JSON Schema
```json
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"properties": {
"name": {
"type": "string"
},
"alter": {
"type": "integer",
"minimum": 0
}
},
"required": ["name"]
}
```
---
## Querverweise
- [[LF8-02-Schnittstellen|Zurück: Schnittstellen]]
- [[LF8-04-ETL-Prozesse|Nächstes Thema: ETL-Prozesse]]
---
*Stand: 2024*

217
2-Ausbildungsjahr/LF8-Datenintegration/LF8-04-ETL-Prozesse.md Normal file
View File

@@ -0,0 +1,217 @@
# 8.4 ETL-Prozesse
## Was ist ETL?
**ETL** = Extract, Transform, Load
```
ETL - Prozess
┌─────────┐ ┌─────────────┐ ┌─────────┐
│ Extract │ → │ Transform │ → │ Load │
│(Extrahieren)│ │(Transformieren)│ │(Laden) │
└─────────┘ └─────────────┘ └─────────┘
```
### Anwendungsfälle
| Fall | Beschreibung |
|------|-------------|
| Data Warehouse | Daten für Analysen konsolidieren |
| Migration | Daten auf neues System übertragen |
| Integration | Daten aus verschiedenen Quellen zusammenführen |
| Reporting | Daten für Reports aufbereiten |
---
## Extract (Extraktion)
### Extraktionsarten
| Typ | Beschreibung |
|-----|-------------|
| Full Load | Alle Daten laden |
| Incremental | Nur neue/geänderte Daten |
| CDC | Change Data Capture |
### Quelldaten
```
Extraktionsquellen
├── Datenbanken
├── Dateien (CSV, JSON, XML)
├── APIs
└── Streams
```
### Beispiel
```python
# Datenbank
df_quelle = pd.read_sql("SELECT * FROM tabelle", conn)
# API
response = requests.get('https://api.example.com/daten')
df_quelle = pd.DataFrame(response.json())
# Datei
df_quelle = pd.read_csv('daten.csv')
```
---
## Transform (Transformation)
### Transformationstypen
```
Transformationen - Übersicht
├── Datentyp-Konvertierung
├── Berechnungen
├── Aggregationen
├── Filterung
├── JOINs
├── Normalisierung
└── Bereinigung
```
### Bereinigung
```python
# Fehlende Werte
df['alter'].fillna(df['alter'].mean(), inplace=True)
# Duplikate entfernen
df.drop_duplicates(inplace=True)
# Groß-/Kleinschreibung
df['name'] = df['name'].str.lower()
# Trimmen
df['name'] = df['name'].str.strip()
```
### Berechnungen
```python
# Neue Spalte
df['umsatz_mit_mwst'] = df['umsatz'] * 1.19
# Bedingte Werte
df['rabatt'] = df.apply(
lambda x: x['umsatz'] * 0.1 if x['umsatz'] > 100 else 0,
axis=1
)
```
### Aggregation
```python
# Gruppieren und aggregieren
df_grouped = df.groupby('kategorie').agg({
'umsatz': 'sum',
'anzahl': 'count'
}).reset_index()
```
---
## Load (Laden)
### Ladestrategien
| Typ | Beschreibung |
|-----|-------------|
| Full Load | Tabelle komplett ersetzen |
| Incremental Load | Nur neue Daten hinzufügen |
| Upsert | Update oder Insert |
### Ziel-Systeme
```
Lade-Ziele
├── Datenbank (MySQL, PostgreSQL)
├── Data Warehouse (Snowflake, BigQuery)
├── Datei (CSV, JSON)
└── Cloud Storage
```
### Beispiel
```python
# In Datenbank laden
df.to_sql('ziel_tabelle', conn, if_exists='replace', index=False)
# In CSV schreiben
df.to_csv('ausgabe.csv', index=False)
# In Excel schreiben
df.to_excel('ausgabe.xlsx', index=False)
```
---
## Orchestrierung
### Tools
| Tool | Beschreibung |
|------|-------------|
| Apache Airflow | Workflow-Orchestrierung |
| Luigi | Python-basiert |
| dbt | Data Transformation |
| Talend | ETL-Werkzeug |
| Apache NiFi | Datenfluss |
### Airflow DAG
```python
from airflow import DAG
from airflow.operators.python import PythonOperator
from datetime import datetime
dag = DAG('etl_pipeline', start_date=datetime(2024, 1, 1))
extract = PythonOperator(
task_id='extract',
python_callable=extract_daten,
dag=dag
)
transform = PythonOperator(
task_id='transform',
python_callable=transform_daten,
dag=dag
)
load = PythonOperator(
task_id='load',
python_callable=load_daten,
dag=dag
)
extract >> transform >> load
```
---
## Fehlerbehandlung
```
ETL - Fehlerstrategien
├── Logging
├── Benachrichtigung
├── Retry-Logik
├── Quarantäne (Problem-Daten)
└── Monitoring
```
---
## Querverweise
- [[LF8-03-Datenformate|Zurück: Datenformate]]
- [[LF9-Netzwerke-Dienste|Nächstes Lernfeld: Netzwerke und Dienste]]
---
*Stand: 2024*

32
2-Ausbildungsjahr/LF9-Netzwerke-Dienste/LF9-00-Übersicht.md Normal file
View File

@@ -0,0 +1,32 @@
# Lernfeld 9: Netzwerke und Dienste bereitstellen
## Übersicht
Dieses Lernfeld behandelt die Bereitstellung von Netzwerken und Netzwerkdiensten.
## Themen
| Nr. | Thema | Beschreibung |
|-----|-------|-------------|
| 9.1 | [[LF9-01-Netzwerkdienste|Netzwerkdienste]] | DHCP, DNS, HTTP |
| 9.2 | [[LF9-02-Server|Server]] | Betrieb, Virtualisierung |
| 9.3 | [[LF9-03-Virtualisierung|Virtualisierung]] | Container, Cloud |
| 9.4 | [[LF9-04-Monitoring|Monitoring]] | Überwachung, Alerts |
## Lernziele
- Netzwerkdienste konfigurieren
- Server betreiben
- Virtualisierung verstehen
- Systeme überwachen
---
## Querverweise
- [[LF8-04-ETL-Prozesse|Zurück: ETL-Prozesse]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Betriebswirtschaft]]
---
*Stand: 2024*

157
2-Ausbildungsjahr/LF9-Netzwerke-Dienste/LF9-01-Netzwerkdienste.md Normal file
View File

@@ -0,0 +1,157 @@
# 9.1 Netzwerkdienste
## Wichtige Netzwerkdienste
### Übersicht
```
Netzwerkdienste
├── DHCP (IP-Adressen)
├── DNS (Namen auflösen)
├── HTTP/HTTPS (Web)
├── SMTP (E-Mail)
├── FTP/SFTP (Dateien)
├── SSH (Remote-Zugriff)
└── LDAP (Verzeichnis)
```
---
## DHCP (Dynamic Host Configuration Protocol)
### Funktion
```
DHCP - Ablauf
Client → DHCP Discover (Broadcast)
Server → DHCP Offer
Client → DHCP Request
Server → DHCP Acknowledge
```
### Konfiguration
```
DHCP-Server - Einstellungen
├── IP-Bereich (Pool)
├── Subnetzmaske
├── Gateway
├── DNS-Server
├── Lease Time
└── Reservierungen
```
### Beispiel
```yaml
# DHCP-Konfiguration (ISC DHCP)
subnet 192.168.1.0 netmask 255.255.255.0 {
range 192.168.1.100 192.168.1.200;
option routers 192.168.1.1;
option domain-name-servers 8.8.8.8, 8.8.4.4;
default-lease-time 600;
max-lease-time 7200;
}
```
---
## DNS (Domain Name System)
### Aufbau
```
DNS - Hierarchie
. (Root)
├── de
│ └── example.de
├── com
│ └── example.com
└── org
└── wikipedia.org
```
### DNS-Records
| Typ | Bedeutung | Beispiel |
|-----|----------|----------|
| A | IPv4-Adresse | example.com → 93.184.216.34 |
| AAAA | IPv6-Adresse | example.com → ... |
| CNAME | Alias | www → example.com |
| MX | Mail-Server | @ → mail.example.com |
| TXT | Text | v=spf1 include:_spf.google.com ~all |
### nslookup/dig
```bash
# DNS-Abfrage
nslookup example.com
dig example.com
# Bestimmter Record-Typ
dig MX example.com
```
---
## HTTP/HTTPS
### HTTP-Request
```
GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html
```
### HTTPS/TLS
```
HTTPS - Ablauf
1. Client → Server: Hallo
2. Server → Client: Zertifikat + Public Key
3. Client: Zertifikat prüfen
4. Client → Server: Pre-Master-Secret (verschlüsselt)
5. Beide: Session Key generieren
6. Verschlüsselte Kommunikation
```
---
## Weitere Dienste
### SSH (Secure Shell)
```bash
# Verbinden
ssh benutzer@server.example.com
# Datei kopieren
scp datei.txt benutzer@server:/pfad/
# Schlüssel generieren
ssh-keygen -t ed25519
```
### SMTP (E-Mail-Versand)
```
SMTP - Ablauf
1. EHLO client
2. MAIL FROM: absender@example.com
3. RCPT TO: empfaenger@example.com
4. DATA
5. Nachricht
6. QUIT
```
---
## Querverweise
- [[LF9-02-Server|Nächstes Thema: Server]]
---
*Stand: 2024*

179
2-Ausbildungsjahr/LF9-Netzwerke-Dienste/LF9-02-Server.md Normal file
View File

@@ -0,0 +1,179 @@
# 9.2 Server
## Server-Grundlagen
### Serverarten
| Typ | Aufgabe |
|-----|----------|
| Webserver | HTTP bereitstellen |
| Datenbankserver | Daten speichern |
| Fileserver | Dateien bereitstellen |
| Mailserver | E-Mail |
| Druckserver | Drucker verwalten |
| Authentifizierungsserver | Anmeldung (AD, LDAP) |
### Betriebssysteme
```
Server-Betriebssysteme
├── Windows Server
│ ├── 2019
│ └── 2022
├── Linux
│ ├── Ubuntu Server
│ ├── CentOS/RHEL
│ └── SUSE
└── BSD
```
---
## Linux-Server
### Grundbefehle
```bash
# Paketverwaltung (Debian/Ubuntu)
apt update
apt upgrade
apt install paketname
# Systemd
systemctl start dienst
systemctl stop dienst
systemctl status dienst
systemctl enable dienst
# Prozesse
ps aux
top
htop
```
### Benutzerverwaltung
```bash
# Benutzer anlegen
sudo useradd -m benutzername
# Passwort ändern
sudo passwd benutzername
# Zur Gruppe hinzufügen
sudo usermod -aG gruppe benutzername
# Benutzer löschen
sudo userdel benutzername
```
---
## Windows Server
### Rollen
```
Windows Server Rollen
├── Active Directory (AD DS)
├── DNS-Server
├── DHCP-Server
├── IIS (Webserver)
├── Dateiserver
├── Drucker-Server
└── Hyper-V
```
### PowerShell
```powershell
# Dienst starten
Start-Service -Name "Spooler"
# Prozesse anzeigen
Get-Process
# Benutzer anlegen
New-LocalUser -Name "Benutzer" -Password (ConvertTo-SecureString "Passwort" -AsPlainText -Force)
```
---
## Webserver
### Apache
```apache
# Virtual Host
<VirtualHost *:80>
ServerName example.com
DocumentRoot /var/www/html
<Directory /var/www/html>
Options Indexes FollowSymLinks
AllowOverride All
</Directory>
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
```
### Nginx
```nginx
server {
listen 80;
server_name example.com;
root /var/www/html;
index index.html index.php;
location / {
try_files $uri $uri/ =404;
}
location ~ \.php$ {
fastcgi_pass unix:/var/run/php/php-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
}
```
---
## Server-Hardware
### Komponenten
| Komponente | Bedeutung |
|------------|----------|
| CPU | Rechenleistung |
| RAM | Arbeitsspeicher |
| Festplatte | Speicher (SSD bevorzugen) |
| Netzwerk | Bandbreite |
| USV | Ausfallschutz |
### RAID
```
RAID - Stufen
├── RAID 0: Striping (keine Redundanz)
├── RAID 1: Mirroring (Spiegelung)
├── RAID 5: Parität (min. 3 Platten)
├── RAID 6: Doppelte Parität
└── RAID 10: Spiegel + Striping
```
---
## Querverweise
- [[LF9-01-Netzwerkdienste|Zurück: Netzwerkdienste]]
- [[LF9-03-Virtualisierung|Nächstes Thema: Virtualisierung]]
---
*Stand: 2024*

175
2-Ausbildungsjahr/LF9-Netzwerke-Dienste/LF9-03-Virtualisierung.md Normal file
View File

@@ -0,0 +1,175 @@
# 9.3 Virtualisierung
## Virtualisierung - Grundlagen
### Was ist Virtualisierung?
```
Virtualisierung
Mehrere virtuelle Maschinen auf einer
physischen Hardware betreiben
```
### Vorteile
| Vorteil | Beschreibung |
|---------|-------------|
| Kosteneinsparung | Weniger Hardware |
| Flexibilität | Schnell bereitgestellt |
| Isolation | Getrennte Umgebungen |
| Skalierung | Leicht erweiterbar |
| Testumgebung | Schnell aufgesetzt |
---
## Virtualisierungstypen
### Full Virtualization
```
Gast-OS läuft unverändert
├── VMware Workstation
├── VirtualBox
└── Hyper-V
```
### Para-Virtualization
```
Gast-OS weiß von Virtualisierung
├── Xen
└── Citrix XenServer
```
### Container-Virtualisierung
```
Leichtgewichtige Virtualisierung
├── Docker
├── Podman
└── Kubernetes
```
---
## Docker
### Grundlagen
```
Docker - Begriffe
├── Image: Vorlage (Template)
├── Container: Laufende Instanz
├── Dockerfile: Image-Beschreibung
├── Registry: Image-Speicher
└── Volume: Persistenter Speicher
```
### Docker-Befehle
```bash
# Container starten
docker run -d -p 8080:80 nginx
# Container auflisten
docker ps
docker ps -a
# Container stoppen
docker stop container_id
# Image bauen
docker build -t mein-image .
# Container entfernen
docker rm container_id
```
### Dockerfile
```dockerfile
# Basis-Image
FROM node:18-alpine
# Arbeitsverzeichnis
WORKDIR /app
# Dateien kopieren
COPY package*.json ./
COPY . .
# Abhängigkeiten installieren
RUN npm install
# Port freigeben
EXPOSE 3000
# Startbefehl
CMD ["node", "server.js"]
```
---
## Kubernetes
### Architektur
```
Kubernetes - Komponenten
├── Master Node
│ ├── API Server
│ ├── Scheduler
│ ├── Controller Manager
│ └── etcd
├── Worker Nodes
│ ├── Kubelet
│ ├── Kube Proxy
│ └── Container Runtime
└── Add-ons (DNS, Dashboard)
```
### Kubernetes-Objekte
| Objekt | Beschreibung |
|--------|-------------|
| Pod | Kleinste Einheit (1+ Container) |
| Deployment | Replikate, Updates |
| Service | Netzwerkzugriff |
| Ingress | HTTP-Routing |
| ConfigMap | Konfiguration |
| Secret | Sensitive Daten |
---
## Cloud-Computing
### Service-Modelle
```
Cloud - Modelle
├── IaaS: Infrastructure as a Service
│ └── Virtuelle Maschinen, Netzwerk
├── PaaS: Platform as a Service
│ └── Laufzeitumgebung
└── SaaS: Software as a Service
└── Fertige Anwendung
```
### Anbieter
| Anbieter | Service |
|----------|----------|
| AWS | EC2, S3, Lambda |
| Azure | VMs, Blob, Functions |
| Google Cloud | Compute Engine, Cloud Storage |
---
## Querverweise
- [[LF9-02-Server|Zurück: Server]]
- [[LF9-04-Monitoring|Nächstes Thema: Monitoring]]
---
*Stand: 2024*

176
2-Ausbildungsjahr/LF9-Netzwerke-Dienste/LF9-04-Monitoring.md Normal file
View File

@@ -0,0 +1,176 @@
# 9.4 Monitoring
## Monitoring - Grundlagen
### Was wird überwacht?
```
Monitoring-Bereiche
├── Verfügbarkeit (Ist das System erreichbar?)
├── Performance (CPU, RAM, Disk)
├── Netzwerk (Traffic, Latenz)
├── Anwendungen (Logs, Fehler)
└── Sicherheit (Eindringlinge)
```
### Wichtige Metriken
| Metrik | Beschreibung | Beispiel |
|--------|-------------|----------|
| CPU | Auslastung | < 80% |
| RAM | Speicherauslastung | < 85% |
| Disk | Festplattennutzung | < 90% |
| Network | Durchsatz | 100 Mbps |
| Latency | Antwortzeit | < 200ms |
---
## Monitoring-Tools
### Nagios
```
Nagios - Features
├── Host-Überwachung
├── Service-Überwachung
├── Alerting
├── Plugins
└── Web-Interface
```
### Prometheus + Grafana
```
Stack
├── Prometheus: Metriken sammeln
├── Alertmanager: Alarme
├── Grafana: Visualisierung
└── Exporters: Datenquellen
```
### Prometheus - Beispiel
```yaml
# prometheus.yml
global:
scrape_interval: 15s
scrape_configs:
- job_name: 'node'
static_configs:
- targets: ['localhost:9100']
```
### Grafana Dashboard
```
Grafana - Verwendung
1. Datenquelle hinzufügen (Prometheus)
2. Dashboard erstellen
3. Panels konfigurieren (Graph, Stat, Table)
4. Alerts einrichten
```
---
## Logging
### Log-Management
```
Log-Stufen
├── DEBUG: Detaillierte Informationen
├── INFO: Allgemeine Informationen
├── WARNING: Warnungen
├── ERROR: Fehler
└── CRITICAL: Kritische Fehler
```
### Zentrales Logging
```
ELK-Stack
├── Elasticsearch: Suchmaschine
├── Logstash: Verarbeitung
├── Kibana: Visualisierung
└── Beats: Sammlung
```
### Logging in Python
```python
import logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
logger.info("Anwendung gestartet")
logger.error("Fehler aufgetreten")
```
---
## Alerting
### Alert-Regeln
```yaml
groups:
- name: example
rules:
- alert: HighCPU
expr: cpu_usage > 80
for: 5m
labels:
severity: warning
annotations:
summary: "Hohe CPU-Auslastung auf {{ $labels.instance }}"
```
### Benachrichtigungswege
| Kanal | Einsatz |
|-------|----------|
| E-Mail | Standard |
| Slack | Team-Kommunikation |
| PagerDuty | Incident Management |
| SMS | Kritische Alarme |
---
## Verfügbarkeit
### Uptime
```
Uptime-Berechnung
99% → 7,3 Stunden/Jahr offline
99,9% → 8,7 Stunden/Jahr offline
99,99% → 52 Minuten/Jahr offline
99,999% → 5 Minuten/Jahr offline
```
### Checks
```
Verfügbarkeitsprüfung
├── Ping
├── Port-Check
├── HTTP-Response
├── Zertifikat
└── Transaktion
```
---
## Querverweise
- [[LF9-03-Virtualisierung|Zurück: Virtualisierung]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Betriebswirtschaft]]
---
*Stand: 2024*

187
2-Ausbildungsjahr/LF9-Netzwerke-Dienste/LF9-Notizen.md Normal file
View File

@@ -0,0 +1,187 @@
# LF 9: Netzwerke und Dienste bereitstellen
> **2. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, Netzwerke und Dienste zu planen, zu konfigurieren und zu erweitern.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Anforderungen an Netzwerke und Dienste ermitteln
- [ ] Netzwerkkomponenten auswählen
- [ ] Dienste konfigurieren (DNS, DHCP, etc.)
- [ ] Netzwerksicherheit implementieren
- [ ] Funktionsprüfungen durchführen
- [ ] Dokumentation erstellen
---
## Netzwerkdienste
### DNS (Domain Name System)
**Aufgabe**: Namen zu IP-Adressen auflösen
**Zonentypen:**
- **Master**: Originaldaten, Schreibzugriff
- **Slave**: Kopie vom Master
- **Forward**: Name → IP
- **Reverse**: IP → Name
**Beispiel named.conf:**
```
zone "example.com" {
type master;
file "db.example.com";
};
```
### DHCP (Dynamic Host Configuration Protocol)
**Aufgabe**: IP-Konfiguration automatisch vergeben
**Konfigurationsbeispiel:**
```
subnet 192.168.1.0 netmask 255.255.255.0 {
range 192.168.1.100 192.168.1.200;
option routers 192.168.1.1;
option domain-name-servers 8.8.8.8, 8.8.4.4;
default-lease-time 86400;
}
```
### Weitere Dienste
| Dienst | Port | Beschreibung |
|--------|------|--------------|
| HTTP | 80/443 | Webserver |
| FTP | 21 | Dateiübertragung |
| SSH | 22 | Sichere Shell |
| SMTP | 25 | E-Mail-Versand |
| IMAP/POP3 | 143/110 | E-Mail-Abruf |
| LDAP | 389 | Verzeichnisdienst |
| SNMP | 161/162 | Netzwerküberwachung |
---
## Netzwerksicherheit
### Firewall
**Typen:**
- **Paketfilter**: Layer 3/4
- **Stateful Inspection**: Verbindungsverfolgung
- **Application Layer Gateway**: Layer 7
**iptables-Beispiel:**
```bash
# Eingehend blocken, ausgehend erlauben
iptables -P INPUT DROP
iptables -P OUTPUT ACCEPT
# Lokale Kommunikation erlauben
iptables -A INPUT -i lo -j ACCEPT
# SSH erlauben
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
# Bestehende Verbindungen erlauben
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
```
### VPN (Virtual Private Network)
**Arten:**
- **Site-to-Site**: Netzwerk-zu-Netzwerk
- **Remote Access**: Einzelner Client
**Protokolle:**
- **IPsec**: Sicher, weit verbreitet
- **OpenVPN**: Open Source, flexibel
- **WireGuard**: Modern, einfach
---
## VLAN (Virtual Local Area Network)
### VLAN-Konzepte
```
┌────────────────────────────────────┐
│ Switch │
├──────┬──────┬──────┬─────────────┤
│ VLAN10│ VLAN20│ VLAN30│ Native │
│ (Mgmt)│ (Data)│ (Voice)│ │
└──────┴──────┴──────┴─────────────┘
```
**VLAN-Tagging (802.1Q):**
- Jeder Frame erhält VLAN-ID
- Tagged Frames über Trunk-Ports
### Routing zwischen VLANs
```
┌────────┐ ┌────────┐
│ VLAN10 │──────│ │
│ 192.168.10.0/24 │ Router│
├────────┤ │ │ ┌────────┐
│ VLAN20 │──────│ │──────│ VLAN30 │
│ 192.168.20.0/24 │ │ │ 192.168.30.0/24
└────────┘ └────────┘ └────────┘
```
---
## Netzwerk-Monitoring
### Tools
| Tool | Typ | Beschreibung |
|------|-----|--------------|
| Nagios | Monitoring | Verfügbarkeitsprüfung |
| Zabbix | Monitoring | Umfassend |
| Wireshark | Analyse | Paket Sniffing |
| tcpdump | Analyse | Kommandozeile |
| Cacti | Visualisierung | Graphen |
### SNMP (Simple Network Management Protocol)
**Komponenten:**
- **Manager**: Überwachungssystem
- **Agent**: Auf überwachtem Gerät
- **MIB**: Management Information Base
**SNMP-Versionen:**
- v1: Keine Sicherheit
- v2c: Performance, keine Sicherheit
- v3: Authentifizierung und Verschlüsselung
---
## Handlungsphasen
1. **Informieren**: Anforderungen erheben, recherchieren
2. **Planen**: Konzept erstellen, Komponenten wählen
3. **Konfigurieren**: Dienste einrichten, testen
4. **Dokumentieren**: Konfiguration beschreiben
5. **Reflektieren**: Optimierungsmöglichkeiten finden
---
## Prüfungsrelevanz
- Wichtig für Systemintegration
- Netzwerkkenntnisse in Teil 2
---
## Querverweise
- [[2-Ausbildungsyear/LF8-Daten-bereitstellen|Vorher: LF 8]]
- [[3-Ausbildungsyear/LF10a-Benutzeroberflächen|Nachher: LF 10a]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

231
3-Ausbildungsjahr/LF10a-Benutzeroberflächen/LF10a-Notizen.md Normal file
View File

@@ -0,0 +1,231 @@
# LF 10a: Benutzerschnittstellen gestalten und entwickeln
> **3. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, Benutzeroberflächen für softwarebasierte Arbeitsabläufe und Geschäftsprozesse zu gestalten und zu entwickeln.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Geschäftsprozesse analysieren und modellieren
- [ ] Benutzeroberflächen ergonomisch gestalten
- [ ] UI/UX-Prinzipien anwenden
- [ ] Responsive Design umsetzen
- [ ] Agile Entwicklungsmethoden anwenden
- [ ] Datenschutz und Benutzerfreundlichkeit prüfen
---
## UI/UX-Grundlagen
### UI (User Interface)
```
Gestaltungselemente:
├── Layout
│ ├── Struktur
│ ├── Hierarchie
│ └── Weißraum
├── Typografie
│ ├── Schriftart
│ ├── Schriftgröße
│ └── Lesbarkeit
├── Farben
│ ├── Farbschema
│ ├── Kontrast
│ └── Bedeutung
└── Komponenten
├── Buttons
├── Formulare
└── Navigation
```
### UX (User Experience)
```
UX-Prinzipien:
├── Benutzerzentrierung
├── Konsistenz
├── Feedback
├── Fehlertoleranz
├── Übersichtlichkeit
└── Erwartungskonformität
```
---
## Web-Entwicklung
### HTML5
```html
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Beispielseite</title>
<link rel="stylesheet" href="style.css">
</head>
<body>
<header>
<nav>
<a href="/">Start</a>
<a href="/produkte">Produkte</a>
<a href="/kontakt">Kontakt</a>
</nav>
</header>
<main>
<h1>Willkommen</h1>
<p>Dies ist eine Beispielseite.</p>
</main>
<footer>&copy; 2024</footer>
</body>
</html>
```
### CSS3
```css
/* Responsive Design */
.container {
max-width: 1200px;
margin: 0 auto;
padding: 1rem;
}
/* Mobile First */
@media (min-width: 768px) {
.grid {
display: grid;
grid-template-columns: repeat(2, 1fr);
}
}
@media (min-width: 1024px) {
.grid {
grid-template-columns: repeat(3, 1fr);
}
}
/* Flexbox Navigation */
nav {
display: flex;
justify-content: space-between;
align-items: center;
}
```
### JavaScript
```javascript
// DOM Manipulation
document.addEventListener('DOMContentLoaded', () => {
const button = document.getElementById('submit-btn');
button.addEventListener('click', async (event) => {
event.preventDefault();
const formData = new FormData(document.querySelector('form'));
const data = Object.fromEntries(formData);
try {
const response = await fetch('/api/submit', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(data)
});
if (response.ok) {
alert('Erfolgreich gesendet!');
}
} catch (error) {
console.error('Fehler:', error);
}
});
});
```
---
## Geschäftsprozess-Modellierung
### BPMN (Business Process Model and Notation)
```
BPMN-Elemente:
├── Start/End Event
├── Task (Aufgabe)
├── Gateway (Verzweigung)
│ ├── XOR (entweder-oder)
│ ├── AND (parallel)
│ └── OR (möglicherweise)
├── Sequence Flow (Sequenzfluss)
└── Message Flow (Nachrichtenfluss)
```
### EPK (Ereignisgesteuerte Prozesskette)
```
Komponenten:
├── Funktionen (Aktivitäten)
├── Ereignisse (Auslöser)
├── Kanten (Verknüpfungen)
└── Operatoren (UND, ODER, XOR)
```
---
## Agile Methoden
### Scrum
```
Scrum-Rollen:
├── Product Owner
├── Scrum Master
└── Development Team
Scrum-Events:
├── Sprint Planning
├── Daily Standup
├── Sprint Review
└── Sprint Retrospective
Scrum-Artefakte:
├── Product Backlog
├── Sprint Backlog
└── Increment
```
### Kanban
```
Kanban-Prinzipien:
├── Visualisierung
├── Limit Work in Progress
├── Flow-Management
└── Kontinuierliche Verbesserung
```
---
## Prüfungsrelevanz
- Wichtig für LF 12a (Abschlussprojekt)
- UI-Design wird in Teil 2 geprüft
---
## Querverweise
- [[2-Ausbildungsjahr/LF9-Netzwerke-Dienste|Vorher: LF 9]]
- [[3-Ausbildungsjahr/LF11a-Funktionalität-realisiren|Nachher: LF 11a]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

261
3-Ausbildungsjahr/LF11a-Funktionalität-realisiren/LF11a-Notizen.md Normal file
View File

@@ -0,0 +1,261 @@
# LF 11a: Funktionalität in Anwendungen realisieren
> **3. Ausbildungsjahr** | Zeitrichtwert: **80 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, modulare Komponenten zur informationstechnischen Verarbeitung von Arbeitsabläufen und Geschäftsprozessen zu entwickeln und deren Qualität zu sichern.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Datenstrukturen und Funktionalitäten aus Anforderungen ableiten
- [ ] Modulare Softwarekomponenten planen
- [ ] Objektorientierte Programmierung anwenden
- [ ] Schnittstellen dokumentieren
- [ ] Testfälle formulieren und automatisierte Tests durchführen
- [ ] Qualitätskriterien anwenden
---
## Objektorientierte Programmierung (OOP)
### Grundkonzepte
```
OOP-Prinzipien:
├── Kapselung (Encapsulation)
│ └── Daten und Methoden zusammenfassen
├── Vererbung (Inheritance)
│ └── Gemeinsame Eigenschaften vererben
├── Polymorphismus
│ └── Gleiches Verhalten, unterschiedliche Formen
└── Abstraktion
└── Komplexität reduzieren
```
### Klassen-Beispiel (Python)
```python
from abc import ABC, abstractmethod
from datetime import datetime
class Kunde(ABC):
"""Abstrakte Basisklasse für Kunden"""
def __init__(self, kundennummer: int, name: str):
self._kundennummer = kundennummer
self._name = name
self._erstellt_am = datetime.now()
@property
def kundennummer(self) -> int:
return self._kundennummer
@abstractmethod
def berechne_rabatt(self, betrag: float) -> float:
"""Berechnet den Rabatt für den Kunden"""
pass
def __str__(self) -> str:
return f"Kunde {self._kundennummer}: {self._name}"
class Privatkunde(Kunde):
"""Privatkunde mit Standard-Rabatt"""
def __init__(self, kundennummer: int, name: str):
super().__init__(kundennummer, name)
self._rabatt_stufe = 1
def berechne_rabatt(self, betrag: float) -> float:
return betrag * 0.05 * self._rabatt_stufe
class Firmenkunde(Kunde):
"""Firmenkunde mit erhöhtem Rabatt"""
def __init__(self, kundennummer: int, name: str, firmenname: str):
super().__init__(kundennummer, name)
self._firmenname = firmenname
self._rabatt_stufe = 2
def berechne_rabatt(self, betrag: float) -> float:
return betrag * 0.10 * self._rabatt_stufe
```
---
## Entwurfsmuster (Design Patterns)
### Singleton
```python
class DatabaseConnection:
"""Singleton für Datenbankverbindung"""
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
cls._instance.connection = None
return cls._instance
def connect(self, connection_string: str):
if self.connection is None:
print(f"Verbinde mit: {connection_string}")
self.connection = "Datenbankverbindung hergestellt"
def disconnect(self):
if self.connection:
print("Trenne Verbindung")
self.connection = None
```
### Factory Method
```python
class KundeFactory:
"""Factory für Kunden-Erstellung"""
@staticmethod
def create_kunde(kundentyp: str, **kwargs) -> Kunde:
if kundentyp == "privat":
return Privatkunde(**kwargs)
elif kundentyp == "firma":
return Firmenkunde(**kwargs)
else:
raise ValueError(f"Unbekannter Kundentyp: {kundentyp}")
```
---
## Schnittstellen
### API-Design
```python
from typing import List, Optional
from pydantic import BaseModel
class BestellPosition(BaseModel):
"""Datenmodell für Bestellposition"""
artikel_id: int
menge: int
einzelpreis: float
class Bestellung(BaseModel):
"""Datenmodell für Bestellung"""
bestell_id: Optional[int] = None
kundennummer: int
positionen: List[BestellPosition]
gesamtpreis: float
def berechne_gesamtsumme(self) -> float:
return sum(p.menge * p.einzelpreis for p in self.positionen)
```
### REST-API mit FastAPI
```python
from fastapi import FastAPI, HTTPException
from typing import List
app = FastAPI(title="Bestell-API")
bestellungen: List[Bestellung] = []
@app.post("/bestellungen", response_model=Bestellung)
async def create_bestellung(bestellung: Bestellung):
"""Neue Bestellung erstellen"""
bestellung.gesamtpreis = bestellung.berechne_gesamtsumme()
bestellung.bestell_id = len(bestellungen) + 1
bestellungen.append(bestellung)
return bestellung
@app.get("/bestellungen/{bestell_id}")
async def get_bestellung(bestell_id: int):
"""Bestellung abrufen"""
for b in bestellungen:
if b.bestell_id == bestell_id:
return b
raise HTTPException(status_code=404, detail="Nicht gefunden")
```
---
## Qualitätssicherung
### Testmethoden
```
Test-Pyramide:
╱╲
╱ ╲ E2E Tests
╱────╲
╱ ╲ Integrationstests
╱────────╲
╱ ╲ Unit-Tests
╱────────────╲
```
### Unit-Tests (pytest)
```python
import pytest
from bestellung import Bestellung, BestellPosition
class TestBestellung:
@pytest.fixture
def beispiel_bestellung(self):
positionen = [
BestellPosition(artikel_id=1, menge=2, einzelpreis=10.00),
BestellPosition(artikel_id=2, menge=1, einzelpreis=25.00)
]
return Bestellung(kundennummer=100, positionen=positionen)
def test_gesamtsumme_berechnung(self, beispiel_bestellung):
"""Test der Gesamtsummen-Berechnung"""
ergebnis = beispiel_bestellung.berechne_gesamtsumme()
# 2 × 10 + 1 × 25 = 45
assert ergebnis == 45.00
def test_leere_bestellung(self):
"""Test mit leerer Positionen-Liste"""
bestellung = Bestellung(kundennummer=100, positionen=[])
ergebnis = bestellung.berechne_gesamtsumme()
assert ergebnis == 0.00
```
---
## Handlungsphasen
1. **Analysieren**: Anforderungen verstehen, Datenmodelle ableiten
2. **Planen**: Module und Schnittstellen entwerfen
3. **Implementieren**: Komponenten entwickeln
4. **Testen**: Tests durchführen, Qualität sichern
5. **Optimieren**: Verbesserungen einarbeiten
---
## Prüfungsrelevanz
- Programmierkenntnisse für Teil 2
- Wichtig für Abschlussprojekt
---
## Querverweise
- [[3-Ausbildungsjahr/LF10a-Benutzeroberflächen|Vorher: LF 10a]]
- [[3-Ausbildungsjahr/LF12a-Kundenspezifische-Entwicklung|Nachher: LF 12a]]
- [[Programmiersprachen/Python|OOP mit Python]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

273
3-Ausbildungsjahr/LF12a-Kundenspezifische-Entwicklung/LF12a-Notizen.md Normal file
View File

@@ -0,0 +1,273 @@
# LF 12a: Kundenspezifische Anwendungsentwicklung durchführen
> **3. Ausbildungsjahr** | Zeitrichtwert: **120 Stunden**
## Kernkompetenz
Die Schülerinnen und Schüler verfügen über die Kompetenz, einen Kundenauftrag zur Anwendungsentwicklung vollständig durchzuführen und zu bewerten.
---
## Lernziele
Nach diesem Lernfeld kannst du:
- [ ] Eine Anforderungsanalyse durchführen
- [ ] Ein Projekt planen und kalkulieren
- [ ] Lösungsvarianten entwickeln und vergleichen
- [ ] Ein Angebot erstellen
- [ ] Die Lösung implementieren
- [ ] Qualitätssicherung durchführen
- [ ] Das Projekt präsentieren und dokumentieren
---
## Projektphasen
```
PROJEKTLEBENSZYKLUS
┌─────────────┐
│ 1. Start │ Kick-off, Projektziele definieren
└──────┬──────┘
│
▼
┌─────────────┐
│ 2. Analyse │ Anforderungen erheben, Lastenheft
└──────┬──────┘
│
▼
┌─────────────┐
│ 3. Planung │ Pflichtenheft, Aufwandsschätzung
└──────┬──────┘
│
▼
┌─────────────┐
│ 4. Design │ Architektur, Datenmodell, UI
└──────┬──────┘
│
▼
┌─────────────┐
│ 5. Implem. │ Programmierung, Tests
└──────┬──────┘
│
▼
┌─────────────┐
│ 6. Test │ Qualitätssicherung, Abnahme
└──────┬──────┘
│
▼
┌─────────────┐
│ 7. Abschluss│ Übergabe, Schulung, Dokumentation
└─────────────┘
```
---
## Anforderungsanalyse
### Lastenheft (vom Kunden)
```markdown
# Lastenheft - Projekt [Name]
## 1. Ausgangslage
[Beschreibung der aktuellen Situation]
## 2. Zielsetzung
[Was soll erreicht werden?]
## 3. Funktionale Anforderungen
- [ ] Anforderung 1
- [ ] Anforderung 2
## 4. Nicht-funktionale Anforderungen
- Performance: < 2s Ladezeit
- Verfügbarkeit: 99%
- Sicherheit: TLS-Verschlüsselung
## 5. Randbedingungen
- Budget: [Betrag]
- Zeitrahmen: [Datum]
- Technologien: [Liste]
```
### Pflichtenheft (vom Auftragnehmer)
```markdown
# Pflichtenheft - Projekt [Name]
## 1. Zielbestimmung
[Festlegung der zu erreichenden Ziele]
## 2. Produkteinsatz
[Für wen/was wird das Produkt eingesetzt?]
## 3. Produktfunktionen
### F001: [Funktionsname]
- Beschreibung: [Was macht die Funktion?]
- Priorität: [Must/Should/Could]
## 4. Produktdaten
[List der zu verwaltenden Daten]
## 5. Produktleistungen
- Antwortzeit: < 500ms
- Verfügbarkeit: 99,9%
## 6. Abnahmekriterien
[Wie wird die Abnahme durchgeführt?]
```
---
## Projektkalkulation
### Aufwandsschätzung
**Funktionspunktmethode:**
```
FP = Σ (Komplexität × Gewichtung)
Beispiel:
- Bildschirmmasken: 5 × 5 = 25 FP
- Datenbanktabellen: 8 × 10 = 80 FP
- Schnittstellen: 3 × 7 = 21 FP
- Berichte: 4 × 5 = 20 FP
────────────────────────────
Gesamt-FP: 146
Aufwand (Stunden) = 146 × 4h = 584h
```
### Kostenberechnung
```
PERSONALKOSTEN:
Entwickler 500€/Tag × 60 Tage = 30.000€
Projektleiter 600€/Tag × 20 Tage = 12.000€
────────────────────────────────────────────
Summe Personal: = 42.000€
SACHKOSTEN:
Software-Lizenzen = 5.000€
Hardware = 3.000€
Reisekosten = 2.000€
────────────────────────────────────────────
Summe Sachkosten: = 10.000€
GESAMTKOSTEN: = 52.000€
+ Gewinn (15%): = 7.800€
+ MwSt (19%): = 11.382€
─────────────────────────────────────────────────────
ANGEBOTSPREIS: = 71.182€
```
---
## Qualitätssicherung
### Testverfahren
```
TESTMETHODEN
├── Statische Tests
│ ├── Code-Review
│ └── Statische Analyse
├── Dynamische Tests
│ ├── Unit-Tests
│ ├── Integrationstests
│ ├── Systemtests
│ └── Abnahmetests
└── Weitere
├── Performance-Tests
├── Security-Tests
└── Usability-Tests
```
### Testdokumentation
```markdown
# Testprotokoll
## Testobjekt: [Komponente/Funktion]
## Testfall TC-001
| Schritt | Beschreibung | Erwartetes Ergebnis | Ergebnis |
|--------|--------------|---------------------|---------|
| 1 | Start Button klicken | Anwendung startet | ✓ OK |
| 2 | Login eingeben | Feld zeigt Eingabe | ✓ OK |
| 3 | Falsches Passwort | Fehlermeldung | ✓ OK |
## Tester: [Name]
## Datum: [Datum]
## Ergebnis: BESTANDEN / NICHT BESTANDEN
```
---
## Präsentation und Übergabe
### Präsentationsstruktur
```
PRÄSENTATION (15-20 Minuten)
1. Einleitung (2 min)
- Projektvorstellung
- Ausgangslage
2. Lösung (5 min)
- Vorgehensweise
- Architektur
- Kernfunktionen
3. Demonstration (5 min)
- Live-Vorführung
- Highlight-Features
4. Projektmanagement (3 min)
- Zeitplan
- Herausforderungen
5. Fazit (2 min)
- Erreichte Ziele
- Ausblick
```
### Übergabedokumentation
- Installationsanleitung
- Benutzerhandbuch
- Administratorhandbuch
- Technische Dokumentation
- Abnahmeprotokoll
---
## Prüfungsrelevanz
- **Gewichtung Teil 2: 50%**
- Betriebliche Projektarbeit (40h + Dokumentation)
- Präsentation + Fachgespräch (30 min)
---
## Tipps für die Prüfung
1. **Projektplanung**: Realistische Zeitplanung
2. **Dokumentation**: Vollständig und nachvollziehbar
3. **Präsentation**: Übung, Übung, Übung!
4. **Fachgespräch**: Fachbegriffe sicher beherrschen
---
## Querverweise
- [[3-Ausbildungsjahr/LF11a-Funktionalität-realisiren|Vorher: LF 11a]]
- [[Prüfungsvorbereitung/Teil2-Projekt|Teil 2 Projekt]]
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan 13.12.2019*

101
Betriebliche-Ausbildung/Ausbildungsnachweis-Vorlage.md Normal file
View File

@@ -0,0 +1,101 @@
# Ausbildungsnachweis (Berichtsheft)
> Vorlage für den betrieblichen Ausbildungsnachweis gemäß § 13 BBiG
---
## Persönliche Daten
| Feld | Eintrag |
|------|---------|
| Name | [Dein Name] |
| Ausbildungsberuf | Fachinformatiker Anwendungsentwicklung |
| Ausbildungsbetrieb | [Firmenname] |
| Ausbildungsdauer | [Start] bis [Ende] |
| Ausbilder/in | [Name] |
---
## Ausbildungsnachweis
### Woche Nr. ____
**Datum:** ____.__.20__ bis ____.__.20__
#### Tägliche Einträge
| Tag | Uhrzeit | Tätigkeit | Ausbildungsnachweis |
|-----|---------|-----------|---------------------|
| Mo | 08:00 - 16:30 | [Tätigkeit] | [LF/Thema] |
| Di | 08:00 - 16:30 | [Tätigkeit] | [LF/Thema] |
| Mi | 08:00 - 16:30 | [Tätigkeit] | [LF/Thema] |
| Do | 08:00 - 16:30 | [Tätigkeit] | [LF/Thema] |
| Fr | 08:00 - 14:00 | [Tätigkeit] | [LF/Thema] |
---
### Zusammenfassung der Woche
**Geleistete Arbeitszeit:** ___ Stunden
**Ausbildungsinhalte:**
1. _______________________________________________
2. _______________________________________________
3. _______________________________________________
**Besonders interessant/für mich neu:**
_________________________________________________
**Noch nicht verstanden / Fragen:**
_________________________________________________
---
## Checkliste: Lernfeld-Abdeckung
### 1. Ausbildungsjahr
- [ ] LF 1: Unternehmen und eigene Rolle
- [ ] LF 2: Arbeitsplätze nach Kundenwunsch
- [ ] LF 3: Clients in Netzwerke einbinden
- [ ] LF 4: Schutzbedarfsanalyse
- [ ] LF 5: Software zur Datenverwaltung
### 2. Ausbildungsjahr
- [ ] LF 6: Serviceanfragen bearbeiten
- [ ] LF 7: Cyber-physische Systeme
- [ ] LF 8: Daten systemübergreifend bereitstellen
- [ ] LF 9: Netzwerke und Dienste
### 3. Ausbildungsjahr
- [ ] LF 10a: Benutzeroberflächen
- [ ] LF 11a: Funktionalität realisieren
- [ ] LF 12a: Kundenspezifische Entwicklung
---
## Unterschriften
| | Datum | Unterschrift Auszubildende/r | Unterschrift Ausbilder/in |
|---|-------|---------------------------|------------------------|
| Woche 1 | | | |
| Woche 2 | | | |
| ... | | | |
---
## Hinweise
- Führe den Ausbildungsnachweis regelmäßig (mindestens wöchentlich)
- Achte auf Vollständigkeit aller Tage
- Unterschriften rechtzeitig einholen
- Bei Fehlzeiten: Angabe der Gründe (Krankheit, Urlaub, etc.)
---
*Gemäß § 13 Berufsbildungsgesetz (BBiG) ist der Ausbildungsnachweis zu führen.*

145
Prüfungsvorbereitung/Prüfungsübersicht.md Normal file
View File

@@ -0,0 +1,145 @@
# Prüfungsvorbereitung - Fachinformatiker Anwendungsentwicklung
## Übersicht
### Abschlussprüfung - Teil 1
**Zeitpunkt:** Nach dem 4. Ausbildungshalbjahr (ca. nach 1,5 Jahren)
**Prüfungsbereich:**
- Einrichten eines IT-gestützten Arbeitsplatzes
**Inhalte:**
- Kundenbedarfe ermitteln
- Hard- und Software auswählen
- IT-Arbeitsplatz konfigurieren und testen
- Datenschutz und IT-Sicherheit beachten
- Kunden einweisen
**Dauer:** 90 Minuten (schriftlich)
**Gewichtung:** 20%
---
### Abschlussprüfung - Teil 2
**Zeitpunkt:** Am Ende der Ausbildung
**Prüfungsbereiche:**
| Prüfungsbereich | Gewichtung |
|-----------------|------------|
| Planen und Umsetzen eines Softwareprojektes | 50% |
| Planen eines Softwareproduktes | 10% |
| Entwicklung und Umsetzung von Algorithmen | 10% |
| Wirtschafts- und Sozialkunde | 10% |
---
## Prüfungsbereich 1: Softwareprojekt (50%)
### Projektarbeit
- Dauer: max. 80 Stunden
- Dokumentation mit praxisbezogenen Unterlagen
- Projektbeschreibung zur Genehmigung vorlegen
### Projektphasen
1. **Analyse**: Kundenspezifische Anforderungen
2. **Planung**: Projektplanung durchführen
3. **Wirtschaftliche Betrachtung**: Kosten/Nutzen
4. **Implementierung**: Software erstellen/anpassen
5. **Test**: Software testen, Einführung vorbereiten
6. **Dokumentation**: Projekt dokumentieren
### Präsentation
- Dauer: max. 15 Minuten
- Vorstellung der Ergebnisse
### Fachgespräch
- Dauer: max. 30 Minuten (inkl. Präsentation)
- Begründung der Vorgehensweise
---
## Prüfungsbereich 2: Planen eines Softwareproduktes (10%)
**Dauer:** 90 Minuten (schriftlich)
### Inhalte
- Entwicklungsumgebungen und -bibliotheken auswählen
- Programmspezifikationen festlegen
- Bedienoberflächen konzipieren
- Qualitätskontrolle planen
---
## Prüfungsbereich 3: Algorithmen (10%)
**Dauer:** 90 Minuten (schriftlich)
### Inhalte
- Programmcode interpretieren
- Algorithmen in Programmiersprache umsetzen
- Algorithmen grafisch darstellen (Struktogramm, PAP)
- Testszenarien auswählen
- Datenbankabfragen erstellen (SQL)
---
## Prüfungsbereich 4: Wirtschafts- und Sozialkunde (10%)
**Dauer:** 60 Minuten (schriftlich)
### Themenübersicht
- Wirtschaftliche Grundlagen
- Rechtliche Rahmenbedingungen
- Arbeitsrecht
- Sozialrecht
- Unternehmensformen
- Marketing
- Controlling
---
## Mündliche Ergänzungsprüfung
### Voraussetzungen
- Antrag in einem Prüfungsbereich
- Schlechter als "ausreichend"
- Kann zum Bestehen führen
### Ablauf
- Dauer: 15 Minuten
- Verhältnis: 2:1 (schriftlich : mündlich)
---
## Lerntipps
1. **Frühzeitig beginnen**: Nicht erst kurz vor der Prüfung
2. **Alte Prüfungen üben**: Praxisbezug herstellen
3. **Zeitmanagement üben**: Prüfungssimulation
4. **Gruppen lernen**: Unterschiedliche Perspektiven
5. **Fragen stellen**: Bei Unsicherheiten nachfragen
---
## Ressourcen
- [IHK Prüfungstermine](https://www.ihk-bremen.de)
- [Rahmenlehrplan KMK](http://www.kmk.org)
- [Fachinformatiker Prüfungsvorbereitung](https://fachinformatikerpruefungsvorbereitung.de)
---
*Stand: 2024*

286
Wissen/Programmiersprachen/Programmierübersicht.md Normal file
View File

@@ -0,0 +1,286 @@
# Programmierübersicht - Fachinformatiker Anwendungsentwicklung
> Wichtige Programmiersprachen und Konzepte für die Ausbildung
---
## Übersicht
| Sprache | Typ | Typisierung |Paradigma | Hauptverwendung |
|---------|-----|------------|----------|-----------------|
| **Python** | Interpreter | Dynamisch | OOP, funktional | Scripting, Web, Data Science |
| **Java** | Kompiliert | Statisch | OOP | Enterprise, Android |
| **JavaScript** | Interpreter | Dynamisch | OOP, funktional | Web-Entwicklung |
| **C#** | Kompiliert | Statisch | OOP | .NET, Games |
| **SQL** | deklarativ | - | - | Datenbanken |
| **HTML/CSS** | Markup/Stylesheet | - | - | Web-Frontend |
| **Bash/Shell** | Interpreter | Dynamisch | Prozedural | Systemadministration |
---
## Python
### Grundlagen
```python
# Variablen
name = "Max"
alter = 25
ist_student = True
# Datentypen
text = "Hallo Welt" # str
zahl = 42 # int
komma = 3.14 # float
listen = [1, 2, 3] # list
tuples = (1, 2) # tuple
wörter = {"a": 1, "b": 2} # dict
# Kontrollstrukturen
if alter >= 18:
print("Volljährig")
elif alter >= 16:
print("Führerschein")
else:
print("Minderjährig")
# Schleifen
for i in range(5):
print(i)
while alter > 0:
alter -= 1
# Funktionen
def gruss(name):
return f"Hallo, {name}!"
# Klassen
class Person:
def __init__(self, name, alter):
self.name = name
self.alter = alter
def vorstellen(self):
return f"Ich bin {self.name}"
```
### List Comprehension
```python
# Traditionell
quadrate = []
for i in range(10):
quadrate.append(i**2)
# Elegant
quadrate = [i**2 for i in range(10)]
# Mit Bedingung
gerade = [i for i in range(20) if i % 2 == 0]
```
---
## JavaScript
### Grundlagen
```javascript
// Variablen (ES6+)
let name = "Max"; // Veränderbar
const alter = 25; // Konstante
var alter2 = 30; // Veraltet, nicht mehr nutzen
// Datentypen
const text = "Hallo"; // string
constzahl = 42; // number
const istWahr = true; // boolean
const array = [1, 2, 3]; // array
const objekt = { key: "value" }; // object
// Arrow Functions
const gruss = (name) => `Hallo, ${name}!`;
// Klassen
class Person {
constructor(name, alter) {
this.name = name;
this.alter = alter;
}
vorstellen() {
return `Ich bin ${this.name}`;
}
}
// DOM Manipulation
document.getElementById("meinElement").addEventListener("click", () => {
console.log("Geklickt!");
});
```
### Async/Await
```javascript
// Promise
fetch("https://api.example.com/data")
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error(error));
// Async/Await (moderner)
async function ladeDaten() {
try {
const response = await fetch("https://api.example.com/data");
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}
}
```
---
## SQL
### Grundlegende Abfragen
```sql
-- Daten abfragen
SELECT spalte1, spalte2
FROM tabelle
WHERE spalte1 = 'wert'
ORDER BY spalte2 DESC;
-- Mit JOIN
SELECT k.name, b.bestelldatum
FROM kunde k
JOIN bestellung b ON k.id = b.kunde_id;
-- Aggregatfunktionen
SELECT
COUNT(*) AS anzahl,
SUM(preis) AS gesamt,
AVG(preis) AS durchschnitt
FROM produkte
WHERE kategorie = 'Elektronik';
-- Gruppierung
SELECT kategorie, COUNT(*) AS anzahl
FROM produkte
GROUP BY kategorie
HAVING COUNT(*) > 5;
```
### Datenmanipulation
```sql
-- Einfügen
INSERT INTO kunde (name, email)
VALUES ('Max Mustermann', 'max@example.com');
-- Aktualisieren
UPDATE kunde
SET email = 'neu@example.com'
WHERE id = 1;
-- Löschen
DELETE FROM kunde WHERE id = 1;
```
---
## Java
### Grundlagen
```java
// Klassenstruktur
public class Person {
private String name;
private int alter;
// Konstruktor
public Person(String name, int alter) {
this.name = name;
this.alter = alter;
}
// Getter
public String getName() {
return this.name;
}
// Setter
public void setName(String name) {
this.name = name;
}
// main-Methode
public static void main(String[] args) {
Person p = new Person("Max", 25);
System.out.println(p.getName());
}
}
```
---
## Wichtige Konzepte
### OOP-Prinzipien
1. **Kapselung**: Daten nach außen schützen
2. **Vererbung**: Eigenschaften weitergeben
3. **Polymorphismus**: Gleiches Verhalten, unterschiedliche Formen
4. **Abstraktion**: Komplexität verbergen
### Entwurfsmuster
- **Singleton**: Eine Instanz einer Klasse
- **Factory**: Erstellt Objekte, ohne exakte Klasse zu kennen
- **Observer**: Ereignisbenachrichtigung
- **Strategy**: Austauschbare Algorithmen
---
## Versionskontrolle (Git)
### Grundbefehle
```bash
# Repository initialisieren
git init
# Änderungen hinzufügen
git add .
git commit -m "Nachricht"
# Branching
git checkout -b feature-neu
# Merge
git checkout main
git merge feature-neu
# Remote
git push origin main
git pull origin main
```
---
## IDEs und Tools
| IDE | Sprache | Kosten |
|-----|---------|--------|
| VS Code | Multi | Kostenlos |
| IntelliJ IDEA | Java | Community Edition |
| PyCharm | Python | Community Edition |
| Eclipse | Java | Kostenlos |
---
*Stand: 2024*

207
Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung.md Normal file
View File

@@ -0,0 +1,207 @@
# WISO - Wirtschaft und Sozialkunde
> Prüfungsrelevante Themen für die Abschlussprüfung
---
## 1. Wirtschaft
### Wirtschaftssysteme
```
Wirtschaftssysteme
├── Planwirtschaft (Staatswirtschaft)
│ └── Staat plant und lenkt
├── Marktwirtschaft
│ ├──freie Marktwirtschaft (soziale Marktwirtschaft)
│ └──Preise durch Angebot und Nachfrage
└── Mixed Economy (gemischte Wirtschaft)
```
### Wirtschaftssektoren
| Sektor | Beispiel |
|--------|----------|
| **Primär** | Landwirtschaft, Bergbau |
| **Sekundär** | Industrie, Handwerk |
| **Tertiär** | Dienstleistungen |
| **Quartär** | Forschung, Entwicklung |
### Unternehmen
#### Rechtsformen
| Rechtsform | Stammkapital | Haftung | Organe |
|-----------|--------------|---------|--------|
| **GmbH** | ≥25.000€ | Gesellschaft | GF, Gesellschafter |
| **UG** | ≥1€ | Gesellschaft | GF, Gesellschafter |
| **AG** | ≥50.000€ | Gesellschaft | Vorstand, Aufsichtsrat |
| **OHG** | - | Persönlich | Gesellschafter |
| **KG** | - | Komplementär: persönlich | Komplementär, Kommanditist |
| **Einzelunternehmen** | - | Persönlich | Inhaber |
#### Unternehmensziele
- **Ökonomisch**: Gewinnmaximierung, Umsatzwachstum
- **Ökologisch**: Umweltschutz, Nachhaltigkeit
- **Sozial**: Mitarbeiterzufriedenheit, Gesellschaft
---
## 2. Recht
### Vertragsrecht
#### Vertragsarten
| Vertrag | Beschreibung |
|---------|--------------|
| **Kaufvertrag** | Eigentumsübergang gegen Geld |
| **Werkvertrag** | Herstellung eines Werkes |
| **Dienstvertrag** | Arbeitsleistung |
| **Mietvertrag** | Überlassung gegen Miete |
### Arbeitsrecht
#### Rechte und Pflichten
**Arbeitnehmer:**
- Arbeitsleistung nach Weisung
- Sorgfaltspflicht
- Treuepflicht
**Arbeitgeber:**
- Vergütungspflicht
- Schutzpflicht
- Fürsorgepflicht
#### Kündigung
- **Ordentliche Kündigung**: Fristgemäß
- **Außerordentliche**: Fristlos bei wichtigem Grund
- **Betriebsbedingte**: wirtschaftliche Gründe
- **Personenbedingte**: persönliche Gründe
- **Verhaltensbedingte**: Fehlverhalten
---
## 3. Marketing
### Marketing-Instrumente (4P)
```
Produkt (Product)
├── Qualität
├── Design
├── Verpackung
└── Marke
Preis (Price)
├── Preispolitik
├── Rabatte
└── Zahlungsbedingungen
Standort (Place)
├── Vertriebskanäle
└── Logistik
Kommunikation (Promotion)
├── Werbung
├── PR
├── Verkaufsförderung
└── Direktmarketing
```
---
## 4. Controlling
### Kennzahlen
#### Rentabilität
```
Umsatzrentabilität = Gewinn / Umsatz × 100
Eigenkapitalrentabilität = Gewinn / Eigenkapital × 100
Gesamtkapitalrentabilität = (Gewinn + Zinsen) / Gesamtkapital × 100
```
#### Liquidität
```
Liquidität 1. Grades = (flüssige Mittel / kurzfr. Verb.) × 100
Liquidität 2. Grades = ((flüssige Mittel + Forderungen) / kurzfr. Verb.) × 100
Liquidität 3. Grades = (Umlaufvermögen / kurzfr. Verb.) × 100
```
---
## 5. Finanzierung
### Finanzierungsarten
| Art | Quelle |
|-----|--------|
| **Innenfinanzierung** | Gewinn, Abschreibungen |
| **Außenfinanzierung** | Eigenkapital, Fremdkapital |
| **Selbstfinanzierung** | Einbehaltene Gewinne |
| **Fremdfinanzierung** | Kredite, Darlehen |
### Kostenrechnung
```
Kostenarten:
├── Materialkosten
├── Personalkosten
├── Abschreibungen
└── Sonstige Kosten
Kostenstellen:
├── Material
├── Fertigung
├── Verwaltung
└── Vertrieb
```
---
## 6. Rechtsformen der Unternehmen
### GmbH (Gesellschaft mit beschränkter Haftung)
- Mindestkapital: 25.000€
- Haftung: Nur Gesellschaftsvermögen
- Organe: Geschäftsführer, Gesellschafterversammlung
### UG (Unternehmergesellschaft)
- Mindestkapital: 1€
- Haftung: Nur Gesellschaftsvermögen
- Pflicht: 25% des Gewinns in Rücklage
---
## 7. Datenschutz (DSGVO)
### Grundsätze
- Rechtmäßigkeit
- Zweckbindung
- Datenminimierung
- Richtigkeit
- Speicherbegrenzung
- Integrität und Vertraulichkeit
### Betroffenenrechte
- Auskunft
- Berichtigung
- Löschung
- Datenübertragbarkeit
- Widerspruch
---
*Stand: 2024 | Quelle: KMK Rahmenlehrplan*