Fisi

---
name: fisi
description: Fachinformatiker für Systemintegration - Unterstützung bei allen Themen der FiSi-Ausbildung/Umschulung. Verwende diesen Skill bei: FiSi-Lehrplan-Themen (Netzwerke, Linux/Windows-Server, Datenbanken, Scripting, IT-Sicherheit, Cloud, Virtualisierung), Prüfungsvorbereitung (AP1/AP2), Projektarbeit, Hausaufgaben, Code-Reviews, Konfigurationsdateien, Examensfragen,typische FiSi-Aufgaben wie "Wie richte ich einen DHCP-Server ein?", "Erkläre mir Subnetting", "Hilf mir bei der Bash-Skript-Aufgabe", "Was braucht man für eine Firewall-Konfiguration?", "Erstelle ein Konzept für...", "Bewerte diese Architektur", "Wie bereite ich mich auf die Abschlussprüfung vor?".
compatibility: Benötigt Bash-Zugriff für Scriptausführung, Serena-Tools für Code-Analyse
---

# FiSi-Skill: Fachinformatiker für Systemintegration

## Überblick

Dieser Skill unterstützt dich umfassend bei deiner Umschulung zum Fachinformatiker für Systemintegration. Er deckt alle relevanten Themenbereiche ab und hilft sowohl bei theoretischen Konzepten als auch bei praktischen Aufgaben.

## Themenbereiche

### 1. Netzwerke (Network Infrastructure)
- OSI-Modell, TCP/IP-Stack
- IP-Adressierung, Subnetting (IPv4/IPv6)
- Routing-Protokolle (RIP, OSPF, BGP)
- VLANs, Trunking, Spanning-Tree
- DHCP, DNS, NAT
- VPN-Konfigurationen
- Netzwerksicherheit, Firewalls

### 2. Server-Administration
- **Linux-Server**: Debian/Ubuntu, RHEL/CentOS, SUSE
  - User-Management, Permissions
  - Package-Management (apt, yum, zypper)
  - Services: Apache, Nginx, SSH, Samba, NFS
  - Log-Analyse, Monitoring
- **Windows-Server**: Active Directory, GPOs, DNS, DHCP, WSUS
  - PowerShell-Scripting
  - Rollen und Features

### 3. Datenbanken
- SQL-Grundlagen (SELECT, INSERT, UPDATE, DELETE, JOINs)
- Datenbank-Design, Normalisierung
- MySQL, PostgreSQL, SQLite
- Backup-Strategien, Replikation

### 4. Scripting & Automatisierung
- **Bash**: Shell-Skripte, Textverarbeitung (grep, sed, awk)
- **Python**: Automatisierung, API-Integration
- **PowerShell**: Windows-Administration
- **YAML**: Konfigurationsdateien (Ansible, Docker)

### 5. Virtualisierung & Cloud
- VMware, Hyper-V, KVM
- Docker, Kubernetes
- Cloud-Plattformen: AWS, Azure, Google Cloud
- IaaS, PaaS, SaaS-Modelle

### 6. IT-Sicherheit
- Verschlüsselung (SSL/TLS, PGP, AES)
- Authentifizierung (LDAP, Kerberos, 2FA)
- Security Hardening
- OWASP Top 10
- Incident Response

### 7. Storage
- RAID-Level (0, 1, 5, 6, 10)
- SAN, NAS, DAS
- ZFS, LVM
- Backup-Strategien (3-2-1-Regel)

### 8. Soft Skills & Projektmanagement
- AGILE, SCRUM, Kanban
- Dokumentation
- Kundenkommunikation
- Wirtschaftlichkeitsberechnung

## Prüfungsvorbereitung (AP1 & AP2)

### Abschlussprüfung Teil 1 (AP1)
- Zeitraum: Mitte der Ausbildung
- Inhalte: Grundlagen aller oben genannten Bereiche
- Fokus: Verständnis, Basis-Konfigurationen

### Abschlussprüfung Teil 2 (AP2)
- Zeitraum: Ende der Ausbildung
- Inhalte: Vertiefte Themen, Projektarbeit, Wirtschaftlichkeit
- Fokus: Praxis, Konzepte, Entscheidungsbegründungen

## Arbeitsweise

1. **Verstehen**: Ich analysiere deine Anfrage und stelle bei Bedarf Rückfragen
2. **Erklären**: Konzepte werden verständlich und praxisnah erklärt
3. **Anwenden**: Ich liefere Code-Snippets, Konfigurationsbeispiele, Schritt-für-Schritt-Anleitungen
4. **Überprüfen**: Bei Code/Configs gebe ich Feedback und Verbesserungsvorschläge
5. **Zusammenfassen**: Wichtige Punkte werden hervorgehoben

## Code- und Config-Qualität

Ich achte auf:
- **Best Practices**: Sichere, effiziente Lösungen
- **Kommentare**: Erklärungen im Code
- **Fehlerbehandlung**: Robuste Skripte
- **Dokumentation**: Nachvollziehbare Konfigurationen

## Typische Aufgabenformate

- "Erkläre mir [Konzept]"
- "Wie richte ich [Service] ein?"
- "Debugge dieses Skript"
- "Erstelle ein Konzept für [Anforderung]"
- "Berechne [wirtschaftliche Aufgabe]"
- "Was ist der Unterschied zwischen X und Y?"
- "Hilf mir bei der Prüfungsvorbereitung für [Thema]"

## Beispiele und Musterlösungen

### Subnetting-Berechnung (IPv4)

**Aufgabenstellung:** Berechne Subnetze bei gegebenem Netz und erforderlicher Host-Zahl.

**Vorgehensweise:**
1. Bestimme die benötigte Host-Anzahl (plus 2 für Netzwerk- und Broadcast-Adresse)
2. Finde die nächste potenz von 2: `2^n >= required_hosts`
3. Berechne Subnetzmaske: `/32 - n` oder `255.255.255.x`
4. Berechne Netzadresse, erster/letzter Host und Broadcast

**Beispiel:** `192.168.10.0/24`, benötigt 6 Subnetze mit mindestens 20 Hosts

| Subnetz | Netzadresse | Nutzbarer Bereich | Broadcast |
|---------|-------------|-------------------|-----------|
| 1 | 192.168.10.0 | 192.168.10.1 - 192.168.10.30 | 192.168.10.31 |
| 2 | 192.168.10.32 | 192.168.10.33 - 192.168.10.62 | 192.168.10.63 |
| 3 | 192.168.10.64 | 192.168.10.65 - 192.168.10.94 | 192.168.10.95 |

**Berechnung:** Für 20+ Hosts braucht man 5 Bits (`2^5=32`). Subnetzmaske: `/27` (255.255.255.224).

### Linux Dateiberechtigungen

**Aufgabe:** Verzeichnis `/var/www/projekt` konfigurieren:
- Besitzer (www-data): Lesen, Schreiben, Ausführen (rwx)
- Gruppe (webentwickler): Lesen, Ausführen (r-x)
- Andere: Kein Zugriff (---)
- Neue Dateien erben Gruppe webentwickler

**Befehle:**
```bash
# Besitzer und Gruppe setzen
sudo chown www-data:webentwickler /var/www/projekt

# Berechtigungen: rwxr-x--- (750)
sudo chmod 750 /var/www/projekt

# SGID-Bit setzen (Gruppenvererbung)
sudo chmod g+s /var/www/projekt
# oder: sudo chmod 2750 /var/www/projekt
```

**Oktalnotation:**
- 7 = rwx (4+2+1) → Besitzer
- 5 = r-x (4+0+1) → Gruppe
- 0 = --- (0+0+0) → Andere
- 2 = SGID-Bit (spezielle Berechtigung)

### Docker-Containerisierung

**Container vs. Virtuelle Maschinen:**
- **Container**: Teilen den Host-Kernel, leichtgewichtig, schneller Start (Sekunden), geringer Overhead
- **VM**: Eigenes Betriebssystem, schwerer, langsamerer Start (Minuten), höherer Ressourcenverbrauch

**Dockerfile für Node.js-Backend:**
```dockerfile
# Multi-Stage Build für optimierte Image-Größe
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine
RUN addgroup -g 1001 -S nodejs && adduser -S nodeuser -u 1001
WORKDIR /app
COPY --from=builder --chown=nodeuser:nodejs /app/node_modules ./node_modules
COPY --chown=nodeuser:nodejs . .
USER nodeuser
EXPOSE 3000
CMD ["node", "server.js"]
```

**docker-compose.yml (Node.js + PostgreSQL + Nginx):**
```yaml
version: '3.8'

services:
  backend:
    build: ./backend
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/appdb
    depends_on:
      - db
    networks:
      - appnet

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=appdb
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - appnet

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - backend
    networks:
      - appnet

volumes:
  db_data:

networks:
  appnet:
```

**Sicherheitshinweise:**
- Nicht als root innerhalb des Containers laufen lassen
- `.dockerignore` erstellen (node_modules, .env, .git ausschließen)
- Multi-Stage Build verwenden für kleinere Images
- Offizielle Base Images aus Docker Hub verwenden

### RAID-Level Vergleich

**Aufgabe:** Fileserver mit 8 Festplatten à 2 TB konfigurieren. Vergleiche RAID 1, RAID 5 und RAID 10.

**Vergleichstabelle:**

| RAID-Level | Nutzbare Kapazität | Lesen | Schreiben | Max. Ausfälle |
|------------|-------------------|-------|-----------|---------------|
| RAID 1 (Spiegelung) | 8 TB (50%) | Sehr gut | Gut | 7 Platten* |
| RAID 5 (Striping + Parität) | 14 TB (87.5%) | Gut | Mäßig | 1 Platte |
| RAID 10 (Spiegel + Stripe) | 8 TB (50%) | Sehr gut | Sehr gut | Bis zu 4 Platten** |

\* Bei 4 gespiegelten Paaren: Ein Ausfall pro Paar tolerierbar
\*\* Bei RAID 10: Bis zu 50% Ausfälle, solange kein Paar komplett ausfällt

**Berechnung:**