typo?

ADDC als Bonus

.gitignore

@@ -0,0 +1,4 @@
+mkdocs/site/
+*.pdf
+*.PDF
+.cache

Dockerfile

@@ -1,12 +1,16 @@
-FROM pandoc/latex:latest
+FROM squidfunk/mkdocs-material:latest
 
-WORKDIR /data
-
-## Eisvogel Template kopieren (lokal notwendig)
-#COPY eisvogel.tex /data/eisvogel.tex
-
-# Script kopieren und ausführbar machen
-COPY mkdocs-to-pdf.sh /usr/local/bin/mkdocs-to-pdf.sh
-RUN chmod +x /usr/local/bin/mkdocs-to-pdf.sh
-
-ENTRYPOINT ["/usr/local/bin/mkdocs-to-pdf.sh"]
+# Laufzeit-Pakete (inkl. weasyprint) + temporäre Build-Dependencies zum Kompilieren (z.B. libsass)
+RUN apk add --no-cache \
+        weasyprint \
+        cairo \
+        pango \
+        gdk-pixbuf \
+        libjpeg-turbo \
+        zlib \
+        fontconfig \
+        ttf-dejavu \
+    && apk add --no-cache --virtual .build-deps \
+        build-base python3-dev libffi-dev cairo-dev pango-dev gdk-pixbuf-dev libjpeg-turbo-dev zlib-dev pkgconfig \
+    && pip install --no-cache-dir mkdocs-to-pdf \
+    && apk del .build-deps

README.md

@@ -16,7 +16,7 @@ Dieses Projekt enthält ein Bash-Skript und eine Umgebung zum automatischen Konv
 ## Nutzung
 ````bash
 Alle Markdown-Dateien in mkdocs/docs pdfen:
-./mkdocs-to-pdf.sh
+./mkdocs-complete.sh
 
 Einzelne Datei konvertieren:
 ./mkdocs-to-pdf.sh Linux_Unternehmen/nextcloud-ldap.md
@@ -34,7 +34,7 @@ Mehrere Dateien gleichzeitig
 - LaTeX Template Datei `eisvogel.latex` im Projektverzeichnis
 
 ## Verzeichnisstruktur
-
+````
 mkdocs/
 ├── docs/ <- Markdown Quelldateien und Medien
 │ ├── Linux_Unternehmen/
@@ -43,7 +43,7 @@ mkdocs/
 │ └── basics/
 ├── mkdocs.yml <- MkDocs Konfigurationsdatei
 └── site/ <- Ergebnis von MkDocs Build (HTML, PDF)
-
+````
 mkdocs-to-pdf.sh <- Bash Skript zur automatischen PDF-Erstellung
 eisvogel.latex <- LaTeX Vorlage für Pandoc PDF Export
 docker-compose.yml <- Containerdefintionen für MkDocs Umgebung
@@ -59,4 +59,7 @@ text
 ---
 
 Bei Fragen oder Problemen gerne Issues öffnen oder direkt kontaktieren.
-Diese README.md beschreibt übersichtlich Zweck, Nutzung, Voraussetzungen, Verzeichnisstruktur und wichtige Hinweise zum Projekt. Gerne kann sie noch projektspezifisch erweitert werden.
+Diese README.md beschreibt übersichtlich Zweck, Nutzung, Voraussetzungen, Verzeichnisstruktur und wichtige Hinweise zum Projekt. Gerne kann sie noch projektspezifisch erweitert werden.
+
+Für mkdocs highlighiting und so:
+https://github.com/domWalters/mkdocs-to-pdf/tree/develop/docs/examples

docker-compose.yml

@@ -1,19 +1,19 @@
 services:
   mkdocs:
-    image: squidfunk/mkdocs-material:latest
+    build: .
+    #image: squidfunk/mkdocs-material:latest
     volumes:
       - ./mkdocs:/docs
     ports:
       - 80:8000
 
   vscode:
-    image: linuxserver/code-server
+    image: lscr.io/linuxserver/code-server:latest
     environment:
-      - PUID=${UID}
-      - PGID=${GID}
       - TZ=Europe/Berlin
+      - DEFAULT_WORKSPACE=/workspace/mkdocs
     volumes:
       - ./workspace:/config/workspace
-      - ./mkdocs:/workspace/projects
+      - ./mkdocs:/workspace/mkdocs
     ports:
       - 8443:8443

mkdocs-complete.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+MKDOCS_DIR="mkdocs/docs"
+
+find "$MKDOCS_DIR" -name "*.md" | while read -r md_file; do
+  # Überspringe index.md
+  if [[ "$(basename "$md_file")" == "index.md" ]]; then
+    echo "Überspringe: $md_file"
+    continue
+  fi
+
+  echo "Verarbeite: $md_file"
+
+  base_name=$(basename "$md_file" .md | tr ' ' '_')
+  dir_name=$(dirname "$md_file")
+
+  pdf_path="${dir_name}/${base_name}.pdf"
+  pdf_link="\n\n[PDF herunterladen](${base_name}.pdf){ .md-button }"
+
+  # PDF immer neu erzeugen
+  rm -f "$pdf_path"
+  
+  # Temp MD nur für MkDocs-Syntax bereinigen
+  temp_md="${dir_name}/temp_${base_name}.md"
+  sed 's/{[^}]*}//g; s/^[ \t]*{[^}]*}$//gm' "$md_file" > "$temp_md"
+  
+  # **Working directory = Markdown-Verzeichnis** für korrekte Bildpfade!
+  md_dir=$(dirname "$md_file")
+  
+  docker run --rm \
+    --volume "$(pwd)":/data \
+    --user $(id -u):$(id -g) \
+    --workdir "/data/$md_dir" \
+    pandoc/extra \
+    "./$(basename "$md_file")" \
+    -o "./${base_name}.pdf" \
+    --template /data/eisvogel.latex \
+    --syntax-highlighting=idiomatic
+
+  # Temp Dateien löschen
+  rm -f "$temp_md"
+  
+  echo "  → PDF erstellt: $pdf_path"
+
+  # PDF-Link nur einmal hinzufügen
+  if ! tail -n 10 "$md_file" | grep -q "PDF herunterladen"; then
+    echo -e "$pdf_link" >> "$md_file"
+    echo "  → PDF-Link hinzugefügt"
+  else
+    echo "  → PDF-Link bereits vorhanden"
+  fi
+done
+
+# MkDocs neu bauen
+docker compose -f ./docker-compose.yml run --rm mkdocs build
+docker compose -f ./docker-compose.yml restart mkdocs
+echo "Fertig: mkdocs neu gebaut."

mkdocs-to-pdf-copy.sh

@@ -1,56 +0,0 @@
-#!/bin/bash
-
-MKDOCS_DIR="mkdocs/docs"
-
-# Einzelne Datei als Parameter übergeben
-if [ $# -eq 0 ]; then
-  echo "Usage: $0 <pfad/zur/datei.md> [z.B. Linux_Unternehmen/nextcloud-ldap.md]"
-  exit 1
-fi
-
-md_file="$MKDOCS_DIR/$1"
-
-if [[ ! -f "$md_file" ]]; then
-  echo "Fehler: $md_file nicht gefunden!"
-  exit 1
-fi
-
-echo "Verarbeite einzeln: $md_file"
-
-base_name=$(basename "$md_file" .md | tr ' ' '_')
-dir_name=$(dirname "$md_file")
-pdf_path="${dir_name}/${base_name}.pdf"
-pdf_link="\n\n[PDF herunterladen](${base_name}.pdf){ .md-button }"
-
-# PDF neu erzeugen
-rm -f "$pdf_path"
-
-md_dir=$(dirname "$md_file")
-
-docker run --rm \
-  --volume "$(pwd)":/data \
-  --user $(id -u):$(id -g) \
-  --workdir "/data/$md_dir" \
-  pandoc/extra \
-  "./$(basename "$md_file")" \
-  -o "./${base_name}.pdf" \
-  --template /data/eisvogel.latex \
-  --syntax-highlighting=idiomatic
-
-echo "  → PDF erstellt: $pdf_path"
-
-# PDF-Link nur einmal hinzufügen
-if ! tail -n 10 "$md_file" | grep -q "PDF herunterladen"; then
-  echo -e "$pdf_link" >> "$md_file"
-  echo "  → PDF-Link hinzugefügt"
-else
-  echo "  → PDF-Link bereits vorhanden"
-fi
-
-echo "Fertig: $pdf_path"
-
-echo "mkdocs wird neu gebaut"
-
-docker compose -f ./docker-compose.yml run --rm mkdocs build
-docker compose -f ./docker-compose.yml restart mkdocs
-echo "Fertig: mkdocs neu gebaut."

mkdocs-to-pdf.sh

@@ -2,45 +2,55 @@
 
 MKDOCS_DIR="mkdocs/docs"
 
-find "$MKDOCS_DIR" -name "*.md" | while read -r md_file; do
-  # Überspringe index.md
-  if [[ "$(basename "$md_file")" == "index.md" ]]; then
-    echo "Überspringe: $md_file"
-    continue
-  fi
+# Einzelne Datei als Parameter übergeben
+if [ $# -eq 0 ]; then
+  echo "Usage: $0 <pfad/zur/datei.md> [z.B. Linux_Unternehmen/nextcloud-ldap.md]"
+  exit 1
+fi
 
-  echo "Verarbeite: $md_file"
+md_file="$MKDOCS_DIR/$1"
 
-  base_name=$(basename "$md_file" .md | tr ' ' '_')
-  dir_name=$(dirname "$md_file")
+if [[ ! -f "$md_file" ]]; then
+  echo "Fehler: $md_file nicht gefunden!"
+  exit 1
+fi
 
-  pdf_path="${dir_name}/${base_name}.pdf"
-  pdf_link="\n\n[PDF herunterladen](${base_name}.pdf){ .md-button }"
+echo "Verarbeite einzeln: $md_file"
 
-  rm -f "$pdf_path"
+base_name=$(basename "$md_file" .md | tr ' ' '_')
+dir_name=$(dirname "$md_file")
+pdf_path="${dir_name}/${base_name}.pdf"
+pdf_link="\n\n[PDF herunterladen](${base_name}.pdf){ .md-button }"
 
-  docker run --rm \
-    --volume "$(pwd)":/data \
-    --user $(id -u):$(id -g) \
-    pandoc/extra \
-    "/data/$md_file" \
-    -o "/data/$pdf_path" \
-    --template eisvogel \
-    --lua-filter=/data/process_comments.lua \
-    --syntax-highlighting=idiomatic
+# PDF neu erzeugen
+rm -f "$pdf_path"
 
-  # PDF-Link nur anhängen wenn noch nicht vorhanden
-  if ! tail -n 10 "$md_file" | grep -q "PDF herunterladen"; then
-    echo -e "$pdf_link" >> "$md_file"
-    echo "  → PDF-Link hinzugefügt"
-  else
-    echo "  → PDF-Link bereits vorhanden"
-  fi
-done
+md_dir=$(dirname "$md_file")
+
+docker run --rm \
+  --volume "$(pwd)":/data \
+  --user $(id -u):$(id -g) \
+  --workdir "/data/$md_dir" \
+  pandoc/extra \
+  "./$(basename "$md_file")" \
+  -o "./${base_name}.pdf" \
+  --template /data/eisvogel.latex \
+  --syntax-highlighting=idiomatic
+
+echo "  → PDF erstellt: $pdf_path"
+
+# PDF-Link nur einmal hinzufügen
+if ! tail -n 10 "$md_file" | grep -q "PDF herunterladen"; then
+  echo -e "$pdf_link" >> "$md_file"
+  echo "  → PDF-Link hinzugefügt"
+else
+  echo "  → PDF-Link bereits vorhanden"
+fi
+
+echo "Fertig: $pdf_path"
 
-echo "Fertig: PDF Dateien erstellt und Links aktualisiert."
 echo "mkdocs wird neu gebaut"
 
 docker compose -f ./docker-compose.yml run --rm mkdocs build
 docker compose -f ./docker-compose.yml restart mkdocs
-echo "Fertig: mkdocs neu gebaut."
+echo "Fertig: mkdocs neu gebaut."

mkdocs/docs/Linux_Unternehmen/Praxisprojekt_Freigaben_im_Unternehmen.md

@@ -0,0 +1,173 @@
+# Geschäfts-Samba-Server: Eingeschränkte Freigaben für Abteilungen
+*Anleitung zur Einrichtung von Samba-Freigaben mit granularen Rechten für Hans Wurst (Produktion) und Peter Lustig (Verwaltung)*
+
+## 1. Zielbeschreibung
+Dieses Projekt zeigt eine saubere, praxisnahe Einrichtung von
+
+* eingeschränkten Freigaben mit Gruppenrechten,
+* Homeverzeichnissen,
+* einem Netzwerkpapierkorb.​
+  
+|              | Lesen
Angebote | Schreiben
Angebote | Lesen
Lieferscheine | Schreiben
Lieferscheine |
+| ------------ | ------------------ | ---------------------- | ----------------------- | --------------------------- |
+| Hans Wurst   | X                  |                        |                         | X                           |
+| Peter Lustig |                    | X                      |                         | X                           |
+
+!!! Note ``Samba`` sollte bereits installiert sein
+
+---
+
+## 2. Benutzer und Gruppen anlegen
+
+### 2.1 Benutzer erstellen
+```bash
+# Benutzer für Produktion und Verwaltung anlegen
+sudo adduser hwurst   # Hans Wurst (Produktion)
+sudo adduser plustig  # Peter Lustig (Verwaltung)
+```
+### 2.2 Gruppen für Rechteverwaltung erstellen
+````bash
+# Gruppen für Lese-/Schreibrechte
+sudo addgroup angebote_r    # Leserechte für Angebote
+sudo addgroup angebote_w   # Schreibrechte für Angebote
+sudo addgroup lieferscheine_r # Leserechte für Lieferscheine (hier nicht genutzt)
+sudo addgroup lieferscheine_w # Schreibrechte für Lieferscheine
+````
+### 2.3 Benutzer den Gruppen zuweisen
+````bash
+# Hans Wurst: Darf Angebote lesen und Lieferscheine schreiben
+sudo usermod -aG angebote_r hwurst
+sudo usermod -aG lieferscheine_w hwurst
+
+# Peter Lustig: Darf Angebote und Lieferscheine schreiben
+sudo usermod -aG angebote_w plustig
+sudo usermod -aG lieferscheine_w plustig
+````
+
+### 2.4 Benutzer in Samba bekannt machen
+````bash
+# Samba-Passwörter für beide Benutzer setzen
+sudo smbpasswd -a hwurst
+sudo smbpasswd -a plustig
+````
+> Passwort im Kurs: "passw0rd#"
+
+## 3. Verzeichnisse erstellen und Rechte setzen
+### 3.1 Ordner für Angebote und Lieferscheine anlegen
+````bash
+sudo mkdir -p /srv/samba/{angebote,lieferscheine}
+````
+### 3.2 Besitzer und Gruppe setzen
+````bash
+# Angebote: Besitzer = nobody, Gruppe = angebote_w (Schreibrechte)
+sudo chown -R nobody:angebote_w /srv/samba/angebote
+
+# Lieferscheine: Besitzer = nobody, Gruppe = lieferscheine_w (Schreibrechte)
+sudo chown -R nobody:lieferscheine_w /srv/samba/lieferscheine
+````
+### 3.3 Berechtigungen setzen
+
+````bash
+sudo chmod -R 0077 /srv/samba/angebote
+sudo chmod -R 0077 /srv/samba/lieferscheine
+# - 0: Keine Spezialrechte (Sticky Bit/SUID/SGID)
+# - 0: Besitzer (nobody) hat keine Rechte (wird durch Samba überschrieben)
+# - 7: Gruppe hat Vollzugriff (rwx)
+# - 7: Andere haben Vollzugriff (wird durch Samba eingeschränkt)
+````
+!!! note Die tatsächlichen Rechte werden später durch Samba (````force create mode, valid users````) gesteuert.
+
+## 4. Samba-Freigaben konfigurieren
+
+### 4.1 ````smb.conf```` bearbeiten
+````bash
+sudo nano /etc/samba/smb.conf
+````
+### 4.2 Freigaben für Angebote und Lieferscheine
+Fügen Sie folgende Abschnitte am Ende der Datei ein:
+````ini
+[Angebote]
+   comment = Angebote an Kunden
+   path = /srv/samba/angebote
+   guest ok = no
+   browseable = yes
+   read only = yes  # Standardmäßig schreibgeschützt
+   valid users = @angebote_r, @angebote_w  # Nur diese Gruppen dürfen zugreifen
+   write list = @angebote_w  # Nur diese Gruppe darf schreiben
+   force create mode = 0775  # Neue Dateien: rwxrwxr-x
+   force directory mode = 0775 # Neue Ordner: rwxrwxr-x
+   force group = angebote_w  # Neue Dateien gehören dieser Gruppe
+
+[Lieferscheine]
+   copy = Angebote # Überträgt alle Einstellungen von Angebote, die nicht nachfolgend angepasst werden:
+   comment = Lieferscheine von Lieferanten
+   path = /srv/samba/lieferscheine
+   valid users = @lieferscheine, @lieferscheine_w  # Nur diese Gruppe darf zugreifen
+   write list = @lieferscheine_w  # Nur diese Gruppe darf schreiben
+   force group = lieferscheine_w
+````
+## 5. Userverzeichnisse (Home-Freigaben)
+
+Jeder Benutzer kann auf sein eigenes Home-Verzeichnis zugreifen.
+Aktivieren Sie die [homes]-Freigabe in ````/etc/samba/smb.conf```` (entkommentieren):
+````ini
+[homes]
+   comment = Privates Verzeichnis
+   browseable = no  # Nur für den Benutzer selbst sichtbar
+   read only = no    # Benutzer darf schreiben
+   create mask = 0700 # Neue Dateien: rwx------
+   directory mask = 0700 # Neue Ordner: rwx------
+   valid users = %S  # %S = Name des aktuellen Benutzers
+````
+!!! note ``%S`` wird automatisch durch den Benutzernamen ersetzt (z. B. hwurst).
+## 6. Netzwerkpapierkorb
+Gelöschte Dateien auf Netzlaufwerken können mit dem **Samba Recycle Bin Modul** gesichert werden.
+### 6.1 Konfiguration in ````smb.conf````
+Fügen Sie folgende Optionen global (unter [global]) oder pro Freigabe ein:
+````ini
+    vfs objects = recycle  # Virtuelles Dateisystem für Papierkorb
+    recycle:repository = .recyclebin  # Ordner für gelöschte Dateien
+    recycle:keeptree = yes   # Pfadstruktur im Papierkorb erhalten
+    recycle:versions = yes   # Gleichnamige Dateien nicht überschreiben
+    recycle:maxsize = 0      # Keine Größenbegrenzung pro Datei
+    recycle:touch = yes      # Zeitstempel anpassen
+````
+### 6.2 Automatische Bereinigung mit Cron
+Fügen Sie einen [Cron-Job](../basics/Automatisierung_mit_cron_und_systemd.md) hinzu, um alte Dateien im Papierkorb zu löschen:
+````bash
+sudo crontab -e
+````
+Fügen Sie folgende Zeile ein (löscht Dateien älter als 14 Tage):
+````bash
+0 12 * * * for path in $(grep "path =" /etc/samba/smb.conf | cut -d= -f2 | sed 's/ //g'); do find "${path}/.recyclebin" -mindepth 1 -mtime +14 -exec rm -rf {} ; 2>/dev/null; done
+````
+!!! note Erklärung
+    * ````0 12 * * *````: Täglich um 12:00 Uhr.
+    * ````grep "path ="````: Sucht alle ````path````-Einträge in ````smb.conf````.
+    * ````find ... -mtime +14````: Löscht Dateien älter als 14 Tage im .recyclebin-Ordner.
+  
+## 7 Häufige Fehler und Lösungen
+
+|Problem                       |Ursache                            |Lösung                                                       |
+|------------------------------|-----------------------------------|-------------------------------------------------------------|
+|Benutzer kann nicht zugreifen |Falsche Gruppe oder Passwort.      |groups [benutzer] prüfen, smbpasswd -a [benutzer] neu setzen.|
+|Schreibrechte fehlgeschlagen  |Benutzer nicht in write list.      |valid users und write list in smb.conf prüfen.               |
+|Papierkorb funktioniert nicht |vfs objects = recycle fehlt.       |In smb.conf für die Freigabe oder global ergänzen.           |
+|Rechte werden nicht übernommen|force group oder create mask fehlt.|In smb.conf ergänzen und Samba neu starten.                  |
+|Linux kann zugreifen, Windows nicht|Protokollversion zu Alt       |In smb.conf ````    server min protocol = SMB2```` und    ````smb encrypt = desired ```` nachtragen| 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

mkdocs/docs/Linux_Unternehmen/Server_Installation.md

@@ -0,0 +1,251 @@
+# Ubuntu Server installieren und vorbereiten
+
+## 1. Vorbereitung der virtuellen Maschine in VirtualBox
+### Schritt 1: Virtuelle Maschine erstellen
+Öffnen Sie VirtualBox und klicken Sie auf "Neu".
+Nutzen Sie folgende Konfiguration:
+````
+Name: SV1
+Typ: Linux
+Version: Ubuntu (64-bit)
+````
+````
+CPU: 2 Kerne (4 empfohlen)
+RAM: Mindestens 2 GB (4 GB empfohlen).
+Festplatte: 40 GB (dynamisch alloziert, VDI-Format).
+````
+Netzwerk:
+
+Wählen Sie "Netzwerkbrücke" oder "NAT" (je nach Anforderungen).
+Hinweis: Stellen Sie sicher, dass der Server später auf 10.10.224.119 (cache-server) zugreifen kann.
+
+!!! info  ISO download: ubuntu.com/download/server
+
+### Schritt 2: VM starten und Installation beginnen
+
+Starten Sie die VM und wählen Sie "Try or Install Ubuntu Server".
+
+## 2. Installation von Ubuntu 24.04 Server
+### Schritt 1: Sprache
+
+Sprache: Deutsch
+
+### Schritt 2: Installer-Aktualisieren
+in den Meisten Fällen einfach ````ohne aktualisierung fortfahren````.
+Eine aktualsierung findet im Anschluss ohnehin statt.
+
+### Schritt 3: Tastatur-Belegung
+Durch die Sprachauswahl am Anfang ist hier bereits Alles auf ````German```` und kann so belassen werden.
+
+### Schritt 4: Auswahl des Installationstyps
+**Option 1: Ubuntu Server (voreingestellt)**
+
+Beschreibung:
+Diese Option installiert eine Standardversion von Ubuntu Server mit einer ausgewählten Sammlung von Paketen, die einen komfortablen Betrieb des Servers ermöglichen.
+
+Empfehlung für den Meisterkurs IT im Handwerk:
+Wählen Sie diese Option, da sie die beste Grundlage für die weiteren Schritte in der Anleitung bietet.
+
+
+**Option 2: Ubuntu Server (minimized)**
+
+Beschreibung:
+Diese Option installiert eine minimale Version von Ubuntu Server mit einem sehr kleinen Laufzeit-Fußabdruck.
+
+Optimiert für Umgebungen, in denen keine menschlichen Benutzer angemeldet sind (z. B. Container, Cloud-Instanzen, eingebettete Systeme).
+Enthält nur die absolut notwendigen Pakete und verzichtet auf zusätzliche Tools.
+Nicht empfohlen für den Meisterkurs, da später manuell viele Pakete nachinstalliert werden müssten.
+
+
+**Zusätzliche Optionen**
+
+**Search for third-party drivers:**
+
+Diese Option ermöglicht die Suche nach Drittanbieter-Treibern (z. B. für spezielle Hardware wie WLAN-Karten oder RAID-Controller).
+
+### Schritt 5: Netzwerkkonfiguration
+
+Der Installer versucht automatisch, eine Verbindung herzustellen, und zeigt diese auch oben an. 
+Statische IP (optional):
+
+Falls nötig, geben Sie manuell eine IP aus dem Netzwerkbereich ein (passend für ihr Subnetz hinter der Fritzbox).
+* ````Edit IPv4```` an der Netzwerkkarte ````enp0s3```` auswählen.
+* ````Automatisch (DHCP)```` ändern auf ````Manuell````
+* Subnetz     ````192.168.100.0/24````
+* Adresse     ````192.168.100.250````
+* Gateway     ````192.168.100.1````
+* Nameserver  ````192.168.100.1,1.1.1.1````
+* Suchdomäne  ````TN00.ITO````
+
+Erstelle Bond: Hiermit könnenn mehrere Netzwerkkarten dann auch gekoppelt werden wenn dies am Switch ebenfalls so konfiguriert ist.
+
+### Schritt 6: Proxy Konfiguration
+Leer lassen. Der ````apt-cache-server```` muss an einer anderen Stelle konfiguriert werden.
+
+### Schritt 7: Mirror
+Aus standard belassen, da dieser schon in Deutschland ausgewählt ist.
+
+### Schritt 8: Festplattenpartitionierung
+
+**Option 1: Eine ganze Festplatte verwenden**
+
+Beschreibung:
+
+Diese Option löscht alle Daten auf der ausgewählten Festplatte und verwendet die gesamte Festplatte für die Ubuntu-Installation.
+Empfohlen für den Meisterkurs IT im Handwerk, wenn Sie eine neue, leere Festplatte in VirtualBox verwenden.
+Die Festplatte wird automatisch partitioniert (z. B. ``/``, ``/boot``, ``swap``).
+
+**Ausgewählte Festplatte:**
+
+VBOX_HARDDISK_XXXXXXXXXXXXX (40.00 GB)
+> Hinweis: Stellen Sie sicher, dass die richtige Festplatte ausgewählt ist, da alle Daten auf dieser Festplatte gelöscht werden.
+
+
+**LVM-Gruppe konfigurieren:**
+
+Aktiviert (X): Diese Option erstellt eine LVM-Gruppe (Logical Volume Manager).
+Vorteile von LVM:
+
+* Flexible Verwaltung von Partitionen (z. B. einfache Größenanpassung).
+* Ermöglicht das Hinzufügen weiterer Festplatten zu einem späteren Zeitpunkt.
+
+**LVM-Gruppe mit LUKS verschlüsseln:**
+
+Deaktiviert ( ): Standardmäßig ist die Festplattenverschlüsselung deaktiviert.
+* Verschlüsselung aktivieren: Falls Sie die Festplatte verschlüsseln möchten, setzen Sie hier ein Häkchen.
+  * Passphrase: Geben Sie ein sicheres Passwort ein, um die Festplatte zu verschlüsseln.
+> Hinweis: Die Verschlüsselung erhöht die Sicherheit, erfordert aber bei jedem Systemstart die Eingabe der Passphrase.
+
+* Recovery Key erstellen:
+
+Deaktiviert ( ): Falls Sie die Verschlüsselung aktivieren, können Sie hier einen Recovery Key erstellen.
+> Dieser Key wird im Live-System und im Zielsystem gespeichert und kann im Notfall zur Datenwiederherstellung verwendet werden.
+
+
+**Option 2: Benutzerdefinierte Partitionierung**
+
+Beschreibung:
+
+Diese Option ermöglicht die manuelle Partitionierung der Festplatte.
+Nur für fortgeschrittene Benutzer empfohlen, die spezielle Anforderungen an die Partitionierung haben (z. B. separate Partitionen für /home, /var oder /opt).
+
+**Zusammenfassung für den Meisterkurs:**
+
+* Wählen Sie die Option "Eine ganze Festplatte verwenden".
+* Aktivieren Sie die LVM-Gruppe, um später flexibel auf Speicheränderungen reagieren zu können.
+* Deaktivieren Sie die Festplattenverschlüsselung, um den Installationsprozess zu vereinfachen.
+
+Am Ende bestätigen und in der Übersicht dann nochmals ``Erledigt`` auswählen
+
+*** Schritt 9: Benutzerkonfiguration
+````
+Ihr Name:           Max Mustermann
+Your servers name:  sv1 
+Nutzername:         meisterkurs (oder Ihr gewünschter Name)
+Passwort:           passw0rd#
+````
+
+### Schritt 9: Ubuntu Pro
+Canonical bietet Zusatzleitungen wie automatische updates und Live-Kernel-Updates an. Bei großen Netzwerken kann das Lohnenswert sein. 
+Wählen Sie ``Skip for now`` und ``Fortfahren``
+
+### Schritt 10: SSH configuration
+OpenSSH Server installieren: Ja (wichtig für Remote-Zugriff!)
+
+### Schritt 11: Featured snaps
+Hier nichts auswählen, da im Kurs alle Pakete manuell installiert werden.
+
+### Schritt 12: Installation abschließen
+
+Warten Sie auf den Abschluss und starten Sie die VM neu.
+
+## Erste Schritte nach der Installation
+Schritt 0: Sonderfall etz
+
+!!! warning **Wichtiger Hinweis:**
+    Damit alle Teilnehmer im Kurs effizient Updates und Software installieren können, wird im Schulungsnetzwerk ein lokaler Paket-Cache (Proxy) verwendet. 
+    **Diesen Schritt müssen Sie außerhalb der Schulungsstätte (z.B. zu Hause) nicht durchführen!**
+
+So richten Sie den Proxy ein:
+
+1. Öffnen Sie ein Terminal (z.B. über das Startmenü).
+2. Geben Sie folgenden Befehl ein (ersetzen Sie ggf. die IP-Adresse, durch die im Kurs verwendete):
+
+    ```bash
+    echo 'Acquire::http::Proxy "http://10.10.224.119:3142";' | sudo tee /etc/apt/apt.conf.d/02proxy
+    ```
+
+3. Fahren Sie nun mitt Schritt 1 fort
+
+### Schritt 1: System aktualisieren
+````bash
+sudo apt update && sudo apt upgrade -y
+````
+
+### Schritt 2 SSH-Key-Authentifizierung für Windows/PuTTY
+#### 1. SSH-Key mit PuTTYgen (Windows) erstellen
+
+1. Laden Sie PuTTYgen herunter: putty.org
+2. Öffnen Sie PuTTYgen und wählen Sie "EdSDA" und Ed25519.
+3. Klicken Sie auf "Generate" und bewegen Sie die Maus zufällig, um Entropie zu erzeugen.
+4. Speichern Sie den privaten Schlüssel (z. B. ``meisterkurs_priv.ppk``) und kopieren Sie den öffentlichen Schlüssel aus dem oberen Fenster.
+#### 2. Öffentlichen Schlüssel auf den Server übertragen
+
+Melden Sie sich per Putty mit Passwort auf ihrem Server an:
+
+Erstellen Sie das .ssh-Verzeichnis (falls nicht vorhanden):
+````bash
+mkdir -p ~/.ssh
+chmod 700 ~/.ssh
+````
+Fügen Sie den öffentlichen Schlüssel zur authorized_keys hinzu:
+````bash
+echo "IHR_ÖFFENTLICHER_SCHLÜSSEL" >> ~/.ssh/authorized_keys
+chmod 600 ~/.ssh/authorized_keys
+````
+
+#### 3. SSH-Login mit PuTTY testen
+
+* Öffnen Sie PuTTY.
+* Geben Sie die Server-IP ein.
+* Gehen Sie zu "Connection" → "SSH" → "Auth" → "Credentials" und wählen Sie die bei ``Private Key...`` ihre ``meisterkurs_priv.ppk`` Datei aus.
+* Klicken Sie auf "Open" und melden Sie sich an.
+#### 4. Passwort-Login deaktivieren 
+
+!!! warning erst nach erfolgreicher Key-Anmeldung!
+
+Bearbeiten Sie die SSH-Konfiguration:
+````bash
+# Cloud-Init-deaktivieren, da dort Passwort-Login aktiviert wird.
+sudo rm /etc/ssh/sshd_config.d/50-cloud-init.conf
+# Die eigentliche config dazu bringen:
+sudo nano /etc/ssh/sshd_config
+````
+
+Setzen Sie folgende Optionen:
+````ini
+PasswordAuthentication no
+PermitRootLogin no
+````
+
+Speichern Sie und starten Sie SSH neu:
+````bash
+sudo systemctl restart ssh
+````
+!!! tip Versuchen Sie sich erneut mit einem Passwort einzuloggen, wenn es nicht geht, ist alles in Ordnung!
+### Automatische Updates einrichten
+````bash
+sudo apt install unattended-upgrades -y
+sudo dpkg-reconfigure unattended-upgrades
+````
+
+Wählen Sie "Ja" für automatische Sicherheitsupdates.
+
+#### Backup-Strategie (Grundlagen)
+
+Manuelles Backup mit rsync:
+````bash
+sudo apt install rsync -y
+rsync -av /home/meisterkurs/ /backup/meisterkurs/
+````
+!!! note Die Ordner sollten natürlich vorhanden sein, und der User ausreichende Berechtigung dazu haben. Siehe [Ordner erstellen](../basics/Grundlagen_der_Konsole.md) bzw. Berechtigungen in der [Samba-Anleitung](../basics/Windows_Freigaben_fuer_Linux-Einsteiger.md). Wie das regelmäßg gemacht wird, haben Sie schon mit [cron](../basics/Automatisierung_mit_cron_und_systemd.md) gelernt.

mkdocs/docs/Linux_Unternehmen/nextcloud-ldap.md

@@ -16,12 +16,10 @@ Open-Source mySQL Ableger MariaDB empfohlen.
 ```bash
 sudo apt install apache2 mariadb-server libapache2-mod-php php php-mysql php-xml php-gd php-curl php-zip php-mbstring php-intl php-bcmath php-gmp php-imagick php-redis redis-server php-ldap php-smbclient unzip phpmyadmin
 ```
+!!! warning 
+    Während der Installation für ``phpmyadmin`` werden Sie nach dem zu konfigurierenden webserver abgefragt.Wählen Sie hierfür mit der <kbd>Leertaste</kbd> apache2 aus. Sie erkennen die Auswahl am ````*````.
 
-Abfragen nach dem zu verwendenden Webserver: apache2
-
-Konfiguriere phpmyadmin: Ja Datenbank Konfigurieren
-
-Passwort setzen
+!!! info Konfiguriere phpmyadmin: Ja Datenbank Konfigurieren und Passwort setzen
 
 Im Anschluss muss die Datenbank noch gesichert werden um etwaigen
 Missbrauch zu unterbinden und auch das Root-Passwort wird hier gesetzt
@@ -31,38 +29,26 @@ sudo mysql_secure_installation
 ```
 1. Abfrage des aktuellen Passwortes NICHTS EINGEBEN NUR BESTÄTIGEN
 
-2. Soll ein Root-Passwort gesetzt werden? Y
+2. Soll auf Unix-Socket-Auth gewechselt werden? N
 
-3. Passwort eingeben und wiederholen
+3. Soll ein Root-Passwort gesetzt werden? Y
 
-4. Soll der Anonyme User entfernt werden? Y
+4. Passwort eingeben und wiederholen
 
-5. Remote-Login für Root deaktivieren? Y
+5. Soll der Anonyme User entfernt werden? Y
 
-6. test-Datenbank entfernen? Y
+6. Remote-Login für Root deaktivieren? Y
 
-7. Änderungen übernehmen? Y
+7. test-Datenbank entfernen? Y
 
-Jetzt muss einmalig in die SQL-Datenbank der Login für root über das
-Webinterface aktiviert werden:
+8. Änderungen übernehmen? Y
 
-````bash
-sudo mysql -u root -p
-````
-
-````sql
-use mysql;
-update user set plugin='' where User='root';
-flush privileges;
-\q
-````
 
 Zugriff auf ihre Datebank per Webinterface:
 
 http://IP/phpmyadmin
 
-Legen Sie einen neuen Nutzer für NextCloud an und gewähren Sie dem Nutzer alle Rechte an seiner Datenbank „Nextcloud".
-/newpage
+!!! attention Legen Sie einen neuen Nutzer für NextCloud an und gewähren Sie dem Nutzer alle Rechte an seiner Datenbank „NextCloud".
 
 ## NextCloud installieren
 
@@ -87,7 +73,7 @@ erstellen ````/etc/apache2/sites-available/nextcloud.conf```` mit Inhalt:
 
 <VirtualHost *:80>
     DocumentRoot "/var/www/nextcloud"
-    ServerName nextcloud.hensel.dom
+    ServerName nextcloud.tnxx.ito
     ErrorLog ${APACHE_LOG_DIR}/error.log
     CustomLog ${APACHE_LOG_DIR}/access.log combined
         <Directory /var/www/nextcloud/>
@@ -123,12 +109,11 @@ sudo a2enmod ssl
 sudo systemctl restart apache2
 ```
 
-Nun können Sie per http auf den Webserver zugreifen 
-http://nextcloud.hensel.dom
+Nun können Sie per http auf den Webserver zugreifen http://IP oder http://nextcloud.tnxx.ito
 
-![Erster Login, Eingabe der Admindaten](./nextcloud-ldap-media/image1.png){ align=left }
+![Erster Login, Eingabe der Admindaten](./nextcloud-ldap-media/image1.png)
 
-Hier legen Sie nun das Administrator-Konto ein, wobei natürlich Admin und ein schwaches Passwort hier Tabu sind.
+Hier legen Sie nun das Administrator-Konto an, wobei natürlich Admin und ein schwaches Passwort hier Tabu sind.
 
 Geben Sie als Datenverzeichnis das gerade angelegte Verzeichnis an und geben Sie die entsprechenden Daten die beim Anlagen der Datenbank gesetzt wurden ein.
 
@@ -146,18 +131,15 @@ Kümmern wir uns erst einmal um den Cache, wobei wir den Redis-Server bereits in
 sudo nano /var/www/nextcloud/config/config.php
 ```
 Fügen Sie eine weitere Zeile vor der schließenden Klammer ein:
-...
+
 ````php
-'dbtype' => 'mysql',
-  'version' => '12.0.0.29',
-  'dbname' => 'NextCloud',
-  'dbhost' => 'localhost',
-  'dbport' => '',
-  'dbtableprefix' => 'oc_',
-  'dbuser' => 'NextCloud',
-  'dbpassword' => 'passw0rd#',
-  'logtimezone' => 'UTC',
+...
+
   'installed' => true,
+````
+neu:
+
+````php
   'memcache.distributed' => '\OC\Memcache\Redis',
   'memcache.local' => '\OC\Memcache\Redis',
   'memcache.locking' => '\OC\Memcache\Redis',
@@ -165,6 +147,10 @@ Fügen Sie eine weitere Zeile vor der schließenden Klammer ein:
      'host' => 'localhost',
      'port' => 6379,
      ),
+````
+
+zwingend vor:
+````php
 );
 ````
 Laden Sie Sie Administrator-Seite neu -- Der Fehler sollte weg sein.
@@ -185,7 +171,9 @@ Bearbeiten der Datei ````/etc/apache2/sites-available/nextcloud.conf````
 
 ````apacheconf
 <VirtualHost *:80>
-    Redirect permanent / https://nextcloud.hensel.dom
+    RewriteEngine On
+    RewriteCond %{HTTPS} Off
+    RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI}
 </VirtualHost>
 
 <IfModule mod_ssl.c>
@@ -199,8 +187,8 @@ Bearbeiten der Datei ````/etc/apache2/sites-available/nextcloud.conf````
         </IfModule>
 
         DocumentRoot "/var/www/nextcloud"
-        ServerName nextcloud.hensel.dom
-        ServerAlias www.nextcloud.hensel.dom
+        ServerName nextcloud.tnxx.ito
+        ServerAlias www.nextcloud.tnxx.ito
 
         ErrorLog ${APACHE_LOG_DIR}/error.log
         CustomLog ${APACHE_LOG_DIR}/access.log combined
@@ -222,7 +210,6 @@ Bearbeiten der Datei ````/etc/apache2/sites-available/nextcloud.conf````
 Aktivieren:
 
 ```bash
-sudo a2ensite default-ssl.conf
 sudo systemctl restart apache2
 ```
 
@@ -230,7 +217,7 @@ Apache Neustarten und Fertig
 
 ## CronJob für regelmäßige Aktualisierung der Datenbank
 
-NextCloud aktualisiert bei jedem Zugriff auf das Webinterface die Datenbank, allerdings kostet dies wertvolle Sekunden bei einem „Wohlfühl-Interface" daher aktivieren Wir einen [CronJob](../basics/Automatisierung mit cron und systemd.md)
+NextCloud aktualisiert bei jedem Zugriff auf das Webinterface die Datenbank, allerdings kostet dies wertvolle Sekunden bei einem „Wohlfühl-Interface" daher aktivieren Wir einen [CronJob](../basics/Automatisierung_mit_cron_und_systemd.md)
 
 Die Aktion soll vom User www-data ausgeführt werden
 
@@ -240,15 +227,33 @@ sudo crontab -u www-data -e
 nun können wir einen neuen Job einfügen:
 
 ```
-\*/15 \* \* \* \* php -f /var/www/nextcloud/cron.php
+*/15 * * * * php -f /var/www/nextcloud/cron.php
 ```
 Wählen Sie nun im Administrations-Bereich von NextCloud bei Cron entsprechend auch cron aus.
 
 Im Anschluss am besten einmal reboot
 
-## LDAP
+## Optische Anpassung ans Firmenlayout
 
-Konfiguration smb.conf bei einem Samba AD-DC
+Nextcloud ermöglicht eine einfache Anpassung des Designs an Ihr Firmenlayout direkt über das Webinterface.
+
+> Wichtig: Dateinamen ohne Leerzeichen verwenden, Formate ````.png```` oder ````.jpg````.
+
+### Design über Webinterface anpassen
+* Melden Sie sich als Administrator in Nextcloud an.
+* Klicken Sie oben rechts auf Benutzermenü → Administrationseinstellungen.
+* Wählen Sie im linken Menü ````Design````.
+* Passen Sie folgende Elemente an:
+  * Name: Meisterwolke
+  * Slogan: Wir kennen die Festplatte mit Vornamen
+  * Primärfarbe: Primärfarbe: #70706B Hintergrundfarbe: #70706B 
+  * Logo: [Firmenlogo](./Nextcloud_Design/Logo.png)
+  * Hintergrund und Anmeldebild: [Eingangsbereich](./Nextcloud_Design/Login_Image.jpg)
+  * Kopfbereichslogo: [Firmenlogo](./Nextcloud_Design/Logo.png)
+  * Favicon: [Favicon](./Nextcloud_Design/favicon.ico)
+
+## LDAP
+!!! note Konfiguration ``smb.conf`` bei einem [Samba AD-DC](../bonus/linux-als-ad-server.md)
 ````ini
 [global]
 ldap server require strong auth = no
@@ -286,6 +291,3 @@ Hier definieren Sie welche Gruppen ihres Servers in NextCloud übernommen werden
 ![Einrichtungstab Expert](./nextcloud-ldap-media/image7.png)
 
 In der Benutzerübersicht sollen alle Nutzer mit ihrem Benutzernamen und nicht mit der UUID angezeigt werden. Somit ist es auch für die Nutzer einfacher, sich gegenseitig zu finden.
-
-
-[PDF herunterladen](nextcloud-ldap.pdf){ .md-button }

mkdocs/docs/basics/Automatisierung_mit_cron_und_systemd.md

@@ -1,15 +1,16 @@
 # Automatisierung mit cron und systemd
 
+
 Stellen Sie sich vor, Sie betreiben einen Server oder eine Anwendung, die rund um die Uhr laufen muss. Als IT-Meister möchten Sie jederzeit nachvollziehen können, ob Ihr System aktiv ist und wann es zuletzt gestartet wurde. Dafür können Sie zwei klassische Linux-Automatisierungswerkzeuge nutzen:
 
-* **Cronjob:** Führt regelmäßig Aufgaben aus, z.B. jede Minute, jede Stunde oder einmal täglich.
-* **systemd-Unit:** Startet Aufgaben beim Systemstart oder zu bestimmten Ereignissen.
+* **Cronjob:** Führt regelmäßig Aufgaben aus, z.B. jede Minute, jede Stunde oder einmal täglich.
+* **systemd-Unit:** Startet Aufgaben beim Systemstart oder zu bestimmten Ereignissen.
 
 Mit diesen Werkzeugen können Sie z.B. eine Datei anlegen oder aktualisieren, um so einen „Herzschlag" (Heartbeat) Ihres Systems zu dokumentieren.
 
-# Cron-Job: Jede Minute eine Datei aktualisieren
+## Cron-Job: Jede Minute eine Datei aktualisieren
 
-> Praxisbeispiel: Heartbeat-File
+### Praxisbeispiel: Heartbeat-File
 
 Sie möchten, dass jede Minute der Zeitstempel einer Datei (/tmp/heartbeat.txt) aktualisiert wird. Das ist nützlich, um zu prüfen, ob Cron und das System laufen.
 
@@ -27,14 +28,18 @@ Fügen Sie folgende Zeile hinzu:
 * * * * * /usr/bin/touch /tmp/heartbeat.txt
 ```
 
-Jetzt wird jede Minute die Datei /tmp/heartbeat.txt neu angelegt oder ihr Zeitstempel aktualisiert.
+Jetzt wird jede Minute die Datei /tmp/heartbeat.txt neu angelegt oder ihr Zeitstempel aktualisiert. Prüfen Sie das ergebnis, indem Sie sich den Zeitstempel der neuen Datei anschauen:
+
+```bash
+ls -lah /tmp/heartbeat.txt
+```
 
 \newpage
 
-# Crontab-Syntax erklärt:
+### Crontab-Syntax erklärt:
 
 | Feld        | Bedeutung       | Wert im Beispiel                  | Bedeutung           |
-| ----------- | --------------- | --------------------------------- | ------------------- |
+| ----------* | --------------* | --------------------------------* | ------------------* |
 | Minute      | 0-59            | \*                                | jede Minute         |
 | Stunde      | 0-23            | \*                                | jede Stunde         |
 | Tag (Monat) | 1-31            | \*                                | jeder Tag           |
@@ -59,14 +64,14 @@ Jetzt wird jede Minute die Datei /tmp/heartbeat.txt neu angelegt oder ihr Zeit
 *  jeden Tag um Mitternacht
 
 ```
-1/5 * * * * /usr/bin/touch /tmp/every5min.txt
+*/5 * * * * /usr/bin/touch /tmp/every5min.txt
 ```
 
-*  alle 5 Minuten beginnend 5 Minuten nach 1 also 6,11,16,...
+* alle 5 Minuten beginnend 5 Minuten
 
-# systemd-Unit: Datei beim Systemstart aktualisieren
+## systemd-Unit: Datei beim Systemstart aktualisieren
 
-## **Praxisbeispiel: Boot-Marker**
+### Praxisbeispiel: Boot-Marker
 
 Sie möchten beim Systemstart eine Datei (/tmp/boot.txt) anlegen oder deren Zeitstempel aktualisieren, um den letzten Bootvorgang zu protokollieren.
 
@@ -101,7 +106,7 @@ sudo systemctl enable touch-at-boot.service
 sudo systemctl start touch-at-boot.service
 ```
 
-Nach jedem Neustart wird /tmp/boot.txt aktualisiert.
+Nach jedem Neustart wird /tmp/boot.txt aktualisiert.
 
 **systemd-Unit erklärt:**
 
@@ -127,7 +132,4 @@ sudo systemctl stop <service> # Service stoppen
 **Wann nutze ich was?**
 
 * **Cronjob**: Für wiederkehrende Aufgaben (regelmäßig, z.B. jede Minute, stündlich, täglich)
-* **systemd-Unit**: Für Aufgaben beim Systemstart, beim Herunterfahren oder bei bestimmten Ereignissen
-
-
-[PDF herunterladen](Automatisierung_mit_cron_und_systemd.pdf){ .md-button }
+* **systemd-Unit**: Für Aufgaben beim Systemstart, beim Herunterfahren oder bei bestimmten Ereignissen

mkdocs/docs/basics/Einstieg_in_Linux-Desktop.md

@@ -1,5 +1,17 @@
 # Einstieg in Linux-Desktop
 
+## Warum Linux? Weil es mehr kann!
+Linux ist nicht nur ein Betriebssystem – es ist **Freiheit**. Keine Lizenzkosten, keine erzwungenen Updates, keine Datensammelwut. Stattdessen:
+
+* **Volle Kontrolle** über dein System (keine Blackbox wie bei Windows/macOS).
+* **Sicherheit** durch Open Source: Jeder kann den Code prüfen – Backdoors? Fehlanzeige!
+* **Anpassbar** wie Lego: Von minimalistisch bis vollgepackt mit Tools – du entscheidest.
+* **Perfekt für Entwickler, Maker & Tüftler**: Docker, Python, Server-Tools – alles läuft out-of-the-box.
+* **Ressourcenschonend**: Läuft auch auf alter Hardware flüssig (z. B. als Media-Center oder NAS).
+
+**Ihr Ziel heute:**
+Sie richten einen **Ubuntu-Desktop in VirtualBox** ein, lernen die Oberfläche kennen und setzten ein **Mini-Projekt** um: **Einen lokalen Webserver mit Python**, den sie später sogar von ihrem Host-PC aus aufrufen können.
+
 ## Notieren Sie bei jedem Schritt:
 
 * Welche Menüpunkte oder Symbole Sie verwendet haben.
@@ -29,10 +41,9 @@
 
 ## Sonderfall etz
 
-> **Wichtiger Hinweis:**
-
-> Damit alle Teilnehmer im Kurs effizient Updates und Software installieren können, wird im Schulungsnetzwerk ein lokaler Paket-Cache (Proxy) verwendet.
-> **Diesen Schritt müssen Sie außerhalb der Schulungsstätte (z.B. zu Hause) nicht durchführen!**
+!!! warning **Wichtiger Hinweis:**
+    Damit alle Teilnehmer im Kurs effizient Updates und Software installieren können, wird im Schulungsnetzwerk ein lokaler Paket-Cache (Proxy) verwendet. 
+    **Diesen Schritt müssen Sie außerhalb der Schulungsstätte (z.B. zu Hause) nicht durchführen!**
 
 So richten Sie den Proxy ein:
 
@@ -50,6 +61,8 @@ So richten Sie den Proxy ein:
 * Öffnen Sie den grafischen Paketmanager („Empfohlene Software“ oder „Add/Remove Software“).
 * Suchen Sie nach „VLC“.
 * Installieren Sie den VLC Media Player.
+  
+Weitere Programme können Sie in einem kleinen Projekt ausprobieren: [Mein erstes kleines Linux Projekt](Mein_erstes_kleines_Linux-Projekt.md)
 
 ## System aktualisieren
 
@@ -64,15 +77,9 @@ So richten Sie den Proxy ein:
 
 ## Remote-Zugriff einrichten und testen
 
-* Aktivieren Sie „SSH“ und/oder „VNC“ und „RDP“ für den Fernzugriff. (VNC ist unter Ubuntu nicht mehr nativ vorhanden)
+* Aktivieren Sie „SSH“ und „RDP“ für den Fernzugriff.
 * Testen Sie den Remote-Zugriff auch von einem Windows-PC aus:
-  * Für SSH: Verwenden Sie z.B. das Programm „PuTTY“.
-  * Für VNC: Verwenden Sie z.B. „RealVNC Viewer“ (geht auch ohne Registrierung)
-  * Für RDP: Verwenden Sie Micrsoft Remotedesktopverbindung
-  * Melden Sie sich mit den Zugangsdaten Ihres Accounts an.
+  * Für SSH: Verwenden Sie z.B. das Programm „PuTTY“ von ihrem Windows aus.
+  * Für RDP: Verwenden Sie Microsoft Remotedesktopverbindung
 
-> *Viel Erfolg beim Erkunden und Einrichten Ihres Linux Desktops!*
-
-
-
-[PDF herunterladen](Einstieg_in_Linux-Desktop.pdf){ .md-button }
+Versuchen Sie die Remotezugriffe auf eigene Faust einzurichten. Falls Sie doch lieber eine Schritt-für-Schritt-Anleitung möchten, finden Sie diese [hier](Remotezugriff_einrichten.md).

mkdocs/docs/basics/Grundlagen der Konsole.md

@@ -1,143 +0,0 @@
-# Grundlagen der Konsole
-
-### Installation nützlicher Programme
-
-Bevor Sie beginnen, installieren Sie bitte folgende Programme, die Sie im Kurs benötigen:
-
-* nano: Einfache Textbearbeitung im Terminal
-* tree: Anzeige von Ordnerstrukturen
-* htop: Übersichtliche Systemüberwachung
-
-Führen Sie diesen Befehl im Terminal aus:
-
-```bash
-sudo apt update
-sudo apt install nano tree htop
-```
-
-### Wo befinden Sie sich?
-
-Lassen Sie sich das aktuelle Verzeichnis anzeigen.
-
-```bash
-pwd
-```
-
-### Wechseln Sie in Ihr Home-Verzeichnis.
-
-Tipp: Das Home-Verzeichnis erreichen Sie mit:
-
-```bash
-cd ~
-```
-
-### Erstellen Sie im Home-Verzeichnis einen Ordner „projekt".
-
-```bash
-mkdir projekt
-```
-
-### Erstellen Sie darin zwei Unterordner „dokumente" und „bilder".
-
-```bash
-mkdir projekt/dokumente projekt/bilder
-```
-
-### Wechseln Sie in den Ordner „projekt".
-
-```bash
-cd projekt
-```
-
-### Erstellen Sie drei Textdateien: „notizen.txt", „aufgaben.txt", „ideen.txt".
-
-```bash
-touch notizen.txt aufgaben.txt ideen.txt
-```
-
-### Erstellen Sie zwei Bilddateien (Platzhalter): „bild1.jpg" und „bild2.jpg".
-
-```bash
-touch bild1.jpg bild2.jpg
-```
-
-### Kopieren Sie „notizen.txt" und „aufgaben.txt" in den Ordner „dokumente".
-
-```bash
-cp notizen.txt aufgaben.txt dokumente/
-```
-
-### Verschieben Sie „ideen.txt" in den Ordner „dokumente".
-
-```bash
-mv ideen.txt dokumente/
-```
-
-### Verschieben Sie „bild1.jpg" und „bild2.jpg" in den Ordner „bilder".
-
-```bash
-mv bild1.jpg bild2.jpg bilder/
-```
-
-### Zeigen Sie die Ordnerstruktur mit „tree" an.
-
-```bash
-tree ~/projekt
-```
-
-### Öffnen Sie eine der Textdateien mit „nano" und schreiben Sie einen kurzen Text hinein.
-
-```bash
-nano dokumente/notizen.txt
-```
-
-> Speichern Sie mit Strg+O, beenden Sie mit Strg+X.
-
-### Zeigen Sie Ihre aktuelle IP-Adresse an.
-
-```bash
-ip address
-```
-
-**oder**
-
-```bash
-hostname -I
-```
-
-### Überwachen Sie Ihr System mit „htop".
-
-```bash
-htop
-```
-
-### Zeigen Sie die Speicherauslastung an.
-
-```bash
-df -h
-```
-
-### Zeigen Sie die Arbeitsspeicher-Auslastung an.
-
-```bash
-free -h
-```
-
-### 18. Wie finden Sie Hilfe zu einem Befehl?
-
-```bash
-man <Befehl>
-```
-
-Beispiel:
-
-```bash
-man ls
-```
-
-**Zusatzaufgabe:****Erstellen Sie eine weitere Datei im Ordner „dokumente" und verschieben Sie diese anschließend in den Ordner „bilder". Zeigen Sie danach erneut die Struktur mit tree an.**
-
-> Viel Erfolg beim Erkunden der Linux-Befehle und beim Organisieren Ihrer Dateien!
-
-
-[PDF herunterladen](Grundlagen_der_Konsole.pdf){ .md-button }

mkdocs/docs/basics/Grundlagen_der_Konsole.md

@@ -0,0 +1,259 @@
+# Grundlagen der Konsole
+
+## Installation nützlicher Programme
+
+Bevor Sie beginnen, installieren Sie bitte folgende Programme, die Sie im Kurs benötigen:
+
+* nano: Einfache Textbearbeitung im Terminal
+* tree: Anzeige von Ordnerstrukturen
+* htop: Übersichtliche Systemüberwachung
+
+Führen Sie diesen Befehl im Terminal aus:
+
+```bash
+sudo apt update
+sudo apt install nano tree htop
+```
+
+## Wo befinden Sie sich?
+
+Lassen Sie sich das aktuelle Verzeichnis anzeigen.
+
+```bash
+pwd
+```
+
+Kurzbeispielausgabe:
+```bash
+/home/benutzer
+```
+
+## Wechseln Sie in Ihr Home-Verzeichnis.
+
+Tipp: Das Home-Verzeichnis erreichen Sie mit:
+
+```bash
+cd ~
+```
+
+Kurzbeispielausgabe nach cd:
+
+```bash
+pwd
+/home/benutzer
+```
+
+## Erstellen Sie im Home-Verzeichnis einen Ordner „projekt".
+
+```bash
+mkdir -p projekt
+```
+
+Prüfung:
+
+```bash
+ls 
+projekt
+```
+
+## Erstellen Sie darin zwei Unterordner „dokumente" und „bilder".
+
+```bash
+mkdir -p projekt/dokumente projekt/bilder
+```
+
+Prüfung:
+
+```bash
+ls -lah projekt
+```
+
+## Wechseln Sie in den Ordner „projekt".
+
+```bash
+cd projekt
+```
+
+Prüfung:
+
+```bash
+pwd
+/home/benutzer/projekt
+```
+
+## Erstellen Sie drei Textdateien: „notizen.txt", „aufgaben.txt", „ideen.txt".
+
+```bash
+touch notizen.txt aufgaben.txt ideen.txt
+```
+
+Prüfung:
+
+```bash
+ls -la
+tree
+```
+
+## Erstellen Sie zwei Bilddateien (Platzhalter): „bild1.jpg" und „bild2.jpg".
+
+```bash
+touch bild1.jpg bild2.jpg
+```
+
+Prüfung:
+
+```bash
+ls -la
+tree
+```
+
+## Kopieren Sie „notizen.txt" und „aufgaben.txt" in den Ordner „dokumente".
+
+```bash
+cp notizen.txt aufgaben.txt dokumente/
+```
+
+Prüfung:
+```bash
+tree
+```
+
+## Verschieben Sie „ideen.txt" in den Ordner „dokumente".
+
+```bash
+mv ideen.txt dokumente/
+```
+
+Prüfung:
+```bash
+tree -a
+```
+
+## Verschieben Sie „bild1.jpg" und „bild2.jpg" in den Ordner „bilder".
+
+```bash
+mv bild1.jpg bild2.jpg bilder/
+```
+
+Prüfung:
+```bash
+tree
+```
+
+## Zeigen Sie die Ordnerstruktur mit „tree" an.
+
+```bash
+tree ~/projekt
+```
+
+Erweiterte Prüfung:
+```bash
+tree ~/projekt
+```
+
+## Öffnen Sie eine der Textdateien mit „nano" und schreiben Sie einen kurzen Text hinein.
+
+```bash
+nano dokumente/notizen.txt
+```
+
+!!! note Speichern Sie mit <kbd>strg</kbd>+<kbd>s</kbd>, beenden Sie mit <kbd>strg</kbd>+<kbd>X</kbd>.
+
+Prüfung:
+```bash
+cat dokumente/notizen.txt
+```
+
+## Zeigen Sie Ihre aktuelle IP-Adresse an.
+
+```bash
+ip address
+```
+
+Abgekürzte Beispielausgabe (IPv4):
+```bash
+2: eth0: <...>
+    inet 192.168.1.10/24 brd 192.168.1.255 scope global eth0
+```
+
+Alternative:
+
+```bash
+hostname -I
+```
+
+Beispielausgabe:
+```bash
+192.168.1.10
+```
+
+## Überwachen Sie Ihr System mit „htop".
+
+```bash
+htop
+```
+
+Abgekürzte Beispielausgabe (nicht-interaktiv, Snap‑Shot):
+```bash
+PID USER     PRI  NI  VIRT   RES   SHR S  %CPU %MEM TIME+ COMMAND
+1234 benutzer  20   0  150M  20M  8M  S   1.2  0.5  0:01.23 python3
+567  root      20   0  50M   5M   3M  S   0.5  0.1  0:00.45 sshd
+```
+
+
+
+## Zeigen Sie die Speicherauslastung an.
+
+```bash
+df -h
+```
+
+Abgekürzte Beispielausgabe:
+```bash
+Filesystem      Size  Used Avail Use% Mounted on
+/dev/sda1        50G   12G   36G  25% /
+```
+
+
+
+## Zeigen Sie die Arbeitsspeicher-Auslastung an.
+
+```bash
+free -h
+```
+
+Abgekürzte Beispielausgabe:
+```bash
+              total  used  free  shared buff/cache available
+Mem:           7.8G  1.2G  4.8G   50M   1.8G      6.1G
+Swap:          2.0G   0B   2.0G
+```
+
+
+
+## Wie finden Sie Hilfe zu einem Befehl?
+
+```bash
+man <Befehl>
+```
+
+Beispiel:
+
+```bash
+man ls
+```
+!!! attention Zum verlassen <kbd>q</kbd> oder <kbd>strg</kbd>+<kbd>c</kbd>
+
+## Zusatzaufgabe:
+Erstellen Sie eine weitere Datei im Ordner „dokumente" und verschieben Sie diese anschließend in den Ordner „bilder". Zeigen Sie danach erneut die Struktur mit tree an.
+
+Beispiel:
+```bash
+touch dokumente/zusatz.txt
+echo "Testinhalt" > dokumente/zusatz.txt
+mv dokumente/zusatz.txt bilder/
+tree ~/projekt
+```
+
+
+!!! success Viel Erfolg beim Erkunden der Linux-Befehle und beim Organisieren Ihrer Dateien!

mkdocs/docs/basics/Mein_erstes_kleines_Linux-Projekt.md

@@ -0,0 +1,84 @@
+# Mein erstes Linux Projekt
+
+**Aufgabe**: Installieren Sie **3 Programme** aus der Liste und dokumentieren:
+
+1.  **Warum** haben Sie sie gewählt?
+2.  **Wie** haben Sie sie installiert (Terminal vs. Anwendungsverwaltung)?
+3.  **Was** können Sie damit machen? (z. B. Screenshot mit Flameshot, Backup mit Timeshift).
+
+## Tools für Einsteiger
+
+Warum diese Programme? Weil sie:
+
+* **Alltagsprobleme lösen** (z. B.Screenshots, PDFs bearbeiten). 
+* **Spaß machen** (z. B. Spiele, Medien). 
+* **Produktivität steigern** (z. B. Notizen, Cloud-Sync). 
+* **Linux spannender machen** (z. B. Terminal-Tools, System-Info).
+
+Hier sind praktische und nützliche Programme für Linux-Einsteiger, die nicht standardmäßig in Linux Mint vorinstalliert sind -- sortiert nach Kategorien mit klarem Nutzen und Istallationsbefehlen falls nicht über die Programmsuche findbar.
+
+## Tipps
+
+1. **Anwendungsverwaltung / Ubuntu Software-Center**:
+Manche Programme (z. B. GIMP) gibt es dort mit **Bewertungen** - hilfreich für Einsteiger!
+2. **Flatpak vs. APT**:
+* **Flatpak** (````sudo flatpak install \...````): Einfacher, aber manchmal langsamer.
+* **APT** (````sudo apt install \...````): Schneller, aber manuell Updates nötig.
+
+---
+
+## Medien & Unterhaltung
+
+| **Programm**  | **Nutzen** | **Installationsbefehl** |
+|---------------|--------------------------------------|-------------------------|
+| **Kdenlive** |  Video-Schnitt (einfacher als OpenShot,aber mächtiger). | sudo apt install kdenlive |
+| **Spotify**  |  Musik-Streaming (offizielle Linux-App). | sudo flatpak install spotify |
+| **GIMP**   |    Bildbearbeitung  (Photoshop-Alternative). | sudo apt install gimp |
+| **OBS Studio** | Bildschirmaufnahmen & Livestreams.  |     sudo apt install obs-studio |
+| **Stacer** | System-Optimierung (wie CCleaner für Linux) | sudo apt install stacer |  
+
+---
+
+## Produktivität & Office
+
+|**Programm**    | **Nutzen**      |                 **Installationsbefehl** |
+| ----------------|--------------------------------|---------------------------|
+|**OnlyOffice**  | Kompatibler mit MS Office (bessere Formatierung als LibreOffice).   |    sudo flatpak install onlyoffice-desktopeditors |
+| **Flameshot** | Screenshots mit Bearbeitung (besser als gnome-screenshot). |  sudo apt install flameshot |
+|  **KeePassXC** | Passwort-Manager (sicher & offline).| sudo apt install keepassxc|
+|  **Nextcloud Client**  |    Cloud-Sync (z. B. für Meisterkurs/Arbeit).   |         sudo apt install nextcloud-desktop |
+
+---
+
+## System & Tools
+
+| **Programm**  |  **Nutzen**    | **Installationsbefehl**
+|---------------|----------------------------------|---------------------------|
+| **Timeshift** |  System-Backups (wie \"Wiederherstellungspunkt\" in Windows). | sudo apt install timeshift |
+| **GParted** | Partitionen verwalten (z. B. USB-Sticks formatieren). | sudo apt install gparted |
+| **Neofetch** | Zeigt coole System-Infos im Terminal (Motivation!). | sudo apt install neofetch (dann ````neofetch```` eingeben) |
+| **htop** | Bessere Task-Manager-Alternative. | sudo apt install htop (dann ````htop```` eingeben) | 
+| **Guake** | Dropdown-Terminal (nach start mit F12 ein-/ausblenden). | sudo apt install guake |
+                                    
+---
+
+## Spiele & Spaß
+| **Programm**      | **Nutzen**                                      |**Installationsbefehl**| 
+| ------------------|-----------------------------------              |-------------------------|
+| **Steam**         |Spiele-Plattform (viele Linux-Spiele verfügbar). | sudo apt install steam |
+| **Lutris**        |Spiele-Manager für Windows-Spiele (via Wine).    | sudo apt install lutris |
+| **SuperTuxKart**  |Mario-Kart-ähnliches Rennspiel (Open Source).    | sudo apt install supertuxkart |
+| **0 A.D.**        |Strategie-Spiel (wie Age of Empires).            | sudo apt install 0ad |
+
+
+------------------------------------------------------------------------
+
+## Entwicklung & Tüfteln
+
+| **Programm**  |  **Nutzen**                       |  **Installationsbefehl** |
+  --------------- |-----------------------------------| -------------------------|
+| **VS Code**   |  Code-Editor (besser als Gedit).  |   sudo flatpak install \--classic code|
+| **Docker**   |   Container für Projekte (z. B. Webserver, Datenbanken).   |    sudo apt install docker.io|
+| **GitKraken** |  Git-Client mit GUI (einfacher als Terminal). |  sudo flatpak install gitkraken |\--classic |
+| **Postman**   |  API-Testing (für Web-Entwickler). |  sudo flatpak install postman|
+

mkdocs/docs/basics/Praxisprojekt_Medien-NAS_fuer_KODI.md

@@ -0,0 +1,232 @@
+# Praxisprojekt Medien-NAS für KODI
+
+## Ziel des Projekts
+
+Aufgebaut wird ein **Medien-Server mit Samba**, auf den **Windows-Clients** Medien (Musik, Videos, Bilder, ROMs) per **Windows-Freigabe** ablegen, und den eine **Kodi-VM** wiederum per SMB einbindet.  
+
+## 1. Vorbereitung
+
+### 1.1 Voraussetzungen
+
+* Linux-Server (z. B. Ubuntu 24.04 LTS oder Linux Mint)  
+* Samba ist installiert und läuft  
+* Windows-PC im gleichen Netzwerk (legt Medien per Freigabe ab)  
+* Virtuelle Maschine (z. B. VirtualBox) mit:
+  * Linux Mint + Kodi **oder**
+  * Direkt in Windows
+* Netzwerkzugriff zwischen Server, Windows-PC und VM
+
+### 1.2 Samba-Grundkonfiguration prüfen
+
+Konfigurationsdatei öffnen:
+
+````bash
+sudo nano /etc/samba/smb.conf
+````
+
+Minimal sinnvoller globaler Abschnitt (Beispiel):
+
+````ini
+[global]
+workgroup = WORKGROUP
+server string = %h Samba Server
+
+security = user
+
+server min protocol = SMB2
+client min protocol = SMB2
+
+unix charset = UTF-8
+ntlm auth = yes
+
+log file = /var/log/samba/log.%m
+max log size = 1000
+````
+
+Samba testen und Dienst starten:
+
+````bash
+sudo samba-tool testparm
+sudo systemctl restart smbd
+````
+
+## 2. Medienverzeichnisse für Samba anlegen
+
+Die Medien sollen vom Windows-Client aus über freigegebene Ordner auf dem Server landen. Hierfür müssen Ordner mit passenden Rechten angelegt werden.
+
+### 2.1 Ordnerstruktur anlegen
+
+````bash
+sudo mkdir -p /srv/samba/{musik,videos,bilder,roms}
+````
+````-p```` erzeugt alle notwendigen Ordner darüber
+die Worte in den geschweiften Klammern ````{}```` werden nacheinander mit im Befehl ersetzt
+
+### 2.2 Rechte für einfache (Gast-)Nutzung setzen
+
+````bash
+sudo chown -R nobody:nogroup /srv/samba/{musik,videos,bilder,roms}
+sudo chmod -R 775 /srv/samba/{musik,videos,bilder,roms}
+````
+* `nobody:nogroup`: typischer Besitzer für anonyme Zugriffe  
+* `775`: Besitzer/Gruppe Vollzugriff, andere lesen + ausführen
+  
+## 3. Samba-Freigaben für Medien einrichten
+
+Freigaben in der Datei ````smb.conf```` anhängen:
+
+````ini
+
+[Musik]
+comment = Musik-Freigabe
+path = /srv/samba/musik
+browseable = yes
+read only = no
+guest ok = yes
+force create mode = 0664
+force directory mode = 0775
+
+[Videos]
+comment = Video-Freigabe
+path = /srv/samba/videos
+browseable = yes
+read only = no
+guest ok = yes
+force create mode = 0664
+force directory mode = 0775
+
+[Bilder]
+comment = Bilder-Freigabe
+path = /srv/samba/bilder
+browseable = yes
+read only = no
+guest ok = yes
+force create mode = 0664
+force directory mode = 0775
+
+[ROMs]
+comment = ROMs für Retro-Spiele
+path = /srv/samba/roms
+browseable = yes
+read only = no
+guest ok = yes
+force create mode = 0664
+force directory mode = 0775
+````
+Samba testen und Dienst starten:
+
+````bash
+sudo samba-tool testparm
+sudo systemctl restart smbd
+````
+## 4. Medien vom Windows-PC auf den Server kopieren
+
+### 4.1 Freigaben von Windows aus verbinden
+
+Auf dem Windows-PC im Explorer:
+````
+\\IP_DES_SERVERS\Musik
+\\IP_DES_SERVERS\Videos
+\\IP_DES_SERVERS\Bilder
+\\IP_DES_SERVERS\ROMs
+````
+Falls Gastzugriff erlaubt ist (`guest ok = yes`), kann meist ohne Benutzername/Passwort zugegriffen werden.  
+In produktiven Szenarien sollten stattdessen Benutzerkonten und `guest ok = no` verwendet werden.
+### 4.2 Medien kopieren
+
+* Auf dem Windows-PC:
+  * Musik-Dateien nach `\\IP\Musik` kopieren  
+  * Video-Dateien nach `\\IP\Videos`  
+  * Bilder nach `\\IP\Bilder`  
+  * ROMs (z. B. `.nes`, `.sfc`, `.iso`) nach `\\IP\ROMs`  
+
+Zur Kontrolle auf dem Server:
+````bash
+ls /srv/samba/musik
+ls /srv/samba/videos
+ls /srv/samba/bilder
+ls /srv/samba/roms
+````
+
+## 5. Kodi installieren
+
+## 5.1 Option A: Kodi auf Ubuntu-Desktop
+Installieren Sie das Programm KODI aus der Softwaresammlung oder:
+````bash
+sudo apt update
+sudo apt install kodi
+````
+## 5.2 Option B: Kodi auf Windows
+Laden Sie Kodi von der [Homepage kodi.tv](https://kodi.tv/download/) herunter und instlalieren Sie
+
+## 6. Samba-Freigaben in Kodi einbinden
+
+### 6.1 Netzwerkfreigaben als Quellen hinzufügen
+
+In Kodi:
+
+1. **Dateimanager** öffnen  
+2. **Quelle hinzufügen**  
+3. **Durchsuchen → Netzwerkfreigabe hinzufügen → SMB**  
+4. Server-IP eintragen (z. B. `192.168.178.50`)  
+5. Freigabe auswählen, z. B.:
+   * `Musik`
+   * `Videos`
+   * `Bilder`
+   * `ROMs`  
+
+Wenn `guest ok = yes` gesetzt ist, kann meist mit **Gast** zugegriffen werden.  
+Bei Benutzerauthentifizierung:
+
+* Benutzername: Samba-Benutzer (z. B. `medienuser`)  
+* Passwort: entsprechend `smbpasswd`  
+
+Quelle benennen, z. B. „Musik-Samba“.
+
+### 6.2 Medienbibliothek einrichten
+
+#### Musik
+
+1. In Kodi zu **Musik → Dateien**  
+2. Quelle „Musik-Samba“ auswählen  
+3. Kontextmenü (Rechtsklick oder Menütaste) → **Zur Bibliothek hinzufügen**  
+4. Scraper wählen (z. B. „Universal Album Scraper“)  
+
+#### Videos
+
+Analog:
+
+1. **Filme/Serien → Dateien**  
+2. Quelle „Videos-Samba“ auswählen  
+3. **Inhalt festlegen** → Typ (Filme, Serien…)  
+4. Passenden Scraper wählen  
+
+#### Bilder
+
+Unter **Bilder** Quellen hinzufügen und direkt als Bilderquelle verwenden.
+
+## 7. Kodi anpassen
+
+### 7.1 Wetter-Add-on
+
+1. **Add-ons → Aus Repository installieren → Wetter**  
+2. Ein Wetter-Add-on (z. B. OpenWeatherMap) auswählen  
+3. Installieren  
+4. In den Add-on-Einstellungen:
+   * API-Schlüssel eintragen (bei Bedarf vorher erstellen)  
+   * Standort konfigurieren (z. B. „Berlin, DE“)  
+
+### 7.2 Retro-Spiele (ROMs)
+
+1. **Add-ons → Aus Repository installieren → Spiele → Emulator-Add-ons**  
+2. Passende Emulatoren (z. B. für NES, SNES, PlayStation) installieren  
+3. In den Emulator-Einstellungen:
+   * ROM-Pfade hinzufügen, z. B. `smb://192.168.178.50/ROMs`  
+Mehr Funktionen was Spielen angeht müssen Sie sich im Netz informieren.
+
+### 7.3 Skin anpassen
+
+1. **Einstellungen → Oberfläche → Skin**  
+2. „Weitere Skins herunterladen“ auswählen  
+3. Z. B. **Estuary Mod V2** installieren  
+4. Aktivieren → Kodi neustarten  

mkdocs/docs/basics/Remotezugriff_einrichten.md

@@ -0,0 +1,115 @@
+# Remote-Zugriff auf Linux Mint von Windows aus (GUI-basiert)
+
+Diese Anleitung zeigt Schritt für Schritt, wie Sie von einem Windows-Rechner aus auf ein Linux‑Mint‑System zugreifen:
+
+1. Zuerst richten Sie **grafischen Remote-Desktop** mit **xrdp** und der Windows-Remotedesktop-App ein und testen ihn direkt.  
+2. Anschließend richten Sie den **SSH-Zugriff** mit **PuTTY** ein und testen ihn ebenfalls sofort.
+
+## 1. Grafischer Remote-Desktop mit xrdp
+
+### 1.1 xrdp auf Linux Mint installieren
+
+1. Melden Sie sich lokal an Ihrem **Linux‑Mint‑Rechner** an.  
+2. Öffnen Sie das **Menü** und starten Sie die **Anwendungsverwaltung** (Software-Manager).  
+3. Geben Sie oben im Suchfeld **„xrdp“** ein.  
+4. Wählen Sie den Eintrag **„xrdp“** aus.  
+5. Klicken Sie auf **„Installieren“** und geben Sie bei Nachfrage Ihr Passwort ein.  
+6. Warten Sie, bis die Installation abgeschlossen ist – der Dienst startet danach automatisch. 
+
+!!! tip Hinweis: Bei der Installation legt xrdp automatisch die Gruppe **„xrdp“** an. Nur Benutzer dieser Gruppe dürfen sich per Remote Desktop anmelden. 
+
+### 1.2 Benutzer grafisch der Gruppe „xrdp“ hinzufügen
+
+1. Öffnen Sie das **Menü**.  
+2. Gehen Sie zu **„Einstellungen“ → „Benutzer und Gruppen“** (oder ähnlich benannter Eintrag).  
+3. Bestätigen Sie bei Bedarf mit Ihrem Passwort.  
+4. Wählen Sie in der Benutzerliste den gewünschten Benutzer (z. B. `meister`) aus.  
+5. Klicken Sie auf **„Gruppen verwalten“** oder **„Erweiterte Einstellungen“**.  
+6. In der Liste der Gruppen setzen Sie ein **Häkchen** bei **„xrdp“**.  
+7. Bestätigen Sie mit **„OK“**, **„Anwenden“** oder **„Speichern“**.  
+8. Melden Sie den Benutzer einmal **ab und wieder an**, damit die Gruppenzugehörigkeit aktiv wird. 
+
+### 1.3 IP-Adresse von Linux Mint ohne Terminal ermitteln
+
+1. Klicken Sie unten rechts in der Panel-Leiste auf das **Netzwerksymbol** (LAN oder WLAN).  
+2. Wählen Sie **„Verbindungsinformationen“** oder **„Netzwerkverbindungen“**.   
+3. In den Verbindungsdetails sehen Sie die **IPv4-Adresse**, z. B. `192.168.1.50`.  
+4. Notieren Sie sich diese Adresse – sie wird gleich für den Test benötigt.
+
+### 1.4 Remote Desktop von Windows aus testen
+
+1. Wechseln Sie an Ihren **Windows-Rechner**.  
+2. Öffnen Sie das Startmenü und suchen Sie nach **„Remotedesktopverbindung“** oder geben Sie `mstsc` in die Suche ein.  
+3. Starten Sie die Anwendung **„Remotedesktopverbindung“**.  
+4. Im Feld **„Computer“** tragen Sie die IP-Adresse des Linux‑Mint‑Rechners ein, z. B. `192.168.1.50`.  
+5. Optional: Klicken Sie auf **„Optionen einblenden“**, um Anzeigeeinstellungen anzupassen.  
+6. Klicken Sie auf **„Verbinden“**.  
+7. Beim ersten Verbindungsaufbau erscheint ein Hinweis zur Identität des Remotecomputers:
+   * Bestätigen Sie mit **„Ja“**.  
+8. Es erscheint der **xrdp-Anmeldebildschirm**:
+   * Sitzungsart: **„Xorg“** belassen (Standard)  
+   * **Benutzername**: z. B. `meister`  
+   * **Passwort**: Passwort des Linux-Kontos  
+9. Klicken Sie auf **„OK“** oder **„Anmelden“**.
+
+Nach kurzer Zeit sollte der Linux‑Mint‑Desktop in einem Fenster auf Ihrem Windows-Rechner erscheinen.  
+Sie haben damit den ersten Erfolg: grafischer Remote-Zugriff funktioniert.
+
+--* 
+
+## 2. Textbasierter Zugriff mit SSH und PuTTY
+
+Nach dem erfolgreichen grafischen Zugriff richten Sie nun den SSH-Zugriff ein.
+
+### 2.1 OpenSSH-Server über die Anwendungsverwaltung installieren
+
+1. Melden Sie sich (falls nötig) wieder lokal an Ihrem **Linux‑Mint‑Rechner** an.  
+2. Öffnen Sie das **Menü** und starten Sie erneut die **Anwendungsverwaltung**.  
+3. Geben Sie im Suchfeld **„OpenSSH Server“** oder **„openssh-server“** ein.  
+4. Wählen Sie den Eintrag **„OpenSSH Server“** aus.  
+5. Klicken Sie auf **„Installieren“** und geben Sie Ihr Passwort ein.  
+6. Warten Sie, bis die Installation abgeschlossen ist – der SSH-Dienst startet automatisch und wird beim Systemstart aktiviert.
+
+!!! tip  Die IP-Adresse bleibt dieselbe wie im Remote-Desktop-Teil; sie muss nicht neu gesucht werden.
+
+
+
+### 2.2 PuTTY auf Windows installieren
+
+1. Öffnen Sie auf dem **Windows-Rechner** den Webbrowser.  
+2. Rufen Sie die offizielle PuTTY-Downloadseite auf, z. B.:  
+   `https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html`  
+3. Laden Sie den **64‑Bit Windows Installer** herunter.  
+4. Starten Sie den Installer per Doppelklick und folgen Sie dem Assistenten (Standardeinstellungen reichen).  
+5. Nach der Installation finden Sie **PuTTY** im Startmenü.
+
+
+### 2.3 SSH-Verbindung mit PuTTY testen
+
+1. Starten Sie **PuTTY** über das Windows-Startmenü.  
+2. Im Feld **„Host Name (or IP address)“** tragen Sie die IP-Adresse des Linux‑Mint‑Rechners ein, z. B. `192.168.1.50`.  
+3. Prüfen Sie:
+   * **Port**: `22`  
+   * **Connection type**: `SSH`  
+4. Optional:
+   * Geben Sie unter **„Saved Sessions“** einen Namen wie `Mint-SSH` ein.  
+   * Klicken Sie auf **„Save“**, um die Sitzung zu speichern.  
+5. Klicken Sie auf **„Open“**.  
+6. Beim ersten Verbindungsaufbau erscheint ein Sicherheitshinweis zum Server-Schlüssel:
+   * Bestätigen Sie mit **„Accept“** bzw. **„Ja“**.  
+7. Geben Sie im Terminalfenster den **Benutzernamen** Ihres Linux-Kontos ein und drücken Sie Enter.  
+8. Geben Sie anschließend Ihr **Passwort** ein (es wird beim Tippen nicht angezeigt) und bestätigen Sie mit Enter.
+
+Sie sind nun per SSH mit Linux Mint verbunden und können textbasierte Befehle ausführen, Konfigurationsdateien bearbeiten und Protokolle ansehen.
+
+---
+
+## 3. Kurzer Überblick: Was wurde erreicht?
+
+* **xrdp + Remotede sktop**:  
+  * Grafischer Zugriff auf den Linux‑Mint‑Desktop von Windows aus  
+  * Benutzersteuerung über die bestehende Gruppe **„xrdp“**  
+
+* **OpenSSH-Server + PuTTY**:  
+  * Textbasierter Zugriff (Shell) auf Linux Mint  
+  * Ideal für Administration, Skripte und Log-Analyse  

mkdocs/docs/basics/Windows-Freigabe mit Samba.md

@@ -1,304 +0,0 @@
-# Windows-Freigabe mit Samba
-
-Samba ist die Linux-Variante um SMB-Verbindungen zu Windows, Linux und OS X (macOS) herzustellen. Hierfür wird ein Serverdienst installiert und über eine übersichtliche Konfigurationsdatei entsprechend den Anforderungen eingestellt. Es existieren zwar auch Möglichkeiten diese Freigaben über GUI-Programme oder Webinterfaces zu konfigurieren allerdings sind deren Funktionsumfang meist auf Basis-Funktionen beschränkt. Samba bietet eine Überprüfungsmöglichkeit der Konfigurationsdatei, um Schreibfehler und deren Konsequenzen übersichtlich darzustellen.
-
-## Installation
-
-Für die Installation empfiehlt sich die Shell da hierüber sinnvoll beobachtet werden kann welche weiteren Abhängigkeiten installiert werden.
-
-### Shell-Installation
-
-Update der Paketdatenbank und der installierten Pakete
-
-```bash
-sudo apt update && sudo apt-get upgrade -y
-```
-
-Installation des Samba-Dienstes
-
-```bash
-sudo apt install samba
-```
-
-Nach der Installation des Dienstes kann dieser über die Konfigurationsdatei /etc/samba/smb.conf bearbeitet werden. Die von Ubuntu vorkonfigurierte Version ist nahezu vollständig selbsterklärend und mit entsprechenden Beispielen versehen.
-
-## smb.conf
-
-```ini
-[global]
-workgroup = WORKGROUP
-```
-
-Hier wird die Arbeitsgruppe bzw. die Domäne, in der der Samba-Server
-betrieben werden soll definiert.
-
-```ini
-server string = %h server (Samba, Ubuntu)
-```
-
-Die Beschreibung des Servers (mouse-over) wobei für %h für der hostname
-des Servers eingesetzt wird.
-
-```ini
-wins support = no
-wins server = w.x.y.z
-```
-
-Kann geändert werden zu 
-
-```ini
-wins support = yes
-# wins server = w.x.y.z
-```
-
-Damit übernimmt der Samba-Server die [WINS](https://de.wikipedia.org/wiki/Windows_Internet_Naming_Service)-Aufgaben.
-
-**In einem Netzwerk sollte immer nur ein WINS-Server aktiv laufen.**
-
-```ini
-dns proxy = no
-```
-
-Bei der Grundkonfiguration no wird kein DNS-Server für die Namensauflösung genutzt sondern nur die lokalen host Dateien, WINS-Server und Broadcasts. Wenn ein funktionierender DNS-Server im Netzwerk vorhanden ist kann dieser durch den Einsatz von yes ebenfalls genutzt werden.
-
-```ini
-interfaces = 127.0.0.0/8 eth0
-bind interfaces only = yes
-```
-
-Hier kann konfiguriert werden ob der Samba-Server auf einer, mehreren oder allen Netzwerkkarten und IP-Adressen verfügbar ist. Wenn Sie hier nichts verändern ist der Server Grundsätzlich auf allen Netzwerkkarten und Subnetzen erreichbar.
-
-```ini
-server role =
-```
-
-standalone server: Die einfachste Variante, nur User die per smbpasswd hinzugefügt wurden können auf den Samba-Server zugreifen.
-
-member server: Der Server ist Mitglied einer Domäne und hat ein Maschinenkonto auf dem ADDC an welchen auch die Benutzeranfragen weitergegegeben werden.
-
-classic primary domain controller: Samba agiert als NT4 PDC
-
-classic backup domain controller : Samba ist ein sekundärer NT4 DC
-
-active directory domain controller: Samba agiert als ADDC und übernimmt die gesamte Benutzerauthentifizierung. Diese Einstellung sollte nicht von Hand genutzt werden da hierfür ein Provisionierungsscript genutzt wird.
-
-```
-map to guest = bad user
-```
-
-Was passiert mit unbekannten Nutzern.
-
-## Freigaben
-
-Freigaben werden je nach Funktionalität unterschiedlich beschrieben wobei es auch besondere Freigaben gibt, welche z.B. Drucker, Clientspezifisch oder Userspezifische Freigaben betreffen.
-
-## Beispiel einer freien Freigabe z.B. Medienfreigabe im Privatbereich
-
-```ini
-[Musik]
-comment = Musikfreigabe
-path = /srv/samba/musik
-read only = no
-browseable = yes
-```
-
-Nach dem Speichern überprüfen Sie ob alle Funktionen, die sie definiert
-haben korrekt übernommen werden konnten:
-
-```bash
-sudo samba-tool testparm
-```
-
-Sie werden feststellen, dass die Option browseable nicht angezeigt wird. Dies liegt daran, dass diese Kombination browseable = yes ein defaultwert ist und somit nicht angezeigt wird.
-
-Damit diese Freigabe auch funktioniert, muss Sie auch auf dem System vorhanden sein, sowie die korrekte Rechtevergabe erfolgt sein.
-
-```bash
-sudo mkdir /srv/samba
-sudo mkdir /srv/samba/musik
-sudo chmod -R a+rw /srv/samba/musik
-```
-
-nach Abschluss dieser Aktion muss der Samba-Dienst und der NetBIOS-Nameserver neu gestartet werden.
-
-```bash
-sudo systemctl restart smbd.service nmbd.service
-```
-
-Alle vor der Installation von Samba vorhandenen User sind nicht in der Samba-Datenbank hinterlegt und müssen nachgepflegt werden. Hierbei geben sie ihren Usernamen und ihr Passwort erneut ein. Spätere Änderungen werden synchronisiert.
-
-```bash
-sudo smbpasswd -a USERNAME
-```
-
-Nun können Sie von einem beliebigen Client auf diese Freigabe zugreifen:
-
-Windows:
-
-Explorer öffnen und in der Adresszeile:
-
-```
-\\IP des Servers\Musik
-```
-
-eingeben oder direkt ein Netzlaufwerk verbinden
-
-Linux und OSX:
-
-Im Dateimanager in die Adresszeile:
-
-```
-smb://IP des Servers/Musik
-```
-
-## Beispiel eingeschränkte Freigabe z.B. Unterlagen für bestimmten Personenkreis.
-
-Im Vorfeld solcher Freigaben müssen die betreffenden Benutzer zum einen auf dem System vorhanden sein und auch noch ergänzend in Samba bekannt gemacht werden. Dazu legen wir nun 2 neue Nutzer an, um später nachvollziehen zu können wer was darf. Dazu als Beispiel Hans Wurst aus der Produktion und Peter Lustig aus der Verwaltung.
-
-Im folgenden werden Zugriffsgruppen definiert welche es ermöglichen die Lese- und Schreibrechte sauber Granuliert darzustellen:
-
-|              | Lesen
Angebote | Schreiben
Angebote | Lesen
Lieferscheine | Schreiben
Lieferscheine |
-| ------------ | ------------------ | ---------------------- | ----------------------- | --------------------------- |
-| Hans Wurst   | X                  |                        |                         | X                           |
-| Peter Lustig |                    | X                      |                         | X                           |
-
-```bash
-sudo adduser hwurst 
-sudo adduser plustig
-sudo addgroup angebote_l
-sudo addgroup angebote_ae
-sudo addgrouo lieferscheine_l
-sudo addgroup lieferscheine_ae
-sudo usermod -aG angebote_l hwurst
-sudo usermod -aG lieferscheine_ae hwurst
-sudo usermod -aG angebote_ae plustig
-sudo usermod -aG lieferscheine_ae plustig
-```
-
-Bekanntgabe an Samba:
-
-```bash
-sudo smbpasswd -a hwurst
-sudo smbpasswd -a plustig
-```
-
-Erstellen der Verzeichnisse:
-
-```bash
-sudo mkdir /srv/samba/angebote
-sudo mkdir /srv/samba/lieferscheine
-sudo chown -R nobody:angebote_ae /srv/samba/angebote
-sudo chown -R nobody:lieferscheine_ae /srv/samba/lieferscheine
-sudo chmod -R 0077 /srv/samba/angebote
-sudo chmod -R 0077 /srv/samba/lieferscheine
-sudo nano /etc/samba/smb.conf
-```
-
-```ini
-[Angebote]
-comment = Angebote an Kunden
-path = /srv/samba/angebote
-guest ok = no
-browseable = yes
-readonly = yes
-valid users = @angebote_l, @angebote_ae
-write list = @angebote_ae
-force create mode = 0775
-force directory mask = 0775
-force group = angebote_ae
-
-[Lieferscheine]
-copy = Angebote
-comment = Lieferscheine von Lieferanten
-path = /srv/samba/lieferscheine
-valid users = @lieferscheine_l, @lieferscheine_ae
-write list = @lieferscheine_ae
-force group = lieferscheine_ae
-
-```
-
-## Userverzeichnis
-
-> Jeder User der Zugriffsrechte auf Samba selbst hat kann durch eine spezielle Freigabe automatisch Zugriff auf sein eigenes Home-Verzeichnis erhalten. Diese ist in der Beispielkonfiguration der smb.conf bereits auskommentiert vorhanden und kann schlicht wieder ein kommentiert werden.
-
-```ini
-[homes]
-comment = Privates Verzeichnis
-browseable = no
-read only = yes
-create mask = 0700
-directory mask = 0700
-valid users = %S
-
-```
-
-„homes" ist hier nur ein Platzhalter dieser wird automatisch durch den jeweiligen Usernamen ersetzt und auch der Zugriff ist dann nur für diesen User verfügbar.
-
-## Sonderfall Drucker
-
-Für Drucker ist standartmäßig eine Freigabe aktiviert ähnlich wie dies auch Windows in einem Heimnetzwerk tut. Die Konfiguration können Sie der Beispielkonfiguration der smb.conf entnehmen es sind 2 Freigaben notwendig, um ALLE Drucker freizugeben.
-
-```ini
-[printers]
-comment = Alle Drucker
-browseable = no
-path = /var/spool/samba
-printable = yes
-guest ok = no
-read only = yes
-create mask = 0700
-```
-
-Damit werden Alle Drucker, die am System eingerichtet sind mit jeweils einem eigenen Eintrag freigegeben.
-
-```ini
-[print$]
-comment = Drucker Treiber
-path /var/lib/samba/printers
-browseable = yes
-read only = yes
-guest ok = no
-
-```
-
-Hier sucht Windows nach Druckertreibern. Die Treiber müssen entweder über andere Wege in dieses Verzeichnis gelegt werden oder es kann auch ein write list Eintrag hinzugefügt werden.
-
-## Netzwerkpapierkorb
-
-Auf einem Netzlaufwerk gelöschte Dateien können schnell mal verloren gehen, dafür lässt sich ein Netzwerkpapierkorb einsetzen. Entweder unter global für alle Freigaben oder pro Freigabe einmal einsetzen.
-
-```ini
-# Virtuelles File System "recycle" wird angelegt
-vfs object = recycle
-# Der Pfad zum Papierkorb relativ zur Freigabe (".recyclebin" ist
-Default).
-recycle:repository = .recyclebin
-# Im Papierkorb bleiben Pfad-Angaben erhalten.
-recycle:keeptree = Yes
-# Beim Verschieben wird der Zeitstempel angepasst.
-recycle:touch = Yes
-# Gleichnamige Dateien werden nicht überschrieben.
-recycle:versions = Yes
-# Keine Begrenzung der Dateigröße pro gelöschter Datei.
-recycle:maxsize = 0
-```
-
-Und wer leert den? Durch Cron wird jeden Tag der Papierkorb durchsucht
-und alles, was älter als 14 Tage ist gelöscht.
-
-```bash
-sudo crontab -e
-```
-
-In einer Zeile:
-
-```
-0 12 * * * for path in $(grep path /etc/samba/smb.conf | cut -d= -f2 | sed -e 's/ //' -e 's/\%S/*/'); do if  ; then find ${path}/.recycle -mindepth 1 -mtime +14 -exec rm -rf {} \;; fi; done
-```
-
-Was steht da nun drin:
-
-Jeden Tag um 0:12 soll in der smb.conf nach Pfad-Angaben gesucht werden und innerhalb dieser die Pfade „.recycle" nach Dateien durchsucht werden die älter als 14 Tage sind. Diese werden gelöscht.
-
-
-[PDF herunterladen](Windows-Freigabe_mit_Samba.pdf){ .md-button }

mkdocs/docs/basics/Windows_Freigaben_fuer_Linux-Einsteiger.md

@@ -0,0 +1,463 @@
+# Samba-Konfiguration für Linux-Einsteiger
+
+## Einführung in Samba
+**Samba** ist eine Open-Source-Software, die es Linux-Systemen ermöglicht, **Datei* und Druckdienste** für Windows-, macOS* und andere Linux-Clients bereitzustellen. Samba implementiert das **SMB/CIFS-Protokoll** (Server Message Block / Common Internet File System), das in Windows-Netzwerken standardmäßig verwendet wird.
+
+### Wichtige Anwendungsfälle:
+* **Dateifreigaben** im lokalen Netzwerk (z. B. für Medien, Dokumente oder Backups).
+* **Druckerfreigaben** für Windows-Clients.
+* **Zentraler Speicher** für mehrere Nutzer (z. B. in kleinen Büros oder Heimnetzwerken).
+
+### Voraussetzungen:
+* Ein **Linux-Server** (z. B. Ubuntu, Debian, Raspberry Pi OS).
+* **Root-Zugriff** oder ````sudo````-Berechtigungen.
+* Grundkenntnisse in der **Linux-Kommandozeile**.
+
+---
+
+## Installation von Samba
+
+### 1. Paketdatenbank aktualisieren
+```bash
+sudo apt update && sudo apt upgrade -y
+```
+### 2. Samba installieren
+````bash
+sudo apt install samba
+````
+### 3. Dienststatus prüfen
+````bash
+sudo systemctl status smbd
+````
+
+> Erwarteter Output: active (running).
+Falls nicht aktiv: sudo systemctl start smbd und sudo systemctl enable smbd.
+
+Zum verlassen ````q```` oder ````strg + c````
+
+## Die Konfigurationsdatei smb.conf
+Die zentrale Konfigurationsdatei /etc/samba/smb.conf steuert das Verhalten des Samba-Servers. Sie ist in zwei Hauptbereiche unterteilt:
+
+**[global]**: Globale Einstellungen für den gesamten Server.
+**[Freigabename]**: Definition einzelner Freigaben (Ordner, Drucker).
+### Globale Einstellungen ````[global]````
+Die globalen Einstellungen gelten für alle Freigaben, sofern sie nicht in einer Freigabe überschrieben werden.
+Wichtige Optionen für einen Standalone-Server:
+````ini
+
+[global]
+   # Netzwerk-Identifikation
+   workgroup = WORKGROUP          # Name der Arbeitsgruppe (wie in Windows)
+   server string = %h server (Samba, Ubuntu)  # Beschreibung des Servers (%h = Hostname)
+
+   # Netzwerk-Interfaces
+   interfaces = 127.0.0.0/8 eth0  # Auf welchen Interfaces soll Samba laufen?
+   bind interfaces only = yes     # Nur auf den genannten Interfaces
+
+   # Protokollierung
+   log file = /var/log/samba/log.%m  # Log-Datei pro Client (%m = Client-Name)
+   max log size = 1000               # Maximale Log-Größe in KB
+   logging = file                    # Logs nur in Dateien (nicht syslog)
+
+   # Sicherheit
+   server role = standalone server   # Server arbeitet allein (keine Domain)
+   map to guest = bad user          # Unbekannte Nutzer werden als "Gast" behandelt
+   obey pam restrictions = yes        # Nutzer müssen Linux-PAM-Regeln einhalten
+   unix password sync = yes         # Samba-Passwort ändert auch Linux-Passwort
+   passwd program = /usr/bin/passwd %u  # Programm zum Ändern des Passworts
+   pam password change = yes        # PAM für Passwort-Änderungen nutzen
+
+   # Nutzerfreigaben
+   usershare allow guests = yes    # Gäste dürfen auf Nutzerfreigaben zugreifen
+````
+Hinweise:
+````
+; oder #:
+; = Deaktivierter Vorschlag (kann aktiviert werden).
+# = Standardwert (wird auch ohne Angabe genutzt).
+````
+Platzhalter:
+````
+%h = Hostname des Servers.
+%m = Name des Clients.
+%S = Name der aktuellen Freigabe.
+````
+#### Anpassungen an Windows 11
+Fügen sie unterhalb dieser Einstellungen im noch im Bereich [Global] :
+````ini
+    # Protokolle und Kompatibilität
+    server min protocol = SMB2
+    smb encrypt = desired 
+````
+### Freigaben definieren 
+Freigaben werden in eigenen Abschnitten definiert, z. B. [Musik] oder [Dokumente]. Jede Freigabe hat einen Namen (erscheint im Netzwerk) und Optionen für Zugriffsrechte.
+Grundlegende Optionen:
+
+|Option        |Bedeutung                                                               |Beispiel                  |
+|--------------|------------------------------------------------------------------------|--------------------------|
+|comment       |Beschreibung der Freigabe (erscheint im Explorer).                      |comment = Medienarchiv    |
+|path          |Pfad zum freigegebenen Ordner.                                          |path = /srv/samba/musik   |
+|browseable    |yes: Freigabe ist im Netzwerk sichtbar. no: Nur mit direktem Pfad.      |browseable = yes          |
+|read only     |yes: Nur Lesezugriff. no: Schreibzugriff erlaubt.                       |read only = no            |
+|guest ok      |yes: Gäste (ohne Passwort) dürfen zugreifen.                            |guest ok = yes            |
+|valid users   |Liste der Nutzer/Gruppen, die überhaupt zugreifen dürfen.               |valid users = @mitarbeiter|
+|write list    |Liste der Nutzer/Gruppen, die schreiben dürfen (überschreibt read only).|write list = @teamleitung |
+|create mask   |Berechtigungen für neue Dateien (oktal).                                |create mask = 0664        |
+|directory mask|Berechtigungen für neue Ordner (oktal).                                 |directory mask = 0775     |
+|force group   |Neue Dateien/Ordner gehören automatisch zu dieser Gruppe.               |force group = mitarbeiter |
+
+#### Sonderfälle: Home-Verzeichnisse und Drucker
+1. Nutzer-Home-Verzeichnisse
+Jeder Nutzer kann automatisch auf sein eigenes Home-Verzeichnis zugreifen:
+````ini
+
+[homes]
+   comment = Persönlicher Ordner
+   browseable = no       # Nur der eigene Nutzer sieht die Freigabe
+   read only = no        # Nutzer darf schreiben
+   valid users = %S      # %S = aktueller Nutzer (z. B. "felix")
+   create mask = 0700    # Neue Dateien: rwx------
+   directory mask = 0700 # Neue Ordner: rwx------
+````
+ 2. Druckerfreigabe
+Samba kann Drucker für Windows-Clients freigeben:
+````ini 
+
+[printers]
+   comment = Alle Drucker
+   path = /var/spool/samba  # Spoolfolder für Druckaufträge
+   browseable = no          # Drucker sind nicht im Explorer sichtbar
+   printable = yes          # Erlaubt Druckaufträge
+   guest ok = no            # Nur authentifizierte Nutzer dürfen drucken
+
+[print\$]
+   comment = Druckertreiber
+   path = /var/lib/samba/printers
+   browseable = yes
+   read only = yes
+   guest ok = no
+   write list = root, @lpadmin  # Nur Admins dürfen Treiber hochladen
+````
+
+
+## Rechteverwaltung unter Linux
+Die korrekte Vergabe von Datei* und Ordnerrechten ist essenziell für die Sicherheit und Funktionalität von Samba-Freigaben.
+### ````chown````: Besitzer und Gruppe ändern
+Jede Datei/Ordner gehört einem **Besitzer (User)** und einer **Gruppe (Group)**.
+Syntax:
+````bash
+sudo chown [BESITZER]:[GRUPPE] [DATEI/ORDNER]
+````
+Beispiele:
+
+|Befehl| Wirkung|
+|-|-|
+|sudo chown felix:mitarbeiter /srv/samba|Besitzer: felix, Gruppe: mitarbeiter.                                 |
+|sudo chgrp mitarbeiter /srv/samba|Ändert nur die Gruppe auf mitarbeiter.                                  |
+|sudo chown -R nobody:mitarbeiter /srv/samba|Rekursiv: Besitzer: nobody, Gruppe: mitarbeiter für alle Unterordner/Dateien.|
+
+
+
+Hinweise:
+
+**sudo** ist erforderlich, wenn Sie nicht der Besitzer sind.
+**-R** (rekursiv): Wendet die Änderung auf alle Unterordner/Dateien an.
+**Samba-Empfehlung**: Für Freigaben oft nobody oder root als Besitzer und eine **spezifische Gruppe** (z. B. mitarbeiter) verwenden.
+
+### ````chmod````: Zugriffsrechte setzen
+Die Zugriffsrechte werden für **drei Kategorien** von Nutzern definiert:
+
+**Besitzer (User)**: Der Nutzer, dem die Datei/der Ordner gehört.
+**Gruppe (Group)**: Die Gruppe, der die Datei/der Ordner zugeordnet ist.
+**Andere (Others)**: Alle anderen Nutzer.
+
+Jede Kategorie kann drei Rechte haben:
+
+````r```` **(Read)**: Lesen.
+````w```` **(Write)**: Schreiben.
+````x```` **(Execute)**: Ausführen (bei Ordnern: Betreten).
+#### Symbolische Darstellung:
+````
+rwx r-x r--
+│   │   │
+│   │   └─ Andere (Others): Lesen (r), kein Schreiben (–), kein Ausführen (–)
+│   └───── Gruppe (Group): Lesen (r), kein Schreiben (–), Ausführen (x)
+└───────── Besitzer (User): Lesen (r), Schreiben (w), Ausführen (x)
+````
+#### Oktal-Darstellung:
+Jedes Recht wird durch eine **Zahl** repräsentiert:
+
+````r```` = 4
+````w```` = 2
+````x```` = 1
+Die Rechte für jede Kategorie werden **addiert**:
+
+|Rechte|Oktal-Wert|Bedeutung            |
+|------|----------|---------------------|
+|````---````   |0         |Keine Rechte         |
+|````--x````   |1         |Nur Ausführen        |
+|````-w-````   |2         |Nur Schreiben        |
+|````-wx````   |3         |Schreiben + Ausführen|
+|````r--````   |4         |Nur Lesen            |
+|````r-x````   |5         |Lesen + Ausführen    |
+|````rw-````   |6         |Lesen + Schreiben    |
+|````rwx````   |7         |Vollzugriff          |
+
+
+Die Oktal-Modi für alle drei Kategorien werden kombiniert:
+
+* ````755```` = ````rwxr-xr-x```` (Besitzer: Vollzugriff, Gruppe/Andere: Lesen + Ausführen)
+* ````644```` = ````rw-r--r--```` (Besitzer: Lesen + Schreiben, Gruppe/Andere: Nur Lesen)
+* ````770```` = ````rwxrwx---```` (Besitzer/Gruppe: Vollzugriff, Andere: Keine Rechte)
+  
+Syntax von chmod:
+````bash
+sudo chmod [OPTIONEN] [RECHTE] [DATEI/ORDNER]
+````
+
+* ````RECHTE````: Symbolisch (z. B. ````u=rwx,g=rx,o=rx````) oder oktal (z. B. ````755````).
+* ````OPTIONEN````:
+
+  * ````-R````: Rekursiv (für alle Unterordner/Dateien).
+
+#### Beispiele:
+
+|Befehl                      |Wirkung                                      |
+|----------------------------|---------------------------------------------|
+|sudo chmod 755 /srv/samba   |Besitzer: rwx, Gruppe/Andere: r-x.           |
+|sudo chmod 644 datei.txt    |Besitzer: rw-, Gruppe/Andere: r--.           |
+|sudo chmod -R 770 /srv/samba|Rekursiv: Besitzer/Gruppe: rwx, Andere: ---. |
+|sudo chmod u+x skript.sh    |Fügt dem Besitzer das Ausführrecht (x) hinzu.|
+|sudo chmod g-w /srv/samba   |Entfernt das Schreibrecht für die Gruppe.    |
+
+
+Samba-spezifische Empfehlungen:
+
+**Freigabe-Ordner:**
+
+* ````775```` ````(rwxrwxr-x)````: Besitzer und Gruppe haben Vollzugriff, Andere dürfen lesen und Ordner betreten.
+* ````770```` ````(rwxrwx---)````: Nur Besitzer und Gruppe haben Zugriff (empfohlen für sensible Daten).
+
+**Dateien in Freigaben:**
+
+* ````664```` ````(rw-rw-r--)````: Besitzer und Gruppe dürfen lesen/schreiben, Andere nur lesen.
+* ````660```` ````(rw-rw----)````: Nur Besitzer und Gruppe dürfen lesen/schreiben.
+
+
+### Gruppenverwaltung
+Gruppen ermöglichen die zentrale Steuerung von Zugriffsrechten für mehrere Nutzer.
+#### 1. Nutzer und Gruppe erstellen:
+````bash
+sudo adduser felix
+sudo addgroup mitarbeiter
+````
+#### 2. Nutzer einer Gruppe hinzufügen:
+````bash
+
+sudo usermod -aG mitarbeiter felix  # Fügt "felix" der Gruppe "mitarbeiter" hinzu.
+````
+
+**````-aG````**: ````-a```` (append) stellt sicher, dass der Nutzer nicht aus anderen Gruppen entfernt wird.
+#### 3. Gruppe einer Datei/Ordner zuweisen:
+````bash
+
+sudo chgrp mitarbeiter /srv/samba/dokumente  # Setzt die Gruppe auf "mitarbeiter".
+sudo chmod 770 /srv/samba/dokumente           # Gruppe erhält Vollzugriff.
+````
+#### 4. Gruppe in Samba nutzen:
+````ini
+
+[Dokumente]
+   path = /srv/samba/dokumente
+   valid users = @mitarbeiter      # Nur Nutzer der Gruppe "mitarbeiter" dürfen zugreifen.
+   write list = @teamleitung       # Nur Gruppe "teamleitung" darf schreiben.
+   force group = mitarbeiter       # Neue Dateien/Ordner gehören automatisch zur Gruppe "mitarbeiter".
+````
+
+## Samba-Freigaben in der Praxis
+### Beispiel 1: Öffentliche Freigabe
+Anwendungsfall: Medienfreigabe für alle Nutzer im Netzwerk (z. B. Musik, Filme).
+**Schritt 1: Ordner erstellen und Rechte setzen**
+````bash
+sudo mkdir -p /srv/samba/medien
+sudo chown nobody:nogroup /srv/samba/medien  # Besitzer: "nobody", Gruppe: "nogroup"
+sudo chmod 777 /srv/samba/medien              # Temporär volle Rechte (für Test)
+````
+**Schritt 2: Freigabe in smb.conf definieren**
+````ini
+[Medien]
+   comment = öffentliche Medienfreigabe
+   path = /srv/samba/medien
+   browseable = yes
+   read only = no
+   guest ok = yes
+````
+**Schritt 3: Samba neu starten**
+````bash
+sudo systemctl restart smbd
+````
+**Schritt 4: Von Windows aus testen**
+> Im Explorer: ````\\<IP-des-Servers>\Medien```` eingeben.
+
+### Beispiel 2: Eingeschränkte Freigabe
+Anwendungsfall: Vertrauliche Dokumente für bestimmte Nutzer/Gruppen.
+**Schritt 1: Gruppe und Nutzer anlegen**
+````bash
+sudo adduser felix
+sudo adduser hans
+sudo addgroup mitarbeiter
+sudo addgroup teamleitung
+sudo usermod -aG mitarbeiter felix
+sudo usermod -aG mitarbeiter hans
+sudo usermod -aG teamleitung felix
+````
+**Schritt 2: Ordner erstellen und Rechte setzen**
+````bash
+sudo mkdir -p /srv/samba/dokumente
+sudo chown nobody:mitarbeiter /srv/samba/dokumente
+sudo chmod 770 /srv/samba/dokumente
+````
+**Schritt 3: Freigabe in smb.conf definieren**
+````ini
+[Dokumente]
+   comment = Vertrauliche Dokumente
+   path = /srv/samba/dokumente
+   browseable = yes
+   read only = no
+   guest ok = no
+   valid users = @mitarbeiter      # Nur Gruppe "mitarbeiter" darf zugreifen
+   write list = @teamleitung      # Nur Gruppe "teamleitung" darf schreiben
+   force group = mitarbeiter      # Neue Dateien/Ordner gehören zur Gruppe "mitarbeiter"
+   force create mode = 0660        # Neue Dateien: rw-rw----
+   force directory mode = 0770     # Neue Ordner: rwxrwx---
+````
+**Schritt 4: Nutzer zu Samba hinzufügen**
+````bash
+sudo smbpasswd -a felix
+sudo smbpasswd -a hans
+````
+**Schritt 5: Samba neu starten**
+````bash
+sudo systemctl restart smbd
+````
+
+## Schritt-für-Schritt: Neue Freigabe erstellen
+
+
+**1. Ordner anlegen:**
+````bash
+sudo mkdir -p /srv/samba/neue_freigabe
+````
+
+
+**2. Besitzer und Gruppe setzen:**
+````bash
+sudo chown nobody:mitarbeiter /srv/samba/neue_freigabe
+````
+
+**3. Rechte setzen:**
+````bash
+
+sudo chmod 770 /srv/samba/neue_freigabe
+````
+
+**4. Freigabe in /etc/samba/smb.conf definieren:**
+````ini
+
+[NeueFreigabe]
+   comment = Beschreibung der Freigabe
+   path = /srv/samba/neue_freigabe
+   browseable = yes
+   read only = no
+   guest ok = no
+   valid users = @mitarbeiter
+   write list = @teamleitung
+````
+**5. Konfiguration testen:**
+````bash
+
+sudo samba-tool testparm
+````
+
+**6. Samba neu starten:**
+````bash
+
+sudo systemctl restart smbd
+````
+
+
+## Häufige Fehler und Lösungen:
+
+|Problem                             |Ursache                                               |Lösung                                                                |
+|------------------------------------|------------------------------------------------------|----------------------------------------------------------------------|
+|Freigabe nicht sichtbar             |browseable = no oder Firewall blockiert Samba.        |browseable = yes setzen oder Firewall prüfen (sudo ufw allow samba).  |
+|Zugriff verweigert                  |Nutzer nicht in smbpasswd oder falsche Rechte.        |sudo smbpasswd -a nutzername ausführen. Rechte mit chmod/chown prüfen.|
+|Dateien können nicht gelöscht werden|Nutzer ist nicht Besitzer und hat keine Schreibrechte.|chmod g+w oder chown anpassen.                                        |
+|Gruppe wird nicht übernommen        |force group fehlt in smb.conf.                        |force group = gruppenname ergänzen.                                   |
+|Neue Dateien haben falsche Rechte   |force create mode/force directory mode fehlt.         |force create mode = 0660 und force directory mode = 0770 setzen.      |
+
+
+
+## Wichtige Befehle im Überblick
+|Befehl                                 |Beschreibung                                         |
+|---------------------------------------|-----------------------------------------------------|
+|````sudo apt install samba````                 |Samba installieren.                                  |
+|````sudo systemctl restart smbd````            |Samba-Dienst neu starten.                            |
+|````sudo samba-tool testparm ````                         |Konfiguration auf Fehler prüfen.                     |
+|````sudo smbpasswd -a nutzername````           |Nutzer zu Samba hinzufügen.                          |
+|````sudo chown besitzer:gruppe pfad````        |Besitzer und Gruppe einer Datei/eines Ordners ändern.|
+|````sudo chmod 755 pfad````                    |Rechte auf rwxr-xr-x setzen.                         |
+|````sudo chmod -R 770 pfad````                 |Rechte rekursiv auf rwxrwx--* setzen.                |
+|````sudo adduser nutzername````                |Benutzer erstellen. |
+|````sudo addgroup gruppenname````              |Gruppe erstellen.                                    |
+|````sudo usermod -aG gruppenname nutzername````|Nutzer einer Gruppe hinzufügen.                      |
+|````smbclient -L //localhost -U %````          |Freigegebene Ordner/Drucker auflisten (lokal).       |
+
+## Sicherheitshinweise
+
+**Minimale Rechte vergeben:**
+* Vermeiden Sie ````chmod 777````. Nutzen Sie stattdessen ````770```` oder ````750````.
+
+**Keine Gastzugriffe für sensible Daten:**
+
+* Setzen Sie ````guest ok = no```` für vertrauliche Freigaben.
+
+**Regelmäßige Backups:**
+
+* Sichern Sie die ````smb.conf```` und wichtige Freigabe-Ordner.
+
+**Firewall konfigurieren:**
+````bash
+
+sudo ufw allow samba  # Erlaubt Samba-Ports (139, 445).
+````
+
+Logs prüfen:
+
+Fehler finden Sie in ````/var/log/samba/log.%m````.
+
+
+## Anhang: Spezialrechte (Sticky Bit, SUID, SGID)
+Für fortgeschrittene Anwendungsfälle können Spezialrechte gesetzt werden:
+
+|Recht     |Oktal|Symbolisch|Wirkung                                                                               |
+|----------|-----|----------|--------------------------------------------------------------------------------------|
+|Sticky Bit|1    |t         |Nur der Besitzer darf Dateien in einem Ordner löschen (z. B. ````/tmp````).                   |
+|SUID      |4    |s         |Führt eine Datei mit den Rechten des **Besitzers** aus (z. B. ````passwd````).                    |
+|SGID      |2    |s         |Neue Dateien/Ordner erben die **Gruppe** des Elternordners (nützlich für Samba-Freigaben).|
+
+**Beispiele:**
+
+|Befehl                           |Wirkung                                                            |
+|---------------------------------|-------------------------------------------------------------------|
+|````sudo chmod 1777 /tmp````             |Setzt das **Sticky Bit** (nur Besitzer darf Dateien löschen).          |
+|````sudo chmod 2775 /srv/samba````       |Setzt **SGID**: Neue Dateien/Ordner erben die Gruppe des Elternordners.|
+|````sudo chmod 4755 /usr/bin/programm````|Setzt **SUID**: Programm läuft mit Rechten des Besitzers.              |
+
+
+**Samba-spezifische Nutzung:**
+
+* **SGID** ist nützlich, um sicherzustellen, dass neue Dateien/Ordner in einer Freigabe automatisch der richtigen Gruppe gehören:
+````bash
+sudo chmod 2770 /srv/samba/dokumente  # SGID + Besitzer/Gruppe: rwx
+````

mkdocs/docs/basics/Windows_Programme_unter_Linux.md

@@ -0,0 +1,185 @@
+# Windows-Programme unter Linux
+
+Diese Anleitung zeigt Schritt für Schritt, wie Sie unter Linux Mint zuerst Notepad++ und anschließend 7‑Zip (Windows‑Version) mit Bottles installieren.  
+
+## Voraussetzungen
+
+* Installiertes Linux Mint  
+* Internetzugang  
+* Ein normales Benutzerkonto
+
+## Bottles installieren
+
+1. Öffnen Sie das **Menü** unten links und starten Sie den **Software‑Manager**.  
+2. Suchen Sie nach **„Bottles“**.  
+3. Wählen Sie **„Bottles“** (Quelle „Flathub“ oder „Flatpak“) und klicken Sie auf **Installieren**.  
+4. Nach der Installation finden Sie Bottles im Menü, z. B. unter **Zubehör → Bottles**.
+
+## Flatseal installieren und Berechtigungen für Bottles setzen
+
+Damit Verknüpfungen (Desktop‑Icons und Menüeinträge) korrekt angelegt werden können, braucht Bottles Zugriff auf bestimmte Ordner.
+
+### Flatseal installieren
+
+1. Öffnen Sie erneut den **Software‑Manager**.  
+2. Suchen Sie nach **„Flatseal“**.  
+3. Wählen Sie **„Flatseal“** aus und klicken Sie auf **Installieren**.  
+
+### Berechtigungen für Bottles anpassen
+
+1. Starten Sie **Flatseal** über das Menü.  
+2. Wählen Sie in der linken Liste die Anwendung **„Bottles“** aus.  
+3. Gehen Sie zum Bereich **„Filesystem“** (oder „Dateisystem“).  
+4. Aktivieren bzw. fügen Sie folgende Pfade hinzu:
+   * ```xdg-data/applications```
+   * ```~/.local/share/applications```
+5. Speichern ist nicht nötig; die Änderungen gelten sofort.  
+6. Schließen Sie Flatseal und starten Sie **Bottles** einmal neu.
+
+Damit kann Bottles jetzt Desktop‑Verknüpfungen und Menüeinträge korrekt anlegen.
+
+---
+
+## Notepad++
+
+### Erste Bottle für Notepad++ anlegen
+
+1. Starten Sie **Bottles**.  
+2. Klicken Sie auf **„Create a new bottle“** bzw oben links auf das ````+````.  
+3. Geben Sie einen Namen ein, zum Beispiel **„NotepadPlusPlus“**.  
+4. Wählen Sie als Umgebung **„Application“** (Programm).  
+5. Klicken Sie auf **„Create“** und warten Sie, bis die Bottle erstellt wurde.
+
+
+
+### Notepad++ herunterladen
+
+1. Öffnen Sie Ihren **Webbrowser** (z. B. Firefox).  
+2. Rufen Sie die Seite auf:  
+   * `https://notepad-plus-plus.org`  
+3. Klicken Sie auf **Download**.  
+4. Laden Sie den **Windows‑Installer** (Dateiname ähnlich `npp.x.y.Installer.exe`) in den Ordner **Downloads** herunter.
+
+
+
+### Notepad++ in Bottles installieren
+
+1. Wechseln Sie zu **Bottles** und öffnen Sie die Bottle **„NotepadPlusPlus“**.  
+2. Klicken Sie auf **„Run executable“**.  
+3. Navigieren Sie im Dateidialog zum Ordner **Downloads**.  
+4. Wählen Sie die Datei `npp.x.y.Installer.exe` aus und klicken Sie auf **Öffnen**.  
+5. Im Installationsassistenten:
+   * Sprache auswählen (z. B. Deutsch)  
+   * Lizenzbedingungen akzeptieren  
+   * Standardpfad beibehalten  
+   * Komponenten unverändert lassen  
+6. Zum Schluss auf **Fertigstellen** klicken.
+
+Bottles legt nun in dieser Bottle einen Programmeintrag für Notepad++ an und kann – mit den eingestellten Rechten – auch Verknüpfungen anlegen.
+
+
+
+### Notepad++ starten und testen
+
+1. Öffnen Sie in **Bottles** die Bottle **„NotepadPlusPlus“**.  
+2. Unter **„Programs“** (Programme) finden Sie **„Notepad++“**.  
+3. Klicken Sie auf **Notepad++**, um das Programm zu starten.  
+4. Testen Sie die Funktion:
+   * Neue Datei anlegen  
+   * Text schreiben  
+   * Datei in Ihrem Home‑Ordner speichern  
+
+Wenn die Berechtigungen korrekt gesetzt sind, können Sie in Bottles außerdem eine **Desktop‑Verknüpfung** oder einen **Menüeintrag** erstellen. Hierfür einfach auf ````...```` klicken und 
+
+## 7-Zip
+
+### Zweite Bottle für 7‑Zip anlegen
+
+1. Starten Sie **Bottles**, falls es geschlossen ist.  
+2. Klicken Sie auf **„Create a new bottle“**.  
+3. Geben Sie einen Namen ein, z. B. **„7zip“**.  
+4. Wählen Sie wieder die Umgebung **„Application“**.  
+5. Klicken Sie auf **„Create“** und warten Sie, bis die Bottle eingerichtet ist.
+
+
+
+### 7‑Zip herunterladen
+
+1. Öffnen Sie den **Webbrowser**.  
+2. Rufen Sie die offizielle 7‑Zip‑Seite auf:  
+   * `https://www.7-zip.org`  
+3. Laden Sie die **64‑Bit‑Version für Windows** herunter (Datei ähnlich `7zxx-x64.exe`).  
+4. Speichern Sie die Datei im Ordner **Downloads**.
+
+---
+
+### 7‑Zip in Bottles installieren
+
+1. Öffnen Sie in **Bottles** die Bottle **„7zip“**.  
+2. Klicken Sie auf **„Run executable“**.  
+3. Wählen Sie im Ordner **Downloads** die Datei `7zxx-x64.exe` aus.  
+4. Bestätigen Sie mit **Öffnen**.  
+5. Im Installationsfenster von 7‑Zip:
+   * Installationspfad unverändert lassen (`C:\Program Files\7-Zip`)  
+   * Auf **Install** klicken  
+   * Nach Abschluss auf **Close** klicken
+
+Auch hier kann Bottles mit den zuvor gesetzten Berechtigungen Verknüpfungen zu 7‑Zip anlegen.
+
+
+
+### 7‑Zip starten
+
+1. Öffnen Sie in **Bottles** die Bottle **„7zip“**.  
+2. Unter **„Programs“** finden Sie **„7zFM“**.  
+3. Klicken Sie auf diesen Eintrag, um den 7‑Zip‑Dateimanager zu starten.
+
+
+
+#### Dateien mit 7‑Zip komprimieren
+
+1. Im 7‑Zip‑Fenster wählen Sie oben ein Laufwerk aus, z. B. **„Z:“**.  
+   * „Z:“ ist normalerweise mit Ihrem Linux‑Dateisystem verbunden.  
+2. Navigieren Sie zu Ihrem **Home‑Ordner** und zu einem Testordner (z. B. `Dokumente/Test`).  
+3. Markieren Sie einige Dateien, die Sie komprimieren möchten.  
+4. Klicken Sie oben auf **„Add“** (Hinzufügen).  
+5. Im Dialog:
+   * Archivname eingeben, z. B. `testarchiv.7z`  
+   * Format wählen (z. B. `7z` oder `zip`)  
+   * Kompressionsstufe auswählen (z. B. „Normal“)  
+6. Klicken Sie auf **OK**.  
+7. Das neue Archiv erscheint im gleichen Ordner.
+
+
+
+#### Archive mit 7‑Zip entpacken
+
+1. Suchen Sie im 7‑Zip‑Fenster ein vorhandenes Archiv (`.zip`, `.7z` o. Ä.).  
+2. Markieren Sie das Archiv mit einem Linksklick.  
+3. Klicken Sie oben auf **„Extract“** (Entpacken).  
+4. Wählen Sie im Dialog den Zielordner oder akzeptieren Sie den vorgeschlagenen Ordner.  
+5. Klicken Sie auf **OK**.  
+6. Die entpackten Dateien erscheinen anschließend im gewählten Ordner.
+
+
+
+## Häufige Probleme und einfache Lösungen
+
+### Programm startet nicht
+
+* Schließen Sie die Bottle und öffnen Sie sie erneut.  
+* Starten Sie Bottles bei Bedarf vollständig neu und versuchen Sie es noch einmal.  
+
+### Desktop‑Verknüpfung fehlt
+
+* Desktop-Verknüpfungen sind erst mal nur im Startmenü
+* Prüfen Sie in **Flatseal**, ob Bottles Zugriff auf  
+  * `~/Desktop`  
+  * `~/.local/share/applications`  
+  hat.  
+* Falls Änderungen vorgenommen wurden, muss bottles neu gestartet werden. Idealerweise reboot.
+
+### Dateien im Linux‑System nicht sichtbar
+
+* Stellen Sie im 7‑Zip‑Fenster sicher, dass Sie das Laufwerk **„Z:“** gewählt haben.  
+* Navigieren Sie von dort in Ihr Home‑Verzeichnis.

mkdocs/docs/bonus/automatisierung-mit-ansible.md

@@ -0,0 +1,332 @@
+# Ansible-Basics-Handbuch
+
+## 1. Einführung in Ansible
+
+### Was ist Ansible?
+Ansible ist ein **Open-Source-Tool zur Automatisierung von IT-Infrastrukturen**. Es ermöglicht die **zentrale Verwaltung, Konfiguration und Bereitstellung** von Servern, Netzwerkgeräten und Anwendungen. Ansible ist besonders nützlich, weil es:
+
+- **Zeit spart**: Automatisiert Routineaufgaben wie Software-Installationen, Updates oder Benutzerverwaltung.
+- **Fehler reduziert**: Durch die Verwendung von **Playbooks** (Skripte in YAML) werden Konfigurationen **wiederholbar und konsistent** umgesetzt.
+- **Einfach zu erlernen**: Nutzt **YAML**, eine leicht lesbare Sprache, und erfordert keine Programmierkenntnisse.
+- **Agentenlos arbeitet**: Benötigt auf den verwalteten Systemen **keine zusätzliche Software** – nur **SSH** ist erforderlich.
+- **Flexibel einsetzbar**: Unterstützt eine Vielzahl von Systemen, darunter **Ubuntu-Server, Docker-Container und Netzwerkgeräte**.
+
+### Typische Anwendungsfälle
+- **Server-Setup**: Automatisierte Installation und Konfiguration von Servern (z. B. für Webserver oder Datenbanken).
+- **Benutzerverwaltung**: Erstellen und Verwalten von Benutzern und Gruppen.
+- **Sicherheitsupdates**: Regelmäßige, automatische Updates für alle Systeme.
+- **Software-Bereitstellung**: Installation und Konfiguration von Programmen wie **Nginx, Samba oder Docker**.
+- **Backup-Strategien**: Automatisierte Sicherung von Daten.
+
+
+### Wie funktioniert Ansible?
+Ansible arbeitet nach dem **Push-Prinzip**:
+
+1. **Control Node**: Der Rechner, von dem aus Ansible gesteuert wird. (Im Kurs das Linux Mint)
+2. **Managed Nodes**: Die Systeme, die von Ansible verwaltet werden. (Im Kurs der Ubuntu-Server)
+3. **Inventar**: Eine Liste der verwalteten Systeme (IP-Adressen oder Hostnamen).
+4. **Playbooks**: Skripte, die definieren, welche Aufgaben auf den verwalteten Systemen ausgeführt werden sollen.
+
+**Beispiel:**
+Sie möchten auf mehreren Servern **Nginx installieren** und eine **Standard-Webseite** bereitstellen. Statt auf jedem Server manuell Befehle auszuführen, schreiben Sie ein **Ansible-Playbook**, das diese Aufgabe **automatisiert und zentral** erledigt.
+
+---
+
+### Voraussetzungen
+- **Ubuntu Server** (als Managed Node).
+- **SSH-Zugriff** auf die Server (mit Schlüsselpaar).
+- **Ansible** auf dem Control Node (Linux Mint) installiert.
+
+---
+
+## 2. Vorbereitung: SSH-Key-Paar für Ansible erstellen
+
+### Schritt 1: Schlüsselpaar auf dem Ansible-Control-Node erstellen
+````bash
+ssh-keygen -t ed25519 -C "ansible@control-node"
+````
+* Speicherort: /home/benutzer/.ssh/id_ed25519 (Standard)
+* Passphrase: Optional, aber für zusätzliche Sicherheit empfohlen.
+
+### Schritt 2: Öffentlichen Schlüssel auf die Managed Nodes übertragen
+Kopieren Sie den öffentlichen Schlüssel mit folgendem Befehl auf Ihre Server:
+````bash
+ssh-copy-id -i ~/.ssh/id_ed25519.pub benutzer@server-ip
+````
+Beispiel:
+````bash
+ssh-copy-id -i ~/.ssh/id_ed25519.pub meisterkurs@192.168.100.250
+````
+Test der Verbindung:
+````bash
+ssh Meisterkurs@192.168.100.250
+````
+Die Anmeldung sollte jetzt **ohne Passwortabfrage** möglich sein.
+
+## 3. Ansible installieren und konfigurieren
+
+### Ansible auf dem Control Node installieren
+Installieren Sie Ansible mit den folgenden Befehlen:
+````bash
+sudo apt update
+sudo apt install ansible -y
+````
+### Inventar-Datei erstellen
+Legen Sie eine Inventar-Datei an, z. B. ````/etc/ansible/hosts````, und tragen Sie Ihre Server ein:
+````yaml
+ubuntu_servers:
+  hosts:
+    sv1:
+      ansible_host: 192.168.100.250
+      ansible_user: meisterkurs
+      ansible_become: true
+      ansible_become_method: sudo
+      ansible_become_password: passw0rd#
+````
+### Verbindung testen
+
+````bash
+ansible -m ping all
+````
+
+> Erwartete Ausgabe:
+````json
+"sv1": {
+  "ping": "pong"
+}
+````
+
+## 4. System-Updates mit Ansible durchführen
+### Playbook: 01-playbook-update_system.yml 
+Erstellen Sie eine Datei namens 01-playbook-update_system.yml mit folgendem Inhalt:
+````yaml
+---
+- name: Ubuntu Updates
+  hosts: ubuntu_servers # Zielgruppe: Alle Ubuntu-Server im Inventar
+  become: yes # Root-Rechte für Paketverwaltung
+  tasks:
+    - name: System-Paketlisten aktualisieren
+      apt:
+        update_cache: yes
+      # Aktualisiert die Paketlisten, um die neuesten Versionen zu erhalten
+
+    - name: Alle Pakete auf den neuesten Stand bringen
+      apt:
+        upgrade: dist # Führt ein Distribution-Upgrade durch
+        autoremove: yes # Entfernt nicht mehr benötigte Pakete
+      # Installiert alle verfügbaren Updates und bereinigt das System
+
+    - name: Überprüfen, ob ein Neustart erforderlich ist
+      stat:
+        path: /var/run/reboot-required
+      register: reboot_required
+      # Prüft, ob ein Neustart nach den Updates erforderlich ist
+    
+    - name: Hinweis auf Neustart ausgeben (falls erforderlich)
+      debug:
+        msg: "Ein Neustart des Servers {{ inventory_hostname }} ist erforderlich!"
+      when: reboot_required.stat.exists
+      # Zeigt eine Warnung an, wenn ein Neustart erforderlich ist
+  
+````
+
+Führen Sie das Playbook aus:
+````bash
+ansible-playbook 01-playbook-update_system.yml
+````
+
+## 5. Programm installieren und konfigurieren (Beispiel: Nginx)
+
+### Playbook: 02-playbook-install-nginx.yaml
+
+Erstellen Sie Datei 01-playbook-install.nginx.yaml
+
+````yaml
+---
+- name: Installiere nginx auf einstellbarem Port
+  hosts: ubuntu_servers
+  become: yes
+  vars:
+    nginx_port: 5000 # Port, auf dem Nginx laufen soll
+    example_page_content: |
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Nginx auf Port 5000</title>
+          <style>
+            body { font-family: Arial, sans-serif; text-align: center; margin-top: 50px; }
+            h1 { color: #0078d7; }
+          </style>
+        </head>
+        <body>
+          <h1>Willkommen auf der Nginx-Beispielseite!</h1>
+          <p>Diese Seite wird auf <strong>Port {{ nginx_port }}</strong> bereitgestellt.</p>
+          <p>Ansible-Playbook erfolgreich ausgeführt!</p>
+        </body>
+      </html>
+
+  tasks:
+    - name: Nginx installieren
+      apt:
+        name: nginx
+        state: present
+    # Installiert Nginx, falls nicht bereits vorhanden
+
+    - name: Nginx-Konfiguration für Port 5000 anpassen
+      template:
+        src: nginx.conf.j2 # Template-Datei für die Nginx-Konfiguration
+        dest: /etc/nginx/sites-available/default
+      notify: Nginx neu starten
+    # Ersetzt die Standardkonfiguration von Nginx durch unsere angepasste Version
+
+    - name: Beispiel-HTML-Seite bereitstellen
+      copy:
+        dest: /var/www/nginx/index.html
+        content: "{{ example_page_content }}"
+      notify: Nginx neu starten
+    # Kopiert die Beispiel-HTML-Seite in das Webverzeichnis von Nginx
+
+    - name: Nginx-Dienst starten und aktivieren
+      service:
+        name: nginx
+        state: started
+        enabled: yes
+    # Startet Nginx und aktiviert den Autostart beim Systemstart
+
+    - name: Firewall für Port 5000 öffnen (falls UFW aktiv)
+      ufw:
+        rule: allow
+        port: "{{ nginx_port }}"
+        proto: tcp
+      when: "'ufw' in ansible_facts.packages"
+    # Öffnet den Port 5000 in der Firewall, falls UFW installiert ist
+
+    - name: Überprüfen, ob Nginx auf Port 5000 erreichbar ist
+      uri:
+        url: "http://localhost:{{ nginx_port }}"
+        return_content: yes
+      register: nginx_status
+      until: nginx_status.status == 200
+      retries: 5
+      delay: 10
+    # Prüft, ob Nginx auf dem konfigurierten Port erreichbar ist
+    # - retries: 5: Wiederholt die Prüfung 5 Mal, falls der Port noch nicht erreichbar ist
+    # - delay: 10: Wartezeit von 10 Sekunden zwischen den Versuchen
+
+    - name: Statusmeldung ausgeben
+      debug:
+        msg: "Nginx ist erfolgreich auf Port {{ nginx_port }} gestartet und erreichbar unter http://{{ ansible_host }}:{{ nginx_port }}"
+      # Zeigt eine Erfolgsmeldung mit der URL zur Beispielseite an
+
+
+  handlers:
+    - name: Nginx neu starten
+      service:
+        name: nginx
+        state: restarted
+    # Startet Nginx neu, um Änderungen an der Konfiguration zu übernehmen
+````
+#### Was sind Handler?
+> Handler in Ansible sind spezielle Aufgaben, die nur dann ausgeführt werden, wenn sie von einer anderen Aufgabe explizit benachrichtigt (notify) werden. Sie werden typischerweise für Dienst-Neustarts oder Konfigurationsänderungen verwendet, die nur dann notwendig sind, wenn sich etwas geändert hat.
+
+
+### Nginx-Konfigurationsdatei (nginx.conf.j2)
+
+Im Script wird eine Kopierquelle für die konfiguration des Servers angegeben. Diese darf direkt daneben angelegt werden: ````nginx.conf.j2````
+
+````nginx
+server {
+    listen {{ nginx_port }} default_server;
+    listen [::]:{{ nginx_port }} default_server;
+
+    root /var/www/nginx;
+    index index.html;
+
+    server_name _;
+
+    location / {
+        try_files $uri $uri/ =404;
+    }
+}
+````
+
+
+Ausführung des Playbooks:
+````bash
+ansible-playbook 01-playbook-install.nginx.yaml
+````
+
+### Nach der Installation: 
+Öffnen Sie einen Browser und verbinden Sie sich mit port 5000
+> Sie sollten die Beispielseite sehen.
+Port-Überprüfung:
+Das Playbook prüft automatisch, ob Nginx auf Port 5000 erreichbar ist, und gibt eine Erfolgsmeldung aus.
+
+## 6. Playbook: Benutzer und Gruppen verwalten
+````03-playbook-manage-users.yml````
+````yaml
+---
+- name: Benutzer und Gruppen auf den Managed Nodes verwalten
+  hosts: sv1
+  become: yes
+
+  vars:
+    users:
+      - name: dbecker
+        groups: ["Geschäftsleitung"]
+      - name: spoller
+        groups: ["Projektleitung"]
+    groups:
+      - Geschäftsleitung
+      - Projektleitung
+
+  tasks:
+    - name: Gruppen erstellen
+      group:
+        name: "{{ item }}"
+        state: present
+      loop: "{{ groups }}"
+      # Erstellt die in der Variable "groups" definierten Gruppen
+
+    - name: Benutzer erstellen
+      user:
+        name: "{{ item.name }}"
+        groups: "{{ item.groups | join(',') }}"
+        shell: /bin/bash
+      loop: "{{ users }}"
+      # Erstellt die in der Variable "users" definierten Benutzer
+      # - groups: Fügt die Benutzer den angegebenen Gruppen hinzu
+      # - shell: Setzt die Standard-Shell auf Bash
+````
+
+## 7. Playbook: Automatische Updates einrichten
+````04-playbook-auto-update.yml````
+
+````yaml
+---
+- name: Automatische Updates auf den Managed Nodes einrichten
+  hosts: ubuntu_servers
+  become: yes
+
+  tasks:
+    - name: unattended-upgrades installieren
+      apt:
+        name: unattended-upgrades
+        state: present
+      # Installiert das Paket für automatische Updates
+
+    - name: Automatische Updates aktivieren
+      copy:
+        dest: /etc/apt/apt.conf.d/20auto-upgrades
+        content: |
+          APT::Periodic::Update-Package-Lists "1";
+          APT::Periodic::Unattended-Upgrade "1";
+      # Konfiguriert die automatische Aktualisierung der Paketlisten und Installation von Updates
+````
+## 8. Zusammenfassung
+Was wurde erreicht?
+
+* SSH-Key-Authentifizierung für sichere Ansible-Kommunikation.
+* Automatisierte System-Updates und Programm-Installation.
+* Benutzer- und Gruppenverwaltung.
+* Automatische Sicherheitsupdates.

mkdocs/docs/bonus/docker-grundlagen.md

@@ -0,0 +1,256 @@
+# Docker-Grundlagen
+## Virtuelle Maschinen (VMs) vs. Container
+
+|Kriterium          |Virtuelle Maschine (VM)                       |Container                           |
+|-------------------|----------------------------------------------|------------------------------------|
+|Isolation          |Vollständige OS-Isolation (Hardware-Ebene)    |Prozess-Isolation (OS-Ebene)        |
+|Ressourcenverbrauch|Hoch (eigenes OS pro VM)                      |Gering (teilt Host-OS-Kernel)       |
+|Startzeit          |Minuten                                       |Sekunden                            |
+|Portabilität       |Schwerer (große Images)                       |Leicht (kleine Images)              |
+|Anwendungsfall     |Vollständige Systeme (z. B. Windows auf Linux)|Mikroservices, Web-Apps, Datenbanken|
+
+**Fazit**: Container sind ideal für schnelle, ressourcenschonende Bereitstellung von Anwendungen.
+## Docker installieren
+
+[Immer aktuelles Setup anschauen](https://docs.docker.com/engine/install/ubuntu/)
+
+````bash
+# Alte Docker-Versionen entfernen
+sudo apt removes docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc
+# Abhängigkeiten installieren
+sudo apt update
+sudo apt install -y ca-certificates curl gnupg
+
+# Docker-Repository hinzufügen
+sudo install -m 0755 -d /etc/apt/keyrings
+sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
+sudo chmod a+r /etc/apt/keyrings/docker.asc
+sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
+Types: deb
+URIs: https://download.docker.com/linux/ubuntu
+Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
+Components: stable
+Signed-By: /etc/apt/keyrings/docker.asc
+EOF
+
+# Docker installieren
+sudo apt update
+sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+
+# Docker-Dienst starten und aktivieren
+sudo systemctl enable docker
+sudo systemctl start docker
+
+# Benutzer zur Docker-Gruppe hinzufügen (für Passwortlosigkeit)
+sudo usermod -aG docker $USER
+newgrp docker  # Aktuelle Shell aktualisieren
+````
+
+## Erste Schritte: "Hello World" mit Docker
+Fertigen Container ausprobieren:
+````bash
+docker run hello-world
+````
+> Ausgabe:
+````
+Hello from Docker!
+This message shows that your installation appears to be working correctly.
+...
+````
+Tatsächlich erklärt der Container selbst was er getan hat.
+* ````docker run````: Führt einen Container aus.
+* ````hello-world````: Offizielles Test-Image von Docker Hub.
+
+## Eigenes Dockerfile für einen Webserver (Nginx)
+
+### Dockerfile
+Erstellen Sie eine Datei namens ````Dockerfile```` mit folgendem Inhalt:
+````dockerfile
+# Basis-Image: Offizielles Nginx-Image
+FROM nginx:latest
+
+# Standard-HTML-Seite ersetzen
+COPY index.html /usr/share/nginx/html
+
+# Port 80 freigeben
+EXPOSE 80
+````
+### HTML-Datei bereitstellen
+Erstellen Sie eine Datei ````index.html```` im selben Verzeichnis:
+````html
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Meisterkurs IT</title>
+</head>
+<body>
+    <h1>Willkommen zum Docker-Webserver!</h1>
+    <p>Dieser Container läuft auf Port 80.</p>
+</body>
+</html>
+````
+###
+Image bauen und Container starten
+````bash
+# Image aus dem Dockerfile bauen
+docker build -t mein-nginx .
+
+# Container im Hintergrund starten und Port 8080 des Hosts auf Port 80 des Containers mappen
+docker run -d -p 8080:80 --name mein-webserver mein-nginx
+````
+
+### Testen
+
+Öffnen Sie einen Browser und rufen Sie ````http://<Ihre-Server-IP>:8080```` auf.
+Sie sollten die HTML-Seite sehen.
+
+## Docker Compose für BackupPC
+
+Warum Docker Compose?
+
+* Vereinfacht das Management mehrerer Container
+* Definiert alle Dienste in einer YAML-Datei.
+### Beispiel: backuppc/docker-compose.yml für BackupPC 
+compose-Dateien immer in einem Ordner!
+
+````yaml
+services:
+  backuppc:
+    image: adferrand/backuppc
+    container_name: backuppc
+    restart: unless-stopped
+    ports:
+      - "8081:80"  # Webinterface auf Port 8081
+    volumes:
+      - /etc/localtime:/etc/localtime:ro # Uhrzeit vom Host
+      - /etc/timezone:/etc/timezone:ro # Zeitzone vom Host
+      - ./etc:/etc/backuppc # Einstellungen
+      - ./home:/home/backuppc # "Userdata" von backuppc. z.B. ssh-keys
+      - ./backups:/data/backuppc # Das Backupverzeichnis
+    environment:
+      - BACKUPC_WEB_USER=meisterkurs
+      - BACKUPC_WEB_PASSWORD=passw0rd#
+      - BACKUPPC_UUID=100
+      - BACKUPPC_GUID=101
+
+````
+### Projekt starten
+````bash
+# Docker Compose-Projekt starten
+docker compose up -d
+
+# Status prüfen
+docker compose ps
+
+# Log des Container anzeigen
+docker compose logs
+````
+
+### Zugriff auf BackupPC
+
+Öffnen Sie ````http://<Ihre-Server-IP>:8081```` im Browser.
+Anmeldung mit ````meisterkurs```` und ````passw0rd````.
+
+## Docker-Grundlagenbefehle
+
+### Container-Verwaltung
+|Befehl                          |Beschreibung                             |
+|--------------------------------|-----------------------------------------|
+|docker ps                       |Liste aller laufenden Container anzeigen.|
+|docker ps -a                    |Liste aller Container (auch gestoppte) anzeigen.|
+|docker start <Container>        |Einen gestoppten Container starten.      |
+|docker stop <Container>         |Einen laufenden Container stoppen.       |
+|docker restart <Container>      |Einen Container neu starten.             |
+|docker rm <Container>           |Einen gestoppten Container entfernen.    |
+|docker rm -f <Container>        |Einen Container erzwingen zu entfernen (auch laufende).|
+|docker logs <Container>         |Logs eines Containers anzeigen.          |
+|docker logs -f <Container>      |Logs eines Containers live verfolgen.    |
+|docker exec -it <Container> bash|Eine interaktive Shell im laufenden Container öffnen.|
+|docker inspect <Container>      |Detaillierte Informationen zu einem Container anzeigen (z. B. IP, Volumes).|
+
+### Image-Verwaltung
+
+|Befehl                  |Beschreibung                                                  |
+|------------------------|--------------------------------------------------------------|
+|docker images           |Liste aller lokalen Images anzeigen.                          |
+|docker pull <Image>     |Ein Image von Docker Hub herunterladen.                       |
+|docker rmi <Image>      |Ein Image entfernen.                                          |
+|docker rmi -f <Image>   |Ein Image erzwingen zu entfernen.                             |
+|docker build -t <Name> .|Ein Image aus einem Dockerfile im aktuellen Verzeichnis bauen.|
+|docker push <Image>     |Ein Image zu Docker Hub oder einer Registry hochladen.        |
+
+### Docker Compose-Befehle
+
+|Befehl                          |Beschreibung                                                               |
+|--------------------------------|---------------------------------------------------------------------------|
+|docker compose up -d            |Ein Projekt im Hintergrund starten (Detached-Modus).                       |
+|docker compose up --build       |Projekt starten und Images neu bauen (falls Änderungen im Dockerfile).     |
+|docker compose down             |Ein Projekt komplett stoppen und entfernen (Container, Netzwerke, Volumes).|
+|docker compose ps               |Status aller Container im Projekt anzeigen.                                |
+|docker compose logs             |Logs aller Container im Projekt anzeigen.                                  |
+|docker compose logs -f          |Logs aller Container live verfolgen.                                       |
+|docker compose logs <Service>   |Logs eines bestimmten Services anzeigen.                                   |
+|docker compose restart <Service>|Einen bestimmten Service im Projekt neu starten.                           |
+|docker compose build            |Images für alle Services im Projekt neu bauen.                             |
+|docker compose pull             |Alle Images für das Projekt neu herunterladen.                             |
+|docker compose config           |Die Konfiguration des Projekts validieren (z. B. Syntax prüfen).           |
+|docker compose top              |Prozesse in den Containern des Projekts anzeigen.                          |
+
+### Volumes und Netzwerke
+
+|Befehl                           |Beschreibung                                                    |
+|---------------------------------|----------------------------------------------------------------|
+|docker volume ls                 |Liste aller Docker-Volumes anzeigen.                            |
+|docker volume inspect <Volume>   |Details zu einem Volume anzeigen (z. B. Mountpunkt).            |
+|docker volume rm <Volume>        |Ein Volume entfernen.                                           |
+|docker network ls                |Liste aller Docker-Netzwerke anzeigen.                          |
+|docker network inspect <Netzwerk>|Details zu einem Netzwerk anzeigen (z. B. verbundene Container).|
+
+### Praktische Beispiele:
+
+#### BackupPC-Projekt neu starten
+````bash
+# Projekt stoppen und entfernen
+docker compose down
+
+# Projekt mit neuem Passwort starten
+docker compose up -d
+````
+
+#### Logs von BackupPC live verfolgen
+````bash
+docker compose logs -f backuppc
+````
+
+#### Shell im BackupPC-Container öffnen
+````bash
+docker exec -it backuppc bash
+````
+
+#### BackupPC-Image neu bauen (nach Änderungen am Dockerfile)
+````bash
+docker compose build backuppc
+docker compose up -d
+````
+#### Alle Images und Container bereinigen
+````bash
+# Alle gestoppten Container entfernen
+docker container prune
+
+# Alle nicht verwendeten Images entfernen
+docker image prune -a
+
+# Alle nicht verwendeten Volumes entfernen
+docker volume prune
+````
+
+
+
+
+
+
+
+
+
+
+

mkdocs/docs/bonus/linux-als-ad-client.md

@@ -104,7 +104,3 @@ Eintragen (Beispiel):
 **Hinweis:**\
 Bei Fehlern prüfen Sie die Logdateien (/var/log/sssd/, /var/log/auth.log,
 /var/log/syslog) und die Netzwerkkonfiguration.
-
-
-
-[PDF herunterladen](linux-als-ad-client.pdf){ .md-button }

mkdocs/docs/bonus/linux-als-ad-server.md

@@ -102,18 +102,19 @@ sudo nano /etc/netplan/01-tnXX-netz.yaml
 # This file describes the network interfaces available on your system
 # For more information, see netplan(5).
 network:
+  version: 2
   ethernets:
     enp0s3:
-      addresses: [192.168.2XX.250/24]
-        routes:
-          - to: 0.0.0.0/0
-            via: 192.168.2XX.1
-        dhcp4: no
-        nameservers:
-          addresses: \[192.168.2.XX.250,1.1.1.1\]
-          search: \[tnXX.ito\]
-        optional: true
-  version: 2
+      dhcp4: false
+      addresses:
+        - 192.168.2XX.250/24
+      routes:
+        - to: default
+          via: 192.168.2XX.1
+      nameservers:
+        addresses: [192.168.2XX.250, 1.1.1.1]
+        search: [tnXX.ito]
+      optional: true
 ```
 Die Anpassung des Hostnamen wurde auch kompatibel mit der Cloud-Config
 gemacht daher neuer Vorgehensweise:
@@ -189,7 +190,7 @@ sudo systemctl restart chrony
 ```
 Testen ob der Dienst aktiv ist:
 ```bash
-ss -tulpen:
+ss -tulpen
 ```
 > udp 0 0 0.0.0.0:123 0.0.0.0:\* 0 22432 1180/chronyd
 
@@ -221,7 +222,7 @@ Fertig.
 ```bash
 sudo systemctl enable --now samba-ad-dc
 ```
-Samba nur auf den angegeben Netzwerkkarten starten, auf diese Weise gibt es keine Konflikte mit dem internen Nameserver edit in /etc/samba/smb.conf unter global 
+Samba nur auf den angegeben Netzwerkkarten starten, auf diese Weise gibt es keine Konflikte mit dem internen Nameserver edit in ````/etc/samba/smb.conf```` unter global 
 ```bash
 bind interfaces only = yes
 interfaces = lo enp0s3
@@ -260,8 +261,7 @@ sudo netplan apply
 Internen Resolver übernehmen
 ```bash
 sudo rm /etc/resolv.conf
-echo -e \"nameserver 127.0.0.1\\nsearch TNXX.ITO\" \| sudo tee
-/etc/resolv.conf
+echo -e \"nameserver 127.0.0.1\\nsearch TNXX.ITO\" \| sudo tee /etc/resolv.conf
 ```
 
 ## Überprüfen der DNS-Konfiguration
@@ -503,6 +503,3 @@ nt acl support = yes
 
 Jetzt kann die Freigabe vom Admin mit den Jeweiligen User-Gruppenrechten
 gesetzt werden. Hierfür in einer Windows-Umgebung die Eigenschaften des Netzlaufwerkes anpassen.
-
-
-[PDF herunterladen](ubuntu-ad-dc.pdf){ .md-button }

mkdocs/mkdocs.yml

@@ -1,21 +1,26 @@
-site_name: Linux Grundlagen MK-IT
+site_name: Linux Grundlagen Meisterkurs IT
+site_author: Florian Hensel
+ 
 nav:
   - Home: index.md
   - Grundlagen:
-    - Einstieg in Linux-Desktop: basics/Einstieg in Linux-Desktop.md
-    - Grundlagen der Konsole: basics/Grundlagen der Konsole.md
-    - Windows-Freigabe mit Samba: basics/Windows-Freigabe mit Samba.md
-    - Automatisierung mit cron und systemd: basics/Automatisierung mit cron und systemd.md
+    - Einstieg in Linux-Desktop: basics/Einstieg_in_Linux-Desktop.md
+    - Remotezugriff einrichten: basics/Remotezugriff_einrichten.md
+    - Kleines Linux-Projekt: basics/Mein_erstes_kleines_Linux-Projekt.md
+    - Windows-Programme unter Linux: basics/Windows_Programme_unter_Linux.md
+    - Grundlagen der Konsole: basics/Grundlagen_der_Konsole.md
+    - Automatisierung mit cron und systemd: basics/Automatisierung_mit_cron_und_systemd.md
+    - Windows-Freigaben für Linux-Einsteiger: basics/Windows_Freigaben_fuer_Linux-Einsteiger.md
+    - Praxisprojekt Medien-NAS für KODI: basics/Praxisprojekt_Medien-NAS_fuer_KODI.md
   - Linux im Unternehmen:
-    - Ubuntu Servr als Active Directory Domain Controller: Linux_Unternehmen/ubuntu-ad-dc.md
-    - Linux als Client in Active Directory: Linux_Unternehmen/linux-als-ad-client.md
+    - Ubuntu Server installieren und konfigurieren: Linux_Unternehmen/Server_Installation.md
+    - Praxisprojekt Freigaben im Unternehmen: Linux_Unternehmen/Praxisprojekt_Freigaben_im_Unternehmen.md
     - Nextcloud mit LDAP-Anbindung: Linux_Unternehmen/nextcloud-ldap.md
   - Bonuskapitel:
-    - Docker-Grundlagen: bonus/docker-grundlagen.md
-    - Docker-Projekte:
-      - Pi-Hole: bonus/docker-pi-hole.md
-      - BackupPC: bonus/docker-backuppc.md
-
+    - Linux als Active Directory Server: bonus/linux-als-ad-server.md
+    - Linux als Client in Active Directory: bonus/linux-als-ad-client.md
+    - Automatisierung mit Ansible: bonus/automatisierung-mit-ansible.md
+    - Docker Grundlagen: bonus/docker-grundlagen.md
 # Theme
 theme:
   logo: assets/Logo.png
@@ -49,4 +54,26 @@ markdown_extensions:
 #      permalink: true
   - pymdownx.highlight
   - pymdownx.superfences
-
+  - admonition
+  - pymdownx.details
+  - pymdownx.superfences
+  - pymdownx.critic
+  - pymdownx.caret
+  - pymdownx.keys
+  - pymdownx.mark
+  - pymdownx.tilde
+plugins:
+  - offline
+  - search:
+  - optimize:
+      concurrency: 2
+  - to-pdf:
+      enabled: true
+      output_path: pdf/linux-grundlagen-mk-it.pdf
+      author: "Florian Hensel"
+      toc_level: 2
+      toc_title: "Inhaltsverzeichnis"
+      ordered_chapter_level: 2
+      cover: true
+      cover_subtitle: "Umfangreiches Handbuch für Einsteiger und Fortgeschrittene"
+      download_link: header

process_comments.lua

@@ -1,6 +0,0 @@
-function RawBlock(el)
-  if el.text:match("%% ONLY FOR PANDOC:") then
-    local latex_cmd = el.text:match("\\([a-z]+{})")
-    return pandoc.RawBlock('latex', latex_cmd)
-  end
-end

rebuild-all.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+
+MKDOCS_DIR="mkdocs/docs"
+
+# Funktion für die Verarbeitung (DRY-Prinzip)
+process_file() {
+  local md_file="$1"
+  echo "Verarbeite: $md_file"
+
+  local base_name=$(basename "$md_file" .md | tr ' ' '_')
+  local dir_name=$(dirname "$md_file")
+  local pdf_path="${dir_name}/${base_name}.pdf"
+  local pdf_link="\n\n[PDF herunterladen](${base_name}.pdf){ .md-button }"
+
+  # PDF neu erzeugen
+  rm -f "$pdf_path"
+
+  # Temp MD nur für MkDocs-Syntax bereinigen (LaTeX behalten)
+  local temp_md="${dir_name}/temp_${base_name}.md"
+  sed 's/{[^}]*}//g; s/^[ \t]*{[^}]*}$//gm' "$md_file" > "$temp_md"
+  
+  local md_dir=$(dirname "$md_file")
+
+  docker run --rm \
+    --volume "$(pwd)":/data \
+    --user $(id -u):$(id -g) \
+    --workdir "/data/$md_dir" \
+    pandoc/extra \
+    "./temp_${base_name}.md" \
+    -o "./${base_name}.pdf" \
+    --template /data/eisvogel.latex \
+    --syntax-highlighting=idiomatic
+
+  # Temp Datei löschen
+  rm -f "$temp_md"
+  
+  echo "  → PDF erstellt: $pdf_path"
+
+  # PDF-Link nur einmal hinzufügen (ändert Markdown!)
+  if ! tail -n 10 "$md_file" | grep -q "PDF herunterladen"; then
+    echo -e "$pdf_link" >> "$md_file"
+    echo "  → PDF-Link hinzugefügt"
+  else
+    echo "  → PDF-Link bereits vorhanden"
+  fi
+  echo ""
+}
+
+# Wenn keine Parameter → alle Dateien verarbeiten
+if [ $# -eq 0 ]; then
+  echo "Keine Dateien angegeben → Verarbeite ALLE Markdown-Dateien"
+  find "$MKDOCS_DIR" -name "*.md" | while read -r md_file; do
+    # Überspringe index.md
+    if [[ "$(basename "$md_file")" == "index.md" ]]; then
+      echo "Überspringe: $md_file"
+      continue
+    fi
+    process_file "$md_file"
+  done
+else
+  # Einzelne Dateien verarbeiten
+  for param in "$@"; do
+    md_file="$MKDOCS_DIR/$param"
+    if [[ ! -f "$md_file" ]]; then
+      echo "Fehler: $md_file nicht gefunden!"
+      continue
+    fi
+    process_file "$md_file"
+  done
+fi
+
+# **IMMER MkDocs neu bauen** (Markdown + PDF-Links ändern sich)
+echo "MkDocs wird neu gebaut (wegen Markdown-Änderungen)..."
+docker compose -f ./docker-compose.yml run --rm mkdocs build
+docker compose -f ./docker-compose.yml restart mkdocs
+echo "Fertig: mkdocs neu gebaut."