Anleitungen

Anleitungen für Fachinformatiker

Hier findest du detaillierte Schritt-für-Schritt-Anleitungen zu typischen Aufgaben und Problemstellungen im Bereich der Systemintegration. Perfekt für die Ausbildung und den Arbeitsalltag.

Apache Webserver unter Debian einrichten

Eine Anleitung zur Installation und Grundkonfiguration eines Apache Webservers auf einem Debian-System. Dies ist ein grundlegender Schritt für viele Webprojekte.

Voraussetzungen:

  • Ein laufendes Debian-System (z.B. Debian 11/12)
  • Internetzugang
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. System aktualisieren:
    sudo apt update && sudo apt upgrade -y
    Stellt sicher, dass alle Pakete auf dem neuesten Stand sind.
  2. Apache installieren:
    sudo apt install apache2 -y
    Hiermit wird der Apache Webserver installiert.
  3. Firewall konfigurieren (UFW):
    sudo ufw app list

    Zeigt verfügbare Anwendungsprofile an.

    sudo ufw allow 'Apache'

    Erlaubt HTTP-Verkehr (Port 80).

    sudo ufw allow 'Apache Full'

    Erlaubt HTTP (Port 80) und HTTPS (Port 443).

    sudo ufw enable

    Aktiviert die Firewall.

    sudo ufw status

    Überprüft den Status der Firewall.

  4. Apache-Dienst überprüfen:
    sudo systemctl status apache2

    Der Status sollte "active (running)" sein. Falls nicht, kannst du ihn starten mit:

    sudo systemctl start apache2

    Und für den Autostart beim Systemstart aktivieren:

    sudo systemctl enable apache2
  5. Standard-Webseite testen:

    Öffne deinen Webbrowser und gib die IP-Adresse deines Servers ein (z.B. `http://DEINE_SERVER_IP`). Du solltest die Apache2 Debian Default Page sehen.

  6. Virtuelle Hosts einrichten (optional, aber empfohlen):

    Für mehrere Webseiten auf einem Server. Erstelle eine Konfigurationsdatei für deine Seite (z.B. `/etc/apache2/sites-available/deine_seite.conf`):

    sudo nano /etc/apache2/sites-available/deine_seite.conf

    Beispielinhalt:

    <VirtualHost *:80>
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/deine_seite
        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
    </VirtualHost>

    Erstelle das Document Root Verzeichnis:

    sudo mkdir /var/www/deine_seite

    Aktiviere den virtuellen Host und deaktiviere den Standard-Host:

    sudo a2ensite deine_seite.conf
    sudo a2dissite 000-default.conf

    Apache neu laden:

    sudo systemctl reload apache2

Dein Apache Webserver ist nun eingerichtet und bereit für deine Webprojekte!

SSH-Zugriff absichern

Tipps und Schritte zur Erhöhung der Sicherheit deines SSH-Zugriffs auf Linux-Servern. Ein gesicherter SSH-Zugang ist entscheidend für die Server-Sicherheit, um unautorisierten Zugriff zu verhindern.

Voraussetzungen:

  • Ein Linux-Server mit installiertem OpenSSH-Server
  • Benutzer mit sudo-Rechten
  • Grundkenntnisse der Kommandozeile

Schritt-für-Schritt-Anleitung:

  1. Standard-SSH-Port ändern:

    Der Standard-SSH-Port 22 ist oft Ziel von Angriffen. Ändere ihn in einen ungenutzten Port (z.B. 2222 oder einen anderen hohen Port über 1024).

    sudo nano /etc/ssh/sshd_config

    Suche die Zeile `#Port 22` und ändere sie in:

    Port 2222

    (oder einen Port deiner Wahl). Speichere und schließe die Datei.

  2. Root-Login deaktivieren:

    Der direkte Login als 'root' ist ein Sicherheitsrisiko. Aktiviere stattdessen den Login über einen normalen Benutzer mit sudo-Rechten.

    sudo nano /etc/ssh/sshd_config

    Suche die Zeile `#PermitRootLogin prohibit-password` oder `PermitRootLogin yes` und ändere sie in:

    PermitRootLogin no
  3. Passwort-Authentifizierung auf Schlüssel umstellen (empfohlen):

    Die Authentifizierung mittels SSH-Schlüsseln ist sicherer als Passwörter, da sie wesentlich schwerer zu erraten sind.

    Auf deinem lokalen Rechner:

    ssh-keygen -t rsa -b 4096

    Folge den Anweisungen (speichere die Keys an einem sicheren Ort und vergib eine Passphrase).

    Öffentlichen Schlüssel auf den Server kopieren:

    ssh-copy-id benutzername@dein_server_ip

    Alternativ manuell (falls `ssh-copy-id` nicht verfügbar):

    cat ~/.ssh/id_rsa.pub | ssh benutzername@dein_server_ip "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

    Auf dem Server: SSH-Passwort-Authentifizierung deaktivieren.

    sudo nano /etc/ssh/sshd_config

    Suche die Zeile `#PasswordAuthentication yes` und ändere sie in:

    PasswordAuthentication no
  4. SSH-Dienst neu starten und Firewall anpassen:

    Nach den Änderungen in `sshd_config` musst du den SSH-Dienst neu starten.

    sudo systemctl restart ssh

    Wenn du den Port geändert hast, musst du auch deine Firewall (z.B. UFW) anpassen:

    sudo ufw allow 2222/tcp
    sudo ufw delete allow 22/tcp
    sudo ufw reload

    WICHTIG: Bevor du die bestehende SSH-Sitzung schließt, öffne eine *neue* Sitzung mit den neuen Einstellungen, um sicherzustellen, dass der Zugriff noch funktioniert! Teste den Login mit dem neuen Port und dem SSH-Schlüssel.

  5. Fail2Ban installieren (optional, aber empfohlen):

    Fail2Ban überwacht Log-Dateien und blockiert IP-Adressen, die wiederholt fehlgeschlagene Login-Versuche (z.B. Brute-Force-Angriffe) durchführen.

    sudo apt install fail2ban -y

    Erstelle eine lokale Konfigurationsdatei, um die Standardeinstellungen nicht zu überschreiben:

    sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
    sudo nano /etc/fail2ban/jail.local

    Unter dem `[sshd]`-Abschnitt kannst du den Port anpassen, falls du ihn geändert hast (z.B. `port = 2222`). Überprüfe auch `bantime` und `maxretry`. Aktiviere es, falls es noch nicht der Fall ist: `enabled = true`.

    sudo systemctl enable fail2ban
    sudo systemctl start fail2ban

Dein SSH-Zugriff ist nun deutlich sicherer! Denke daran, deine SSH-Schlüssel sicher zu verwahren und regelmäßig System-Updates durchzuführen.

Benutzerverwaltung unter Windows Server

Anleitung zum Anlegen und Verwalten von Benutzerkonten und Gruppen in einer Windows Server Active Directory Umgebung. Dies ist eine Kernaufgabe für jeden Fachinformatiker für Systemintegration.

Voraussetzungen:

  • Ein Windows Server (z.B. 2019, 2022) mit installierter Active Directory Domain Services (AD DS)-Rolle
  • Admin-Rechte auf dem Domain Controller
  • Grundkenntnisse der Active Directory-Struktur

Schritt-für-Schritt-Anleitung:

  1. Active Directory-Benutzer und -Computer öffnen:

    Dies ist das zentrale Tool für die Benutzer- und Gruppenverwaltung.

    • Öffne den **Server-Manager**.
    • Gehe zu **Tools** und wähle **Active Directory-Benutzer und -Computer**.
    • Alternativ: Drücke `Win + R`, gib `dsa.msc` ein und drücke Enter.
  2. Neue Organisationseinheit (OU) erstellen (empfohlen):

    Zum besseren Strukturieren von Benutzern und Computern solltest du OUs anlegen.

    • Navigiere im linken Bereich zu deiner Domain (z.B. `deinefirma.local`).
    • Rechtsklick auf die Domain oder eine vorhandene OU, wähle **Neu** > **Organisationseinheit**.
    • Gib einen Namen ein (z.B. "Benutzer" oder "Abteilung IT") und klicke **OK**.
  3. Neuen Benutzer anlegen:

    So erstellst du ein neues Benutzerkonto in Active Directory.

    • Navigiere zu der OU, in der der Benutzer angelegt werden soll (z.B. der gerade erstellten "Benutzer"-OU).
    • Rechtsklick auf die OU, wähle **Neu** > **Benutzer**.
    • Fülle die Pflichtfelder aus:
      • **Vorname:** Max
      • **Nachname:** Mustermann
      • **Anmeldename des Benutzers:** `m.mustermann` (dies wird der Benutzername für die Anmeldung)
    • Klicke **Weiter**.
    • Lege ein **Passwort** fest und bestätige es. Wähle die gewünschten Optionen:
      • `Benutzer muss Kennwort bei der nächsten Anmeldung ändern` (Standard und empfohlen)
      • `Kennwort läuft nie ab` (nicht empfohlen für normale Benutzer)
      • `Konto ist deaktiviert` (wenn das Konto noch nicht verwendet werden soll)
    • Klicke **Weiter** und dann **Fertig stellen**.
  4. Benutzereigenschaften bearbeiten:

    Um weitere Details oder Einstellungen für einen Benutzer anzupassen.

    • Rechtsklick auf den Benutzer und wähle **Eigenschaften**.
    • Hier findest du verschiedene Tabs:
      • **Allgemein:** Titel, Abteilung, Telefonnummer etc.
      • **Konto:** Anmeldenamen, Anmeldezeiten, Konto-Optionen.
      • **Mitglied von:** Hier kannst du den Benutzer zu Gruppen hinzufügen (siehe nächster Schritt).
      • **Profil:** Pfad für Benutzerprofile oder Anmeldeskripte.
      • **Organisation:** Firmenname, Manager.
    • Nimm die gewünschten Änderungen vor und klicke **Anwenden** > **OK**.
  5. Neue Gruppe erstellen und Benutzer hinzufügen:

    Gruppen erleichtern die Verwaltung von Berechtigungen.

    • Navigiere zu einer geeigneten OU (z.B. "Groups" oder die Abteilung, für die die Gruppe ist).
    • Rechtsklick auf die OU, wähle **Neu** > **Gruppe**.
    • Gib einen **Gruppennamen** ein (z.B. "IT-Administratoren" oder "Vertriebsmitarbeiter").
    • Wähle den **Gruppenbereich** (meist "Global" für Gruppen innerhalb deiner Domain) und den **Gruppentyp** (meist "Sicherheit" für Berechtigungen). Klicke **OK**.
    • Benutzer zu Gruppe hinzufügen:
      • Rechtsklick auf die neu erstellte Gruppe und wähle **Eigenschaften**.
      • Gehe zum Tab **Mitglieder**.
      • Klicke auf **Hinzufügen...**.
      • Gib den Namen des Benutzers ein (z.B. `m.mustermann`), klicke **Namen überprüfen** und dann **OK**.
      • Klicke **Anwenden** > **OK**.
      • Alternativ: Rechtsklick auf den Benutzer, **Eigenschaften**, Tab **Mitglied von**, **Hinzufügen...** und dort die Gruppe auswählen.
  6. Benutzer oder Gruppe Berechtigungen zuweisen (Beispiel Dateifreigabe):

    Um Zugriff auf Ressourcen zu gewähren.

    • Navigiere im **Datei-Explorer** zu dem Ordner, dessen Berechtigungen du verwalten möchtest.
    • Rechtsklick auf den Ordner, wähle **Eigenschaften**.
    • Gehe zum Tab **Sicherheit** und klicke auf **Bearbeiten...**.
    • Klicke auf **Hinzufügen...**.
    • Gib den Namen der Gruppe oder des Benutzers ein, klicke **Namen überprüfen** und dann **OK**.
    • Wähle die hinzugefügte Gruppe/Benutzer aus und setze die gewünschten **Berechtigungen** (z.B. "Vollzugriff", "Ändern", "Lesen & Ausführen").
    • Klicke **Anwenden** > **OK** in allen Fenstern.

Die Benutzer- und Gruppenverwaltung in Active Directory ist die Basis für eine sichere und effiziente IT-Infrastruktur.

Netzwerkkonfiguration und -troubleshooting unter Linux

Dieses Kapitel behandelt grundlegende Schritte zur Netzwerkkonfiguration und zur Behebung häufiger Netzwerkprobleme auf Linux-Systemen. Ein solides Verständnis dieser Befehle ist unerlässlich für jeden Systemintegrator.

Voraussetzungen:

  • Linux-System (z.B. Debian, Ubuntu, CentOS)
  • Terminalzugriff
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. IP-Adresse und Netzwerkschnittstellen überprüfen:

    Der Befehl ip a (kurz für ip address show) ist der moderne Standard, um Informationen über Netzwerkschnittstellen anzuzeigen.

    ip a

    Wichtige Ausgaben:

    • `lo`: Loopback-Schnittstelle (127.0.0.1)
    • `eth0`, `enp0s3`, `ens33`: Typische Namen für Ethernet-Schnittstellen
    • `wlan0`: WLAN-Schnittstelle
    • `inet`: IPv4-Adresse
    • `inet6`: IPv6-Adresse
    • `link/ether`: MAC-Adresse
  2. Routing-Tabelle anzeigen:

    Die Routing-Tabelle zeigt, wie der Server Netzwerkpakete an ihr Ziel sendet. Der Befehl ip r (kurz für ip route show) zeigt die Routing-Tabelle an.

    ip r

    Wichtige Ausgaben:

    • `default via`: Zeigt das Standard-Gateway (Router) an.
    • `dev`: Die Netzwerkschnittstelle, über die das Paket gesendet wird.
    • `src`: Die Quell-IP-Adresse, die für Pakete über diese Route verwendet wird.
  3. DNS-Auflösung testen:

    Um zu prüfen, ob der Server Hostnamen in IP-Adressen auflösen kann, verwendest du ping oder dig/nslookup.

    ping google.com

    Wenn `ping` fehlschlägt, könnte ein DNS-Problem vorliegen.

    dig google.com

    (dig liefert detailliertere DNS-Informationen. Falls nicht installiert: sudo apt install dnsutils oder sudo yum install bind-utils)

    nslookup google.com

    (Alternative zu dig)

    Überprüfe die DNS-Server in `/etc/resolv.conf`:

    cat /etc/resolv.conf
  4. Netzwerkverbindungen und offene Ports anzeigen:

    Der Befehl ss (Socket Statistics) ist der moderne Ersatz für `netstat` und zeigt aktive Netzwerkverbindungen und offene Ports an.

    ss -tuln
    • `-t`: TCP-Verbindungen
    • `-u`: UDP-Verbindungen
    • `-l`: Listening Sockets (offene Ports)
    • `-n`: Numerische Adressen (keine Namensauflösung)

    Dies hilft dir zu sehen, welche Dienste auf welchen Ports lauschen.

  5. Netzwerkkonfiguration anpassen (temporär):

    Du kannst IP-Adressen und Routen temporär ändern, um Probleme zu testen.

    IP-Adresse hinzufügen:

    sudo ip a add 192.168.1.10/24 dev eth0

    IP-Adresse löschen:

    sudo ip a del 192.168.1.10/24 dev eth0

    Standard-Gateway ändern:

    sudo ip route del default
    sudo ip route add default via 192.168.1.1

    (Beachte: Diese Änderungen sind nach einem Neustart des Systems verschwunden.)

  6. Langfristige Netzwerkkonfiguration (Debian/Ubuntu Beispiel):

    Für dauerhafte Änderungen an der Netzwerkkonfiguration unter Debian/Ubuntu verwendet man `/etc/netplan/*.yaml` (bei neueren Versionen) oder `/etc/network/interfaces` (bei älteren Versionen).

    Netplan-Beispiel (YAML):

    sudo nano /etc/netplan/01-netcfg.yaml

    Beispiel für statische IP:

    network:
      version: 2
      renderer: networkd
      ethernets:
        enp0s3:
          dhcp4: no
          addresses: [192.168.1.10/24]
          routes:
            - to: default
              via: 192.168.1.1
          nameservers:
              addresses: [8.8.8.8, 8.8.4.4]

    Änderungen anwenden:

    sudo netplan try
    sudo netplan apply

Diese Befehle und Konzepte bilden die Grundlage für die Netzwerkadministration unter Linux.

Virtualisierung: VMs mit VirtualBox & Erste Schritte mit Docker

Virtualisierung ist ein Kernkonzept in der IT-Systemintegration. Diese Anleitung zeigt, wie man eine virtuelle Maschine (VM) mit VirtualBox einrichtet und die ersten Schritte mit Docker-Containern unternimmt.

Voraussetzungen (Host-System):

  • Ein PC mit Windows, macOS oder Linux
  • Ausreichend RAM und Festplattenspeicher
  • Aktivierte Virtualisierungsunterstützung im BIOS/UEFI (Intel VT-x / AMD-V)
  • Internetzugang

Teil 1: Virtuelle Maschine mit Oracle VirtualBox einrichten

  1. VirtualBox installieren:

    Lade VirtualBox von der offiziellen Website (virtualbox.org/wiki/Downloads) herunter und installiere es wie jede andere Software auf deinem Host-System.

  2. Betriebssystem-ISO herunterladen:

    Lade das ISO-Image des Betriebssystems herunter, das du in der VM installieren möchtest (z.B. Ubuntu Desktop, Debian Netinstall).

  3. Neue Virtuelle Maschine erstellen:
    • Öffne VirtualBox und klicke auf **Neu** (oder `Strg + N`).
    • Gib einen **Namen** für deine VM ein (z.B. "Ubuntu_TestVM"). VirtualBox versucht, den Typ und die Version automatisch zu erkennen.
    • Wähle den **Maschinentyp** und die **Version** (z.B. Linux, Ubuntu (64-bit)).
    • Klicke auf **Weiter**.
    • **Arbeitsspeicher (RAM) zuweisen:** Gib an, wie viel RAM die VM maximal nutzen soll (z.B. 2048 MB für Ubuntu).
    • Klicke auf **Weiter**.
    • **Festplatte erstellen:** Wähle "Virtuelle Festplatte jetzt erzeugen" und klicke auf **Erzeugen**.
    • Wähle **VDI (VirtualBox Disk Image)** als Dateityp und klicke auf **Weiter**.
    • Wähle **Dynamisch alloziert** (empfohlen, da der Speicherplatz auf der physischen Platte nur bei Bedarf wächst) und klicke auf **Weiter**.
    • Gib den **Speicherort und die Größe** der Festplatte an (z.B. 20 GB). Klicke auf **Erzeugen**.
  4. VM konfigurieren und ISO einbinden:
    • Wähle die neu erstellte VM in der VirtualBox-Manager-Liste aus und klicke auf **Einstellungen** (oder `Strg + S`).
    • Gehe zu **Speicher**.
    • Unter dem **Controller: IDE** klicke auf das leere CD-Symbol und dann rechts auf das CD-Symbol neben "Optisches Laufwerk: [Optisches Laufwerk]".
    • Wähle **Datei einer virtuellen optischen Platte auswählen** und navigiere zu deinem heruntergeladenen ISO-Image. Klicke **Öffnen**.
    • Passe bei Bedarf weitere Einstellungen an (z.B. Anzahl der CPUs unter "System" -> "Prozessor", Netzwerkadapter unter "Netzwerk").
    • Klicke **OK**.
  5. VM starten und Betriebssystem installieren:
    • Wähle die VM im VirtualBox-Manager aus und klicke auf **Starten**.
    • Die VM bootet vom ISO-Image. Folge den Anweisungen des Installationsprogramms des jeweiligen Betriebssystems.

Teil 2: Erste Schritte mit Docker-Containern

Docker ermöglicht die Isolation von Anwendungen und ihren Abhängigkeiten in "Containern".

  1. Docker installieren (Linux Beispiel):

    Unter Debian/Ubuntu:

    sudo apt update
    sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release
    curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    sudo apt update
    sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

    Füge deinen Benutzer zur Docker-Gruppe hinzu, um Docker ohne `sudo` nutzen zu können (Neuanmeldung erforderlich):

    sudo usermod -aG docker $USER

    Installationsanweisungen für andere Betriebssysteme findest du auf der offiziellen Docker-Website.

  2. Ersten Docker-Container ausführen:

    Der einfachste Weg, Docker zu testen, ist das Ausführen des "hello-world"-Containers.

    docker run hello-world

    Docker lädt das Image herunter (falls nicht vorhanden) und führt den Container aus, der eine Begrüßungsnachricht ausgibt.

  3. Ein Nginx-Webserver-Container starten:

    Starte einen Nginx-Webserver in einem Container und mache ihn auf Port 8080 deines Hosts zugänglich.

    docker run --name my-nginx -p 8080:80 -d nginx
    • `--name my-nginx`: Gibt dem Container einen Namen.
    • `-p 8080:80`: Leitet Port 80 (Container) auf Port 8080 (Host) um.
    • `-d`: Startet den Container im "detached mode" (im Hintergrund).
    • `nginx`: Das zu verwendende Docker-Image.

    Öffne nun deinen Browser und navigiere zu `http://localhost:8080` (oder die IP-Adresse deines Servers), um die Nginx-Standardseite zu sehen.

  4. Docker-Container verwalten:

    Aktive Container auflisten:

    docker ps

    Alle Container (auch gestoppte) auflisten:

    docker ps -a

    Container stoppen:

    docker stop my-nginx

    Container starten:

    docker start my-nginx

    Container entfernen (muss zuerst gestoppt werden):

    docker rm my-nginx

    Images auflisten:

    docker images

    Image entfernen (muss zuerst alle Container löschen, die es nutzen):

    docker rmi nginx

Dies gibt dir einen ersten Einblick in die Nutzung von VMs und Containern, beides wichtige Technologien im Bereich der Systemintegration.

Automatisierung mit Bash-Skripten unter Linux

Bash-Skripte sind ein mächtiges Werkzeug zur Automatisierung wiederkehrender Aufgaben auf Linux-Systemen. Diese Anleitung zeigt die Grundlagen der Bash-Skripterstellung am Beispiel eines einfachen Systeminformations-Skripts.

Voraussetzungen:

  • Linux-System
  • Terminalzugriff
  • Texteditor (z.B. nano, vim)
  • Grundkenntnisse der Linux-Befehlszeile

Schritt-für-Schritt-Anleitung:

  1. Erstellen der Skriptdatei:

    Erstelle eine neue Datei mit der Endung `.sh` (oder ohne, aber es hilft bei der Erkennung).

    nano systeminfo.sh
  2. Skript-Header (Shebang) hinzufügen:

    Die erste Zeile eines Skripts sollte der "Shebang" sein, der dem System mitteilt, welcher Interpreter verwendet werden soll (hier Bash).

    #!/bin/bash
  3. Kommentare und Variablen:

    Kommentare beginnen mit `#`. Variablen werden mit einem `=` zugewiesen und mit `$` aufgerufen.

    
    # Dies ist ein Beispielskript zur Anzeige grundlegender Systeminformationen
    # Ersteller: Dein Name
    # Datum: 2024-07-22
    
    SERVER_NAME=$(hostname)
    KERNEL_VERSION=$(uname -r)
    IP_ADDRESS=$(hostname -I | awk '{print $1}') # Nimmt die erste IP-Adresse
    
    LOG_FILE="/var/log/systeminfo.log"
                    
  4. Ausgabe von Informationen (Echo):

    Der Befehl `echo` gibt Text auf der Konsole aus.

    
    echo "-----------------------------------"
    echo "Systeminformationen für $SERVER_NAME"
    echo "-----------------------------------"
    echo "Datum und Uhrzeit: $(date)"
    echo "Kernel-Version: $KERNEL_VERSION"
    echo "IP-Adresse: $IP_ADDRESS"
    echo "" # Leere Zeile
                    
  5. Ausführen von Systembefehlen im Skript:

    Du kannst normale Linux-Befehle direkt im Skript verwenden. Die Ausgabe wird dann ins Skript "eingefügt".

    
    echo "Festplattennutzung:"
    df -h /
    
    echo ""
    
    echo "Arbeitsspeichernutzung:"
    free -h
    
    echo ""
    
    echo "Aktuell angemeldete Benutzer:"
    who
    
    echo "-----------------------------------"
    echo "Skriptausführung beendet."
    echo "-----------------------------------"
                    
  6. Skript ausführbar machen:

    Gib der Datei die Berechtigung, als Programm ausgeführt zu werden.

    chmod +x systeminfo.sh
  7. Skript ausführen:

    Starte das Skript von der Kommandozeile aus.

    ./systeminfo.sh

    Um die Ausgabe in eine Log-Datei umzuleiten:

    ./systeminfo.sh > $LOG_FILE

    Oder innerhalb des Skripts direkt in die Log-Datei schreiben (siehe Beispielvariablen):

    
    # Beispiel: Nur Datum in Log schreiben
    echo "Skript gestartet am $(date)" >> $LOG_FILE
                    

Dies ist ein einfacher Startpunkt für Bash-Skripte. Du kannst sie erweitern, um komplexere Aufgaben wie Backups, Dienstüberwachung oder automatisierte Konfigurationen durchzuführen.

Daten-Backups mit rsync unter Linux

Regelmäßige Backups sind ein Eckpfeiler der IT-Sicherheit. rsync ist ein vielseitiges und effizientes Tool zur Synchronisierung von Dateien und Verzeichnissen, ideal für lokale und Remote-Backups. Diese Anleitung zeigt grundlegende Backup-Strategien mit rsync.

Voraussetzungen:

  • Linux-System (Quell- und Zielsystem, wenn Remote-Backup)
  • rsync installiert (meist vorinstalliert, sonst sudo apt install rsync)
  • Ausreichend Speicherplatz auf dem Zielmedium
  • (Für Remote-Backup) SSH-Zugriff zum Zielsystem

Schritt-für-Schritt-Anleitung:

  1. Lokales Backup eines Verzeichnisses:

    Synchronisiert ein Quellverzeichnis mit einem Zielverzeichnis auf demselben System. rsync kopiert nur die geänderten oder neuen Dateien, was sehr effizient ist.

    rsync -avh --delete /quellverzeichnis/ /zielverzeichnis/backup/
    • `-a` (archive mode): Aktiviert Rekursion, kopiert Symlinks, Behält Berechtigungen, Zeiten, Gruppen, Besitzer bei, kopiert Gerätedateien.
    • `-v` (verbose): Zeigt Details zum Kopiervorgang an.
    • `-h` (human-readable): Zeigt Zahlen in lesbarem Format an (z.B. KB, MB).
    • `--delete`: Löscht Dateien im Ziel, die in der Quelle nicht mehr existieren. **Vorsicht bei der Verwendung!**
    • `/quellverzeichnis/`: Wichtig ist der abschließende Schrägstrich `/`, er bedeutet, dass der *Inhalt* des Quellverzeichnisses kopiert wird, nicht das Verzeichnis selbst.

    Beispiel: Home-Verzeichnis nach `/mnt/backup_hdd/` sichern:

    rsync -avh --delete /home/benutzername/ /mnt/backup_hdd/home_backup/
  2. Remote-Backup über SSH (Pull-Methode):

    Du ziehst (pullst) Dateien von einem entfernten Server auf deinen lokalen Server.

    rsync -avh --progress benutzername@entfernter_server_ip:/pfad/zum/quellverzeichnis/ /lokales/zielverzeichnis/
    • `--progress`: Zeigt den Fortschritt einzelner Dateien an.
    • `benutzername@entfernter_server_ip`: SSH-Benutzer und IP-Adresse des Remote-Servers.

    Beispiel: `/var/www` von Remote-Server auf lokalen Server ziehen:

    rsync -avh --progress webadmin@192.168.1.100:/var/www/ /var/backups/webserver/
  3. Remote-Backup über SSH (Push-Methode):

    Du schiebst (pushst) Dateien von deinem lokalen Server auf einen entfernten Server.

    rsync -avh --progress /lokales/quellverzeichnis/ benutzername@entfernter_server_ip:/pfad/zum/zielverzeichnis/

    Beispiel: Lokale Konfigurationsdateien auf einen Backup-Server sichern:

    rsync -avh --progress /etc/config/ backupuser@192.168.1.10:/mnt/backups/configs/
  4. Inkrementelle Backups (Snapshot-Methode mit Hardlinks):

    Erstellt Backup-Versionen, die nur die Änderungen speichern, aber so aussehen, als wären es vollständige Backups. Spart Platz und ermöglicht einfache Wiederherstellung.

    
    #!/bin/bash
    SOURCE="/var/www/"
    DEST="/mnt/backup_hdd/web_snapshots/"
    DATETIME=$(date +%Y-%m-%d_%H-%M-%S)
    CURRENT="$DEST/current"
    NEW_SNAPSHOT="$DEST/$DATETIME"
    
    # Sicherstellen, dass das Zielverzeichnis existiert
    mkdir -p "$DEST"
    
    # Falls 'current' existiert, als Basis für Hardlinks verwenden
    if [ -d "$CURRENT" ]; then
      rsync -av --delete --link-dest="$CURRENT" "$SOURCE" "$NEW_SNAPSHOT"
    else
      # Wenn kein 'current' existiert, komplettes Backup
      rsync -av --delete "$SOURCE" "$NEW_SNAPSHOT"
    fi
    
    # 'current' Symlink aktualisieren
    rm -f "$CURRENT"
    ln -s "$NEW_SNAPSHOT" "$CURRENT"
    
    echo "Backup von $SOURCE nach $NEW_SNAPSHOT abgeschlossen."
                    

    Dieses Skript erstellt einen neuen Snapshot-Ordner mit Datum/Uhrzeit und nutzt Hardlinks zu unveränderten Dateien im vorherigen "current"-Snapshot, um Speicherplatz zu sparen.

  5. Automatisierung mit Cron-Jobs:

    Um Backups regelmäßig durchzuführen, kannst du Cron-Jobs verwenden.

    crontab -e

    Füge eine Zeile hinzu, um z.B. das oben erstellte Skript täglich um 3 Uhr nachts auszuführen:

    0 3 * * * /pfad/zu/deinem/backup_skript.sh > /dev/null 2>&1

    Stelle sicher, dass dein Skript ausführbar ist (`chmod +x dein_skript.sh`).

rsync ist ein unverzichtbares Werkzeug für effiziente und zuverlässige Backup-Strategien in Linux-Umgebungen.

Automatisierung mit Python-Skripten

Python ist eine der vielseitigsten Skriptsprachen für die Systemadministration und Automatisierung. Es eignet sich hervorragend für Aufgaben, die von einfachen Dateimanipulationen bis zur Verwaltung komplexer Netzwerke reichen. Diese Anleitung zeigt die Grundlagen der Python-Skripterstellung am Beispiel eines einfachen Skripts zur Datei- und Verzeichnisverwaltung.

Voraussetzungen:

  • Ein System mit installierter Python-Version (Python 3.x empfohlen)
  • Terminalzugriff
  • Texteditor (z.B. VS Code, Sublime Text, nano)
  • Grundkenntnisse der Python-Syntax

Schritt-für-Schritt-Anleitung:

  1. Python installieren (falls nicht vorhanden):

    Auf den meisten Linux-Distributionen und macOS ist Python vorinstalliert. Für Windows lade den Installer von python.org/downloads/ herunter.

    Auf Debian/Ubuntu:

    sudo apt update
    sudo apt install python3 python3-pip -y

    Überprüfe die Installation:

    python3 --version
    pip3 --version
  2. Erstellen der Skriptdatei:

    Erstelle eine neue Datei mit der Endung `.py`.

    nano file_manager.py
  3. Skript-Header (Shebang für Linux/macOS) und Importe:

    Füge den Shebang für Linux/macOS und die notwendigen Importe am Anfang des Skripts ein. Für Windows ist der Shebang nicht zwingend notwendig.

    #!/usr/bin/env python3
    
    import os
    import shutil
    import datetime
    
    # Dein Skript beginnt hier
                    
    • `os`: Modul für Interaktionen mit dem Betriebssystem (Dateisystem, Umgebungsvariablen).
    • `shutil`: Modul für High-Level-Dateioperationen (Kopieren, Verschieben).
    • `datetime`: Modul für Datum- und Uhrzeitoperationen.
  4. Funktionen zur Datei- und Verzeichnisverwaltung:

    Definiere Funktionen für wiederkehrende Aufgaben, z.B. Ordner erstellen, Dateien kopieren oder löschen.

    
    def create_directory(path):
        if not os.path.exists(path):
            os.makedirs(path)
            print(f"Verzeichnis '{path}' erfolgreich erstellt.")
        else:
            print(f"Verzeichnis '{path}' existiert bereits.")
    
    def copy_file(source, destination_dir):
        try:
            shutil.copy(source, destination_dir)
            print(f"Datei '{source}' erfolgreich nach '{destination_dir}' kopiert.")
        except FileNotFoundError:
            print(f"Fehler: Datei '{source}' nicht gefunden.")
        except Exception as e:
            print(f"Fehler beim Kopieren von '{source}': {e}")
    
    def delete_file(path):
        try:
            os.remove(path)
            print(f"Datei '{path}' erfolgreich gelöscht.")
        except FileNotFoundError:
            print(f"Fehler: Datei '{path}' nicht gefunden.")
        except Exception as e:
            print(f"Fehler beim Löschen von '{path}': {e}")
    
    def list_directory_contents(path):
        print(f"\nInhalt von '{path}':")
        for item in os.listdir(path):
            item_path = os.path.join(path, item)
            if os.path.isdir(item_path):
                print(f"  [DIR] {item}")
            else:
                print(f"  [FILE] {item}")
                    
  5. Hauptlogik des Skripts:

    Rufe die Funktionen auf und definiere die Aktionen, die das Skript ausführen soll.

    
    if __name__ == "__main__":
        # Beispielpfade
        base_dir = "temp_files"
        backup_dir = os.path.join(base_dir, "backups")
        log_file = os.path.join(base_dir, "app.log")
        test_file = os.path.join(base_dir, "test.txt")
    
        # 1. Hauptverzeichnis erstellen
        create_directory(base_dir)
    
        # 2. Log-Datei erstellen und etwas hineinschreiben
        with open(log_file, "w") as f:
            f.write(f"Skript gestartet am: {datetime.datetime.now()}\n")
            f.write("Erstelle Testdatei...\n")
        print(f"Log-Datei '{log_file}' erstellt.")
    
        # 3. Testdatei erstellen
        with open(test_file, "w") as f:
            f.write("Dies ist eine Testdatei für das Python-Skript.\n")
        print(f"Testdatei '{test_file}' erstellt.")
    
        # 4. Backup-Verzeichnis erstellen
        create_directory(backup_dir)
    
        # 5. Testdatei in das Backup-Verzeichnis kopieren
        copy_file(test_file, backup_dir)
    
        # 6. Inhalt des Basisverzeichnisses auflisten
        list_directory_contents(base_dir)
    
        # 7. Original-Testdatei löschen
        delete_file(test_file)
    
        # 8. Inhalt nach dem Löschen auflisten
        list_directory_contents(base_dir)
    
        print("\nSkriptausführung beendet.")
                    
  6. Skript ausführen:

    Speichere die Datei und führe sie im Terminal aus.

    python3 file_manager.py

    Wenn du den Shebang gesetzt hast und die Datei ausführbar gemacht hast (`chmod +x file_manager.py`), kannst du sie auch direkt ausführen:

    ./file_manager.py

Dieses einfache Skript zeigt, wie Python für grundlegende Automatisierungsaufgaben im Dateisystem genutzt werden kann. Python bietet weitreichende Module für Netzwerk, Systemverwaltung, Datenbanken und vieles mehr, die es zu einem mächtigen Werkzeug für Systemintegratoren machen.

DHCP-Server unter Debian einrichten

Ein Dynamic Host Configuration Protocol (DHCP)-Server ist unerlässlich, um Geräten in einem Netzwerk automatisch IP-Adressen, Subnetzmasken, Gateways und DNS-Server zuzuweisen. Diese Anleitung führt dich durch die Installation und Grundkonfiguration eines ISC-DHCP-Servers unter Debian.

Voraussetzungen:

  • Ein Debian-Server mit einer statischen IP-Adresse auf der Netzwerkschnittstelle, die als DHCP-Server dienen soll.
  • Benutzer mit sudo-Rechten.
  • Internetzugang für die Installation der Pakete.

Schritt-für-Schritt-Anleitung:

  1. Statische IP-Adresse konfigurieren:

    Der DHCP-Server muss selbst eine feste IP-Adresse haben. Bearbeite die Netplan-Konfiguration (Debian 10+).

    sudo nano /etc/netplan/01-netcfg.yaml

    Beispiel für eine statische IP auf `enp0s3`:

    network:
      version: 2
      renderer: networkd
      ethernets:
        enp0s3:
          dhcp4: no
          addresses: [192.168.1.1/24] # Deine Server-IP
          routes:
            - to: default
              via: 192.168.1.254 # Dein Gateway
          nameservers:
              addresses: [8.8.8.8, 8.8.4.4] # Externe DNS-Server
    

    Änderungen anwenden:

    sudo netplan apply
  2. ISC-DHCP-Server installieren:

    Aktualisiere die Paketlisten und installiere den DHCP-Server.

    sudo apt update
    sudo apt install isc-dhcp-server -y
  3. DHCP-Server konfigurieren - Netzwerkschnittstelle festlegen:

    Dem DHCP-Server muss mitgeteilt werden, auf welcher Netzwerkschnittstelle er auf Anfragen lauschen soll.

    sudo nano /etc/default/isc-dhcp-server

    Suche die Zeile `INTERFACESv4=""` und füge deine Schnittstelle hinzu (z.B. `enp0s3`).

    INTERFACESv4="enp0s3"
  4. DHCP-Server konfigurieren - Subnetzdefinition:

    Die Hauptkonfiguration erfolgt in `dhcpd.conf`. Hier definierst du den IP-Adressbereich, Gateway, DNS-Server und Lease-Zeiten.

    sudo nano /etc/dhcp/dhcpd.conf

    Füge am Ende der Datei folgenden Block ein und passe die Werte an dein Netzwerk an:

    
    subnet 192.168.1.0 netmask 255.255.255.0 {
        range 192.168.1.100 192.168.1.200; # Bereich der IPs, die vergeben werden
        option routers 192.168.1.254; # Dein Standard-Gateway
        option domain-name-servers 8.8.8.8, 8.8.4.4; # DNS-Server, die an Clients vergeben werden
        option domain-name "dein-netzwerk.local"; # Dein Domain-Name
        default-lease-time 600; # Standard-Lease-Zeit (Sekunden)
        max-lease-time 7200; # Maximale Lease-Zeit (Sekunden)
    }
    
    # Optional: Statische Zuweisung für bestimmte Geräte (z.B. Drucker)
    # host mein-drucker {
    #     hardware ethernet 00:11:22:33:44:55; # MAC-Adresse des Geräts
    #     fixed-address 192.168.1.50; # Feste IP-Adresse
    # }
                    

    Entferne oder kommentiere gegebenenfalls die Zeilen `ddns-update-style` am Anfang der Datei aus, wenn sie Probleme bereiten, da sie für dynamisches DNS-Update sind und nicht immer benötigt werden.

  5. DHCP-Server starten und überprüfen:

    Aktiviere und starte den DHCP-Dienst neu.

    sudo systemctl enable isc-dhcp-server
    sudo systemctl restart isc-dhcp-server

    Überprüfe den Status, um sicherzustellen, dass er läuft:

    sudo systemctl status isc-dhcp-server

    Schau ins Log, ob Fehler auftreten:

    sudo tail -f /var/log/syslog | grep dhcpd
  6. Firewall anpassen:

    Erlaube DHCP-Anfragen auf dem Server (Port 67 UDP).

    sudo ufw allow 67/udp
    sudo ufw reload
  7. Testen des DHCP-Servers:

    Verbinde einen Client (z.B. einen anderen PC, VM oder Smartphone) mit dem Netzwerk und stelle dessen Netzwerkeinstellungen auf "DHCP" oder "IP-Adresse automatisch beziehen". Überprüfe, ob er eine IP-Adresse aus dem definierten Bereich erhält und die korrekten DNS-Server und das Gateway zugewiesen bekommt.

Dein Debian-Server fungiert nun als DHCP-Server und verteilt automatisch Netzwerkkonfigurationen an Clients.

DNS-Server (Bind9) unter Debian einrichten

Ein Domain Name System (DNS)-Server übersetzt für deinen Server und deine Clients Hostnamen (z.B. google.com) in IP-Adressen und umgekehrt. Diese Anleitung zeigt die Grundkonfiguration von Bind9 (oft als `named` bezeichnet) als Caching-Only-DNS-Server oder als autoritativer Server für eine lokale Zone unter Debian.

Voraussetzungen:

  • Ein Debian-Server mit statischer IP-Adresse.
  • Benutzer mit sudo-Rechten.
  • Internetzugang für die Installation der Pakete.

Schritt-für-Schritt-Anleitung:

  1. Bind9 installieren:
    sudo apt update
    sudo apt install bind9 bind9utils bind9-doc -y
  2. Grundkonfiguration als Caching-Only-Server:

    Ein Caching-Only-Server leitet Anfragen an externe DNS-Server weiter und speichert die Antworten, um zukünftige Anfragen schneller zu bearbeiten. Dies ist die einfachste Konfiguration.

    sudo nano /etc/bind/named.conf.options

    Stelle sicher, dass der `forwarders` Block wie folgt aussieht (Google Public DNS als Beispiel):

    options {
        directory "/var/cache/bind";
        recursion yes; # Erlaubt rekursive Anfragen (Standard)
        allow-query { any; }; # Erlaubt Anfragen von jedem (oder beschränke auf dein LAN)
    
        forwarders {
            8.8.8.8;
            8.8.4.4;
        };
    
        dnssec-validation auto; # Wichtig für DNSSEC-Validierung
        listen-on { any; }; # Lausche auf allen IPs (oder beschränke auf deine Server-IP)
    };
                    

    Passe `allow-query` und `listen-on` an, wenn du den Zugriff nur auf dein lokales Netzwerk beschränken möchtest (z.B. `allow-query { 192.168.1.0/24; };`).

  3. Autoritative Zone für dein lokales Netzwerk erstellen (optional):

    Wenn du eigene lokale Hostnamen verwalten möchtest (z.B. `server.meinnetz.local`), musst du eine autoritative Zone einrichten.

    A. Zone in `named.conf.local` definieren:

    sudo nano /etc/bind/named.conf.local

    Füge am Ende der Datei deine Zone und die Reverse-Zone hinzu (ersetze `meinnetz.local` und `1.168.192` mit deinen Werten):

    
    zone "meinnetz.local" {
        type master;
        file "/etc/bind/db.meinnetz.local";
    };
    
    zone "1.168.192.in-addr.arpa" { # Reverse Zone für 192.168.1.0/24
        type master;
        file "/etc/bind/db.192";
    };
                    

    B. Zonendatei für Vorwärtsauflösung erstellen (`db.meinnetz.local`):

    sudo cp /etc/bind/db.local /etc/bind/db.meinnetz.local
    sudo nano /etc/bind/db.meinnetz.local

    Passe den Inhalt an (Beispiel):

    
    $TTL    604800
    @       IN      SOA     ns1.meinnetz.local. admin.meinnetz.local. (
                              2         ; Serial
                         604800         ; Refresh
                          86400         ; Retry
                        2419200         ; Expire
                         604800 )       ; Negative Cache TTL
    ;
    @       IN      NS      ns1.meinnetz.local.
    ns1     IN      A       192.168.1.1 # IP-Adresse deines DNS-Servers
    server  IN      A       192.168.1.1 # Beispiel für einen Hostnamen
    client1 IN      A       192.168.1.10
                    

    C. Zonendatei für Reverse-Auflösung erstellen (`db.192`):

    sudo cp /etc/bind/db.127 /etc/bind/db.192
    sudo nano /etc/bind/db.192

    Passe den Inhalt an (Beispiel, die letzten Oktette deiner IPs):

    
    $TTL    604800
    @       IN      SOA     ns1.meinnetz.local. admin.meinnetz.local. (
                              2         ; Serial
                         604800         ; Refresh
                          86400         ; Retry
                        2419200         ; Expire
                         604800 )       ; Negative Cache TTL
    ;
    @       IN      NS      ns1.meinnetz.local.
    1       IN      PTR     ns1.meinnetz.local. # Für 192.168.1.1
    10      IN      PTR     client1.meinnetz.local. # Für 192.168.1.10
                    
  4. Rechte setzen und Konfiguration überprüfen:

    Stelle sicher, dass Bind auf die Zonendateien zugreifen kann.

    sudo chown -R bind:bind /etc/bind/
    sudo chown -R bind:bind /var/cache/bind/

    Syntax der Konfiguration überprüfen:

    sudo named-checkconf
    sudo named-checkzone meinnetz.local /etc/bind/db.meinnetz.local
    sudo named-checkzone 1.168.192.in-addr.arpa /etc/bind/db.192
  5. Bind9-Dienst neu starten und Firewall anpassen:
    sudo systemctl restart bind9
    sudo systemctl status bind9

    Erlaube DNS-Verkehr (Port 53 TCP/UDP).

    sudo ufw allow 53/udp
    sudo ufw allow 53/tcp
    sudo ufw reload
  6. Client-Konfiguration testen:

    Konfiguriere einen Client so, dass er deinen neuen DNS-Server verwendet (z.B. in den Netzwerkeinstellungen oder in `/etc/resolv.conf` auf einem Linux-Client).

    sudo nano /etc/resolv.conf

    Füge hinzu oder ändere:

    nameserver 192.168.1.1 # IP deines DNS-Servers

    Teste dann die Auflösung:

    dig google.com
    dig server.meinnetz.local
    dig -x 192.168.1.10 # Reverse Lookup

Dein Debian-Server fungiert nun als DNS-Server, der Anfragen auflösen und (optional) deine eigene lokale Zone verwalten kann.

Grundlagen der PowerShell für Windows-Administratoren

PowerShell ist die mächtige Skriptsprache und Kommandozeilen-Shell von Microsoft, die für die Automatisierung von Verwaltungsaufgaben auf Windows-Systemen unerlässlich ist. Diese Anleitung führt dich in die Grundlagen der PowerShell ein.

Voraussetzungen:

  • Ein Windows-System (Windows 10, 11, Windows Server)
  • Grundkenntnisse der Windows-Bedienung
  • Zugriff auf PowerShell (als Administrator für Systemaufgaben)

Schritt-für-Schritt-Anleitung:

  1. PowerShell öffnen:
    • Klicke auf das Startmenü, tippe "PowerShell" und wähle **Windows PowerShell** oder **Windows PowerShell ISE** (Integrated Scripting Environment) aus. Für administrative Aufgaben Rechtsklick und "Als Administrator ausführen".
  2. Cmdlets verstehen (Verb-Nomen-Struktur):

    PowerShell-Befehle werden "Cmdlets" genannt und folgen der Struktur `Verb-Nomen` (z.B. `Get-Process`, `Set-Service`).

    Get-Command -Noun Service

    Zeigt alle Cmdlets an, die sich auf "Service" beziehen.

  3. Hilfe erhalten:

    Für jedes Cmdlet kannst du detaillierte Hilfe erhalten.

    Get-Help Get-Process -Full

    Zeigt vollständige Informationen zu `Get-Process` an, inklusive Beispiele.

    Update-Help

    Aktualisiert die Hilfedateien (Als Administrator ausführen).

  4. Ausgabe filtern und formatieren (Pipelining):

    Du kannst die Ausgabe eines Cmdlets an das nächste weiterleiten (`|`).

    Alle laufenden Prozesse anzeigen:

    Get-Process

    Prozesse nach Namen filtern:

    Get-Process | Where-Object {$_.ProcessName -like "chrome*"}

    Ausgewählte Eigenschaften anzeigen:

    Get-Process | Select-Object Name, Id, WorkingSet

    Ausgabe als Tabelle formatieren:

    Get-Process | Select-Object Name, Id, WorkingSet | Format-Table -AutoSize
  5. Variablen verwenden:

    Variablen beginnen mit `$`. Du kannst Werte speichern und wiederverwenden.

    $service = "Spooler"
    Get-Service -Name $service
    $allServices = Get-Service
    $allServices.Count
  6. Skripte erstellen und ausführen:

    Schreibe Befehle in eine `.ps1`-Datei und führe sie aus.

    A. Skript erstellen (z.B. mit Notepad oder VS Code):

    # MyFirstScript.ps1
    # Dieses Skript zeigt grundlegende Systeminformationen
    Write-Host "Hallo von meinem ersten PowerShell-Skript!"
    Write-Host "Computername: $env:COMPUTERNAME" # Umgebungsvariable
    Get-Service | Where-Object {$_.Status -eq "Running"} | Select-Object Name, Status | Format-Table -AutoSize
                    

    B. Ausführungsrichtlinie ändern (einmalig):

    Standardmäßig sind Skripte nicht ausführbar aus Sicherheitsgründen. Du musst die Ausführungsrichtlinie ändern (Als Administrator ausführen).

    Set-ExecutionPolicy RemoteSigned

    Bestätige mit `J` oder `Y`.

    C. Skript ausführen:

    .\MyFirstScript.ps1
  7. Häufig genutzte Cmdlets:
    • `Get-Service`, `Start-Service`, `Stop-Service`, `Restart-Service`: Dienste verwalten.
    • `Get-Process`, `Stop-Process`: Prozesse steuern.
    • `Get-Item`, `Set-Item`, `Remove-Item`: Dateien und Ordner.
    • `Get-WmiObject` (oder das modernere `Get-CimInstance`): Informationen über Hardware, Software, Systemzustand.
    • `Get-ADUser`, `Set-ADUser` (erfordert RSAT): Active Directory Benutzer verwalten.

PowerShell ist ein mächtiges Tool, das dir hilft, die Verwaltung von Windows-Systemen effizient zu automatisieren und zu überwachen.

Dateifreigaben mit Samba unter Linux konfigurieren

Samba ermöglicht es Linux-Servern, als Dateiserver für Windows-, macOS- und andere Linux-Clients zu fungieren, indem es das SMB/CIFS-Protokoll implementiert. Diese Anleitung zeigt, wie du eine grundlegende öffentliche und eine passwortgeschützte private Freigabe einrichtest.

Voraussetzungen:

  • Linux-Server (z.B. Debian, Ubuntu, CentOS)
  • Benutzer mit sudo-Rechten
  • Internetzugang für die Installation
  • Ein zu teilendes Verzeichnis auf dem Server

Schritt-für-Schritt-Anleitung:

  1. Samba installieren:
    sudo apt update
    sudo apt install samba samba-common-bin -y
  2. Zu teilendes Verzeichnis erstellen und Berechtigungen setzen:

    Erstelle ein Verzeichnis, das du freigeben möchtest, und setze die korrekten Berechtigungen.

    sudo mkdir -p /srv/samba/public
    sudo mkdir -p /srv/samba/private

    Setze die Berechtigungen so, dass Samba-Benutzer darauf zugreifen können (z.B. für öffentliche Freigabe `777`, für private Freigabe `770` und Besitzergruppe).

    sudo chmod -R 0777 /srv/samba/public
    sudo chmod -R 0770 /srv/samba/private
    sudo chown -R root:sambashare /srv/samba/private # 'sambashare' ist eine Standardgruppe von Samba
  3. Samba-Konfigurationsdatei bearbeiten:

    Die Hauptkonfigurationsdatei ist `smb.conf`. Mach eine Sicherungskopie, bevor du sie bearbeitest.

    sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak
    sudo nano /etc/samba/smb.conf

    Globale Einstellungen anpassen (Optional, aber empfohlen):

    Unter dem `[global]`-Abschnitt kannst du den Workgroup-Namen anpassen, falls du nicht "WORKGROUP" verwendest.

    
    [global]
       workgroup = WORKGROUP # Dein Workgroup-Name, z.B. HOME
       server string = %h Samba Server # Name, der im Netzwerk angezeigt wird
       log file = /var/log/samba/log.%m
       max log size = 1000
       logging = file
       panic action = /usr/share/samba/panic-action %d
       server role = standalone server
       obey pam restrictions = yes
       unix password sync = yes
       passwd program = /usr/bin/passwd %u
       passwd chat = *Enter\snew\s*\s*UNIX\spassword:* %n\n *Retype\snew\s*\s*UNIX\spassword:* %n\n *password\supdated\ssuccessfully* .
       pam password change = yes
       map to guest = bad user
       usershare allow guests = yes # Erlaubt öffentlichen Zugriff über shares
       
       # Wenn du nur Authentifizierung willst, deaktiviere Gastzugriff
       # security = user
                    

    Öffentliche Freigabe hinzufügen:

    Füge diesen Block am Ende der Datei hinzu:

    
    [public_share]
       comment = Eine öffentliche Freigabe
       path = /srv/samba/public
       browsable = yes # Sichtbar im Netzwerk
       guest ok = yes # Jeder darf zugreifen (ohne Passwort)
       read only = no # Schreibzugriff erlauben
       create mask = 0775 # Standardberechtigungen für neue Dateien
       directory mask = 0775 # Standardberechtigungen für neue Ordner
                    

    Private Freigabe hinzufügen (passwortgeschützt):

    Füge diesen Block am Ende der Datei hinzu:

    
    [private_share]
       comment = Private Freigabe nur für autorisierte Benutzer
       path = /srv/samba/private
       browsable = yes
       read only = no
       valid users = @sambashare # Nur Benutzer in der Gruppe 'sambashare' dürfen zugreifen
       create mask = 0770
       directory mask = 0770
                    
  4. Samba-Benutzer hinzufügen:

    Samba verwendet eigene Passwörter, die mit den System-Passwörtern synchronisiert werden können, aber separat verwaltet werden.

    Erstelle zuerst einen System-Benutzer (falls noch nicht vorhanden):

    sudo adduser benutzername_samba
    sudo usermod -aG sambashare benutzername_samba # Benutzer zur Gruppe hinzufügen, falls für private Freigabe nötig

    Füge den Benutzer dann zu Samba hinzu und setze ein Samba-Passwort:

    sudo smbpasswd -a benutzername_samba

    Aktiviere den Samba-Benutzer:

    sudo smbpasswd -e benutzername_samba
  5. Samba-Dienst neu starten:

    Nach jeder Änderung der `smb.conf` musst du den Dienst neu starten.

    sudo systemctl restart smbd nmbd
    sudo systemctl status smbd nmbd
  6. Firewall anpassen:

    Erlaube Samba-Dienste (Port 137/UDP, 138/UDP, 139/TCP, 445/TCP).

    sudo ufw allow 'Samba'
    sudo ufw reload
  7. Freigaben vom Client aus testen:

    Windows:

    • Öffne den Datei-Explorer.
    • Gib in der Adressleiste `\\DEIN_SERVER_IP` oder `\\SERVERNAME` ein und drücke Enter.
    • Du solltest deine Freigaben sehen. Für die private Freigabe wirst du nach Benutzername und Passwort gefragt.

    Linux/macOS:

    • Öffne den Dateimanager.
    • Gib in der Adressleiste `smb://DEIN_SERVER_IP/public_share` ein oder nutze die Netzwerkumgebung.

Dein Linux-Server ist nun bereit, Dateien über Samba im Netzwerk zu teilen.

VPN-Server mit OpenVPN unter Linux einrichten

Ein VPN-Server (Virtual Private Network) ermöglicht es, eine sichere, verschlüsselte Verbindung zu einem entfernten Netzwerk herzustellen. OpenVPN ist eine robuste und weit verbreitete Open-Source-Lösung. Diese Anleitung führt dich durch die Installation und Konfiguration eines OpenVPN-Servers unter Linux (Debian/Ubuntu) und die Erstellung von Client-Zertifikaten.

Voraussetzungen:

  • Ein Linux-Server (z.B. Debian 11/12, Ubuntu LTS)
  • Benutzer mit sudo-Rechten
  • Internetzugang auf dem Server
  • Eine statische öffentliche IP-Adresse oder ein DynDNS-Dienst für den Server
  • Firewall (z.B. UFW) installiert und konfiguriert

Schritt-für-Schritt-Anleitung:

  1. System aktualisieren und OpenVPN sowie Easy-RSA installieren:

    Aktualisiere dein System und installiere die benötigten Pakete.

    sudo apt update && sudo apt upgrade -y
    sudo apt install openvpn easy-rsa -y
  2. Public Key Infrastructure (PKI) mit Easy-RSA einrichten:

    Die PKI ist notwendig, um Zertifikate für den Server und die Clients zu erstellen.

    • Kopiere das Easy-RSA-Verzeichnis an einen sicheren Ort (z.B. `/etc/openvpn/easy-rsa`).
    • sudo cp -r /usr/share/easy-rsa /etc/openvpn/
    • Berechtigungen anpassen:
    • sudo chown -R $USER:$USER /etc/openvpn/easy-rsa
      chmod 700 /etc/openvpn/easy-rsa
    • Navigiere in das Easy-RSA-Verzeichnis und initialisiere die PKI:
    • cd /etc/openvpn/easy-rsa
      ./easyrsa init-pki
    • Baue die Zertifizierungsstelle (CA). Du wirst nach einer Passphrase für die CA gefragt und einem "Common Name" (z.B. "MyOpenVPN_CA").
    • ./easyrsa build-ca nopass

      (nopass erstellt die CA ohne Passphrase. Für maximale Sicherheit eine Passphrase verwenden.)

  3. Server-Zertifikat und -Schlüssel erstellen:
    • Fordere ein Server-Zertifikat an. Gib den Common Name für den Server an (z.B. "server").
    • ./easyrsa gen-req server nopass
    • Signiere das Server-Zertifikat mit deiner CA. Bestätige mit "yes".
    • ./easyrsa sign-req server server
    • Kopiere die generierten Dateien in das OpenVPN-Konfigurationsverzeichnis:
    • sudo cp pki/ca.crt /etc/openvpn/
      sudo cp pki/issued/server.crt /etc/openvpn/
      sudo cp pki/private/server.key /etc/openvpn/
  4. Diffie-Hellman-Parameter generieren:

    Dies kann eine Weile dauern (5-10 Minuten oder länger, je nach System). Das ist für einen sicheren Schlüsselaustausch notwendig.

    ./easyrsa gen-dh
    sudo cp pki/dh.pem /etc/openvpn/
  5. TLS-Authentifizierungsschlüssel erstellen (HMAC):

    Dies fügt eine zusätzliche Sicherheitsebene hinzu, um DoS-Angriffe und Port-Scans zu verhindern.

    openvpn --genkey --secret /etc/openvpn/ta.key
  6. OpenVPN-Server-Konfiguration erstellen:

    Erstelle die Hauptkonfigurationsdatei für den Server.

    sudo nano /etc/openvpn/server.conf

    Füge den folgenden Inhalt ein:

    
    port 1194
    proto udp
    dev tun
    
    ca ca.crt
    cert server.crt
    key server.key
    dh dh.pem
    tls-auth ta.key 0 # This file is for HMAC authentication
    cipher AES-256-CBC
    auth SHA256
    
    server 10.8.0.0 255.255.255.0 # VPN Subnetz (nicht mit deinem LAN kollidieren!)
    ifconfig-pool-persist ipp.txt
    
    push "redirect-gateway def1 bypass-dhcp" # Leitet allen Traffic über den VPN
    push "dhcp-option DNS 8.8.8.8" # Google DNS (Optional: eigenen DNS-Server angeben)
    push "dhcp-option DNS 8.8.4.4"
    
    keepalive 10 120
    comp-lzo # Datenkompression (optional)
    
    persist-key
    persist-tun
    
    status openvpn-status.log
    log-append openvpn.log
    verb 3
    explicit-exit-notify 1
    
    # Optional: Berechtigungen für den OpenVPN-Prozess einschränken
    user nobody
    group nogroup
                    

    Speichere die Datei.

  7. IP-Forwarding aktivieren:

    Damit der Server Pakete zwischen dem VPN-Subnetz und dem Internet routen kann.

    sudo nano /etc/sysctl.conf

    Suche die Zeile `#net.ipv4.ip_forward=1` und entferne das `#` davor:

    net.ipv4.ip_forward=1

    Speichern, schließen und die Änderungen anwenden:

    sudo sysctl -p
  8. Firewall (UFW) konfigurieren:

    Erlaube den OpenVPN-Port (standardmäßig UDP 1194) und aktiviere NAT für das VPN-Subnetz.

    • Öffne den OpenVPN-Port:
    • sudo ufw allow 1194/udp
    • Aktiviere NAT für das VPN-Subnetz:

      Öffne die UFW-Regeldatei `before.rules`:

      sudo nano /etc/ufw/before.rules

      Füge am Anfang der Datei, *nach* den Kommentaren und *vor* der Zeile `*filter`, Folgendes hinzu (ersetze `eth0` durch den Namen deines öffentlichen Netzwerkinterfaces, z.B. `enp0s3`):

      
      # START OPENVPN RULES
      # NAT table rules
      *nat
      :POSTROUTING ACCEPT [0:0]
      # Allow traffic from OpenVPN client to eth0 (change eth0 to your public interface)
      -A POSTROUTING -s 10.8.0.0/24 -o eth0 -j MASQUERADE
      COMMIT
      # END OPENVPN RULES
                              

      Speichern und schließen.

      Passe auch die UFW-Standard-FORWARD-Policy an:

      sudo nano /etc/default/ufw

      Suche `DEFAULT_FORWARD_POLICY="DROP"` und ändere es zu:

      DEFAULT_FORWARD_POLICY="ACCEPT"

      Speichern und schließen.

    • UFW neu laden:
    • sudo ufw disable
      sudo ufw enable

      Bestätige mit `y`.

  9. OpenVPN-Dienst starten und aktivieren:
    sudo systemctl start openvpn@server
    sudo systemctl enable openvpn@server

    Überprüfe den Status:

    sudo systemctl status openvpn@server

    Es sollte "active (running)" sein.

  10. Client-Zertifikate und -Schlüssel erstellen:

    Für jeden Client benötigst du ein eigenes Zertifikat und einen Schlüssel.

    • Gehe zurück ins Easy-RSA-Verzeichnis:
    • cd /etc/openvpn/easy-rsa
    • Erstelle eine Anfrage für den Client (ersetze `client1` durch einen eindeutigen Namen):
    • ./easyrsa gen-req client1 nopass
    • Signiere die Client-Anfrage:
    • ./easyrsa sign-req client client1

      Bestätige mit "yes".

  11. Client-Konfigurationsdatei erstellen:

    Erstelle eine `.ovpn`-Datei für den Client. Diese enthält alle benötigten Zertifikate und Konfigurationen.

    nano ~/client1.ovpn

    Füge den folgenden Inhalt ein (ersetze `DEINE_SERVER_IP` durch die öffentliche IP oder DynDNS-Adresse deines VPN-Servers):

    
    client
    dev tun
    proto udp
    remote DEINE_SERVER_IP 1194 # IP-Adresse/Domain deines VPN-Servers
    resolv-retry infinite
    nobind
    
    # Zertifikate (werden direkt in die Datei eingefügt)
    #ca
    #cert
    #key
    #tls-auth
    
    persist-key
    persist-tun
    cipher AES-256-CBC
    auth SHA256
    comp-lzo
    
    verb 3
    explicit-exit-notify 1
    
    <ca>
        # Füge hier den Inhalt von /etc/openvpn/ca.crt ein
    </ca<
    <cert>
        # Füge hier den Inhalt von /etc/openvpn/easy-rsa/pki/issued/client1.crt ein
    </cert>
    <key>
        # Füge hier den Inhalt von /etc/openvpn/easy-rsa/pki/private/client1.key ein
    </key>
    <tls-auth>
        # Füge hier den Inhalt von /etc/openvpn/ta.key ein
    </tls-auth>
                    

    Ersetze die Platzhalter `<ca>` etc. durch den tatsächlichen Inhalt der jeweiligen Dateien. Du kannst die Inhalte der Dateien mit `cat /pfad/zur/datei` anzeigen und kopieren.

    Beispiel für das Einfügen von `ca.crt`:

    cat /etc/openvpn/ca.crt

    Kopiere den Inhalt (inklusive `-----BEGIN CERTIFICATE-----` und `-----END CERTIFICATE-----`) in die `.ovpn`-Datei.

    Mache dies für `client1.crt`, `client1.key` und `ta.key`.

    Speichere die `client1.ovpn`-Datei.

  12. Client-Konfiguration übertragen und testen:

    Kopiere die `client1.ovpn`-Datei auf den Client-Computer. Auf Windows-Clients benötigst du den OpenVPN-Client (openvpn.net/client/client-downloads/). Unter Linux kannst du den `openvpn`-Befehl im Terminal nutzen.

    Starte die Verbindung mit dem Client und teste, ob du Zugriff auf das entfernte Netzwerk hast und deine externe IP-Adresse die des VPN-Servers ist.

    sudo openvpn --config /pfad/zu/client1.ovpn

Dein OpenVPN-Server ist nun einsatzbereit! Achte auf die sichere Speicherung deiner Zertifikate und Schlüssel.

DHCP-Server unter Debian Linux einrichten

Ein DHCP-Server (Dynamic Host Configuration Protocol) ist unerlässlich, um Geräten in einem Netzwerk automatisch IP-Adressen, Subnetzmasken, Gateways und DNS-Server zuzuweisen. Dies vereinfacht die Netzwerkverwaltung erheblich. Diese Anleitung führt dich durch die Installation und Konfiguration des ISC DHCP-Servers unter Debian Linux.

Voraussetzungen:

  • Ein Debian-basiertes Linux-System (z.B. Debian 11/12, Ubuntu LTS)
  • Benutzer mit sudo-Rechten
  • Eine statische IP-Adresse auf der Netzwerkschnittstelle, die der DHCP-Server bedienen soll (z.B. 192.168.1.1/24)
  • Internetzugang (für die Installation)
  • Optional: Firewall (UFW) konfiguriert

Schritt-für-Schritt-Anleitung:

  1. System aktualisieren und DHCP-Server installieren:

    Aktualisiere zuerst dein System und installiere dann das isc-dhcp-server Paket.

    sudo apt update && sudo apt upgrade -y
    sudo apt install isc-dhcp-server -y
  2. Netzwerkschnittstelle für DHCP konfigurieren:

    Du musst dem DHCP-Server mitteilen, auf welcher Netzwerkschnittstelle er auf Anfragen lauschen soll. Bearbeite die Datei /etc/default/isc-dhcp-server.

    sudo nano /etc/default/isc-dhcp-server

    Suche die Zeile, die mit `INTERFACESv4=` beginnt (und ggf. `INTERFACESv6=`) und füge den Namen deiner Netzwerkschnittstelle hinzu (z.B. `enp0s3`).

    INTERFACESv4="enp0s3"

    Speichern und schließen.

    WICHTIG: Stelle sicher, dass die angegebene Schnittstelle eine **statische IP-Adresse** im Netzwerkbereich hat, den der DHCP-Server verwalten soll. Andernfalls kann der DHCP-Server nicht korrekt starten.

  3. DHCP-Konfigurationsdatei bearbeiten (`dhcpd.conf`):

    Dies ist die Hauptkonfigurationsdatei, in der du die IP-Adressbereiche, DNS-Server und andere Optionen definierst. Erstelle zuerst ein Backup der Originaldatei.

    sudo cp /etc/dhcp/dhcpd.conf /etc/dhcp/dhcpd.conf.bak
    sudo nano /etc/dhcp/dhcpd.conf

    Lösche den gesamten Inhalt der Datei oder kommentiere ihn aus und füge deine Konfiguration ein. Hier ist ein Beispiel für ein einfaches Subnetz (ersetze die Werte durch deine Netzwerkparameter):

    
    # Minimalbeispiel für einen DHCP-Server
    default-lease-time 600;
    max-lease-time 7200;
    
    # Dies ist wichtig, wenn dein DHCP-Server nicht der einzige im Netzwerk ist.
    # Wenn ja, setze es auf 'authoritative'.
    authoritative; 
    
    # Log-Anfragen
    log-facility local7;
    
    # DNS-Update-Stil (standardmäßig "none")
    ddns-update-style none;
    
    # Ein Subnetz, das vom DHCP-Server verwaltet wird
    subnet 192.168.1.0 netmask 255.255.255.0 {
        # Adressbereich, aus dem IP-Adressen vergeben werden
        range 192.168.1.100 192.168.1.200; 
        
        # Standard-Gateway (Router-IP)
        option routers 192.168.1.1; 
        
        # DNS-Server (z.B. dein Server selbst, Google DNS, Pi-hole)
        option domain-name-servers 8.8.8.8, 8.8.4.4; 
        
        # Domainname für Clients
        option domain-name "meine-domain.local"; 
        
        # Lease-Zeiten überschreiben Standardwerte
        # default-lease-time 600; 
        # max-lease-time 7200;
    }
    
    # Optional: Statische IP-Zuweisung für bestimmte Geräte (nach MAC-Adresse)
    # host meinpc {
    #   hardware ethernet 00:11:22:33:44:55;
    #   fixed-address 192.168.1.250;
    # }
                    

    Speichern und schließen.

  4. DHCP-Dienst starten und aktivieren:

    Nachdem die Konfiguration abgeschlossen ist, starte den DHCP-Server und aktiviere ihn für den Systemstart.

    sudo systemctl restart isc-dhcp-server
    sudo systemctl enable isc-dhcp-server

    Überprüfe den Status, um sicherzustellen, dass keine Fehler vorliegen:

    sudo systemctl status isc-dhcp-server

    Du kannst auch die Log-Dateien überprüfen, um Fehler beim Start zu finden:

    sudo journalctl -u isc-dhcp-server --no-pager
    sudo tail -f /var/log/syslog
  5. Firewall (UFW) konfigurieren (optional, aber empfohlen):

    Falls du UFW verwendest, musst du den DHCP-Port (UDP 67 und 68) freigeben.

    sudo ufw allow 67/udp
    sudo ufw allow 68/udp
    sudo ufw reload
  6. Testen des DHCP-Servers:

    Verbinde einen Client (PC, Smartphone, VM) mit dem Netzwerk, das vom DHCP-Server bedient wird. Stelle sicher, dass der Client so konfiguriert ist, dass er seine IP-Adresse automatisch bezieht.

    • Auf einem Windows-Client: `ipconfig /release` gefolgt von `ipconfig /renew` in der Eingabeaufforderung.
    • Auf einem Linux-Client: `sudo dhclient -r` gefolgt von `sudo dhclient` oder Neustart des Netzwerkdienstes.

    Überprüfe dann die zugewiesene IP-Adresse und die Netzwerkkonfiguration auf dem Client. Du solltest eine IP aus dem konfigurierten Bereich sowie die von deinem DHCP-Server angebotenen DNS-Server und das Gateway sehen.

  7. DHCP-Leases überprüfen:

    Der DHCP-Server speichert die zugewiesenen Adressen (Leases) in einer Datei.

    cat /var/lib/dhcp/dhcpd.leases

    Hier siehst du, welche Geräte welche IP-Adressen zugewiesen bekommen haben und wann die Leases ablaufen.

Dein DHCP-Server ist nun funktionsbereit und automatisiert die IP-Adressvergabe in deinem Netzwerk!

DNS-Server mit BIND9 unter Debian Linux einrichten

Ein DNS-Server (Domain Name System) ist ein fundamentaler Netzwerkdienst, der Hostnamen in IP-Adressen übersetzt und umgekehrt. BIND (Berkeley Internet Name Domain) ist die am weitesten verbreitete DNS-Software. Diese Anleitung führt dich durch die Installation und Konfiguration eines grundlegenden Caching- und Forwarding-DNS-Servers unter Debian Linux, der auch lokale Zonen auflösen kann.

Voraussetzungen:

  • Ein Debian-basiertes Linux-System (z.B. Debian 11/12, Ubuntu LTS)
  • Benutzer mit sudo-Rechten
  • Eine statische IP-Adresse auf der Netzwerkschnittstelle
  • Internetzugang (für die Installation und Auflösung externer Domains)
  • Optional: Firewall (UFW) konfiguriert

Schritt-für-Schritt-Anleitung:

  1. System aktualisieren und BIND9 installieren:

    Aktualisiere dein System und installiere das bind9 Paket.

    sudo apt update && sudo apt upgrade -y
    sudo apt install bind9 bind9utils bind9-doc -y
  2. Firewall (UFW) konfigurieren (optional, aber empfohlen):

    Wenn du UFW verwendest, musst du den DNS-Port (UDP und TCP 53) freigeben.

    sudo ufw allow 53/udp
    sudo ufw allow 53/tcp
    sudo ufw reload
  3. Basiskonfiguration des DNS-Servers (`named.conf.options`):

    Dies ist die zentrale Datei für globale DNS-Einstellungen wie Forwarder und Logging.

    sudo nano /etc/bind/named.conf.options

    Füge den folgenden Inhalt in den `options { ... };` Block ein oder passe ihn an. Lösche vorhandene `forwarders` oder kommentiere sie aus.

    
    options {
        directory "/var/cache/bind";
    
        // Ermöglicht Anfragen von localhost und deinem lokalen Netzwerk
        allow-query { localhost; 192.168.1.0/24; }; // Ersetze 192.168.1.0/24 durch dein lokales Netzwerk
    
        // Leitet unbekannte Anfragen an externe DNS-Server weiter (z.B. Google DNS)
        forwarders {
            8.8.8.8;
            8.8.4.4;
        };
    
        dnssec-validation auto;
    
        // Optional: Logging-Einstellungen
        // logging {
        //     category queries { default_syslog; };
        // };
    
        recursion yes; // Ermöglicht rekursive Abfragen (Clients können beliebige Domains auflösen)
        listen-on { any; }; // Lauscht auf allen Interfaces. Optional: listen-on { 192.168.1.10; }; für spezifische IP
    };
                    

    Speichern und schließen.

  4. Lokale Forward-Zone für deine eigene Domain erstellen (optional):

    Wenn du eine eigene interne Domain (z.B. `meinefirma.local`) hast und Hostnamen in dieser Domain auflösen möchtest. Erstelle einen Eintrag in `named.conf.local`.

    sudo nano /etc/bind/named.conf.local

    Füge Folgendes hinzu:

    
    zone "meinefirma.local" { // Ersetze "meinefirma.local" durch deine Domain
        type master;
        file "/etc/bind/db.meinefirma.local"; // Pfad zur Zonendatei
    };
                    

    Speichern und schließen.

    Erstelle nun die Zonendatei selbst, basierend auf dem Beispiel für eine Standard-Zonendatei:

    sudo nano /etc/bind/db.meinefirma.local

    Füge den Inhalt ein (ersetze die IP-Adressen und Domainnamen):

    
    $TTL    604800
    @ IN SOA ns1.meinefirma.local. admin.meinefirma.local. (
                  3         ; Serial
             604800         ; Refresh
              86400         ; Retry
            2419200         ; Expire
             604800 )       ; Negative Cache TTL
    ;
    @               IN      NS      ns1.meinefirma.local.
    ns1             IN      A       192.168.1.10   ; IP-Adresse deines DNS-Servers
    webserver       IN      A       192.168.1.20   ; Beispiel: Webserver-IP
    server          IN      A       192.168.1.30   ; Beispiel: Weiterer Server
                    

    Speichern und schließen.

  5. Berechtigungen für Zonendatei setzen:
    sudo chown root:bind /etc/bind/db.meinefirma.local
    sudo chmod 644 /etc/bind/db.meinefirma.local
  6. BIND-Dienst neu starten und aktivieren:

    Nach den Konfigurationsänderungen musst du den BIND-Dienst neu starten.

    sudo systemctl restart bind9
    sudo systemctl enable bind9

    Überprüfe den Status des Dienstes:

    sudo systemctl status bind9

    Wenn es Fehler gibt, überprüfe die Logs:

    sudo journalctl -u bind9 --no-pager
    sudo tail -f /var/log/syslog
  7. DNS-Server auf dem Host-System testen:

    Ändere die `/etc/resolv.conf` deines Servers, um ihn selbst als DNS-Server zu nutzen (oder füge ihn hinzu).

    sudo nano /etc/resolv.conf

    Ändere die `nameserver`-Zeile auf die IP-Adresse deines DNS-Servers (z.B. `127.0.0.1` wenn es der Server selbst ist, oder seine statische LAN-IP).

    nameserver 127.0.0.1

    Testen der Auflösung:

    dig google.com
    dig meinefirma.local
    dig webserver.meinefirma.local

    Die Ausgaben sollten die korrekten IP-Adressen zeigen und angeben, dass die Abfrage von deinem lokalen BIND-Server beantwortet wurde (`SERVER:` sollte die IP deines Servers sein).

  8. Clients konfigurieren:

    Konfiguriere deine Clients (PCs, Laptops, andere Server) so, dass sie deinen neuen DNS-Server verwenden. Dies kann manuell in den Netzwerkeinstellungen geschehen oder automatisch über deinen DHCP-Server (indem du die Option `domain-name-servers` in der `dhcpd.conf` anpasst, falls du einen DHCP-Server betreibst).

Dein BIND9 DNS-Server ist nun eingerichtet und kann Hostnamen auflösen und für dein lokales Netzwerk verwalten!

Verwaltung von Gruppenrichtlinien (GPOs) im Windows Server Active Directory

Gruppenrichtlinienobjekte (GPOs) sind das Herzstück der zentralen Konfiguration und Verwaltung von Benutzer- und Computerumgebungen in einer Windows Active Directory (AD)-Domäne. Mit GPOs kannst du vom Desktophintergrund bis zu komplexen Sicherheitsrichtlinien alles steuern. Diese Anleitung führt dich durch die Grundlagen der GPO-Erstellung, -Verknüpfung und -Bearbeitung.

Voraussetzungen:

  • Ein Windows Server (z.B. 2019, 2022) mit installierter Active Directory Domain Services (AD DS)-Rolle und Domain Controller-Funktion
  • Administratorrechte auf dem Domain Controller
  • Grundkenntnisse der Active Directory-Struktur (Benutzer, Computer, Organisationseinheiten)

Schritt-für-Schritt-Anleitung:

  1. Gruppenrichtlinienverwaltung öffnen:

    Dies ist das zentrale Tool zur Verwaltung aller GPOs in deiner Domäne.

    • Öffne den **Server-Manager**.
    • Gehe zu **Tools** und wähle **Gruppenrichtlinienverwaltung**.
    • Alternativ: Drücke `Win + R`, gib `gpmc.msc` ein und drücke Enter.
  2. Eine neue GPO erstellen:

    GPOs werden erstellt und dann mit einer Domäne oder Organisationseinheit (OU) verknüpft.

    • Erweitere im linken Bereich deine Gesamtstruktur und dann deine Domäne (z.B. `deinefirma.local`).
    • Rechtsklick auf den Ordner **Gruppenrichtlinienobjekte**.
    • Wähle **Neu**.
    • Gib einen **Namen** für das neue GPO ein (z.B. "Desktop-Hintergrund-Richtlinie" oder "Sicherheit_Passwortrichtlinie") und klicke **OK**.
    • Das GPO ist nun erstellt, aber noch nicht aktiv, da es nicht verknüpft ist.
  3. GPO mit einer Organisationseinheit (OU) oder Domäne verknüpfen:

    Eine GPO wird erst aktiv, wenn sie mit einem Container (Domäne, OU, Site) verknüpft wird. Verknüpfe GPOs immer so nah wie möglich an den betroffenen Objekten.

    • Rechtsklick auf die OU oder Domäne, auf die die GPO angewendet werden soll (z.B. deine "Benutzer"-OU oder die gesamte Domäne).
    • Wähle **Vorhandenes GPO verknüpfen...**.
    • Wähle die eben erstellte GPO aus der Liste aus und klicke **OK**.
    • Das GPO ist nun verknüpft und wird auf alle Benutzer und Computer innerhalb dieser OU (und deren Unter-OUs) angewendet.
  4. Eine GPO bearbeiten (Beispiel: Desktop-Hintergrund festlegen):

    Jetzt legst du die eigentlichen Einstellungen im GPO fest.

    • Wähle im linken Bereich das verknüpfte GPO aus (z.B. unter der OU).
    • Rechtsklick auf das GPO und wähle **Bearbeiten...**. Dies öffnet den **Gruppenrichtlinienverwaltungs-Editor**.
    • Im Editor gibt es zwei Hauptbereiche:
      • **Computerkonfiguration:** Einstellungen für Computerobjekte (z.B. Sicherheitseinstellungen, Softwareinstallation). Diese werden beim Start des Computers angewendet.
      • **Benutzerkonfiguration:** Einstellungen für Benutzerobjekte (z.B. Desktophintergrund, Startmenü). Diese werden bei der Benutzeranmeldung angewendet.
    • **Beispiel Desktophintergrund (Benutzerkonfiguration):**
      • Navigiere zu **Benutzerkonfiguration** > **Richtlinien** > **Administrative Vorlagen** > **Desktop** > **Desktop**.
      • Doppelklicke auf die Einstellung **Desktophintergrund**.
      • Wähle **Aktiviert**.
      • Gib unter **Name des Desktophintergrunds** den UNC-Pfad zu einem Bild auf einer Netzwerkfreigabe an (z.B. `\\server\share\background.jpg`).
      • Wähle unter **Desktophintergrundstil** die gewünschte Option (z.B. "Füllen").
      • Klicke **Anwenden** > **OK**.
    • Schließe den Gruppenrichtlinienverwaltungs-Editor.
  5. Gruppenrichtlinien auf Clients/Servern aktualisieren:

    Damit die Änderungen sofort wirksam werden, kannst du ein Update erzwingen.

    • **Auf dem Client-PC oder Server:**
      gpupdate /force

      Starte den Computer neu oder melde den Benutzer ab und wieder an, falls die Richtlinie dies erfordert oder die Änderungen nicht sofort sichtbar sind.

    • **Auf dem Domain Controller (optional, für GPOs im Computerkonfigurations-Bereich):**
      gpupdate /force
  6. GPO-Ergebnisse überprüfen (Troubleshooting):

    Der Befehl gpresult hilft dir zu überprüfen, welche GPOs auf einen Benutzer oder Computer angewendet wurden.

    • Öffne eine Kommandozeile (CMD) oder PowerShell **als Administrator** auf dem Client oder Server.
    • Für Benutzer- und Computerrichtlinien:
      gpresult /R
    • Für detaillierte HTML-Berichte:
      gpresult /H C:\temp\gpreport.html

      Öffne die `gpreport.html` im Browser, um eine umfassende Übersicht aller angewendeten GPOs und deren Einstellungen zu erhalten.

  7. Vererbung blockieren oder Erzwingen (Enforced):

    GPOs werden hierarchisch angewendet. Du kannst dieses Verhalten beeinflussen:

    • **Vererbung blockieren:** Rechtsklick auf eine OU > **Vererbung blockieren**. Dies verhindert, dass GPOs von übergeordneten OUs angewendet werden (außer erzwungene GPOs).
    • **Erzwingen (Enforced):** Rechtsklick auf ein verknüpftes GPO > **Erzwungen**. Diese GPO wird immer angewendet, auch wenn die Vererbung auf einer untergeordneten OU blockiert ist. Erzwingung überschreibt Blockierung.

Die effektive Nutzung von Gruppenrichtlinien ist ein mächtiges Werkzeug für die zentrale Administration in Windows-Umgebungen und ermöglicht eine konsistente und sichere Systemlandschaft.

Arduino: Eine LED blinken lassen

Das "Blink"-Programm ist der Klassiker beim Einstieg in die Welt des Arduino. Es ist das "Hello World!" der Mikrocontroller und demonstriert die grundlegende Steuerung digitaler Ausgänge. Diese Anleitung führt dich Schritt für Schritt durch den Aufbau der Schaltung und das Hochladen des Codes auf dein Arduino-Board.

Voraussetzungen:

  • Ein Arduino-Board (z.B. Arduino Uno)
  • Ein USB-Kabel (passend für dein Arduino-Board)
  • Eine LED (Leuchtdiode)
  • Ein Vorwiderstand für die LED (ca. 220 Ohm bis 330 Ohm)
  • Ein Steckbrett (Breadboard)
  • Verbindungsdrähte (Jumper Cables)
  • Die Arduino IDE (Integrierte Entwicklungsumgebung) auf deinem Computer installiert

Schritt-für-Schritt-Anleitung:

  1. Arduino IDE installieren:

    Lade die aktuelle Version der Arduino IDE von der offiziellen Arduino-Website herunter und installiere sie auf deinem Betriebssystem (Windows, macOS, Linux).

  2. Schaltung aufbauen:

    Baue die folgende Schaltung auf deinem Steckbrett auf:

    • Stecke die **LED** auf das Steckbrett. Die längere Seite der LED ist der Pluspol (Anode), die kürzere der Minuspol (Kathode).
    • Verbinde den **Minuspol (kürzere Seite) der LED** über den **Vorwiderstand** mit dem **GND (Ground)-Pin** deines Arduino-Boards. Der Widerstand ist entscheidend, um die LED vor zu hohem Strom zu schützen.
    • Verbinde den **Pluspol (längere Seite) der LED** mit einem digitalen Ausgangspin deines Arduino-Boards, z.B. **Pin 13**. (Pin 13 hat oft eine eingebaute LED, was das Testen erleichtert.)

    (Optional: Hier könnte ein Bild/Diagramm der Schaltung hilfreich sein, das du später selbst einfügen kannst.)

  3. Arduino IDE starten und Code laden:

    Öffne die Arduino IDE.

    • Du kannst das Beispielprogramm laden: Gehe zu **Datei** > **Beispiele** > **01.Basics** > **Blink**.
    • Alternativ kannst du den folgenden Code in ein neues Sketch-Fenster kopieren:
    
    // Definiere den Pin, an dem die LED angeschlossen ist
    const int ledPin = 13;
    
    // Die setup()-Funktion wird einmal ausgeführt, wenn das Sketch startet
    void setup() {
      // Initialisiere den digitalen Pin als Ausgang.
      pinMode(ledPin, OUTPUT);
    }
    
    // Die loop()-Funktion wird immer und immer wieder ausgeführt
    void loop() {
      digitalWrite(ledPin, HIGH);   // Schalte die LED EIN (HIGH ist die Spannungsebene)
      delay(1000);                  // Warte für eine Sekunde (1000 Millisekunden)
      digitalWrite(ledPin, LOW);    // Schalte die LED AUS, indem du die Spannung LOW setzt
      delay(1000);                  // Warte für eine Sekunde
    }
                    
  4. Board und Port auswählen:

    Verbinde dein Arduino-Board über das USB-Kabel mit deinem Computer.

    • Gehe in der Arduino IDE zu **Werkzeuge** > **Board** und wähle dein spezifisches Arduino-Board aus (z.B. "Arduino Uno").
    • Gehe dann zu **Werkzeuge** > **Port** und wähle den seriellen Port aus, der mit deinem Arduino verbunden ist (auf Windows ist das meist "COMx", auf Linux/macOS "/dev/ttyUSBx" oder "/dev/cu.usbmodemxxx").
  5. Sketch hochladen:

    Klicke auf den **Pfeil-Button** (Hochladen) in der oberen linken Ecke der Arduino IDE. Die IDE kompiliert den Code und lädt ihn auf dein Arduino-Board hoch.

    Während des Hochladens siehst du Statusmeldungen in der Konsole der IDE. Wenn der Upload erfolgreich war, leuchten die TX/RX-LEDs auf dem Arduino kurz auf, und die LED in deiner Schaltung (oder die eingebaute LED auf Pin 13) sollte anfangen zu blinken!

Herzlichen Glückwunsch! Du hast erfolgreich dein erstes Arduino-Projekt umgesetzt und eine LED zum Blinken gebracht.

ESP32/ESP8266: WLAN-Verbindung und Daten senden

Der ESP32 und ESP8266 sind beliebte Microcontroller, die integriertes WLAN bieten und sich daher hervorragend für IoT-Projekte eignen. Diese Anleitung zeigt dir, wie du deinen ESP mit einem WLAN-Netzwerk verbindest und einfache Daten (z.B. einen Wert) per HTTP GET-Anfrage an einen Webserver sendest.

Voraussetzungen:

  • Ein ESP32- oder ESP8266-Entwicklungsboard
  • Ein USB-Kabel (passend für dein Board)
  • Die Arduino IDE auf deinem Computer installiert
  • **Zusätzlich:** Board-Manager-URLs für ESP32/ESP8266 in der Arduino IDE eingerichtet (siehe Schritt 1)
  • Ein WLAN-Netzwerk mit Internetzugang
  • Optional: Ein einfacher Webserver, der GET-Anfragen empfangen kann (z.B. ein lokaler Python-Server oder ein Online-Dienst wie RequestBin zum Testen)

Schritt-für-Schritt-Anleitung:

  1. Board-Unterstützung in der Arduino IDE installieren:

    Falls noch nicht geschehen, musst du die Boards für ESP32 oder ESP8266 in der Arduino IDE hinzufügen.

    • Gehe zu **Datei** > **Voreinstellungen**.
    • Füge unter "Zusätzliche Boardverwalter-URLs" die entsprechende URL ein:
      • Für **ESP32**: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
      • Für **ESP8266**: http://arduino.esp8266.com/stable/package_esp8266com_index.json

      Wenn du beide nutzen möchtest, trenne die URLs mit einem Komma.

    • Gehe zu **Werkzeuge** > **Board** > **Boardverwalter...**.
    • Suche nach "esp32" oder "esp8266" und installiere das jeweilige Paket.
  2. Sketch erstellen und Code eingeben:

    Öffne ein neues Sketch-Fenster in der Arduino IDE und kopiere den folgenden Code hinein. Passe die Platzhalter für `ssid`, `password` und `serverHost` an deine Gegebenheiten an.

    
    #include <WiFi.h> // Für ESP32
    // #include <ESP8266WiFi.h> // Für ESP8266 - kommentiere die obige Zeile aus, wenn du ESP8266 nutzt
    #include <HTTPClient.h>
    
    // Deine WLAN-Anmeldeinformationen
    const char* ssid = "DEIN_WLAN_NAME";
    const char* password = "DEIN_WLAN_PASSWORT";
    
    // Host und Pfad des Servers, an den die Daten gesendet werden
    // Beispiel: Ein einfacher lokaler Python Webserver, der GET-Anfragen empfängt
    // Oder ein RequestBin URL für Tests: https://requestbin.com/
    const char* serverHost = "DEINE_SERVER_IP_ODER_DOMAIN"; // z.B. "192.168.1.100" oder "example.com"
    const int serverPort = 80; // Standard HTTP-Port
    const char* serverPath = "/data_receiver.php"; // Oder ein anderer Pfad, z.B. "/receive_data"
    
    // Eine Beispielvariable, die wir senden wollen
    int sensorValue = 0;
    
    void setup() {
      Serial.begin(115200); // Serielle Kommunikation starten
      delay(100);
    
      Serial.print("Verbinde mit WLAN ");
      Serial.println(ssid);
    
      WiFi.begin(ssid, password); // WLAN-Verbindung aufbauen
    
      while (WiFi.status() != WL_CONNECTED) { // Warten, bis die Verbindung steht
        delay(500);
        Serial.print(".");
      }
    
      Serial.println("");
      Serial.println("WLAN verbunden!");
      Serial.print("IP-Adresse: ");
      Serial.println(WiFi.localIP()); // Zeigt die zugewiesene IP-Adresse an
    }
    
    void loop() {
      // Erhöhe den Wert für den nächsten Sendezyklus
      sensorValue++;
    
      // Baue die URL für die GET-Anfrage
      String url = String("http://") + serverHost + ":" + serverPort + serverPath + "?value=" + sensorValue;
    
      Serial.print("Sende Daten an: ");
      Serial.println(url);
    
      // HTTP-Client initialisieren
      HTTPClient http;
      http.begin(url); // Starte die HTTP-Verbindung
    
      // GET-Anfrage senden
      int httpCode = http.GET();
    
      // Überprüfe den HTTP-Statuscode
      if (httpCode > 0) {
        // HTTP-Header und Antwortinhalt ausgeben
        Serial.printf("[HTTP] GET... code: %d\n", httpCode);
        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
          String payload = http.getString();
          Serial.println(payload);
        }
      } else {
        Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
      }
    
      http.end(); // Verbindung schließen
    
      // Warte 5 Sekunden, bevor die nächste Anfrage gesendet wird
      delay(5000);
    }
                    

    WICHTIG: Wenn du einen ESP8266 nutzt, kommentiere `#include ` aus und entkommentiere `#include `. Die `HTTPClient` Bibliothek ist für beide verfügbar.

  3. Board und Port auswählen:

    Verbinde dein ESP-Board über das USB-Kabel mit deinem Computer.

    • Gehe in der Arduino IDE zu **Werkzeuge** > **Board** und wähle dein spezifisches ESP32- oder ESP8266-Board aus (z.B. "ESP32 Dev Module" oder "NodeMCU 1.0 (ESP-12E Module)").
    • Gehe dann zu **Werkzeuge** > **Port** und wähle den seriellen Port aus, der mit deinem ESP verbunden ist.
  4. Sketch hochladen:

    Klicke auf den **Pfeil-Button** (Hochladen) in der oberen linken Ecke der Arduino IDE. Während des Hochladens kann es sein, dass du die Boot-Taste auf deinem ESP-Board gedrückt halten musst (oft als "BOOT" oder "FLASH" bezeichnet), falls der Upload nicht automatisch startet. Lass die Taste los, sobald der Upload beginnt.

  5. Seriellen Monitor öffnen und testen:

    Nach dem Hochladen öffne den **Seriellen Monitor** in der Arduino IDE (Symbol mit der Lupe oben rechts oder **Werkzeuge** > **Serieller Monitor**). Wähle die Baudrate **115200**.

    Du solltest sehen, wie dein ESP versucht, sich mit dem WLAN zu verbinden, die zugewiesene IP-Adresse anzeigt und dann alle 5 Sekunden Daten an den konfigurierten Webserver sendet. Auf dem Webserver solltest du die eingehenden GET-Anfragen sehen.

    Wenn du einen simplen Python-Webserver zum Testen nutzen möchtest, kannst du folgendes Python-Skript (z.B. `simple_server.py`) ausführen:

    
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import urllib.parse
    
    class MyHandler(BaseHTTPRequestHandler):
        def do_GET(self):
            self.send_response(200)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
    
            parsed_path = urllib.parse.urlparse(self.path)
            query_params = urllib.parse.parse_qs(parsed_path.query)
    
            response_message = f"GET Anfrage empfangen. Pfad: {parsed_path.path}"
            if 'value' in query_params:
                received_value = query_params['value'][0]
                response_message += f", Wert: {received_value}"
    
            print(f"[{self.client_address[0]}] {response_message}")
            self.wfile.write(response_message.encode('utf-8'))
    
    def run_server():
        server_address = ('', 80) # Auf allen verfügbaren IPs auf Port 80 lauschen
        httpd = HTTPServer(server_address, MyHandler)
        print(f"Starte HTTP-Server auf Port 80...")
        httpd.serve_forever()
    
    if __name__ == "__main__":
        run_server()
                    

    Dieses Skript speicherst du als `simple_server.py` und startest es im Terminal deines Servers mit `python3 simple_server.py`. Achte darauf, dass Port 80 frei ist oder ändere ihn im Skript und im ESP-Code.

Du hast nun die Grundlagen gelernt, um deine ESP-Boards in Netzwerke einzubinden und Daten an Server zu senden – ein wichtiger Schritt für IoT-Projekte!

LEMP-Stack (Nginx, MariaDB, PHP-FPM) mit Let's Encrypt SSL einrichten

Ein LEMP-Stack (Linux, Nginx, MariaDB/MySQL, PHP-FPM) ist eine weit verbreitete und leistungsstarke Plattform zum Hosten von dynamischen Webanwendungen. Diese Anleitung führt dich durch die Installation und Konfiguration der Komponenten sowie die Absicherung mit einem kostenlosen SSL-Zertifikat von Let's Encrypt.

Voraussetzungen:

  • Ein Debian-basiertes Linux-System (z.B. Debian 11/12, Ubuntu LTS)
  • Benutzer mit sudo-Rechten
  • Internetzugang auf dem Server
  • Eine registrierte Domain (z.B. deinedomain.de) mit einem A-Record, der auf die öffentliche IP-Adresse deines Servers zeigt
  • Firewall (z.B. UFW) konfiguriert (Ports 80 und 443 müssen offen sein)

Schritt-für-Schritt-Anleitung:

  1. System aktualisieren und Nginx installieren:

    Nginx ist ein leistungsstarker, ereignisbasierter Webserver.

    sudo apt update && sudo apt upgrade -y
    sudo apt install nginx -y

    Aktiviere Nginx und überprüfe den Status:

    sudo systemctl enable nginx
    sudo systemctl start nginx
    sudo systemctl status nginx

    Erlaube HTTP- und HTTPS-Traffic in der Firewall (falls UFW verwendet wird):

    sudo ufw allow 'Nginx Full'
    sudo ufw reload

    Teste im Browser, ob die Nginx-Standardseite unter der IP-Adresse deines Servers erreichbar ist.

  2. MariaDB (MySQL-Server) installieren:

    MariaDB ist ein Open-Source-Datenbankserver und eine beliebte Alternative zu MySQL.

    sudo apt install mariadb-server mariadb-client -y

    Führe das Sicherheitsskript aus, um die Installation abzusichern (Root-Passwort setzen, anonyme Benutzer entfernen, Remote-Login deaktivieren etc.).

    sudo mysql_secure_installation

    Folge den Anweisungen. Es wird empfohlen, ein starkes Root-Passwort zu setzen und alle anderen Sicherheitsfragen mit 'Y' zu beantworten.

  3. PHP und PHP-FPM installieren:

    PHP-FPM (FastCGI Process Manager) ist der PHP-Interpreter, der Nginx die Verarbeitung von PHP-Skripten ermöglicht.

    sudo apt install php-fpm php-mysql php-cli php-curl php-gd php-mbstring php-xml php-zip -y

    Aktiviere PHP-FPM und überprüfe den Status:

    sudo systemctl enable php8.x-fpm
    sudo systemctl start php8.x-fpm
    sudo systemctl status php8.x-fpm

    (Ersetze php8.x-fpm durch deine installierte Version, z.B. php8.2-fpm).

  4. Nginx für PHP konfigurieren (Server Block):

    Erstelle eine Nginx-Konfigurationsdatei für deine Domain.

    sudo nano /etc/nginx/sites-available/deinedomain.conf

    Füge den folgenden Inhalt ein (ersetze deinedomain.de durch deine tatsächliche Domain):

    
    server {
        listen 80;
        listen [::]:80;
        server_name deinedomain.de www.deinedomain.de; # Füge hier deine Domain(s) ein
        root /var/www/deinedomain.de; # Der Document Root für deine Webseite
    
        index index.php index.html index.htm index.nginx-debian.html;
    
        location / {
            try_files $uri $uri/ =404;
        }
    
        location ~ \.php$ {
            include snippets/fastcgi-php.conf;
            fastcgi_pass unix:/var/run/php/php8.x-fpm.sock; # Passe dies an deine PHP-FPM Version an
        }
    
        # Optional: Blockiert den Zugriff auf .htaccess-Dateien (falls vorhanden, auch wenn Nginx sie nicht nutzt)
        location ~ /\.ht {
            deny all;
        }
    }
                    

    Speichern und schließen. Erstelle das Document Root Verzeichnis:

    sudo mkdir -p /var/www/deinedomain.de
    sudo chown -R www-data:www-data /var/www/deinedomain.de
    sudo chmod -R 755 /var/www/deinedomain.de

    Aktiviere den Server Block und teste die Konfiguration:

    sudo ln -s /etc/nginx/sites-available/deinedomain.conf /etc/nginx/sites-enabled/
    sudo nginx -t

    Wenn der Test erfolgreich ist, lade Nginx neu:

    sudo systemctl reload nginx
  5. Certbot (Let's Encrypt Client) installieren:

    Certbot ist das Tool, um SSL-Zertifikate von Let's Encrypt zu erhalten und zu verwalten.

    sudo apt install certbot python3-certbot-nginx -y
  6. SSL-Zertifikat mit Certbot anfordern:

    Lasse Certbot das Zertifikat anfordern und Nginx automatisch konfigurieren.

    sudo certbot --nginx -d deinedomain.de -d www.deinedomain.de

    Folge den Anweisungen: Gib deine E-Mail-Adresse an, stimme den Nutzungsbedingungen zu und entscheide, ob HTTP-Traffic auf HTTPS umgeleitet werden soll (Empfehlung: Redirect).

    Certbot aktualisiert automatisch deine Nginx-Konfiguration (`deinedomain.conf`) und fügt die SSL-Einstellungen und Weiterleitungen hinzu.

  7. Test-PHP-Datei erstellen:

    Erstelle eine einfache PHP-Datei, um die Funktion deines Stacks zu überprüfen.

    sudo nano /var/www/deinedomain.de/info.php

    Füge folgenden Inhalt ein:

    
    <?php
    phpinfo();
    ?>
                    

    Speichern und schließen.

  8. LEMP-Stack testen:

    Öffne deinen Webbrowser und navigiere zu:

    • https://deinedomain.de (Du solltest deine Standard-Nginx-Seite über HTTPS sehen)
    • https://deinedomain.de/info.php (Du solltest die PHP-Info-Seite sehen)

    Überprüfe im Browser, ob das Schloss-Symbol für HTTPS vorhanden ist und das Zertifikat gültig ist.

  9. Automatische Zertifikatserneuerung überprüfen:

    Certbot richtet automatisch einen Cronjob oder Systemd-Timer für die Zertifikatserneuerung ein. Teste ihn manuell:

    sudo certbot renew --dry-run

    Wenn dieser Test erfolgreich ist, werden deine Zertifikate automatisch erneuert.

Dein LEMP-Stack mit Nginx, MariaDB, PHP-FPM und Let's Encrypt SSL ist nun voll funktionsfähig und bereit für die Bereitstellung deiner Webanwendungen!

Server-Monitoring mit Prometheus und Grafana unter Debian Linux einrichten

Ein robustes Monitoring ist entscheidend für den stabilen Betrieb von IT-Infrastrukturen. Prometheus ist ein Open-Source-Monitoring-System, das Metriken sammelt, und Grafana ist ein leistungsstarkes Tool zur Visualisierung dieser Daten. Diese Anleitung führt dich durch die Installation und Grundkonfiguration beider Tools unter Debian Linux, um die Performance und den Zustand deines Servers zu überwachen.

Voraussetzungen:

  • Ein Debian-basiertes Linux-System (z.B. Debian 11/12, Ubuntu LTS)
  • Benutzer mit sudo-Rechten
  • Internetzugang auf dem Server
  • Firewall (z.B. UFW) konfiguriert (Ports 9090, 3000 und 9100 müssen offen sein)

Schritt-für-Schritt-Anleitung:

  1. Prometheus installieren:

    Prometheus sammelt die Metriken. Wir laden die aktuelle Version herunter und richten sie als Dienst ein.

    • Benutzer und Verzeichnisse erstellen:
    • sudo useradd --no-create-home --shell /bin/false prometheus
      sudo mkdir /etc/prometheus
      sudo mkdir /var/lib/prometheus
      sudo chown prometheus:prometheus /var/lib/prometheus
    • Prometheus herunterladen und entpacken:

      Besuche die Prometheus Download-Seite, um die neueste Version zu finden (achte auf die Linux AMD64 Version).

      cd /tmp
      wget https://github.com/prometheus/prometheus/releases/download/vX.Y.Z/prometheus-X.Y.Z.linux-amd64.tar.gz

      (Ersetze `X.Y.Z` durch die aktuelle Versionsnummer)

      tar xvf prometheus-X.Y.Z.linux-amd64.tar.gz
      sudo cp prometheus-X.Y.Z.linux-amd64/prometheus /usr/local/bin/
      sudo cp prometheus-X.Y.Z.linux-amd64/promtool /usr/local/bin/
      sudo chown prometheus:prometheus /usr/local/bin/prometheus
      sudo chown prometheus:prometheus /usr/local/bin/promtool
      sudo cp -r prometheus-X.Y.Z.linux-amd64/consoles /etc/prometheus
      sudo cp -r prometheus-X.Y.Z.linux-amd64/console_libraries /etc/prometheus
      sudo chown -R prometheus:prometheus /etc/prometheus/consoles
      sudo chown -R prometheus:prometheus /etc/prometheus/console_libraries
    • Prometheus Konfigurationsdatei erstellen:
      sudo nano /etc/prometheus/prometheus.yml

      Füge den folgenden Inhalt ein:

      
      global:
        scrape_interval: 15s # Wie oft Metriken gesammelt werden
        evaluation_interval: 15s # Wie oft Regeln ausgewertet werden
      
      scrape_configs:
        - job_name: 'prometheus' # Prometheus überwacht sich selbst
          static_configs:
            - targets: ['localhost:9090']
      
        - job_name: 'node_exporter' # Hier werden die Metriken vom Server selbst gesammelt
          static_configs:
            - targets: ['localhost:9100'] # Später ändern, wenn Node Exporter auf anderem Server läuft
                              

      Speichern und schließen.

      sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
    • Prometheus Systemd-Dienst erstellen:
      sudo nano /etc/systemd/system/prometheus.service

      Füge den folgenden Inhalt ein:

      
      [Unit]
      Description=Prometheus
      Wants=network-online.target
      After=network-online.target
      
      [Service]
      User=prometheus
      Group=prometheus
      Type=simple
      ExecStart=/usr/local/bin/prometheus \
          --config.file /etc/prometheus/prometheus.yml \
          --storage.tsdb.path /var/lib/prometheus/ \
          --web.console.templates=/etc/prometheus/consoles \
          --web.console.libraries=/etc/prometheus/console_libraries
      
      [Install]
      WantedBy=multi-user.target
                              

      Speichern und schließen. Lade Systemd neu, aktiviere und starte den Dienst:

      sudo systemctl daemon-reload
      sudo systemctl enable prometheus
      sudo systemctl start prometheus
      sudo systemctl status prometheus

      Prometheus sollte nun auf Port 9090 erreichbar sein (z.B. `http://DEINE_SERVER_IP:9090`).

  2. Node Exporter installieren (für Host-Metriken):

    Node Exporter liefert Metriken über CPU, RAM, Festplatte etc. an Prometheus.

    • Benutzer erstellen:
    • sudo useradd --no-create-home --shell /bin/false node_exporter
    • Node Exporter herunterladen und entpacken:

      Besuche die Prometheus Download-Seite und lade den Node Exporter herunter.

      cd /tmp
      wget https://github.com/prometheus/node_exporter/releases/download/vX.Y.Z/node_exporter-X.Y.Z.linux-amd64.tar.gz

      (Ersetze `X.Y.Z` durch die aktuelle Versionsnummer)

      tar xvf node_exporter-X.Y.Z.linux-amd64.tar.gz
      sudo cp node_exporter-X.Y.Z.linux-amd64/node_exporter /usr/local/bin/
      sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter
    • Node Exporter Systemd-Dienst erstellen:
      sudo nano /etc/systemd/system/node_exporter.service

      Füge den folgenden Inhalt ein:

      
      [Unit]
      Description=Node Exporter
      Wants=network-online.target
      After=network-online.target
      
      [Service]
      User=node_exporter
      Group=node_exporter
      Type=simple
      ExecStart=/usr/local/bin/node_exporter
      
      [Install]
      WantedBy=multi-user.target
                              

      Speichern und schließen. Lade Systemd neu, aktiviere und starte den Dienst:

      sudo systemctl daemon-reload
      sudo systemctl enable node_exporter
      sudo systemctl start node_exporter
      sudo systemctl status node_exporter

      Node Exporter sollte nun auf Port 9100 erreichbar sein (z.B. `http://DEINE_SERVER_IP:9100/metrics`).

  3. Grafana installieren:

    Grafana ist das Dashboard-Tool, um die gesammelten Metriken zu visualisieren.

    • Grafana GPG-Schlüssel hinzufügen:
    • sudo apt install -y apt-transport-https software-properties-common wget
      sudo mkdir -p /etc/apt/keyrings/
      wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null
    • Grafana Repository hinzufügen:
    • echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
    • Grafana installieren:
    • sudo apt update
      sudo apt install grafana -y
    • Grafana starten und aktivieren:
    • sudo systemctl enable grafana-server
      sudo systemctl start grafana-server
      sudo systemctl status grafana-server

      Grafana sollte nun auf Port 3000 erreichbar sein (z.B. `http://DEINE_SERVER_IP:3000`). Der Standard-Login ist `admin` / `admin`. Du wirst aufgefordert, das Passwort beim ersten Login zu ändern.

  4. Prometheus als Datenquelle in Grafana hinzufügen:
    • Melde dich bei Grafana an (Standard: `admin` / `admin`).
    • Klicke im linken Menü auf das Zahnrad-Symbol (**Configuration**) > **Data sources**.
    • Klicke auf **Add data source**.
    • Wähle **Prometheus** aus der Liste aus.
    • Unter **HTTP** > **URL** gibst du die Adresse deines Prometheus-Servers ein: `http://localhost:9090` (wenn Prometheus auf demselben Server läuft).
    • Scrolle nach unten und klicke auf **Save & test**. Du solltest eine Meldung "Data Source is working" erhalten.
  5. Grafana Dashboard importieren (Node Exporter):

    Um die Metriken des Node Exporters ansprechend darzustellen, kannst du ein vorgefertigtes Dashboard importieren.

    • Gehe im linken Menü auf das Dashboard-Symbol (**Dashboards**) > **Import**.
    • Unter "Import via grafana.com" gibst du die Dashboard-ID für den "Node Exporter Full" ein: `1860`.
    • Klicke auf **Load**.
    • Im nächsten Schritt wählst du deine eben konfigurierte Prometheus-Datenquelle aus.
    • Klicke auf **Import**.
    • Du solltest nun ein detailliertes Dashboard mit allen Metriken deines Servers sehen.

Dein Server-Monitoring mit Prometheus und Grafana ist nun eingerichtet! Du kannst nun weitere Exporter (z.B. für Datenbanken, Webserver-Logs) hinzufügen und eigene Dashboards in Grafana erstellen, um deine Infrastruktur optimal zu überwachen.

Dateifreigaben mit Samba unter Linux konfigurieren

Samba ermöglicht es Linux-Servern, als Dateiserver für Windows-, macOS- und andere Linux-Clients zu fungieren, indem es das SMB/CIFS-Protokoll implementiert. Diese Anleitung zeigt, wie du eine grundlegende öffentliche und eine passwortgeschützte private Freigabe einrichtest.

Voraussetzungen:

  • Linux-Server (z.B. Debian, Ubuntu, CentOS)
  • Benutzer mit sudo-Rechten
  • Internetzugang für die Installation
  • Ein zu teilendes Verzeichnis auf dem Server
  • Optional: Firewall (UFW) konfiguriert

Schritt-für-Schritt-Anleitung:

  1. Samba installieren:
    sudo apt update
    sudo apt install samba samba-common-bin -y
  2. Zu teilendes Verzeichnis erstellen und Berechtigungen setzen:

    Erstelle ein Verzeichnis, das du freigeben möchtest, und setze die korrekten Berechtigungen.

    sudo mkdir -p /srv/samba/public
    sudo mkdir -p /srv/samba/private

    Setze die Berechtigungen so, dass Samba-Benutzer darauf zugreifen können (z.B. für öffentliche Freigabe `777` für Vollzugriff durch alle, für private Freigabe `770` für Besitzer und Gruppe).

    sudo chmod -R 0777 /srv/samba/public
    sudo chmod -R 0770 /srv/samba/private
    sudo chown -R root:sambashare /srv/samba/private # 'sambashare' ist eine Standardgruppe von Samba
  3. Samba-Konfigurationsdatei bearbeiten:

    Die Hauptkonfigurationsdatei ist `smb.conf`. Mach eine Sicherungskopie, bevor du sie bearbeitest.

    sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak
    sudo nano /etc/samba/smb.conf

    Globale Einstellungen anpassen (Optional, aber empfohlen):

    Unter dem `[global]`-Abschnitt kannst du den Workgroup-Namen anpassen, falls du nicht "WORKGROUP" verwendest.

    
    [global]
       workgroup = WORKGROUP # Dein Workgroup-Name, z.B. HOME
       server string = %h Samba Server # Name, der im Netzwerk angezeigt wird
       log file = /var/log/samba/log.%m
       max log size = 1000
       logging = file
       panic action = /usr/share/samba/panic-action %d
       server role = standalone server
       obey pam restrictions = yes
       unix password sync = yes
       passwd program = /usr/bin/passwd %u
       passwd chat = *Enter\snew\s*\s*UNIX\spassword:* %n\n *Retype\snew\s*\s*UNIX\spassword:* %n\n *password\supdated\ssuccessfully* .
       pam password change = yes
       map to guest = bad user
       usershare allow guests = yes # Erlaubt öffentlichen Zugriff über shares
       
       # Wenn du nur Authentifizierung willst, deaktiviere Gastzugriff
       # security = user
                    

    Öffentliche Freigabe hinzufügen:

    Füge diesen Block am Ende der Datei hinzu:

    
    [public_share]
       comment = Eine öffentliche Freigabe
       path = /srv/samba/public
       browsable = yes # Sichtbar im Netzwerk
       guest ok = yes # Jeder darf zugreifen (ohne Passwort)
       read only = no # Schreibzugriff erlauben
       create mask = 0775 # Standardberechtigungen für neue Dateien
       directory mask = 0775 # Standardberechtigungen für neue Ordner
                    

    Private Freigabe hinzufügen (passwortgeschützt):

    Füge diesen Block am Ende der Datei hinzu:

    
    [private_share]
       comment = Private Freigabe nur für autorisierte Benutzer
       path = /srv/samba/private
       browsable = yes
       read only = no
       valid users = @sambashare # Nur Benutzer in der Gruppe 'sambashare' dürfen zugreifen
       create mask = 0770
       directory mask = 0770
                    
  4. Samba-Benutzer hinzufügen:

    Samba verwendet eigene Passwörter, die mit den System-Passwörtern synchronisiert werden können, aber separat verwaltet werden.

    Erstelle zuerst einen System-Benutzer (falls noch nicht vorhanden):

    sudo adduser benutzername_samba
    sudo usermod -aG sambashare benutzername_samba # Benutzer zur Gruppe hinzufügen, falls für private Freigabe nötig

    Füge den Benutzer dann zu Samba hinzu und setze ein Samba-Passwort:

    sudo smbpasswd -a benutzername_samba

    Aktiviere den Samba-Benutzer:

    sudo smbpasswd -e benutzername_samba
  5. Samba-Dienst neu starten:

    Nach jeder Änderung der `smb.conf` musst du den Dienst neu starten.

    sudo systemctl restart smbd nmbd
    sudo systemctl status smbd nmbd
  6. Firewall anpassen:

    Erlaube Samba-Dienste (Port 137/UDP, 138/UDP, 139/TCP, 445/TCP).

    sudo ufw allow 'Samba'
    sudo ufw reload
  7. Freigaben vom Client aus testen:

    Windows:

    • Öffne den Datei-Explorer.
    • Gib in der Adressleiste `\\DEIN_SERVER_IP` oder `\\SERVERNAME` ein und drücke Enter.
    • Du solltest deine Freigaben sehen. Für die private Freigabe wirst du nach Benutzername und Passwort gefragt.

    Linux/macOS:

    • Öffne den Dateimanager.
    • Gib in der Adressleiste `smb://DEIN_SERVER_IP/public_share` ein oder nutze die Netzwerkumgebung.

Dein Linux-Server ist nun bereit, Dateien über Samba im Netzwerk zu teilen.

Zentrale Protokollierung mit ELK Stack (Elasticsearch, Logstash, Kibana) unter Debian Linux einrichten

Ein zentrales Log-Management-System wie der ELK Stack (Elasticsearch, Logstash, Kibana) ist unerlässlich, um Protokolldaten von verschiedenen Servern zu sammeln, zu speichern, zu durchsuchen und zu visualisieren. Dies erleichtert die Fehlerbehebung, Sicherheitsanalyse und Leistungsüberwachung.

Voraussetzungen:

  • Ein Debian-basiertes Linux-System (z.B. Debian 11/12, Ubuntu LTS) mit mindestens 4 GB RAM und 2 CPU-Kernen (für Produktivumgebung mehr)
  • Benutzer mit sudo-Rechten
  • Internetzugang auf dem Server
  • Optional: Firewall (UFW) konfiguriert (Ports 5044, 9200, 5601 müssen offen sein)

Schritt-für-Schritt-Anleitung:

  1. Java installieren (für Elasticsearch und Logstash):

    Elasticsearch und Logstash benötigen Java. Wir installieren OpenJDK.

    sudo apt update && sudo apt upgrade -y
    sudo apt install openjdk-17-jdk -y

    Überprüfe die Java-Version:

    java -version
  2. Elasticsearch installieren:

    Elasticsearch ist die verteilte Suchmaschine und das Herzstück des Speichers.

    • Elasticsearch GPG-Schlüssel hinzufügen:
    • wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg
    • Elasticsearch Repository hinzufügen:
    • echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
    • Elasticsearch installieren:
    • sudo apt update
      sudo apt install elasticsearch -y
    • Elasticsearch konfigurieren:

      Bearbeite die Konfigurationsdatei. Für einen Einzelserver ist oft nur wenig Anpassung nötig.

      sudo nano /etc/elasticsearch/elasticsearch.yml

      Stelle sicher, dass `network.host` und `http.port` korrekt sind. Für lokale Tests `network.host: localhost` oder die IP des Servers für externen Zugriff.

      
      # network.host: 192.168.1.10 # Ersetze durch deine Server-IP oder 'localhost'
      # http.port: 9200
                              

      Speichern und schließen.

    • Elasticsearch starten und aktivieren:
    • sudo systemctl daemon-reload
      sudo systemctl enable elasticsearch
      sudo systemctl start elasticsearch
      sudo systemctl status elasticsearch

      Warte eine Minute und teste, ob Elasticsearch läuft:

      curl -X GET "localhost:9200"

      Du solltest eine JSON-Antwort erhalten.

  3. Kibana installieren:

    Kibana ist die Web-Benutzeroberfläche zur Visualisierung der Daten in Elasticsearch.

    • Kibana installieren (Repository ist bereits hinzugefügt):
    • sudo apt install kibana -y
    • Kibana konfigurieren:
    • sudo nano /etc/kibana/kibana.yml

      Passe `server.port`, `server.host` und `elasticsearch.hosts` an.

      
      server.port: 5601
      server.host: "0.0.0.0" # Für Zugriff von außen, oder "localhost"
      elasticsearch.hosts: ["http://localhost:9200"] # Wenn Elasticsearch auf demselben Server läuft
                          

      Speichern und schließen.

    • Kibana starten und aktivieren:
    • sudo systemctl daemon-reload
      sudo systemctl enable kibana
      sudo systemctl start kibana
      sudo systemctl status kibana

      Kibana sollte nun über deinen Browser unter `http://DEINE_SERVER_IP:5601` erreichbar sein.

  4. Logstash installieren:

    Logstash ist der Daten-Pipeline-Motor, der Logs sammelt, transformiert und an Elasticsearch sendet.

    • Logstash installieren (Repository ist bereits hinzugefügt):
    • sudo apt install logstash -y
    • Logstash Pipeline konfigurieren (Beispiel für Syslog-Input):

      Erstelle eine Konfigurationsdatei für Logstash. Dies ist ein einfaches Beispiel für den Empfang von Logs von Filebeat.

      sudo nano /etc/logstash/conf.d/02-beats-input.conf
      
      input {
        beats {
          port => 5044
        }
      }
                              
      sudo nano /etc/logstash/conf.d/30-elasticsearch-output.conf
      
      output {
        elasticsearch {
          hosts => ["localhost:9200"]
          index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
          #user => "elastic" # Falls du Security aktiviert hast
          #password => "changeme"
        }
        stdout { codec => rubydebug } # Nur für Debugging
      }
                              

      Speichern und schließen.

    • Logstash starten und aktivieren:
    • sudo systemctl daemon-reload
      sudo systemctl enable logstash
      sudo systemctl start logstash
      sudo systemctl status logstash
  5. Filebeat installieren und konfigurieren (auf Client-Servern):

    Filebeat ist ein Lightweight-Shipper, der Logs von deinen Servern sammelt und an Logstash sendet. Dies muss auf jedem Server installiert werden, dessen Logs du sammeln möchtest.

    • Installiere Filebeat (auf dem Client-Server, nicht dem ELK-Server):
    • wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg
      echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
      sudo apt update && sudo apt install filebeat -y
    • Filebeat konfigurieren:
      sudo nano /etc/filebeat/filebeat.yml

      Deaktiviere den Elasticsearch-Output und aktiviere den Logstash-Output (suche die entsprechenden Abschnitte und passe sie an):

      
      #----------------------------- Logstash output --------------------------------
      output.logstash:
        hosts: ["DEINE_ELK_SERVER_IP:5044"] # Ersetze durch die IP deines Logstash-Servers
      
      #----------------------------- Elasticsearch output ---------------------------
      #output.elasticsearch:
        #hosts: ["localhost:9200"]
                              

      Aktiviere relevante Module (z.B. System-Logs):

      sudo filebeat modules enable system

      Speichern und schließen.

    • Filebeat starten und aktivieren:
    • sudo systemctl enable filebeat
      sudo systemctl start filebeat
      sudo systemctl status filebeat
  6. Firewall anpassen (auf ELK-Server):

    Erlaube den Zugriff auf die benötigten Ports.

    sudo ufw allow 5044/tcp comment 'Filebeat to Logstash'
    sudo ufw allow 9200/tcp comment 'Elasticsearch HTTP'
    sudo ufw allow 5601/tcp comment 'Kibana Web UI'
    sudo ufw reload
  7. Daten in Kibana überprüfen:

    Nachdem Filebeat auf den Clients läuft und Logs an Logstash sendet, navigiere zu Kibana (`http://DEINE_SERVER_IP:5601`).

    • Gehe zu **Stack Management** > **Index Patterns**.
    • Klicke auf **Create index pattern**.
    • Gib `filebeat-*` (oder den von dir in Logstash definierten Index) als Index-Muster ein und klicke auf **Next step**.
    • Wähle `@timestamp` als Zeitfilterfeld und klicke auf **Create index pattern**.
    • Navigiere dann zu **Analytics** > **Discover**. Du solltest nun deine Logs sehen und durchsuchen können.

Dein zentrales Log-Management mit dem ELK Stack ist nun eingerichtet! Du kannst nun Dashboards in Kibana erstellen, um deine Logs zu visualisieren und Alarme einzurichten.

Webserver-Härtung (Nginx/Apache) unter Linux

Die Absicherung eines Webservers ist entscheidend, um Angriffe abzuwehren und die Verfügbarkeit deiner Dienste zu gewährleisten. Diese Anleitung behandelt grundlegende Schritte zur Härtung von Nginx und Apache Webservern unter Linux.

Voraussetzungen:

  • Ein Linux-Server mit installiertem Nginx oder Apache Webserver
  • Benutzer mit sudo-Rechten
  • Internetzugang (für Updates und Certbot)
  • Registrierte Domain (für SSL/HTTPS)
  • Firewall (z.B. UFW) konfiguriert

Schritt-für-Schritt-Anleitung:

  1. System aktualisieren und unnötige Dienste deaktivieren:

    Halte dein System und deine Software immer auf dem neuesten Stand, um bekannte Sicherheitslücken zu schließen.

    sudo apt update && sudo apt upgrade -y

    Deaktiviere oder deinstalliere alle Dienste, die nicht benötigt werden:

    sudo systemctl list-unit-files --type=service | grep enabled
    sudo systemctl disable 
  2. Firewall konfigurieren (UFW):

    Erlaube nur die notwendigen Ports (HTTP/HTTPS).

    sudo ufw default deny incoming
    sudo ufw default allow outgoing
    sudo ufw allow OpenSSH
    sudo ufw allow 'Nginx Full' # Oder 'Apache Full' für beide (HTTP und HTTPS)
    sudo ufw enable
  3. SSL/TLS mit Let's Encrypt einrichten (HTTPS):

    Verschlüssle den gesamten Datenverkehr mit HTTPS. Let's Encrypt bietet kostenlose Zertifikate.

    • Certbot installieren:
    • sudo apt install certbot python3-certbot-nginx -y # Oder python3-certbot-apache
    • Zertifikat anfordern und Webserver konfigurieren:
    • sudo certbot --nginx -d deinedomain.de -d www.deinedomain.de # Oder --apache

      Folge den Anweisungen (E-Mail, AGB, Redirect).

    • Automatische Erneuerung testen:
    • sudo certbot renew --dry-run
  4. HTTP-Header absichern:

    Füge Sicherheits-Header hinzu, um Browser vor gängigen Angriffen zu schützen.

    Nginx: Bearbeite deine Nginx-Konfigurationsdatei (z.B. `/etc/nginx/sites-available/deinedomain.conf`) und füge im `server`-Block Folgendes hinzu:

    
    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";
    add_header X-XSS-Protection "1; mode=block";
    add_header Referrer-Policy "no-referrer-when-downgrade";
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
                    

    Apache: Aktiviere die Module `headers` und `rewrite` (falls noch nicht geschehen) und füge in deiner VirtualHost-Konfiguration oder in `.htaccess` Folgendes hinzu:

    
    sudo a2enmod headers rewrite
    sudo systemctl restart apache2
                    
    
    <VirtualHost *:443>
        # ...
        Header always set X-Frame-Options "SAMEORIGIN"
        Header always set X-Content-Type-Options "nosniff"
        Header always set X-XSS-Protection "1; mode=block"
        Header always set Referrer-Policy "no-referrer-when-downgrade"
        Header always set Strict-Transport-Security "max-age=31536000; includeSubDomains"
    </VirtualHost>
                    
  5. Rate Limiting konfigurieren (DDoS-Schutz):

    Beschränke die Anzahl der Anfragen pro IP-Adresse, um Brute-Force-Angriffe und leichte DoS-Attacken abzuwehren.

    Nginx: Füge im `http`-Block von `/etc/nginx/nginx.conf` hinzu:

    
    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
                    

    Und im `server`- oder `location`-Block deiner Domain-Konfiguration:

    
    location / {
        limit_req zone=mylimit burst=20 nodelay;
        # ...
    }
                    

    Apache: Verwende Module wie `mod_evasive` oder `mod_qos`. Installation und Konfiguration sind komplexer.

  6. Unnötige Module deaktivieren und Standardseiten entfernen:

    Deaktiviere nicht benötigte Module, um die Angriffsfläche zu verringern.

    Nginx: Überprüfe `/etc/nginx/nginx.conf` und entferne oder kommentiere Module, die du nicht brauchst.

    Apache:

    sudo a2dismod 

    Entferne die Standard-Willkommensseiten:

    sudo rm /var/www/html/index.nginx-debian.html # Nginx
    sudo rm /var/www/html/index.html # Apache (oder die entsprechende Datei)
  7. Verzeichnis-Listing deaktivieren:

    Verhindere, dass Browser den Inhalt von Verzeichnissen anzeigen, wenn keine Index-Datei vorhanden ist.

    Nginx: Stelle sicher, dass `autoindex off;` in deinen `server`- oder `location`-Blöcken steht.

    Apache: Füge `Options -Indexes` in deine `.htaccess` oder ``-Blöcke hinzu.

  8. PHP-Sicherheit (wenn verwendet):

    Wenn du PHP verwendest, härte die PHP-Konfiguration (`php.ini`).

    sudo nano /etc/php/8.x/fpm/php.ini # Oder apache2/php.ini, cli/php.ini
    • `expose_php = Off`
    • `allow_url_fopen = Off`
    • `allow_url_include = Off`
    • `display_errors = Off` (auf Produktionssystemen)
    • `log_errors = On`
    • Setze `open_basedir` für deine Webseiten-Verzeichnisse.
  9. Regelmäßige Überprüfung und Monitoring:

    Nutze Tools wie Fail2Ban für Brute-Force-Schutz und ein Monitoring-System (z.B. Prometheus/Grafana) zur Überwachung der Server-Gesundheit und des Traffics.

    sudo apt install fail2ban -y
    sudo systemctl enable fail2ban && sudo systemctl start fail2ban

Dies sind grundlegende, aber wichtige Schritte zur Absicherung deines Webservers. Ergänze diese durch regelmäßige Sicherheitsaudits und die Implementierung weiterer Schutzmaßnahmen (z.B. Web Application Firewalls).

Reverse Proxy mit Nginx unter Debian Linux einrichten

Ein Reverse Proxy wie Nginx leitet Client-Anfragen von extern an einen oder mehrere interne Server (Backend-Dienste) weiter. Dies bietet Vorteile wie Lastverteilung, SSL-Terminierung, Caching und erhöhte Sicherheit, da die Backend-Server nicht direkt dem Internet ausgesetzt sind.

Voraussetzungen:

  • Ein Debian-basierter Linux-Server, der als Reverse Proxy dienen soll (z.B. Debian 11/12, Ubuntu LTS)
  • Benutzer mit sudo-Rechten
  • Internetzugang auf dem Reverse Proxy-Server
  • Mindestens ein Backend-Dienst (Webserver, Anwendungsserver etc.), der auf einer anderen IP oder einem anderen Port läuft und vom Reverse Proxy erreichbar ist (z.B. auf `http://127.0.0.1:8080` oder `http://192.168.1.50:80`)
  • Optional: Eine registrierte Domain mit A-Record(s), die auf die öffentliche IP des Reverse Proxy zeigen
  • Optional: Firewall (UFW) konfiguriert (Ports 80 und 443 müssen offen sein)

Schritt-für-Schritt-Anleitung:

  1. Nginx installieren:

    Installiere Nginx auf deinem Server, der als Reverse Proxy agieren soll.

    sudo apt update && sudo apt upgrade -y
    sudo apt install nginx -y

    Aktiviere Nginx und überprüfe den Status:

    sudo systemctl enable nginx
    sudo systemctl start nginx
    sudo systemctl status nginx
  2. Firewall konfigurieren (UFW):

    Stelle sicher, dass HTTP (Port 80) und HTTPS (Port 443) in deiner Firewall erlaubt sind.

    sudo ufw allow 'Nginx HTTP' # Für Port 80
    sudo ufw allow 'Nginx HTTPS' # Für Port 443
    sudo ufw reload
  3. Nginx als Reverse Proxy konfigurieren (Server Block):

    Erstelle eine neue Nginx-Konfigurationsdatei für deine Domain oder IP-Adresse.

    sudo nano /etc/nginx/sites-available/reverse_proxy.conf

    Füge den folgenden Inhalt ein. Passe `deinedomain.de` und die `proxy_pass`-URL an deine Backend-Dienste an.

    
    server {
        listen 80;
        listen [::]:80;
        server_name deinedomain.de www.deinedomain.de; # Ersetze durch deine Domain oder Server-IP
    
        location / {
            proxy_pass http://127.0.0.1:8080; # Die Adresse deines Backend-Dienstes (IP:Port)
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    
        # Optional: Ein zweiter Location-Block für einen anderen Pfad auf ein anderes Backend
        # location /app2/ {
        #     proxy_pass http://192.168.1.10:9000/;
        #     proxy_set_header Host $host;
        #     proxy_set_header X-Real-IP $remote_addr;
        #     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        #     proxy_set_header X-Forwarded-Proto $scheme;
        # }
    }
                    

    Speichern und schließen.

    • `proxy_pass`: Dies ist die wichtigste Direktive. Sie gibt an, wohin die Anfragen weitergeleitet werden sollen.
    • `proxy_set_header`: Diese Header sind wichtig, damit der Backend-Server die ursprüngliche Host-Information, die reale IP des Clients und das verwendete Protokoll kennt.
  4. Server Block aktivieren und Nginx neu laden:

    Erstelle einen Symlink von `sites-available` nach `sites-enabled`.

    sudo ln -s /etc/nginx/sites-available/reverse_proxy.conf /etc/nginx/sites-enabled/

    Teste die Nginx-Konfiguration auf Syntaxfehler:

    sudo nginx -t

    Wenn der Test erfolgreich ist, lade Nginx neu, um die Änderungen zu übernehmen:

    sudo systemctl reload nginx
  5. Backend-Dienst testen:

    Stelle sicher, dass dein Backend-Dienst läuft und vom Reverse Proxy-Server aus erreichbar ist (z.B. mit `curl http://127.0.0.1:8080`).

    Rufe nun im Browser die IP-Adresse deines Reverse Proxy-Servers oder deine konfigurierte Domain auf. Du solltest die Antwort deines Backend-Dienstes sehen.

  6. SSL/TLS (HTTPS) mit Let's Encrypt hinzufügen (optional, aber empfohlen):

    Um eine sichere Verbindung zwischen Client und Reverse Proxy zu gewährleisten, solltest du SSL/TLS verwenden.

    • Certbot installieren:
    • sudo apt install certbot python3-certbot-nginx -y
    • Zertifikat anfordern und Nginx konfigurieren:
    • sudo certbot --nginx -d deinedomain.de -d www.deinedomain.de

      Folge den Anweisungen. Certbot wird deine `reverse_proxy.conf` automatisch aktualisieren, um HTTPS zu unterstützen und HTTP-Anfragen auf HTTPS umzuleiten.

  7. Lastverteilung (Load Balancing) mit Nginx (optional):

    Wenn du mehrere Backend-Server hast, kann Nginx den Traffic auf diese verteilen.

    Füge im `http`-Block von `/etc/nginx/nginx.conf` (oder in einer separaten Konfigurationsdatei, die du dann inkludierst) einen `upstream`-Block hinzu:

    
    http {
        # ...
        upstream backend_servers {
            server 192.168.1.10:80;
            server 192.168.1.11:80;
            # server 192.168.1.12:80; # Weitere Backend-Server
        }
    
        server {
            # ...
            location / {
                proxy_pass http://backend_servers; # Hier wird der Traffic an den upstream-Block geleitet
                # ... (proxy_set_header bleiben gleich)
            }
        }
    }
                    

    Lade Nginx neu nach den Änderungen (`sudo nginx -t && sudo systemctl reload nginx`).

Dein Nginx-Server fungiert nun als Reverse Proxy, der Anfragen an deine Backend-Dienste weiterleitet und dir erweiterte Kontroll- und Sicherheitsmöglichkeiten bietet.

Linux Desktop-Umgebung unter Debian einrichten (GNOME Beispiel)

Einrichtung einer grafischen Desktop-Umgebung unter Debian ist ein grundlegender Schritt, um den Server oder einen dedizierten Arbeitsplatz benutzfreundlich zu gestalten. Diese Anleitung zeigt, wie man die beliebte GNOME-Desktop-Umgebung installiert und grundlegende Anwendungen konfiguriert.

Voraussetzungen:

  • Ein Debian-basiertes Linux-System (z.B. Debian 11/12, Ubuntu Server) mit einer minimalen Installation
  • Benutzer mit sudo-Rechten
  • Internetzugang
  • Ausreichend Festplattenspeicher (min. 10-15 GB für Desktop) und RAM (min. 2 GB, besser 4 GB+)

Schritt-für-Schritt-Anleitung:

  1. System aktualisieren:

    Stelle sicher, dass dein System auf dem neuesten Stand ist.

    sudo apt update && sudo apt upgrade -y
  2. Desktop-Umgebung installieren (GNOME):

    Es gibt verschiedene Desktop-Umgebungen (GNOME, KDE Plasma, XFCE, LXDE etc.). GNOME ist eine vollständige und weit verbreitete Umgebung.

    sudo apt install task-gnome-desktop -y

    Dieser Befehl installiert GNOME zusammen mit vielen Standardanwendungen und dem Display Manager (GDM3).

    Alternativen:

    • KDE Plasma: `sudo apt install task-kde-desktop -y`
    • XFCE (leichtgewichtiger): `sudo apt install task-xfce-desktop -y`
    • Nur die Basis-Desktop-Umgebung ohne viele Extras: `sudo apt install gnome-core -y`

    Während der Installation wirst du möglicherweise gefragt, welchen Display Manager du verwenden möchtest (z.B. `gdm3` für GNOME, `lightdm` für XFCE). Wähle den empfohlenen für deine Desktop-Umgebung.

  3. System neu starten:

    Nach der Installation ist ein Neustart erforderlich, damit die grafische Oberfläche geladen wird.

    sudo reboot

    Nach dem Neustart solltest du den Login-Bildschirm deiner neuen Desktop-Umgebung sehen.

  4. Grundlegende Anwendungen installieren (optional):

    Je nach gewählter Desktop-Umgebung sind einige Anwendungen bereits enthalten. Hier sind Beispiele für nützliche Ergänzungen:

    • Webbrowser (Firefox ist oft Standard, Chrome/Chromium):
      sudo apt install chromium -y
    • Office Suite (LibreOffice):
      sudo apt install libreoffice -y
    • Grafikeditor (GIMP):
      sudo apt install gimp -y
    • Medienplayer (VLC):
      sudo apt install vlc -y
    • Terminal-Emulator (für erweiterte Kommandozeile, z.B. Terminator):
      sudo apt install terminator -y
    • Entwicklungsumgebung (VS Code - manueller Download/Installation oder über Snap/Flatpak)
  5. Netzwerkverbindung über GUI konfigurieren:

    Nach dem Login kannst du die Netzwerkeinstellungen über die grafische Oberfläche anpassen (z.B. WLAN, statische IP). Suche in den Einstellungen nach "Netzwerk" oder "Wi-Fi".

  6. Benutzerkonto anpassen:

    Du kannst dein Benutzerkonto (Passwort, Sprache, Hintergrund, Thema) über die Systemeinstellungen anpassen.

    • Öffne die **Einstellungen** (Zahnrad-Symbol).
    • Navigiere zu **Benutzer**, **Region & Sprache**, **Hintergrund** etc.
  7. Remote-Zugriff einrichten (optional, z.B. XRDP für RDP):

    Wenn du den Desktop remote nutzen möchtest (z.B. von einem Windows-PC mit Remote Desktop Connection).

    sudo apt install xrdp -y
    sudo systemctl enable xrdp && sudo systemctl start xrdp
    sudo ufw allow 3389/tcp # Firewall-Port für RDP öffnen
    sudo ufw reload

Du hast nun eine voll funktionsfähige Linux-Desktop-Umgebung eingerichtet, die du als Arbeitsstation oder zur leichteren Verwaltung deines Servers nutzen kannst.

Festplattenverschlüsselung unter Linux mit LUKS (dm-crypt)

Die Verschlüsselung von Festplatten oder Partitionen ist eine entscheidende Sicherheitsmaßnahme, um Daten vor unbefugtem Zugriff zu schützen, insbesondere bei Laptops oder Servern, die physisch kompromittiert werden könnten. LUKS (Linux Unified Key Setup) in Verbindung mit dm-crypt ist der Standard für Festplattenverschlüsselung unter Linux.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu, CentOS)
  • Benutzer mit sudo-Rechten
  • Eine leere Partition oder Festplatte, die verschlüsselt werden soll (ACHTUNG: Alle Daten auf der Zielpartition/Festplatte gehen verloren!)
  • Live-System (USB-Stick/CD) für die Verschlüsselung der Root-Partition oder des gesamten Systems (nicht in dieser Anleitung behandelt, komplexer!)

Schritt-für-Schritt-Anleitung (Verschlüsselung einer Datenpartition):

  1. Partition identifizieren:

    Identifiziere die Partition, die du verschlüsseln möchtest. Sei hier extrem vorsichtig!

    lsblk -f

    Suche nach dem Gerätenamen (z.B. `/dev/sdb1`, `/dev/nvme0n1p1`). Für dieses Beispiel verwenden wir `/dev/sdb1`.

  2. LUKS-Tools installieren:
    sudo apt update
    sudo apt install cryptsetup -y
  3. Partition für LUKS vorbereiten (WARNUNG: Löscht alle Daten!):

    Es wird dringend empfohlen, die Partition zuerst mit Zufallsdaten zu überschreiben, um jegliche Spur alter Daten zu entfernen. Dieser Schritt kann sehr lange dauern (Stunden bis Tage bei großen Platten).

    sudo shred -v -n 1 /dev/sdb1 # Überschreibt mit Zufallsdaten, nur 1 Durchgang zur Demonstration

    oder (schneller, aber weniger sicher für Geheimhaltung von Altdaten):

    sudo dd if=/dev/zero of=/dev/sdb1 bs=1M status=progress # Überschreibt mit Nullen
  4. LUKS-Header auf der Partition erstellen:

    Dies erstellt den LUKS-Header und fragt nach einem Passphrase, das du dir **unbedingt merken musst**!

    sudo cryptsetup luksFormat /dev/sdb1

    Bestätige mit `YES` (großgeschrieben).

  5. LUKS-Partition öffnen (entschlüsseln):

    Du musst die Partition öffnen, bevor du ein Dateisystem darauf erstellen kannst. Wähle einen Namen für das entschlüsselte Gerät (z.B. `encrypted_data`).

    sudo cryptsetup luksOpen /dev/sdb1 encrypted_data

    Du wirst nach dem Passphrase gefragt, das du in Schritt 4 gesetzt hast.

    Das entschlüsselte Gerät ist nun unter `/dev/mapper/encrypted_data` verfügbar.

  6. Dateisystem auf der entschlüsselten Partition erstellen:

    Erstelle ein Dateisystem auf dem geöffneten (entschlüsselten) Gerät. EXT4 ist eine gängige Wahl.

    sudo mkfs.ext4 /dev/mapper/encrypted_data
  7. Einhängepunkt erstellen und Partition mounten:

    Erstelle ein Verzeichnis, in das die verschlüsselte Partition eingehängt werden soll.

    sudo mkdir -p /mnt/data_secure
    sudo mount /dev/mapper/encrypted_data /mnt/data_secure

    Du kannst nun Daten in `/mnt/data_secure` speichern. Diese Daten sind verschlüsselt, wenn die Partition geschlossen ist.

  8. LUKS-Partition schließen:

    Um die Partition zu sichern (z.B. vor dem Herunterfahren oder wenn sie nicht mehr benötigt wird), musst du sie unmounten und schließen.

    sudo umount /mnt/data_secure
    sudo cryptsetup luksClose encrypted_data

    Die Daten auf `/dev/sdb1` sind nun wieder verschlüsselt und nicht zugänglich.

  9. Automatisches Öffnen beim Systemstart (optional, für Datenpartitionen):

    Um die Datenpartition beim Start automatisch zu öffnen, kannst du Einträge in `/etc/crypttab` und `/etc/fstab` hinzufügen. Dies erfordert die Eingabe des Passphrase beim Start oder die Verwendung eines Keyfiles.

    • A. Keyfile erstellen (sicherer als Passphrase im Klartext):

      Erstelle ein Keyfile und setze die Berechtigungen korrekt. Speichere es an einem sicheren Ort (z.B. auf einer separaten, ebenfalls verschlüsselten Boot-Partition oder einem USB-Stick).

      sudo dd if=/dev/urandom of=/etc/luks/data_secure.key bs=512 count=4 # Keyfile erstellen
      sudo chmod 0400 /etc/luks/data_secure.key # Nur root darf lesen
      sudo cryptsetup luksAddKey /dev/sdb1 /etc/luks/data_secure.key # Keyfile zu LUKS hinzufügen
    • B. Eintrag in `/etc/crypttab` hinzufügen:

      Dies teilt dem System mit, welche LUKS-Geräte beim Start geöffnet werden sollen.

      sudo nano /etc/crypttab

      Füge hinzu (verwende die UUID von `/dev/sdb1` mit `sudo blkid /dev/sdb1`):

      
      encrypted_data UUID= /etc/luks/data_secure.key luks,discard
                              

      `discard` ist für SSDs wichtig, kann aber Sicherheitsrisiken bei Plattenlöschen bergen.

    • C. Eintrag in `/etc/fstab` hinzufügen:

      Dies bindet das nun entschlüsselte Gerät in das Dateisystem ein.

      sudo nano /etc/fstab
      
      /dev/mapper/encrypted_data /mnt/data_secure ext4 defaults 0 2
                              
    • D. Initial Ramdisk aktualisieren:
      sudo update-initramfs -u -k all
    • E. Neustart und Test:
    • sudo reboot

      Nach dem Neustart sollte `/mnt/data_secure` automatisch gemountet sein.

Die Verschlüsselung mit LUKS bietet einen robusten Schutz für deine Daten auf Partitionsebene. Die Verschlüsselung der Root-Partition erfordert eine Installationsmethode, die dies unterstützt, oder eine manuelle, komplexere Konfiguration.

Softwareverteilung unter Windows (GPO / PDQ Deploy)

Die automatisierte Softwareverteilung ist eine Kernaufgabe in IT-Umgebungen, um Anwendungen effizient auf Client-PCs zu installieren, zu aktualisieren und zu deinstallieren. Unter Windows sind Gruppenrichtlinienobjekte (GPOs) und spezialisierte Tools wie PDQ Deploy gängige Methoden.

Voraussetzungen:

  • **Für GPO-Verteilung:**
    • Windows Server mit Active Directory Domain Services (AD DS) und Domain Controller-Funktion
    • Client-PCs, die Mitglieder der Domäne sind
    • Administratorrechte auf dem Domain Controller
    • Softwarepakete im MSI-Format (Microsoft Installer)
    • Eine Netzwerkfreigabe, auf die alle Client-PCs Lesezugriff haben
  • **Für PDQ Deploy:**
    • Windows Server oder Client-PC, auf dem PDQ Deploy installiert wird
    • Netzwerkzugriff auf die Ziel-Client-PCs
    • Administrator-Anmeldeinformationen für die Ziel-Client-PCs (PDQ Deploy verwendet diese, um Installationen auszuführen)
    • Softwarepakete im MSI-, EXE- oder Skript-Format

Teil 1: Softwareverteilung mit Gruppenrichtlinienobjekten (GPO)

Die GPO-basierte Softwareverteilung eignet sich gut für MSI-Pakete und ist kostenfrei, aber weniger flexibel als dedizierte Tools.

  1. Softwarepaket vorbereiten:

    Stelle sicher, dass du das MSI-Installationspaket der Software hast, die du verteilen möchtest.

  2. Verteilungsfreigabe erstellen:

    Erstelle eine Netzwerkfreigabe auf einem Server, auf die alle Domänencomputer Lesezugriff haben.

    • Erstelle einen Ordner (z.B. `C:\SoftwareShare`).
    • Rechtsklick auf den Ordner > **Eigenschaften** > Tab **Freigabe** > **Erweiterte Freigabe...**
    • Aktiviere "Diesen Ordner freigeben", gib einen Freigabenamen ein (z.B. `Software`) und klicke auf **Berechtigungen**.
    • Füge die Gruppe "Domänencomputer" hinzu und gib ihr "Lesen"-Berechtigungen. "Jeder" kann auch Lesezugriff haben.
    • Klicke auf **OK**.
    • Kopiere die MSI-Datei in diesen Freigabeordner (z.B. `\\DEINSERVER\Software\MySoftware.msi`).
  3. Neues GPO erstellen und verknüpfen:
    • Öffne die **Gruppenrichtlinienverwaltung** (`gpmc.msc`).
    • Navigiere zu deiner Domäne oder einer spezifischen OU, in der sich die Zielcomputer befinden.
    • Rechtsklick auf die Domäne/OU und wähle **GPO hier erstellen und verknüpfen...**.
    • Gib einen Namen für das GPO ein (z.B. "Softwareverteilung - MySoftware"). Klicke **OK**.
  4. Softwareverteilung im GPO konfigurieren:
    • Rechtsklick auf das neu erstellte GPO und wähle **Bearbeiten...**.
    • Navigiere im **Gruppenrichtlinienverwaltungs-Editor** zu: `Computerkonfiguration` > `Richtlinien` > `Softwareeinstellungen` > `Softwareinstallation`
    • Rechtsklick auf **Softwareinstallation** > **Neu** > **Paket...**.
    • Navigiere zur MSI-Datei über den **Netzwerkpfad** (z.B. `\\DEINSERVER\Software\MySoftware.msi`), nicht über einen lokalen Pfad. Wähle die Datei aus und klicke **Öffnen**.
    • Wähle "Zugewiesen" als Bereitstellungsmethode und klicke **OK**.
    • Schließe den Editor.
  5. Gruppenrichtlinie auf Clients aktualisieren und testen:

    Die Software wird beim nächsten Neustart des Client-PCs automatisch installiert. Du kannst das Update erzwingen:

    gpupdate /force

    Nach einem Neustart des Client-PCs sollte die Software installiert sein.

    Deinstallation: Im GPO unter Softwareinstallation Rechtsklick auf das Paket > **Alle Aufgaben** > **Entfernen** > "Software sofort deinstallieren".

Teil 2: Softwareverteilung mit PDQ Deploy

PDQ Deploy ist ein beliebtes Drittanbieter-Tool, das mehr Flexibilität und Funktionen bietet als GPOs, insbesondere für EXE-Installationen und Skripte.

  1. PDQ Deploy installieren:

    Lade PDQ Deploy von der offiziellen Website (pdq.com/pdq-deploy/) herunter und installiere es auf einem geeigneten Windows-System.

  2. Paket erstellen:

    Ein "Paket" in PDQ Deploy definiert die Installationsschritte für eine Software.

    • Starte PDQ Deploy und klicke auf **New Package** (oder `Strg + N`).
    • Gib einen **Namen** für das Paket ein (z.B. "Installiere VLC Player").
    • Klicke auf **New Step** > **Install Step**.
    • Gib den Pfad zur Installationsdatei an (z.B. `.exe` oder `.msi`). Du kannst sie auch in PDQ Deploy speichern oder auf einer Netzwerkfreigabe belassen.
    • Füge die notwendigen **Parameter** für eine stille Installation hinzu (z.B. `/S` für EXE, `/quiet /norestart` für MSI). Oft gibt es vorgefertigte Optionen oder du findest sie in der Dokumentation der Software.
    • Klicke **Save**.
  3. Deployment durchführen:

    Ein "Deployment" ist der Prozess der Ausführung eines Pakets auf Zielcomputern.

    • Wähle das erstellte Paket aus.
    • Klicke auf **Deploy Once**.
    • Füge deine **Zielcomputer** hinzu: Du kannst Computer aus Active Directory, einer Textdatei, einem IP-Bereich oder manuell auswählen.
    • Klicke auf **Deploy**.
    • PDQ Deploy wird versuchen, die Software auf den Zielcomputern zu installieren. Du kannst den Fortschritt in der Konsole verfolgen.
  4. Berechtigungen und Fehlersuche:
    • Stelle sicher, dass das Konto, mit dem PDQ Deploy arbeitet (standardmäßig das "Deploy User"-Konto in den Einstellungen), auf den Zielcomputern lokale Administratorrechte besitzt.
    • Überprüfe die Logs in PDQ Deploy für detaillierte Fehlermeldungen bei fehlgeschlagenen Installationen.
    • Firewall-Regeln (Port 135 TCP für RPC, 445 TCP für SMB) müssen auf den Clients für PDQ Deploy offen sein.
  5. Regelmäßige Aktualisierungen und Deinstallationen:

    PDQ Deploy bietet Funktionen zum Erstellen von Update-Paketen und zur Deinstallation von Software. Du kannst auch Zeitpläne für automatische Deployments einrichten.

Beide Methoden bieten Möglichkeiten zur Softwareverteilung in Windows-Umgebungen. GPOs sind gut für grundlegende MSI-Installationen in AD-Umgebungen, während Tools wie PDQ Deploy mehr Flexibilität, Kontrolle und eine bessere Benutzererfahrung für komplexere Szenarien bieten.

DNS-Auflösung mit Unbound als Caching Resolver unter Debian

Unbound ist ein schneller, schlanker und rekursiver DNS-Caching-Resolver, der auf dem Konzept der DNSSEC-Validierung und der direkten Abfrage der Root-Server basiert, um Domainnamen aufzulösen. Im Gegensatz zu BIND, das auch als autoritativer Server agieren kann, konzentriert sich Unbound auf die Rolle des Resolvers und ist dadurch oft performanter und sicherer für lokale Netzwerke.

Voraussetzungen:

  • Ein Debian-basiertes Linux-System (z.B. Debian 11/12, Ubuntu LTS)
  • Benutzer mit sudo-Rechten
  • Internetzugang für die Installation
  • Firewall (z.B. UFW) konfiguriert (Port 53 UDP/TCP muss offen sein)

Schritt-für-Schritt-Anleitung:

  1. Unbound installieren:

    Aktualisiere die Paketlisten und installiere Unbound.

    sudo apt update && sudo apt upgrade -y
    sudo apt install unbound -y
  2. Basiskonfiguration von Unbound:

    Die Hauptkonfigurationsdatei ist /etc/unbound/unbound.conf. Oft wird empfohlen, Konfigurationsschnipsel in /etc/unbound/unbound.conf.d/ abzulegen.

    Erstelle eine neue Konfigurationsdatei für deine lokalen Einstellungen:

    sudo nano /etc/unbound/unbound.conf.d/local-unbound.conf

    Füge den folgenden Inhalt ein und passe die IP-Adressen an dein Netzwerk an:

    
    server:
        # Port auf dem Unbound lauscht (Standard ist 53)
        port: 53
        # Schnittstelle(n), auf denen Unbound lauschen soll
        interface: 0.0.0.0 # Lauscht auf allen verfügbaren IPs
        # interface: 192.168.1.10 # Lauscht nur auf dieser spezifischen IP
    
        # Zugriffssteuerung: Welche Netzwerke dürfen Anfragen stellen?
        # Ersetze 192.168.1.0/24 durch dein lokales Netzwerk
        access-control: 127.0.0.1/32 allow
        access-control: 192.168.1.0/24 allow
    
        # DNSSEC-Validierung aktivieren (empfohlen)
        auto-trust-anchor-file: "/var/lib/unbound/root.key"
    
        # Verbose-Level für Logs (0=minimal, 5=maximal für Debugging)
        verbosity: 1
    
        # Cache-Einstellungen
        num-threads: 2 # Anzahl der Threads, anpassen an CPU-Kerne
        outgoing-range: 8192 # Erhöht die Anzahl gleichzeitiger Anfragen
        cache-max-ttl: 3600 # Maximale Cache-Zeit für Einträge
        cache-min-ttl: 300  # Minimale Cache-Zeit für Einträge
    
        # Performance-Optimierung
        msg-cache-size: 32m
        rrset-cache-size: 64m
        do-ip4: yes
        do-udp: yes
        do-tcp: yes
    
        # Vermeidung von DNS-Rebinding-Angriffen
        private-address: 192.168.0.0/16
        private-address: 172.16.0.0/12
        private-address: 10.0.0.0/8
        private-address: fd00::/8 # IPv6
    
        # Optional: Lokale Overrides (z.B. für interne Hostnamen)
        # local-zone: "meinefirma.local." static
        # local-data: "server1.meinefirma.local. A 192.168.1.50"
        # local-data: "meinpc.meinefirma.local. A 192.168.1.100"
                    

    Speichern und schließen.

  3. Root-Hints und DNSSEC-Trust-Anchor initialisieren:

    Unbound benötigt die Root-Hints, um die DNS-Hierarchie von Grund auf aufzulösen, und den DNSSEC-Trust-Anchor, um DNSSEC-Signaturen zu validieren.

    sudo unbound-anchor -a /var/lib/unbound/root.key

    Dies erstellt die Datei `/var/lib/unbound/root.key`, die den DNSSEC Trust Anchor enthält.

  4. Unbound starten und aktivieren:

    Überprüfe die Konfiguration auf Syntaxfehler:

    sudo unbound-checkconf

    Wenn keine Fehler gefunden wurden, starte Unbound und aktiviere es für den Systemstart:

    sudo systemctl enable unbound
    sudo systemctl start unbound

    Überprüfe den Status des Dienstes:

    sudo systemctl status unbound
  5. Firewall (UFW) anpassen:

    Erlaube den DNS-Verkehr (Port 53 UDP und TCP) zum Unbound-Server.

    sudo ufw allow 53/udp
    sudo ufw allow 53/tcp
    sudo ufw reload
  6. Client-Konfiguration testen:

    Konfiguriere einen Client (oder den Server selbst) so, dass er Unbound als DNS-Server verwendet.

    Auf dem Server selbst (oder einem Linux-Client):

    sudo nano /etc/resolv.conf

    Ändere die `nameserver`-Zeile auf die IP-Adresse deines Unbound-Servers (z.B. `127.0.0.1` wenn es der Server selbst ist, oder seine statische LAN-IP).

    nameserver 127.0.0.1

    Speichern und schließen. (Beachte, dass diese Datei unter vielen modernen Distributionen von NetworkManager oder Netplan überschrieben werden kann. Für dauerhafte Änderungen siehe deren Dokumentation.)

    Testen der Auflösung:

    dig example.com @127.0.0.1
    dig google.com @127.0.0.1

    Du kannst auch DNSSEC-Validierung testen:

    dig sigok.verteiltesysteme.net @127.0.0.1
    dig sigfail.verteiltesysteme.net @127.0.0.1

    Die Antworten sollten "NOERROR" mit Status "AD" (Authentic Data) für `sigok` und "SERVFAIL" für `sigfail` anzeigen, wenn DNSSEC korrekt funktioniert.

  7. Cache leeren (optional):

    Wenn du Änderungen an den DNS-Einträgen vornimmst und möchtest, dass Unbound seinen Cache leert, kannst du das tun:

    sudo systemctl restart unbound

    Oder nur den Cache leeren ohne Neustart des Dienstes (falls `unbound-control` installiert ist und konfiguriert wurde):

    sudo unbound-control reload
    sudo unbound-control dump_cache # Zum Überprüfen des Caches

Dein Unbound DNS-Caching-Resolver ist nun eingerichtet und bietet eine schnelle und sichere DNS-Auflösung für dein lokales Netzwerk.

Systemüberwachung mit Glances unter Linux

Glances ist ein plattformübergreifendes, Terminal-basiertes Überwachungstool, das in Python geschrieben ist. Es bietet eine schnelle und umfassende Übersicht über die Systemressourcen in Echtzeit (CPU, RAM, Festplatte, Netzwerk, Prozesse, Sensoren etc.) und kann auch im Client/Server-Modus oder als Webserver betrieben werden.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu, CentOS)
  • Benutzer mit sudo-Rechten
  • Internetzugang für die Installation
  • Optional: Python und pip (wird meist mitinstalliert)

Schritt-für-Schritt-Anleitung:

  1. Glances installieren:

    Die empfohlene Methode ist die Installation über pip (Python-Paketmanager), um immer die neueste Version zu erhalten. Stelle sicher, dass Python und pip installiert sind.

    sudo apt update
    sudo apt install python3 python3-pip -y

    Installiere Glances mit pip:

    sudo pip3 install glances

    Optional: Installiere zusätzliche Abhängigkeiten für mehr Features (z.B. Docker-Monitoring, GPU-Monitoring).

    sudo apt install python3-dev python3-psutil python3-setuptools python3-wheel -y
    sudo pip3 install 'glances[full]' # Installiert alle optionalen Abhängigkeiten
  2. Glances im interaktiven Modus starten:

    Gib einfach `glances` in deinem Terminal ein, um die Echtzeit-Übersicht zu starten.

    glances

    Du kannst verschiedene Tasten drücken, um die Ansicht zu ändern oder zu filtern (z.B. `c` für CPU-Sortierung, `m` für RAM, `d` für Disk I/O, `n` für Netzwerk, `q` zum Beenden).

  3. Glances als Webserver starten:

    Glances kann einen eigenen Webserver starten, sodass du die Systeminformationen über einen Webbrowser abrufen kannst.

    glances -w

    Standardmäßig lauscht Glances auf Port 61208. Öffne deinen Browser und navigiere zu `http://DEINE_SERVER_IP:61208`.

    Um Glances im Hintergrund zu starten und als Dienst zu betreiben, kannst du `nohup` oder einen Systemd-Dienst verwenden.

  4. Glances im Client/Server-Modus verwenden:

    Du kannst einen Glances-Server auf einem Remote-Rechner starten und dann von einem anderen Rechner (Client) aus die Daten abfragen.

    • Auf dem Server (Remote-Rechner):
    • glances -s

      Glances lauscht nun auf Port 61209 (Standard).

    • Auf dem Client (lokaler Rechner):
    • glances -c DEINE_SERVER_IP

      Ersetze `DEINE_SERVER_IP` durch die IP-Adresse des Servers, auf dem Glances im Server-Modus läuft.

  5. Firewall (UFW) anpassen (wenn im Server- oder Webserver-Modus):

    Erlaube den Glances-Port (standardmäßig 61208 für Webserver, 61209 für Server-Modus).

    sudo ufw allow 61208/tcp comment 'Glances Web UI'
    sudo ufw allow 61209/tcp comment 'Glances Server Mode'
    sudo ufw reload
  6. Glances als Systemd-Dienst (optional):

    Um Glances automatisch beim Systemstart als Webserver zu starten, kannst du einen Systemd-Dienst erstellen.

    sudo nano /etc/systemd/system/glancesweb.service

    Füge den folgenden Inhalt ein:

    
    [Unit]
    Description=Glances Monitoring Tool (Web UI)
    After=network.target
    
    [Service]
    ExecStart=/usr/local/bin/glances -w
    Restart=always
    User=root # Oder einen weniger privilegierten Benutzer, wenn vorhanden
    
    [Install]
    WantedBy=multi-user.target
                    

    Speichern und schließen. Aktiviere und starte den Dienst:

    sudo systemctl daemon-reload
    sudo systemctl enable glancesweb
    sudo systemctl start glancesweb
    sudo systemctl status glancesweb

Glances ist ein vielseitiges Tool zur schnellen Überwachung deiner Linux-Systeme und eine gute Ergänzung für jeden Fachinformatiker-Werkzeugkasten.

Virtuelle Desktops und Remotedesktopdienste (RDS) unter Windows Server einrichten

Remotedesktopdienste (RDS), früher Terminaldienste, ermöglichen es Benutzern, remote auf Desktops und Anwendungen zuzugreifen, die auf einem zentralen Server gehostet werden. Dies ist ideal für die Bereitstellung von Software, die Konsolidierung von Ressourcen und die Ermöglichung von Home-Office-Szenarien.

Voraussetzungen:

  • Ein Windows Server (z.B. 2019, 2022) mit ausreichend Ressourcen (CPU, RAM, Speicher)
  • Der Server ist Mitglied einer Active Directory-Domäne
  • Administratorrechte auf dem Server
  • Ausreichende Lizenzierung für RDS (CALs - Client Access Licenses)
  • Optional: Öffentliche IP-Adresse und DNS-Einträge für den externen Zugriff
  • Firewall konfiguriert (Standard-RDP-Port 3389 TCP muss offen sein, ggf. weitere Ports für Web Access)

Schritt-für-Schritt-Anleitung:

  1. Rollenbasierte oder Remotedesktopdienste-Installation starten:

    Öffne den **Server-Manager** auf deinem Windows Server.

    • Klicke auf **Rollen und Features hinzufügen**.
    • Wähle "Rollenbasierte oder featurebasierte Installation" und klicke **Weiter**.
    • Wähle den Zielserver und klicke **Weiter**.
  2. Remotedesktopdienste-Rollen auswählen:

    Die Installation von RDS kann komplex sein und erfordert mehrere Rollendienste. Für eine grundlegende Bereitstellung sind folgende Rollendienste essentiell:

    • **Remotedesktop-Sitzungshost (RDSH):** Hostet die Anwendungen und Desktops.
    • **Remotedesktop-Lizenzierung (RD-Lizenzierung):** Verwaltet die RDS-CALs.
    • **Remotedesktop-Verbindungsbroker (RDCB):** Verteilt Client-Verbindungen auf RDSH-Server und verwaltet Sitzungen.
    • **Remotedesktop-Web Access (RDWA):** Ermöglicht den Zugriff auf Desktops und Anwendungen über einen Webbrowser.
    • **Remotedesktop-Gateway (RDG):** Ermöglicht sicheren externen Zugriff über HTTPS (optional, aber empfohlen für Internetzugriff).

    Für eine schnelle Erstkonfiguration kannst du mit nur dem **Remotedesktop-Sitzungshost** und **Remotedesktop-Lizenzierung** beginnen, wenn der Zugriff nur intern erfolgt oder du bereits einen anderen Broker/Gateway hast. Für eine komplette Bereitstellung wähle die oben genannten.

    • Wähle die gewünschten Rollendienste aus und klicke **Weiter**.
    • Bestätige die zu installierenden Features und klicke **Weiter**.
    • Bestätige die Rollenauswahl und klicke **Installieren**. (Ein Neustart ist oft erforderlich).
  3. Remotedesktopdienste-Sammlung erstellen:

    Eine Sammlung ist eine Gruppe von RDSH-Servern und veröffentlichten Anwendungen/Desktops.

    • Gehe im **Server-Manager** zu **Remotedesktopdienste** (linke Leiste).
    • Klicke unter "Sammlungen" auf **Aufgaben** > **Sammlung erstellen**.
    • Gib einen **Namen** für die Sammlung ein (z.B. "Standard-Desktop-Benutzer").
    • Wähle den/die **Remotedesktop-Sitzungshost-Server** aus, die Teil dieser Sammlung sein sollen.
    • Wähle die **Benutzergruppen** aus, die auf diese Sammlung zugreifen dürfen.
    • Bestimme den **Speicherort für Benutzerprofile** (optional).
    • Klicke **Erstellen**.
  4. Anwendungen veröffentlichen (RemoteApp) (optional):

    Du kannst einzelne Anwendungen statt des gesamten Desktops veröffentlichen.

    • Wähle deine Sammlung im Server-Manager unter Remotedesktopdienste aus.
    • Klicke unter "REMOTEAPP-PROGRAMME" auf **Aufgaben** > **RemoteApp-Programme veröffentlichen**.
    • Wähle die Anwendungen aus, die du veröffentlichen möchtest (z.B. Word, Calculator).
    • Klicke **Veröffentlichen**.
  5. RDS-Lizenzierung konfigurieren:

    Der Lizenzserver muss aktiviert und die RDS-CALs installiert werden.

    • Gehe im **Server-Manager** zu **Remotedesktopdienste** > **Übersicht** > **Bereitstellungsübersicht**.
    • Rechtsklick auf **RD-Lizenzierung** > **RD-Lizenzierung konfigurieren**.
    • Wähle den Lizenzserver aus.
    • Wähle den Lizenzierungsmodus (Pro Benutzer oder Pro Gerät). "Pro Benutzer" ist oft flexibler.
    • Rechtsklick auf den Lizenzserver unter "RD-Lizenzierung" > **Lizenzen installieren**. Folge dem Assistenten.
  6. Gruppenrichtlinien für RDS-Clients konfigurieren (optional, aber empfohlen):

    Konfiguriere Client-Einstellungen für eine bessere RDS-Erfahrung.

    • Öffne die **Gruppenrichtlinienverwaltung** (`gpmc.msc`).
    • Erstelle oder bearbeite ein GPO, das auf deine RDS-Benutzer angewendet wird.
    • Navigiere zu `Benutzerkonfiguration` > `Richtlinien` > `Administrative Vorlagen` > `Windows-Komponenten` > `Remotedesktopdienste` > `Remotedesktop-Sitzungshost` > `Remotedesktop-Sitzungsumgebung`.
    • Konfiguriere Einstellungen wie "Remotedesktop-Grafikkomprimierung", "Hintergrundbild auf dem Remotecomputer entfernen" etc., um die Performance zu optimieren.
  7. Zugriff testen:
    • **Interner Zugriff:** Öffne den Remotedesktopverbindungs-Client (`mstsc.exe`) auf einem Client-PC. Gib den Namen oder die IP des RDSH-Servers (oder des Verbindungsbrokers) ein und melde dich mit den Benutzerdaten eines erlaubten Benutzers an.
    • **Web Access:** Navigiere im Browser zu `http://DEINSERVER/RDWeb` (wenn RD-Web Access installiert ist). Melde dich an, um auf die veröffentlichten Desktops oder RemoteApps zuzugreifen.

Die Einrichtung von Remotedesktopdiensten kann je nach Komplexität der Umgebung variieren, bietet aber eine leistungsstarke Plattform für die zentrale Bereitstellung von IT-Ressourcen.

Einrichtung von Windows Subsystem for Linux (WSL 2) unter Windows 10/11

Windows Subsystem for Linux (WSL) ermöglicht es Entwicklern und Systemadministratoren, eine vollwertige Linux-Umgebung direkt unter Windows auszuführen, ohne eine herkömmliche virtuelle Maschine oder Dual-Boot zu benötigen. WSL 2 bietet dabei eine verbesserte Performance und volle System-Call-Kompatibilität durch einen echten Linux-Kernel.

Voraussetzungen:

  • Windows 10 Version 2004 oder höher (Build 19041 oder höher) oder Windows 11
  • 64-Bit-System
  • Virtualisierung im BIOS/UEFI aktiviert (Intel VT-x / AMD-V)
  • Internetzugang (für Installation und Distribution-Download)
  • Administratorrechte

Schritt-für-Schritt-Anleitung:

  1. WSL installieren (vereinfachte Methode unter Windows 11 / neuere Windows 10 Builds):

    Die neueste Version von WSL kann oft mit einem einzigen Befehl installiert werden.

    • Öffne PowerShell oder die Eingabeaufforderung **als Administrator**.
    • wsl --install
    • Dieser Befehl aktiviert die notwendigen optionalen Komponenten, lädt den neuesten Linux-Kernel herunter und installiert standardmäßig Ubuntu.
    • Nach der Installation musst du deinen Computer neu starten.
    • Nach dem Neustart wird die Ubuntu-Installation automatisch fortgesetzt. Du wirst aufgefordert, einen Benutzernamen und ein Passwort für deine neue Linux-Distribution zu erstellen.

    Wenn dieser Befehl nicht funktioniert oder du eine spezifische Distribution installieren möchtest, fahre mit der manuellen Installation fort.

  2. Manuelle Installation (für ältere Builds oder spezifische Distributionen):
    • **A. WSL aktivieren:**

      Öffne PowerShell **als Administrator** und führe folgende Befehle aus:

      dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-For-Linux /all /norestart
    • **B. Virtuelle Maschinen-Plattform-Feature aktivieren:**

      WSL 2 benötigt die Virtual Machine Platform.

      dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
    • **C. Computer neu starten:**
    • shutdown /r /t 0
    • **D. WSL 2 Linux-Kernel-Update-Paket herunterladen:**

      Lade das neueste Kernel-Update-Paket von der Microsoft-Website herunter und installiere es: WSL2 Linux-Kernel Update Package

    • **E. WSL 2 als Standardversion festlegen:**

      Öffne PowerShell **als Administrator**:

      wsl --set-default-version 2
    • **F. Linux-Distribution aus dem Microsoft Store installieren:**

      Öffne den **Microsoft Store** und suche nach deiner bevorzugten Linux-Distribution (z.B. Ubuntu, Debian, Kali Linux, openSUSE). Klicke auf "Abrufen" und dann "Installieren".

      Starte die installierte Distribution nach dem Download. Du wirst aufgefordert, einen Benutzernamen und ein Passwort zu erstellen.

  3. WSL-Befehle und grundlegende Nutzung:
    • **Alle installierten Distributionen auflisten:**
      wsl -l -v

      Zeigt den Namen, Status und die WSL-Version (1 oder 2) an.

    • **Standard-Distribution festlegen:**
      wsl --set-default Ubuntu
    • **WSL-Version einer Distribution ändern:**
      wsl --set-version Ubuntu 2

      Dies kann eine Weile dauern.

    • **In die Linux-Umgebung wechseln:**
      wsl

      Oder starte die installierte Distribution über das Startmenü.

    • **Dateizugriff:**

      Von Linux auf Windows-Dateien zugreifen: Windows-Laufwerke sind unter `/mnt/c`, `/mnt/d` etc. gemountet.

      Von Windows auf Linux-Dateien zugreifen: Öffne den Datei-Explorer und gib `\\wsl$` in die Adressleiste ein. Du siehst deine Linux-Distributionen.

    • **Netzwerkzugriff:**

      Standardmäßig hat deine WSL2-Distribution eine eigene IP-Adresse im lokalen Netzwerk, die nicht statisch ist. Du kannst aber über `localhost` auf Dienste zugreifen, die in WSL laufen (z.B. ein Webserver auf Port 80 in WSL ist unter `http://localhost` unter Windows erreichbar).

    • **Updates in Linux:**

      Vergiss nicht, deine Linux-Distribution regelmäßig zu aktualisieren:

      sudo apt update && sudo apt upgrade -y
  4. VS Code Integration (optional, aber empfohlen):

    Installiere Visual Studio Code und die "Remote - WSL"-Erweiterung. Du kannst dann Code-Projekte direkt in deiner WSL-Umgebung bearbeiten und ausführen.

    • Installiere VS Code: code.visualstudio.com/download
    • Installiere die "Remote - WSL" Erweiterung im VS Code Extensions Marketplace.
    • Öffne einen Ordner in WSL über VS Code: `Code .` in deinem Linux-Terminal.

WSL 2 bietet eine nahtlose und leistungsstarke Umgebung für Entwickler und Administratoren, die das Beste aus beiden Welten – Windows und Linux – nutzen möchten.

Monitoring mit Netdata unter Linux

Netdata ist ein leistungsstarkes, echtzeitbasiertes Open-Source-Performance-Monitoring-Tool für Linux, das umfassende Metriken von Systemen und Anwendungen sammelt und in interaktiven Web-Dashboards visualisiert. Es ist darauf ausgelegt, mit minimalen Ressourcen zu laufen und sofortige Einblicke in die Systemleistung zu geben.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu, CentOS)
  • Benutzer mit sudo-Rechten
  • Internetzugang für die Installation
  • Optional: Firewall (UFW) konfiguriert (Port 19999 TCP muss offen sein)

Schritt-für-Schritt-Anleitung:

  1. Netdata installieren:

    Netdata bietet ein einfaches One-Liner-Installationsskript, das alle Abhängigkeiten installiert und Netdata konfiguriert.

    wget -O /tmp/netdata-installer.sh https://my-netdata.io/kickstart.sh
    chmod +x /tmp/netdata-installer.sh
    sudo /tmp/netdata-installer.sh

    Das Skript führt dich durch den Installationsprozess. Es installiert Netdata als Systemd-Dienst.

  2. Netdata-Dienst überprüfen:

    Nach der Installation sollte Netdata automatisch gestartet werden.

    sudo systemctl status netdata

    Der Status sollte "active (running)" sein.

  3. Firewall (UFW) konfigurieren:

    Der Netdata-Webserver lauscht standardmäßig auf Port 19999. Erlaube diesen Port in deiner Firewall.

    sudo ufw allow 19999/tcp comment 'Netdata Web UI'
    sudo ufw reload
  4. Netdata Web-Dashboard aufrufen:

    Öffne deinen Webbrowser und navigiere zu:

    http://DEINE_SERVER_IP:19999

    Du solltest das interaktive Netdata-Dashboard sehen, das Echtzeit-Metriken deines Servers anzeigt (CPU, RAM, Disk I/O, Netzwerk, Prozesse, Systemd-Dienste und vieles mehr).

  5. Grundlegende Konfiguration (optional):

    Die Hauptkonfigurationsdatei von Netdata ist `/etc/netdata/netdata.conf`. Du solltest diese Datei nicht direkt bearbeiten. Stattdessen werden individuelle Konfigurationen in Unterverzeichnissen abgelegt.

    Zum Bearbeiten der globalen Einstellungen (z.B. IP-Binding):

    sudo edit /etc/netdata/netdata.conf

    Um nur auf einer bestimmten IP zu lauschen (z.B. `192.168.1.10`):

    Suche den Abschnitt `[web]` und ändere `bind to = 0.0.0.0` zu `bind to = 192.168.1.10`. Speichere und starte Netdata neu:

    sudo systemctl restart netdata

    Netdata kann auch weitere Quellen (z.B. Nginx, MySQL, Docker) überwachen. Die Konfigurationsdateien dafür befinden sich in `/etc/netdata/conf.d/`. Bearbeite diese Dateien mit `sudo edit /etc/netdata/python.d/nginx.conf` etc.

  6. Agent Cloud anmelden (optional):

    Netdata bietet eine kostenlose Cloud-Plattform (Netdata Cloud), um mehrere Netdata-Agenten zentral zu verwalten, Dashboards zu erstellen und Alarme zu erhalten. Du kannst deinen Agenten dort anmelden:

    • Besuche app.netdata.cloud und erstelle ein kostenloses Konto.
    • Befolge die Anweisungen im Dashboard, um deinen Agenten mit deiner Cloud-Space zu verbinden. Dies beinhaltet normalerweise die Ausführung eines `netdata-installer.sh`-Befehls mit speziellen Parametern oder das Hinzufügen eines Tokens zur Konfiguration.
  7. Alarme konfigurieren:

    Netdata verfügt über ein leistungsstarkes Alarmsystem. Die Alarmkonfigurationen findest du in `/etc/netdata/health.d/`.

    Um zum Beispiel Alarme für zu hohe CPU-Auslastung zu konfigurieren, bearbeite `cpu.conf`.

    sudo edit /etc/netdata/health.d/cpu.conf

    Du kannst Benachrichtigungen über verschiedene Kanäle (E-Mail, Slack, Telegram etc.) einrichten. Die Konfiguration dafür findest du in `/etc/netdata/health_alarm_notify.conf`.

Netdata ist ein hervorragendes Tool für Echtzeit-Monitoring und gibt dir sofortige Einblicke in die Gesundheit und Performance deiner Linux-Systeme.

Automatisches Update-Management unter Windows (WSUS / GPO)

Ein effektives Update-Management ist entscheidend für die Sicherheit und Stabilität von Windows-Clients und -Servern in einer Unternehmensumgebung. Windows Server Update Services (WSUS) in Kombination mit Gruppenrichtlinienobjekten (GPOs) ermöglicht die zentrale Steuerung und Verteilung von Updates.

Voraussetzungen:

  • Ein Windows Server (z.B. 2019, 2022) als Mitglied einer Active Directory-Domäne
  • Client-PCs, die Mitglieder derselben Domäne sind
  • Administratorrechte auf dem WSUS-Server und Domain Controller
  • Ausreichend Festplattenspeicher auf dem WSUS-Server (mindestens 200 GB, besser 400 GB+ für alle Updates)
  • Internetzugang auf dem WSUS-Server für den Download von Updates

Schritt-für-Schritt-Anleitung:

  1. WSUS-Rolle installieren:

    Installiere die WSUS-Rolle auf einem Windows Server.

    • Öffne den **Server-Manager**.
    • Klicke auf **Rollen und Features hinzufügen**.
    • Wähle "Rollenbasierte oder featurebasierte Installation".
    • Wähle den Zielserver aus.
    • Aktiviere die Rolle **Windows Server Update Services**.
    • Bestätige die zusätzlichen Features.
    • Wähle die gewünschten Rollendienste:
      • **WID-Datenbank (Windows Internal Database)**: Standard und einfach für kleinere Umgebungen.
      • **WSUS-Dienste**: Kernkomponente.
      • **Datenbank**: Wenn du eine SQL Server-Instanz verwendest (für größere Umgebungen).
    • Gib den Pfad für die Update-Speicherung an (z.B. `D:\WSUS`).
    • Klicke **Weiter** und dann **Installieren**.
    • Nach der Installation starte den **Post-Installations-Task** aus dem Server-Manager (oben rechts, gelbes Ausrufezeichen).
  2. WSUS-Konfiguration abschließen:

    Der Konfigurationsassistent führt dich durch die Grundeinstellungen.

    • Starte die **Windows Server Update Services** Konsole (vom Server-Manager oder den Tools).
    • Folge dem Assistenten:
      • Wähle, ob du am Microsoft Update Improvement Program teilnehmen möchtest.
      • Wähle den Upstream-Server (Microsoft Update oder ein anderer WSUS-Server).
      • Wähle die **Sprachen** für die Updates (wichtig, um Speicherplatz zu sparen).
      • Wähle die **Produkte** aus, für die du Updates erhalten möchtest (z.B. Windows 10, Windows 11, Office, Windows Server).
      • Wähle die **Klassifizierungen** der Updates (z.B. Kritische Updates, Sicherheitsupdates, Feature Packs, Treiber).
      • Lege den **Synchronisierungszeitplan** fest (z.B. täglich).
    • Klicke **Fertig stellen**. Die erste Synchronisierung beginnt. Dies kann sehr lange dauern!
  3. Computer-Gruppen erstellen (optional, aber empfohlen):

    Organisiere deine Clients in Gruppen, um Updates zielgerichtet zu verteilen.

    • Gehe in der WSUS-Konsole zu **Computer** > **Alle Computer**.
    • Rechtsklick auf **Alle Computer** > **Computergruppe hinzufügen...** (z.B. "Test-Clients", "Produktions-Clients", "Server").
  4. Gruppenrichtlinie (GPO) für WSUS-Clients konfigurieren:

    Clients müssen so konfiguriert werden, dass sie Updates vom WSUS-Server beziehen.

    • Öffne die **Gruppenrichtlinienverwaltung** (`gpmc.msc`).
    • Erstelle ein neues GPO (z.B. "WSUS-Client-Einstellungen") und verknüpfe es mit der OU, in der sich deine Client-Computer befinden.
    • Rechtsklick auf das GPO > **Bearbeiten...**.
    • Navigiere zu `Computerkonfiguration` > `Richtlinien` > `Administrative Vorlagen` > `Windows-Komponenten` > `Windows Update`.
    • Konfiguriere folgende Einstellungen (doppelklicken, aktivieren, Werte setzen):
      • **Intranet-Speicherort für den Microsoft Updatedienst angeben:**
        • Intranetupdatedienst für die Erkennung von Updates festlegen: `http://DEIN_WSUS_SERVERNAME:8530`
        • Intranetstatistiken-Server festlegen: `http://DEIN_WSUS_SERVERNAME:8530`
        (Standard-Port ist 8530 für HTTP, 8531 für HTTPS)
      • **Automatische Updates konfigurieren:**
        • Aktiviert.
        • Option 4: Automatisch herunterladen und geplante Installation (empfohlen für die meisten Clients).
        • Geplanter Installationstag: (z.B. 0 - Jeden Tag, 4 - Donnerstag).
        • Geplante Installationszeit: (z.B. 03:00).
      • **Clientseitiges Zielgruppen-Targeting aktivieren:**
        • Aktiviert.
        • Name der Zielgruppe: Gib den Namen der Computergruppe ein, die du in WSUS erstellt hast (z.B. "Test-Clients").
      • **Sofortiges automatisches Update bei geplanter Installation neu starten:** Deaktiviert (um ungewollte Reboots zu verhindern, Benutzer informieren!).
    • Schließe den GPO-Editor.
  5. GPO auf Clients aktualisieren:

    Erzwinge das GPO-Update auf den Clients.

    gpupdate /force

    Die Clients sollten sich nun beim WSUS-Server melden (kann bis zu einer Stunde dauern) und in der WSUS-Konsole unter der entsprechenden Gruppe erscheinen.

    Um einen Client zu zwingen, sich sofort zu melden:

    wuauclt /resetauthorization /detectnow
  6. Updates in WSUS genehmigen:

    Wenn die Clients Updates vom WSUS beziehen, musst du die Updates manuell genehmigen.

    • Gehe in der WSUS-Konsole zu **Updates** > **Alle Updates**.
    • Filtere nach Status (z.B. "Unerledigt" oder "Benötigt").
    • Rechtsklick auf ein Update > **Genehmigen...**.
    • Wähle die Computergruppe(n) aus, für die das Update genehmigt werden soll, und wähle die Genehmigungsmethode (z.B. "Zur Installation genehmigen").
    • Bestätige.

    Die genehmigten Updates werden dann gemäß dem in der GPO festgelegten Zeitplan auf den Clients installiert.

  7. WSUS-Wartung:

    Führe regelmäßig (monatlich) die WSUS-Server-Bereinigung durch, um Speicherplatz freizugeben und die Datenbank zu optimieren.

    • Gehe in der WSUS-Konsole zu **Optionen** > **Serverbereinigungs-Assistent**.
    • Wähle die gewünschten Optionen aus und starte die Bereinigung.

Ein gut konfiguriertes WSUS-System ist ein mächtiges Werkzeug für die effiziente und sichere Verwaltung von Updates in deiner Windows-Umgebung.

Monitoring mit Zabbix unter Debian Linux einrichten

Zabbix ist eine leistungsstarke und umfassende Open-Source-Monitoring-Lösung für Netzwerke, Server, virtuelle Maschinen und Cloud-Dienste. Es bietet eine zentrale Überwachung von Metriken, Verfügbarkeit und Performance sowie flexible Alarmierung und Visualisierung.

Voraussetzungen:

  • Ein Debian-basierter Linux-Server (z.B. Debian 11/12, Ubuntu LTS) mit mindestens 2 GB RAM (besser 4 GB+) und 2 CPU-Kernen für den Zabbix-Server
  • Benutzer mit sudo-Rechten
  • Internetzugang auf dem Zabbix-Server
  • Datenbank-Server (MySQL/MariaDB oder PostgreSQL) installiert und konfiguriert
  • Webserver (Apache oder Nginx) und PHP installiert und konfiguriert (LEMP/LAMP-Stack)
  • Firewall (z.B. UFW) konfiguriert (Ports 80, 443, 10050, 10051 müssen offen sein)

Schritt-für-Schritt-Anleitung:

  1. Zabbix Repository hinzufügen:

    Füge das offizielle Zabbix Repository hinzu, um die neueste stabile Version zu installieren.

    wget https://repo.zabbix.com/zabbix/6.0/debian/pool/main/z/zabbix-release/zabbix-release_6.0-5+debian11_all.deb # Passe die Version an (6.0-5+debian11 oder höher)
    sudo dpkg -i zabbix-release_6.0-5+debian11_all.deb
    sudo apt update
  2. Zabbix Server mit MySQL/MariaDB und Agent installieren:

    Installiere den Zabbix Server, Frontend und den Zabbix Agent.

    sudo apt install zabbix-server-mysql zabbix-frontend-php php-mysql zabbix-apache-conf zabbix-agent -y

    Wenn du PostgreSQL verwendest, ersetze `zabbix-server-mysql` durch `zabbix-server-pgsql`.

  3. Datenbank für Zabbix erstellen:

    Melde dich bei deiner MariaDB/MySQL-Datenbank an und erstelle eine Datenbank und einen Benutzer für Zabbix.

    sudo mysql -u root -p
    
    CREATE DATABASE zabbix character set utf8mb4 collate utf8mb4_bin;
    CREATE USER 'zabbix'@'localhost' IDENTIFIED BY 'dein_zabbix_passwort';
    GRANT ALL PRIVILEGES ON zabbix.* TO 'zabbix'@'localhost';
    FLUSH PRIVILEGES;
    EXIT;
                    

    Importiere das initiale Schema und die Daten in die Zabbix-Datenbank (du wirst nach dem MariaDB/MySQL-Passwort für den Zabbix-Benutzer gefragt):

    sudo zcat /usr/share/doc/zabbix-server-mysql/create.sql.gz | mysql -u zabbix -p zabbix
  4. Zabbix Server konfigurieren:

    Bearbeite die Hauptkonfigurationsdatei des Zabbix Servers, um die Datenbankzugangsdaten einzutragen.

    sudo nano /etc/zabbix/zabbix_server.conf

    Suche und passe folgende Zeilen an:

    
    DBHost=localhost
    DBName=zabbix
    DBUser=zabbix
    DBPassword=dein_zabbix_passwort
                    

    Speichern und schließen.

  5. PHP-Konfiguration für Zabbix Frontend anpassen:

    Für das Zabbix Web-Frontend müssen einige PHP-Einstellungen optimiert werden.

    sudo nano /etc/php/8.x/apache2/php.ini # Für Apache
    # ODER
    sudo nano /etc/php/8.x/fpm/php.ini # Für Nginx mit PHP-FPM
                    

    Passe folgende Werte an (Suche und ändere):

    
    post_max_size = 16M
    max_execution_time = 300
    max_input_time = 300
    memory_limit = 256M
    upload_max_filesize = 2M
    date.timezone = Europe/Berlin # Passe deine Zeitzone an
                    

    Speichern und schließen. Starte den Webserver neu:

    sudo systemctl restart apache2 # Oder nginx und php8.x-fpm
  6. Zabbix Server und Agent starten und aktivieren:
    sudo systemctl enable zabbix-server zabbix-agent
    sudo systemctl start zabbix-server zabbix-agent
    sudo systemctl status zabbix-server zabbix-agent
  7. Firewall (UFW) konfigurieren:

    Erlaube den Zugriff auf die Zabbix-Ports und Webserver-Ports.

    sudo ufw allow 10050/tcp comment 'Zabbix Agent'
    sudo ufw allow 10051/tcp comment 'Zabbix Server'
    sudo ufw allow 'Apache Full' # Oder 'Nginx Full'
    sudo ufw reload
  8. Zabbix Web-Frontend konfigurieren:

    Öffne deinen Webbrowser und navigiere zu `http://DEINE_SERVER_IP/zabbix`.

    • Klicke auf **Next step**.
    • Prüfe, ob alle Voraussetzungen erfüllt sind. Klicke **Next step**.
    • Gib die Datenbankzugangsdaten ein (Name: `zabbix`, Benutzer: `zabbix`, Passwort: `dein_zabbix_passwort`). Klicke **Next step**.
    • Gib Details für den Zabbix Server ein (Host: `localhost` oder die IP des Servers, Port: `10051`). Klicke **Next step**.
    • Bestätige die Zusammenfassung und klicke **Next step**.
    • Klicke **Finish**.

    Du wirst zum Login-Bildschirm weitergeleitet. Der Standard-Login ist `Admin` (großes A) und das Passwort ist `zabbix`.

    Ändere das Standardpasswort sofort nach dem ersten Login!

  9. Ersten Host in Zabbix hinzufügen (optional):

    Der Zabbix Agent, den du installiert hast, kann nun von deinem Zabbix Server überwacht werden.

    • Melde dich im Zabbix Frontend an.
    • Gehe zu **Configuration** > **Hosts**.
    • Klicke auf **Create host**.
    • Gib den Hostnamen (z.B. `MeinServer`), den sichtbaren Namen und wähle eine Gruppe aus (z.B. `Linux servers`).
    • Unter **Interfaces** klicke auf **Add** > **Agent**. Gib die IP-Adresse deines Zabbix-Servers (die IP, unter der der Agent lauscht, meist 127.0.0.1 für den lokalen Agenten) und Port 10050 ein.
    • Gehe zum Tab **Templates** und klicke auf **Select**. Suche nach `Template OS Linux by Zabbix agent` und wähle es aus. Klicke **Select** und dann **Add**.
    • Klicke **Add** (ganz unten), um den Host hinzuzufügen.

    Nach kurzer Zeit sollte der Status des Agenten grün werden, und du kannst unter **Monitoring** > **Latest data** Metriken von deinem Server sehen.

Dein Zabbix Monitoring-System ist nun eingerichtet und bereit, deine Infrastruktur zu überwachen!

Hardware-Informationen unter Linux abrufen und analysieren

Als Fachinformatiker für Systemintegration ist es unerlässlich, Hardware-Informationen von Linux-Systemen schnell und präzise abrufen zu können. Dies ist wichtig für die Fehlersuche, die Systeminventarisierung oder die Planung von Upgrades. Linux bietet eine Vielzahl von Befehlen und Tools, um detaillierte Informationen über CPU, RAM, Speichermedien, Netzwerkadapter und andere Peripheriegeräte zu erhalten.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu, CentOS)
  • Terminalzugriff
  • Benutzer mit sudo-Rechten (für einige detailliertere Befehle)

Schritt-für-Schritt-Anleitung:

  1. CPU-Informationen abrufen:

    Detaillierte Informationen zur CPU findest du in `/proc/cpuinfo`.

    cat /proc/cpuinfo | less

    Für eine zusammenfassende Übersicht (Anzahl der Kerne, Threads):

    lscpu
  2. Arbeitsspeicher (RAM) Informationen:

    Die Gesamtgröße und Nutzung des RAMs wird mit `free -h` angezeigt.

    free -h

    Detaillierte Informationen über die RAM-Module (Größe, Geschwindigkeit, Hersteller) erhältst du mit `dmidecode` (als root ausführen).

    sudo dmidecode -t memory | less

    Oder nur die Module:

    sudo dmidecode -t 17
  3. Festplatten und Speichermedien:

    Liste alle Blockgeräte (Festplatten, Partitionen) auf:

    lsblk -f

    Zeigt Dateisystemtypen, UUIDs, Mountpoints und Label an.

    Für detailliertere Informationen zu SATA/SAS/NVMe-Geräten (Hersteller, Modell, Seriennummer, Firmware-Version):

    sudo smartctl -a /dev/sda # Ersetze /dev/sda durch dein Festplattengerät

    (Eventuell `sudo apt install smartmontools` nötig).

    Anzeigen der Festplattennutzung pro Partition:

    df -h
  4. PCI-Geräte (Grafikkarten, Netzwerkadapter, USB-Controller etc.):

    Liste alle PCI-Geräte auf (Grafikkarten, Netzwerkadapter, Soundkarten, USB-Controller).

    lspci

    Für detailliertere Informationen (`-nn` zeigt Hersteller-IDs an, `-k` zeigt Kernel-Treiber an):

    lspci -knn
  5. USB-Geräte:

    Liste aller angeschlossenen USB-Geräte:

    lsusb

    Detailliertere Informationen (`-v` für verbose):

    lsusb -v | less
  6. Netzwerkadapter-Informationen:

    Zeigt alle Netzwerkschnittstellen und deren Status an (IP, MAC-Adresse).

    ip a

    Für detaillierte Hardware-Informationen des Netzwerkadapters (Hersteller, Modell, Firmware, unterstützte Geschwindigkeiten):

    ethtool  # z.B. ethtool eth0 oder ethtool enp0s3

    (Eventuell `sudo apt install ethtool` nötig).

  7. Gesamte Systemzusammenfassung:

    Das Tool `hwinfo` kann eine sehr umfassende Übersicht über die gesamte Hardware geben.

    sudo apt install hwinfo -y # Installation
    sudo hwinfo --short # Kurze Zusammenfassung
    sudo hwinfo # Vollständiger Bericht (sehr lang!)

    Das Tool `inxi` ist ebenfalls sehr beliebt für schnelle Systemübersichten.

    sudo apt install inxi -y # Installation
    inxi -Fz # Vollständige Systemübersicht (ohne private IPs)
  8. Kernel- und System-Informationen:

    Kernel-Version:

    uname -r

    Betriebssystem-Release-Informationen:

    cat /etc/os-release

Mit diesen Befehlen kannst du eine umfassende Hardware-Inventur deiner Linux-Systeme durchführen und schnell die benötigten Informationen finden.

WLAN-Repeater mit ESP8266MOD einrichten

Einrichtung eines kostengünstigen WLAN-Repeaters oder Access Points mithilfe eines ESP8266MOD Microcontrollers. Dies ist eine praktische Lösung für einfache Netzwerkaufgaben und die Erweiterung bestehender WLAN-Bereiche.

Voraussetzungen:

  • Ein ESP8266MOD (z.B. NodeMCU ESP-12E oder Wemos D1 Mini)
  • Ein USB-Kabel (passend für Ihr Board)
  • Die Arduino IDE auf Ihrem Computer installiert
  • ESP8266 Board-Paket in der Arduino IDE installiert (siehe Schritt 1)
  • Ein WLAN-Netzwerk, das erweitert werden soll
  • Internetzugang (für die Installation der Software)

Schritt-für-Schritt-Anleitung:

  1. Arduino IDE für ESP8266 vorbereiten:

    Falls noch nicht geschehen, müssen Sie die Unterstützung für ESP8266-Boards in der Arduino IDE hinzufügen.

    • Öffnen Sie die Arduino IDE und gehen Sie zu **Datei** > **Voreinstellungen**.
    • Fügen Sie unter "Zusätzliche Boardverwalter-URLs" die URL http://arduino.esp8266.com/stable/package_esp8266com_index.json hinzu. Trennen Sie mehrere URLs mit einem Komma, falls schon andere vorhanden sind.
    • Gehen Sie zu **Werkzeuge** > **Board** > **Boardverwalter...**.
    • Suchen Sie nach "esp8266" und installieren Sie das "ESP8266 by ESP8266 Community" Paket.
    • Gehen Sie erneut zu **Werkzeuge** > **Board** und wählen Sie Ihr spezifisches ESP8266-Board aus (z.B. "NodeMCU 1.0 (ESP-12E Module)" oder "Wemos D1 Mini").
    • Wählen Sie den korrekten **Port** aus, an dem Ihr ESP8266 angeschlossen ist (z.B. COM3 auf Windows, /dev/ttyUSB0 auf Linux).
  2. WLAN-Repeater-Sketch hochladen:

    Der ESP8266 kann als Repeater oder Access Point konfiguriert werden. Wir nutzen ein Beispiel-Sketch, das ein vorhandenes WLAN aufgreift und als neuen Access Point bereitstellt.

    Kopieren Sie den folgenden Code in ein neues Sketch-Fenster in der Arduino IDE:

    
    #include <ESP8266WiFi.h>
    #include <ESP8266WebServer.h>
    #include <DNSServer.h>
    #include <WiFiManager.h> // Für einfache Konfiguration beim ersten Start
    
    // WLAN-Daten des Routers, zu dem sich der Repeater verbinden soll
    // NICHT hier direkt eintragen, sondern die WiFiManager Funktion nutzen!
    // const char* ssid_sta = "MEIN_BESTEHENDES_WLAN";
    // const char* password_sta = "MEIN_BESTEHENDES_WLAN_PASSWORT";
    
    // SSID und Passwort des neuen Access Points (Repeater)
    const char* ap_ssid = "ESP8266_Repeater";
    const char* ap_password = "repeaterpassword"; // Mindestens 8 Zeichen
    
    void setup() {
      Serial.begin(115200);
      Serial.println("\nStarte ESP8266 WLAN-Repeater...");
    
      // WiFiManager initialisieren. Wenn kein WLAN konfiguriert ist,
      // erstellt er einen temporären Access Point zur Konfiguration.
      WiFiManager wifiManager;
    
      // Setze Callback für wenn ein Konfigurationsportal gestartet wird (Debug-Zwecke)
      wifiManager.setAPCallback(configModeCallback);
    
      // Versuche, sich mit dem zuletzt gespeicherten WLAN zu verbinden.
      // Wenn fehlgeschlagen oder nicht konfiguriert, starte Konfigurationsportal.
      if (!wifiManager.autoConnect(ap_ssid, ap_password)) {
        Serial.println("Verbindung fehlgeschlagen und Konfigurations-AP wurde getrennt. Neustart...");
        delay(3000);
        ESP.restart();
      }
      Serial.println("WLAN verbunden!");
      Serial.print("Verbunden mit: ");
      Serial.println(WiFi.SSID());
      Serial.print("IP-Adresse: ");
      Serial.println(WiFi.localIP());
    
      // Starte den ESP8266 im AP+STA Modus (Access Point + Station)
      // Dies ermöglicht es, sich mit einem WLAN zu verbinden (STA) UND
      // selbst ein WLAN (AP) zu hosten.
      WiFi.mode(WIFI_AP_STA);
    
      // Konfiguriere den Access Point (den Repeater-Modus)
      // WICHTIG: Die AP-IP sollte NICHT mit der Client-IP kollidieren!
      // Hier nutzen wir ein anderes Subnetz für den AP.
      IPAddress ap_local_ip(192, 168, 4, 1);
      IPAddress ap_gateway(192, 168, 4, 1);
      IPAddress ap_subnet(255, 255, 255, 0);
    
      WiFi.softAPConfig(ap_local_ip, ap_gateway, ap_subnet);
      WiFi.softAP(ap_ssid, ap_password);
    
      Serial.print("Repeater AP gestartet: ");
      Serial.print(ap_ssid);
      Serial.print(" mit IP ");
      Serial.println(WiFi.softAPIP());
    
      // Optional: DHCP-Server für den Access Point des Repeaters aktivieren
      // Dieser ist bei WiFi.softAPConfig in der Regel bereits enthalten.
    }
    
    void loop() {
      // Haupt-Loop. Der Repeater-Modus läuft im Hintergrund.
      // Hier können weitere Funktionen hinzugefügt werden, z.B. Datenloggen etc.
      // Für einen reinen Repeater ist diese Loop oft leer oder für Debugging-Ausgaben.
    
      // Überprüfen, ob die STA-Verbindung noch besteht
      if (WiFi.status() != WL_CONNECTED) {
        Serial.println("WLAN-Verbindung zum Hauptrouter verloren. Versuche Neuverbindung...");
        delay(100);
        // Hier könnte man versuchen, die autoConnect-Funktion erneut aufzurufen
        // oder einfach einen Neustart erzwingen.
        ESP.restart();
      }
      delay(1000); // Eine kleine Verzögerung, um den ESP nicht zu überlasten
    }
    
    void configModeCallback (WiFiManager *myWiFiManager) {
      Serial.println("In den Konfigurationsmodus gewechselt (AP gestartet)");
      Serial.print("Öffnen Sie einen Browser und navigieren Sie zu: ");
      Serial.println(myWiFiManager->getConfigPortalURL());
      Serial.println("Warten auf Verbindung...");
    }
                    

    Erläuterung des Codes:

    • Das Skript nutzt die `WiFiManager`-Bibliothek. Diese ist sehr nützlich, da sie beim ersten Start (oder wenn die Zugangsdaten zum Router verloren gehen) einen eigenen Access Point (`ESP8266_Repeater`) erstellt. Verbinden Sie sich damit von Ihrem PC/Smartphone und Sie können über ein Webinterface die Zugangsdaten zu Ihrem Haupt-WLAN eingeben.
    • Nachdem sich der ESP8266 mit Ihrem Haupt-WLAN verbunden hat, startet er einen neuen Access Point mit der definierten SSID (`ESP8266_Repeater`) und dem Passwort. Geräte, die sich mit diesem AP verbinden, erhalten eine IP-Adresse aus dem 192.168.4.x-Bereich (dies ist ein eigenes Subnetz, damit es nicht mit Ihrem Haupt-WLAN kollidiert) und routen den Traffic über den ESP8266 zum Haupt-WLAN.
  3. Zusätzliche Bibliothek installieren (WiFiManager):

    Dieses Sketch benötigt die "WiFiManager" Bibliothek. Diese müssen Sie manuell installieren:

    • Gehen Sie in der Arduino IDE zu **Sketch** > **Bibliothek einbinden** > **Bibliotheken verwalten...**.
    • Suchen Sie nach "WiFiManager" und installieren Sie die Version von "tzapu".
  4. Sketch hochladen:

    Stellen Sie sicher, dass Ihr ESP8266 mit dem Computer verbunden ist und das richtige Board sowie der richtige Port in der Arduino IDE ausgewählt sind.

    Klicken Sie auf den **Pfeil-Button** (Hochladen) in der oberen linken Ecke der Arduino IDE. Beobachten Sie die Statusmeldungen in der Konsole. Wenn der Upload erfolgreich war, leuchten die TX/RX-LEDs auf dem ESP kurz auf.

  5. Erste Konfiguration über Webinterface:

    Öffnen Sie nach dem Hochladen den **Seriellen Monitor** in der Arduino IDE (Symbol mit der Lupe oben rechts) und wählen Sie die Baudrate **115200**.

    • Wenn der ESP8266 das erste Mal startet (oder keine gespeicherten WLAN-Daten findet), erstellt er einen Access Point namens "ESP8266_Repeater".
    • Verbinden Sie sich mit Ihrem PC oder Smartphone mit diesem WLAN.
    • Öffnen Sie einen Webbrowser und navigieren Sie zu `192.168.4.1` (oder der im seriellen Monitor angezeigten Konfigurations-URL).
    • Sie sollten ein Webinterface sehen. Klicken Sie auf "Configure WiFi". Wählen Sie Ihr Heim-WLAN aus der Liste aus und geben Sie das Passwort ein. Speichern Sie die Einstellungen.
    • Der ESP8266 wird sich nun neu starten, mit Ihrem Heim-WLAN verbinden und dann den Repeater-AP starten.
  6. Repeater im eigenen Netzwerk testen:

    Nachdem der ESP8266 erfolgreich mit Ihrem Heim-WLAN verbunden ist, sollte der Access Point "ESP8266_Repeater" aktiv sein.

    • Verbinden Sie ein Gerät (Smartphone, Laptop) mit dem WLAN "ESP8266_Repeater".
    • Überprüfen Sie, ob das Gerät eine IP-Adresse im Bereich 192.168.4.x erhalten hat und Internetzugang hat.
    • Sie haben nun einen funktionierenden WLAN-Repeater mit Ihrem ESP8266MOD!

Der ESP8266MOD ist eine flexible und kostengünstige Möglichkeit, Ihr WLAN zu erweitern oder als kleinen, tragbaren Access Point zu nutzen. Die `WiFiManager`-Bibliothek vereinfacht die Erstkonfiguration erheblich.

Mini-WLAN-Roboter (Rover) mit ESP8266MOD bauen

Bauen Sie einen einfachen, per WLAN steuerbaren Roboter (Rover) mit einem ESP8266MOD. Dieses Projekt vermittelt grundlegende Kenntnisse in der Motorsteuerung, Webserver-Programmierung auf einem Mikrocontroller und drahtloser Kommunikation – ideal für Fachinformatiker mit Interesse an IoT und Robotik.

Voraussetzungen:

  • Ein ESP8266MOD-Board (z.B. NodeMCU ESP-12E oder Wemos D1 Mini)
  • Ein USB-Kabel (passend für Ihr Board)
  • Ein Motortreiber-Modul (z.B. L298N Dual H-Bridge Modul)
  • Zwei kleine Gleichstrommotoren (DC-Motoren), idealerweise mit Getriebe
  • Ein kleines Roboter-Chassis / Fahrgestell mit Rädern (oder selbst gebaut/3D-gedruckt)
  • Eine Stromquelle für den Roboter (z.B. 4x AA-Batterien in einem Halter oder eine Powerbank mit 5V-Ausgang). Beachten Sie die Spannungsanforderungen Ihrer Motoren und des L298N Moduls.
  • Steckbrett (optional, für den Aufbau) und Jumperkabel (Male-Male, Male-Female)
  • Die Arduino IDE auf Ihrem Computer installiert
  • ESP8266 Board-Paket in der Arduino IDE installiert (siehe Schritt 1 der ESP8266 WLAN-Repeater Anleitung)
  • Optional: Ultraschallsensor HC-SR04 (für Hinderniserkennung)

Schritt-für-Schritt-Anleitung:

  1. Hardware zusammenbauen und verdrahten:

    Beginnen Sie mit dem mechanischen Aufbau und der elektrischen Verdrahtung.

    • Befestigen Sie die beiden Gleichstrommotoren am Roboter-Chassis.
    • Platzieren Sie das ESP8266-Board und das L298N-Motortreiber-Modul auf dem Chassis.
    • Motoren mit L298N verbinden:
      • Verbinden Sie die beiden Anschlüsse des Motors 1 mit den Ausgängen `OUT1` und `OUT2` des L298N.
      • Verbinden Sie die beiden Anschlüsse des Motors 2 mit den Ausgängen `OUT3` und `OUT4` des L298N.
    • Stromversorgung für L298N:
      • Verbinden Sie den positiven Pol Ihrer Batterie/Powerbank mit dem `+12V` (oder `+5V` je nach Modul und Motoren) Eingang des L298N.
      • Verbinden Sie den negativen Pol Ihrer Batterie/Powerbank mit dem `GND` (Ground) Eingang des L298N.
      • **Wichtig:** Stellen Sie sicher, dass Ihre Motoren mit der gewählten Spannung kompatibel sind. Viele L298N-Module haben einen 5V-Regler; Sie können den 5V-Ausgang (`5V-EN` oder `5V`) des L298N nutzen, um das ESP8266MOD-Board zu versorgen (Verbindung zu `VIN` oder `5V` des ESP). Verbinden Sie auch die `GND`-Pins von L298N und ESP miteinander.
    • ESP8266 (NodeMCU/Wemos) mit L298N verbinden (Steuerung):

      Die genaue Pin-Belegung kann variieren, dies ist ein gängiges Beispiel:

      • ESP D1 (GPIO5) an L298N `IN1`
      • ESP D2 (GPIO4) an L298N `IN2`
      • ESP D5 (GPIO14) an L298N `IN3`
      • ESP D6 (GPIO12) an L298N `IN4`
      • Optional: ESP D7 (GPIO13) an L298N `ENA` (Enable Motor A, für PWM-Geschwindigkeitssteuerung)
      • Optional: ESP D8 (GPIO15) an L298N `ENB` (Enable Motor B)

      Falls `ENA`/`ENB` nicht verwendet werden sollen, entfernen Sie die Jumper auf dem L298N-Modul, die diese Pins mit 5V verbinden (dauerhaft volle Geschwindigkeit).

    • **Optional: Ultraschallsensor (HC-SR04) verbinden:**
      • HC-SR04 `VCC` an ESP `3V3` oder `5V` (je nach Sensor-Version)
      • HC-SR04 `GND` an ESP `GND`
      • HC-SR04 `Trig` an ESP D3 (GPIO0)
      • HC-SR04 `Echo` an ESP D4 (GPIO2)
  2. Arduino IDE einrichten und benötigte Bibliotheken installieren:
    • Stellen Sie sicher, dass das ESP8266 Board-Paket installiert ist (siehe ESP8266 WLAN-Repeater Anleitung Schritt 1).
    • Wählen Sie Ihr spezifisches ESP8266-Board unter **Werkzeuge** > **Board**.
    • Installieren Sie die folgenden Bibliotheken über **Sketch** > **Bibliothek einbinden** > **Bibliotheken verwalten...**:
      • `ESP8266WiFi` (Standard, sollte dabei sein)
      • `ESP8266WebServer` (Standard, sollte dabei sein)
      • Optional: `NewPing` (für HC-SR04 Ultraschallsensor)
  3. Programmierung (Sketch) des Roboters:

    Kopieren Sie den folgenden Code in ein neues Sketch-Fenster. Passen Sie die WLAN-Zugangsdaten an.

    
    #include <ESP8266WiFi.h>
    #include <ESP8266WebServer.h>
    
    // WLAN-Zugangsdaten
    const char* ssid = "DEIN_WLAN_NAME";
    const char* password = "DEIN_WLAN_PASSWORT";
    
    // Pins für den L298N Motortreiber
    const int IN1 = D1; // GPIO5 (Motor 1 - Vorwärts/Rückwärts)
    const int IN2 = D2; // GPIO4
    const int IN3 = D5; // GPIO14 (Motor 2 - Vorwärts/Rückwärts)
    const int IN4 = D6; // GPIO12
    // Optional: Enable Pins, falls Geschwindigkeitskontrolle benötigt (mit PWM)
    // const int ENA = D7; // GPIO13
    // const int ENB = D8; // GPIO15
    
    // Optional: Für Ultraschallsensor HC-SR04
    // #include <NewPing.h>
    // const int TRIGGER_PIN = D3; // GPIO0
    // const int ECHO_PIN = D4;    // GPIO2
    // const int MAX_DISTANCE = 200; // Maximale Entfernung in cm
    // NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
    
    ESP8266WebServer server(80);
    
    void setup() {
      Serial.begin(115200);
      delay(100);
    
      // Motortreiber-Pins als OUTPUT definieren
      pinMode(IN1, OUTPUT);
      pinMode(IN2, OUTPUT);
      pinMode(IN3, OUTPUT);
      pinMode(IN4, OUTPUT);
      // Optional: pinMode(ENA, OUTPUT);
      // Optional: pinMode(ENB, OUTPUT);
    
      // Motoren am Anfang stoppen
      stopMotors();
    
      Serial.print("Verbinde mit WLAN ");
      Serial.println(ssid);
      WiFi.begin(ssid, password);
    
      while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
      }
    
      Serial.println("\nWLAN verbunden!");
      Serial.print("IP-Adresse: ");
      Serial.println(WiFi.localIP());
    
      // Definition der HTTP-Endpunkte
      server.on("/", handleRoot);
      server.on("/forward", handleForward);
      server.on("/backward", handleBackward);
      server.on("/left", handleLeft);
      server.on("/right", handleRight);
      server.on("/stop", handleStop);
      // Optional: server.on("/distance", handleDistance); // Für Ultraschallsensor
    
      server.begin();
      Serial.println("HTTP-Server gestartet");
    }
    
    void loop() {
      server.handleClient();
      // Optional: Hier könnte man kontinuierlich die Entfernung messen
      // unsigned int distance = sonar.ping_cm();
      // Serial.print("Entfernung: ");
      // Serial.print(distance);
      // Serial.println(" cm");
      // if (distance > 0 && distance < 10) { // Wenn Objekt sehr nah
      //   stopMotors();
      // }
      delay(10); // Kurze Verzögerung für stabilen Betrieb
    }
    
    void stopMotors() {
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, LOW);
      digitalWrite(IN3, LOW);
      digitalWrite(IN4, LOW);
      // Optional: analogWrite(ENA, 0);
      // Optional: analogWrite(ENB, 0);
    }
    
    void moveForward() {
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      digitalWrite(IN3, HIGH);
      digitalWrite(IN4, LOW);
      // Optional: analogWrite(ENA, 255); // Volle Geschwindigkeit
      // Optional: analogWrite(ENB, 255);
      Serial.println("Vorwärts");
    }
    
    void moveBackward() {
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      digitalWrite(IN3, LOW);
      digitalWrite(IN4, HIGH);
      Serial.println("Rückwärts");
    }
    
    void turnLeft() {
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH); // Linker Motor rückwärts
      digitalWrite(IN3, HIGH); // Rechter Motor vorwärts
      digitalWrite(IN4, LOW);
      Serial.println("Links");
    }
    
    void turnRight() {
      digitalWrite(IN1, HIGH); // Linker Motor vorwärts
      digitalWrite(IN2, LOW);
      digitalWrite(IN3, LOW); // Rechter Motor rückwärts
      digitalWrite(IN4, HIGH);
      Serial.println("Rechts");
    }
    
    void handleRoot() {
      String html = R"rawliteral(
        
        
        
            ESP8266 Roboter-Steuerung
            
            
        
        
            

    Roboter-Steuerung

    Verwenden Sie die Tasten, um den Roboter zu steuern.

    )rawliteral"; server.send(200, "text/html", html); } void handleForward() { moveForward(); server.send(200, "text/plain", "Vorwärts"); } void handleBackward() { moveBackward(); server.send(200, "text/plain", "Rückwärts"); } void handleLeft() { turnLeft(); server.send(200, "text/plain", "Links"); } void handleRight() { turnRight(); server.send(200, "text/plain", "Rechts"); } void handleStop() { stopMotors(); server.send(200, "text/plain", "Stop"); } // Optional: Für Ultraschallsensor /* void handleDistance() { unsigned int distance = sonar.ping_cm(); String response = "Distanz: " + String(distance) + " cm"; server.send(200, "text/plain", response); } */

    Wichtige Anpassungen im Code:

    • Ersetzen Sie `DEIN_WLAN_NAME` und `DEIN_WLAN_PASSWORT` durch Ihre tatsächlichen WLAN-Zugangsdaten.
    • Überprüfen Sie die Pin-Belegung für `IN1` bis `IN4` (und optional `ENA`/`ENB`) entsprechend Ihrer Verdrahtung des L298N-Moduls mit dem ESP8266. Die gezeigten Pins (D1, D2, D5, D6) sind typisch für NodeMCU.
    • Wenn Sie den Ultraschallsensor verwenden möchten, entkommentieren Sie die entsprechenden Zeilen (`#include `, `TRIGGER_PIN`, `ECHO_PIN`, `MAX_DISTANCE`, `NewPing sonar(...)` und die Funktion `handleDistance()`). Installieren Sie dann die `NewPing`-Bibliothek.
  4. Sketch hochladen:

    Verbinden Sie Ihr ESP8266-Board über USB mit Ihrem Computer. Wählen Sie den richtigen **Port** in der Arduino IDE unter **Werkzeuge** > **Port**.

    Klicken Sie auf den **Pfeil-Button** (Hochladen) in der Arduino IDE. Beobachten Sie die Konsole auf Fehlermeldungen. Während des Hochladens müssen Sie bei einigen ESP-Boards möglicherweise die "Flash"- oder "Boot"-Taste gedrückt halten, bis der Upload beginnt.

  5. Roboter steuern:

    Nach erfolgreichem Hochladen öffnen Sie den **Seriellen Monitor** in der Arduino IDE (Baudrate: **115200**), um die IP-Adresse zu sehen, die Ihr ESP8266 erhalten hat (z.B. `192.168.1.XXX`).

    • Trennen Sie den ESP8266 vom USB-Kabel des Computers und versorgen Sie ihn über die Batterie/Powerbank.
    • Verbinden Sie ein Smartphone oder einen PC im selben WLAN mit dem Roboter.
    • Öffnen Sie einen Webbrowser und geben Sie die IP-Adresse des ESP8266 ein (z.B. `http://192.168.1.XXX`).
    • Sie sollten nun die einfache Steuerungsoberfläche mit den Buttons "Vorwärts", "Rückwärts", "Links", "Rechts" und "STOP" sehen. Klicken Sie darauf, um Ihren Roboter zu bewegen!

Dieser Mini-WLAN-Roboter ist ein fantastisches Einstiegsprojekt, um sich mit der drahtlosen Steuerung von Hardware vertraut zu machen. Er lässt sich leicht erweitern, z.B. mit weiteren Sensoren, LEDs oder komplexeren Fahrfunktionen.

Docker Compose für Multi-Container-Anwendungen

Docker Compose ist ein Tool zum Definieren und Ausführen von Multi-Container-Docker-Anwendungen. Mit einer einzigen YAML-Datei kannst du alle Dienste, Netzwerke und Volumes deiner Anwendung konfigurieren und mit einem einzigen Befehl starten.

Voraussetzungen:

  • Ein Linux-Server mit installiertem Docker
  • docker-compose installiert (sudo apt install docker-compose)
  • Grundkenntnisse in Docker

Schritt-für-Schritt-Anleitung:

  1. docker-compose.yml-Datei erstellen: Erstelle eine Datei namens docker-compose.yml im Projektverzeichnis.
    version: '3.8'
    services:
      webserver:
        image: nginx:latest
        ports:
          - "80:80"
        volumes:
          - ./html:/usr/share/nginx/html
      php:
        image: php:8.2-fpm
        volumes:
          - ./html:/var/www/html
      mysql:
        image: mysql:8.0
        environment:
          MYSQL_ROOT_PASSWORD: root_password
          MYSQL_DATABASE: my_database
          MYSQL_USER: my_user
          MYSQL_PASSWORD: my_password
  2. Verzeichnisse erstellen: Lege die benötigten lokalen Verzeichnisse an.
    mkdir html
  3. Dienste starten: Navigiere in das Verzeichnis mit der docker-compose.yml und starte die Anwendung.
    sudo docker-compose up -d
  4. Dienste stoppen: Um die Dienste zu stoppen und zu entfernen, verwende den folgenden Befehl:
    sudo docker-compose down
  5. Dienste überprüfen: Mit sudo docker-compose ps kannst du den Status aller Dienste sehen.

FirewallD auf CentOS/RHEL konfigurieren

FirewallD ist der dynamische Daemon zur Verwaltung der Firewall unter Red Hat Enterprise Linux und CentOS. Es verwendet "Zonen", um Regeln basierend auf der Vertrauensstufe der Netzwerkschnittstelle zu verwalten.

Voraussetzungen:

  • Ein CentOS- oder RHEL-System
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Status der FirewallD überprüfen:
    sudo systemctl status firewalld
    Falls nicht aktiv, starte und aktiviere den Dienst: sudo systemctl start firewalld && sudo systemctl enable firewalld
  2. Verfügbare Zonen anzeigen:
    sudo firewall-cmd --get-zones
  3. Dienste in einer Zone hinzufügen: Erlaube den HTTP-Verkehr dauerhaft in der "public" Zone.
    sudo firewall-cmd --zone=public --add-service=http --permanent
  4. Ports in einer Zone hinzufügen: Erlaube Port 8080/TCP dauerhaft.
    sudo firewall-cmd --zone=public --add-port=8080/tcp --permanent
  5. Regeln anwenden: Lade die Firewall neu, um die Änderungen zu übernehmen.
    sudo firewall-cmd --reload
  6. Aktive Regeln überprüfen:
    sudo firewall-cmd --zone=public --list-all

Interne Zertifizierungsstelle (CA) mit Active Directory Certificate Services (AD CS)

Die Einrichtung einer internen Zertifizierungsstelle (CA) ist entscheidend, um eigene SSL/TLS-Zertifikate für interne Server, Webseiten und VPNs auszustellen und zu verwalten.

Voraussetzungen:

  • Ein Windows Server in einer Active Directory-Domäne
  • Administratorrechte auf dem Server
  • DNS-Namen für den CA-Server

Schritt-für-Schritt-Anleitung:

  1. AD CS-Rolle installieren: Öffne den **Server-Manager** und wähle **Rollen und Features hinzufügen**.
  2. Rolle auswählen: Wähle **Active Directory-Zertifikatdienste** aus der Liste der Serverrollen aus.
  3. Rollendienste festlegen: Wähle **Zertifizierungsstelle** aus. Für die meisten Zwecke reicht dies aus.
  4. Konfigurieren: Nach der Installation führe die **Post-Installationskonfiguration** aus.
    • **Setup-Typ:** Wähle "Unternehmens-CA".
    • **CA-Typ:** Wähle "Stammzertifizierungsstelle".
    • **Privater Schlüssel:** Erstelle einen neuen privaten Schlüssel.
    • **Common Name:** Gib einen eindeutigen Namen für deine CA an (z.B. firma-ca).
    • **Gültigkeitsdauer:** Lege die Gültigkeitsdauer für das CA-Zertifikat fest.
  5. Zertifizierungsstelle starten: Nach Abschluss der Konfiguration kannst du die **Zertifizierungsstelle-Konsole** öffnen, um Zertifikate auszustellen und zu verwalten.
  6. Zertifikatsanfragen annehmen: Clients in der Domäne vertrauen der CA automatisch. Du kannst jetzt Zertifikate für Webserver, VPNs usw. ausstellen.

Automatisierung mit Ansible – Dein erster Playbook

Ansible ist ein Open-Source-Tool für die IT-Automatisierung, das die Konfiguration von Servern, die Bereitstellung von Software und die Orchestrierung von Aufgaben vereinfacht. Es arbeitet agentenlos und nutzt SSH.

Voraussetzungen:

  • Ein Linux-System (Controller) mit installiertem Ansible (sudo apt install ansible)
  • Zugriff auf die Zielsysteme per SSH ohne Passwort (ssh-keygen und ssh-copy-id)

Schritt-für-Schritt-Anleitung:

  1. Inventory-Datei erstellen: Erstelle eine Datei namens hosts, die deine Zielsysteme definiert.
    [webserver]
    192.168.1.10
    [database]
    192.168.1.20
  2. Ad-Hoc-Befehl ausführen: Teste die Verbindung zu allen Hosts.
    ansible all -i hosts -m ping
  3. Playbook erstellen: Schreibe ein Playbook in YAML-Format, um eine Aufgabe auszuführen (z. B. Apache installieren).
    ---
    - name: Apache Webserver installieren
      hosts: webserver
      become: yes
      tasks:
        - name: Apache-Paket installieren
          apt:
            name: apache2
            state: present
        - name: Apache-Dienst starten und aktivieren
          service:
            name: apache2
            state: started
            enabled: yes
  4. Playbook ausführen:
    ansible-playbook -i hosts mein_playbook.yml

Git für die Verwaltung von Konfigurationsdateien

Git ist ein dezentrales Versionskontrollsystem, das nicht nur für die Softwareentwicklung nützlich ist, sondern auch für die Verwaltung von Konfigurationsdateien, Skripten und anderen IT-Ressourcen.

Voraussetzungen:

  • Ein Linux-System mit installiertem Git (sudo apt install git)

Schritt-für-Schritt-Anleitung:

  1. Git-Repository initialisieren: Navigiere in das Verzeichnis, das du versionieren möchtest.
    cd /etc/apache2
    sudo git init
  2. Ersten Commit erstellen: Füge die Konfigurationsdateien hinzu und mache den ersten Commit.
    sudo git add .
    sudo git commit -m "Erster Commit der Apache-Konfiguration"
  3. Änderungen verfolgen: Nimm eine Änderung an einer Datei vor und sieh sie dir an.
    sudo nano apache2.conf
    sudo git status
    sudo git diff
  4. Änderungen übernehmen:
    sudo git add apache2.conf
    sudo git commit -m "Port auf 8080 geändert"
  5. Änderungen zurücksetzen: Um zu einer früheren Version zurückzukehren, verwende den Commit-Hash.
    sudo git log --oneline
    sudo git reset --hard 

iSCSI-Target unter Linux einrichten

iSCSI (Internet Small Computer System Interface) ist ein Netzwerkprotokoll zur Übertragung von Speicherblöcken über TCP/IP-Netzwerke. Dies ermöglicht es, Speicherplatz von einem Server (Target) über das Netzwerk bereitzustellen und von einem Client (Initiator) als lokale Festplatte einzubinden.

Voraussetzungen:

  • Ein Linux-Server mit einer zusätzlichen Festplatte oder Partition (Target)
  • Ein Linux- oder Windows-Client (Initiator)
  • Internetzugang (für die Installation)

Schritt-für-Schritt-Anleitung:

  1. Target-Server-Software installieren:
    sudo apt install lio-utils targetcli-fb -y
  2. iSCSI-Target konfigurieren: Öffne die targetcli Shell.
    sudo targetcli
    /backstores/block create iscsi_lun /dev/sdb
    /iscsi create iqn.2025-07.com.deineserver:storage.deineserver
    /iscsi/iqn.2025-07.com.deineserver:storage.deineserver/tpg1/luns create /backstores/block/iscsi_lun
    /iscsi/iqn.2025-07.com.deineserver:storage.deineserver/tpg1/acls create iqn.2025-07.com.deineserver:client
    /iscsi/iqn.2025-07.com.deineserver:storage.deineserver/tpg1/portals create 192.168.1.10
    exit
  3. Firewall anpassen: Erlaube den iSCSI-Port (3260/tcp).
    sudo ufw allow 3260/tcp
  4. Client (Initiator) einrichten: Installiere auf dem Client den iSCSI Initiator und verbinde dich.
    # Linux-Client
    sudo apt install open-iscsi -y
    sudo iscsiadm -m discovery -t sendtargets -p 192.168.1.10
    sudo iscsiadm -m node --loginall=all
    # Windows-Client
    Öffne "iSCSI-Initiator", gib die IP des Targets an und klicke auf "Verbinden".
  5. Speicher nutzen: Auf dem Client erscheint das neue iSCSI-Laufwerk als lokale Festplatte und kann partitioniert und formatiert werden.

Erweiterte Linux-Dateiberechtigungen (ACLs)

Linux verwendet standardmäßig UGO-Berechtigungen (User, Group, Others). Mit ACLs (Access Control Lists) kannst du detailliertere Berechtigungen für einzelne Benutzer und Gruppen vergeben, die nicht in der Standard-UGO-Struktur enthalten sind.

Voraussetzungen:

  • Ein Linux-System
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. ACL-Tools installieren:
    sudo apt install acl -y
  2. Dateisystem-Support überprüfen: Stelle sicher, dass dein Dateisystem (z. B. ext4) ACLs unterstützt.
    tune2fs -l /dev/sda1 | grep "Default mount options"
  3. ACLs setzen: Gib dem Benutzer hans Lese- und Schreibrechte für ein Verzeichnis.
    sudo setfacl -m u:hans:rw /pfad/zum/verzeichnis
  4. ACLs für eine Gruppe setzen: Gib der Gruppe it-admins Vollzugriff.
    sudo setfacl -m g:it-admins:rwx /pfad/zum/verzeichnis
  5. ACLs überprüfen:
    getfacl /pfad/zum/verzeichnis
    Wenn eine Datei ACLs hat, erscheint ein + nach den normalen Berechtigungen (ls -l).
  6. ACLs entfernen:
    sudo setfacl -x u:hans /pfad/zum/verzeichnis
    sudo setfacl -b /pfad/zum/verzeichnis

PVE (Proxmox Virtual Environment) einrichten

Proxmox VE ist eine Open-Source-Virtualisierungsplattform für die Verwaltung von KVM-Virtual-Machines (VMs) und LXC-Containern. Es ist eine umfassende Lösung für die Servervirtualisierung.

Voraussetzungen:

  • Ein dedizierter Server mit mindestens 4 GB RAM
  • Debian-Installation
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Debian konfigurieren: Stelle sicher, dass eine statische IP-Adresse konfiguriert ist und die hosts-Datei korrekt ist.
  2. Proxmox Repository hinzufügen:
    echo "deb [arch=amd64] http://download.proxmox.com/debian/pve bullseye pve-no-subscription" | sudo tee /etc/apt/sources.list.d/pve-install-repo.list
    wget https://download.proxmox.com/debian/proxmox-release-bullseye.gpg -O /etc/apt/trusted.gpg.d/proxmox-release-bullseye.gpg
  3. Pakete aktualisieren und Proxmox installieren:
    sudo apt update && sudo apt full-upgrade -y
    sudo apt install proxmox-ve -y
  4. Neustart:
    sudo reboot
  5. Web-Oberfläche aufrufen: Nach dem Neustart ist die Proxmox-Oberfläche unter der IP deines Servers auf Port 8006 erreichbar.
    https://IP_DEINES_SERVERS:8006
    Du kannst dich mit dem root-Benutzer und deinem Debian-Passwort anmelden.
  6. VM oder Container erstellen: Über die Web-Oberfläche kannst du jetzt ISO-Images hochladen und deine ersten virtuellen Maschinen oder Container erstellen.

Zentralisierte Authentifizierung mit FreeRADIUS

FreeRADIUS ist eine leistungsstarke, Open-Source-RADIUS-Server-Implementierung. Sie ermöglicht die zentrale Authentifizierung, Autorisierung und Abrechnung (AAA) für Netzwerke, z. B. für WLAN-Zugangspunkte, VPNs oder Switches.

Voraussetzungen:

  • Ein Debian-Server für den FreeRADIUS-Server
  • Ein Netzwerkgerät, das RADIUS unterstützt (z. B. WLAN-AP, Switch)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. FreeRADIUS installieren:
    sudo apt install freeradius -y
  2. RADIUS-Client hinzufügen: Konfiguriere die Netzwerkgeräte, die sich mit dem RADIUS-Server verbinden dürfen.
    sudo nano /etc/freeradius/3.0/clients.conf
    Füge am Ende die Konfiguration für dein Netzwerkgerät hinzu:
    client wifi_ap {
            ipaddr = 192.168.1.50
            secret = "mein_geheimes_passwort"
        }
  3. Benutzer hinzufügen: Lege Benutzerkonten für die Authentifizierung an.
    sudo nano /etc/freeradius/3.0/users
    Füge einen Benutzer mit Passwort hinzu:
    mein_benutzer Cleartext-Password := "mein_benutzer_passwort"
  4. RADIUS-Server starten:
    sudo systemctl enable freeradius.service
    sudo systemctl start freeradius.service
  5. Testen: Starte FreeRADIUS im Debug-Modus, um die Authentifizierungsversuche zu sehen.
    sudo freeradius -X
  6. Netzwerkgerät konfigurieren: Konfiguriere deinen WLAN-AP oder Switch so, dass er FreeRADIUS für die Authentifizierung verwendet (z. B. WPA2-Enterprise). Gib die IP-Adresse des RADIUS-Servers und das secret aus Schritt 2 an.

Webserver absichern mit Fail2ban

Fail2ban ist ein Intrusion-Prevention-System, das Log-Dateien nach wiederholten fehlgeschlagenen Login-Versuchen scannt und die entsprechenden IP-Adressen blockiert. Es ist ein wirksamer Schutz gegen Brute-Force-Angriffe.

Voraussetzungen:

  • Ein Linux-Server (z. B. Debian, Ubuntu)
  • Webserver (Apache oder Nginx) installiert
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Fail2ban installieren:
    sudo apt install fail2ban -y
  2. Lokale Konfigurationsdatei erstellen: Kopiere die Standardkonfiguration, um deine eigenen Änderungen vorzunehmen.
    sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
  3. Fail2ban konfigurieren: Bearbeite die jail.local-Datei.
    sudo nano /etc/fail2ban/jail.local
    Passe die globalen Einstellungen an:
    • bantime: Zeit, für die eine IP gesperrt wird (z. B. 1h für 1 Stunde).
    • maxretry: Anzahl der Versuche vor der Sperrung (z. B. 5).
    • findtime: Zeit, in der die Versuche gezählt werden (z. B. 10m).
    Aktiviere die Jails für deine Dienste. Zum Beispiel für Nginx:
    [nginx-http-auth]
    enabled = true
    port = http,https
    filter = nginx-http-auth
    logpath = /var/log/nginx/access.log
    maxretry = 3
    findtime = 600
    bantime = 3600
  4. Dienst neu starten und überprüfen:
    sudo systemctl enable fail2ban
    sudo systemctl restart fail2ban
    sudo fail2ban-client status
    Der Status zeigt die aktiven Jails und die gesperrten IP-Adressen an.
  5. Eine IP manuell entsperren:
    sudo fail2ban-client set nginx-http-auth unbanip 1.2.3.4

Hochverfügbarkeits-Cluster mit Pacemaker und Corosync

Ein Hochverfügbarkeits-Cluster (HA-Cluster) sorgt dafür, dass Dienste auch beim Ausfall eines Servers weiterhin verfügbar bleiben. Pacemaker und Corosync sind die gängigen Open-Source-Komponenten, um eine solche Lösung unter Linux zu realisieren.

Voraussetzungen:

  • Zwei identische Linux-Server (z.B. Debian, Ubuntu)
  • Beide Server haben eine feste IP-Adresse
  • Passwortloser SSH-Zugriff zwischen den Servern
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Software installieren: Installiere die notwendigen Pakete auf beiden Servern.
    sudo apt install corosync pacemaker -y
  2. Corosync konfigurieren: Bearbeite die Konfigurationsdatei /etc/corosync/corosync.conf auf beiden Servern. Ersetze die IP-Adressen durch die deiner Server.
    
    ...
    totem {
        version: 2
        cluster_name: my_ha_cluster
        transport: knet
        interface {
            ringnumber: 0
            bindnetaddr: 192.168.1.0
        }
    }
    
    nodelist {
        node {
            ring0_addr: 192.168.1.10
            name: node1
            nodeid: 1
        }
        node {
            ring0_addr: 192.168.1.11
            name: node2
            nodeid: 2
        }
    }
    ...
    
  3. Dienste starten und aktivieren: Starte und aktiviere die Dienste auf beiden Servern.
    sudo systemctl enable corosync pacemaker
    sudo systemctl start corosync pacemaker
  4. Clusterstatus überprüfen: Überprüfe, ob der Cluster aktiv ist und beide Knoten sieht.
    sudo crm status
  5. Ressource erstellen: Erstelle eine einfache IP-Ressource, die zwischen den Knoten verschoben werden kann.
    sudo crm configure primitive virtual_ip ocf:heartbeat:IPaddr2 params ip=192.168.1.100 cidr_netmask=24
    sudo crm configure commit
  6. Ressource starten:
    sudo crm configure property stonith-enabled=false
    sudo crm configure commit
    Der Cluster wird jetzt die virtuelle IP-Adresse auf einem der Knoten starten.

DNS-Anfragen absichern (DoT/DoH)

Herkömmliche DNS-Anfragen sind unverschlüsselt und können abgehört oder manipuliert werden. DNS over TLS (DoT) und DNS over HTTPS (DoH) verschlüsseln diese Anfragen, um die Privatsphäre und Sicherheit zu erhöhen.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu)
  • Internetzugang
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. DoT mit systemd-resolved aktivieren: Dies ist die einfachste Methode unter vielen modernen Linux-Distributionen.
    sudo nano /etc/systemd/resolved.conf
    Füge die folgenden Zeilen hinzu oder bearbeite sie:
    [Resolve]
    DNS=1.1.1.1 1.0.0.1
    DNSOverTLS=yes
    
  2. Dienst neu starten und testen:
    sudo systemctl restart systemd-resolved
    sudo resolvectl status
    Die Ausgabe sollte `DNSSEC-fähig: ja` und `DNS-over-TLS: ja` zeigen.
  3. DoT/DoH mit stubby: Stubby ist eine Alternative, die DoT mit einer Liste von Anbietern unterstützt.
    sudo apt install stubby -y
  4. stubby konfigurieren:
    sudo nano /etc/stubby/stubby.yml
    Passe die `upstream_recursive_servers` an (z. B. Cloudflare oder Google DNS).
  5. stubby starten und DNS umleiten:
    sudo systemctl enable stubby
    sudo systemctl start stubby
    Ändere in der /etc/resolv.conf den Nameserver auf 127.0.0.1, um die Anfragen an Stubby umzuleiten.

Netzwerktraffic analysieren mit tcpdump

tcpdump ist ein mächtiges Kommandozeilen-Tool zur Analyse von Netzwerkpaketen. Es ermöglicht dir, den Traffic in Echtzeit zu sehen und hilft bei der Fehlersuche, Sicherheitsanalyse und Leistungsüberwachung.

Voraussetzungen:

  • Ein Linux-System
  • tcpdump installiert (sudo apt install tcpdump)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Einfacher Mitschnitt: Zeigt alle Netzwerkpakete auf dem Standard-Interface an.
    sudo tcpdump
  2. Schnittstelle angeben: Gib an, welche Netzwerkschnittstelle gemonitort werden soll.
    sudo tcpdump -i eth0
  3. Pakete nach Port filtern: Zeigt nur den Traffic auf einem bestimmten Port (z. B. Port 22 für SSH).
    sudo tcpdump port 22
  4. Pakete nach Host filtern: Zeigt nur den Traffic von oder zu einer bestimmten IP-Adresse.
    sudo tcpdump host 192.168.1.10
  5. Pakete nach Protokoll filtern: Zeigt nur Pakete eines bestimmten Protokolls (z. B. TCP, UDP, ICMP).
    sudo tcpdump icmp
  6. Traffic in eine Datei speichern: Speichere die Pakete in einer `.pcap`-Datei, die du später mit Wireshark analysieren kannst.
    sudo tcpdump -i eth0 -w traffic.pcap
  7. Datei laden: Lade die gespeicherte Datei zur Analyse.
    sudo tcpdump -r traffic.pcap

VPN-Server mit WireGuard unter Linux einrichten

WireGuard ist ein modernes, schnelles und sicheres VPN-Protokoll, das sich durch seine einfache Konfiguration auszeichnet. Es ist eine hervorragende Alternative zu OpenVPN und eignet sich ideal für private oder kleine Unternehmensnetzwerke.

Voraussetzungen:

  • Ein Linux-Server mit statischer IP-Adresse
  • Benutzer mit sudo-Rechten
  • Internetzugang
  • Firewall (UFW) konfiguriert

Schritt-für-Schritt-Anleitung:

  1. WireGuard installieren:
    sudo apt install wireguard -y
  2. Server-Schlüsselpaar generieren:
    cd /etc/wireguard
    wg genkey | sudo tee privatekey | wg pubkey | sudo tee publickey
    `privatekey` und `publickey` sind die Schlüssel für den Server.
  3. Server-Konfiguration erstellen: Erstelle die Konfigurationsdatei wg0.conf.
    sudo nano /etc/wireguard/wg0.conf
    Füge den Inhalt hinzu und ersetze die Platzhalter:
    
    [Interface]
    Address = 10.0.0.1/24
    ListenPort = 51820
    PrivateKey = 
    PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -A FORWARD -o %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
    PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -D FORWARD -o %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE
    
    [Peer]
    # [Client]
    PublicKey = 
    AllowedIPs = 10.0.0.2/32
    
  4. IP-Forwarding aktivieren:
    sudo nano /etc/sysctl.conf
    Entferne das `#` vor net.ipv4.ip_forward=1 und speichere die Datei. Dann führe sudo sysctl -p aus.
  5. Firewall-Port öffnen:
    sudo ufw allow 51820/udp
  6. Dienst starten:
    sudo wg-quick up wg0
    sudo systemctl enable wg-quick@wg0
  7. Client-Konfiguration: Erstelle ein Schlüsselpaar für den Client und füge es in die Client-Konfigurationsdatei (`client.conf`) ein.
    [Interface]
    PrivateKey = 
    Address = 10.0.0.2/24
    
    [Peer]
    PublicKey = 
    Endpoint = :51820
    AllowedIPs = 0.0.0.0/0
    

Private Container-Registry einrichten

Eine private Container-Registry ist ein zentrales Repository für Docker-Images, das du in deinem eigenen Netzwerk betreiben kannst. Dies ist ideal, um die Images von Anwendungen sicher und effizient zu speichern und zu verteilen.

Voraussetzungen:

  • Ein Linux-Server mit installiertem Docker oder Podman
  • Benutzer mit sudo-Rechten
  • Internetzugang

Schritt-für-Schritt-Anleitung:

  1. Registry-Container starten: Starte einen Docker-Container mit dem offiziellen `registry`-Image.
    sudo docker run -d -p 5000:5000 --name registry registry:2
    Die Registry ist jetzt auf Port 5000 deines Servers verfügbar.
  2. Image taggen: Tagge ein lokales Image, um es auf deine private Registry vorzubereiten.
    sudo docker tag nginx:latest localhost:5000/my-nginx
  3. Image pushen: Pushe das getaggte Image in die Registry.
    sudo docker push localhost:5000/my-nginx
  4. Client-Konfiguration: Auf einem Client, der sich mit der Registry verbinden soll, musst du Docker mitteilen, dass die Verbindung unverschlüsselt ist.
    sudo nano /etc/docker/daemon.json
    
    {
      "insecure-registries" : ["IP_DEINES_REGISTRY-SERVERS:5000"]
    }
    
  5. Docker-Dienst neu starten:
    sudo systemctl restart docker
  6. Image pullen: Du kannst nun Images von der privaten Registry ziehen.
    sudo docker pull IP_DEINES_REGISTRY-SERVERS:5000/my-nginx

Erste Schritte mit dem AWS CLI

Das `AWS Command Line Interface` (CLI) ist ein Tool, das es dir ermöglicht, AWS-Services über dein Terminal zu steuern. Es ist ein unverzichtbares Werkzeug für die Automatisierung und Verwaltung von Cloud-Ressourcen.

Voraussetzungen:

  • Ein Linux-, macOS- oder Windows-System
  • Ein AWS-Konto
  • Ein IAM-Benutzer mit API-Schlüsseln

Schritt-für-Schritt-Anleitung:

  1. AWS CLI installieren:
    # Linux
    sudo apt install awscli -y
  2. AWS CLI konfigurieren: Gib deine Zugangsdaten und die Region ein.
    aws configure
    AWS Access Key ID [None]: 
    AWS Secret Access Key [None]: 
    Default region name [None]: eu-central-1
    Default output format [None]: json
  3. S3-Buckets auflisten: Überprüfe, ob die Konfiguration funktioniert, indem du deine S3-Buckets auflistest.
    aws s3 ls
  4. Eine EC2-Instanz starten: Starte eine neue EC2-Instanz mit einem Amazon Machine Image (AMI).
    aws ec2 run-instances --image-id ami-0123456789abcdef0 --count 1 --instance-type t2.micro --key-name MyKeyPair --region eu-central-1
  5. EC2-Instanzen auflisten:
    aws ec2 describe-instances --region eu-central-1
  6. Eine EC2-Instanz stoppen:
    aws ec2 stop-instances --instance-ids 

PowerShell Remoting einrichten und verwenden

PowerShell Remoting ermöglicht die Ausführung von PowerShell-Befehlen auf einem oder mehreren Remote-Computern. Dies ist ein leistungsstarkes Werkzeug für die zentrale Verwaltung von Windows-Systemen.

Voraussetzungen:

  • Zwei Windows-Systeme (Client und Server)
  • Administratorrechte auf beiden Systemen
  • Firewall (Windows Defender Firewall) auf dem Server konfiguriert

Schritt-für-Schritt-Anleitung:

  1. Remoting auf dem Server aktivieren: Führe diesen Befehl in PowerShell **als Administrator** auf dem Remote-Server aus.
    Enable-PSRemoting -Force
  2. Firewall-Regeln überprüfen: Der obige Befehl öffnet in der Regel die notwendigen Firewall-Ports (5985/TCP für HTTP, 5986/TCP für HTTPS). Überprüfe dies.
    Get-NetFirewallRule -DisplayName 'Windows Remote Management (HTTP-In)'
  3. Vertrauenswürdige Hosts konfigurieren (optional): Wenn der Client nicht in derselben Domäne wie der Server ist, musst du den Server als vertrauenswürdigen Host hinzufügen.
    Set-Item WSMan:\localhost\Client\TrustedHosts -Value "RemoteServerName"
  4. Sitzung erstellen: Erstelle vom Client aus eine neue Remoting-Sitzung.
    $session = New-PSSession -ComputerName "RemoteServerName" -Credential "AdminUser"
    Gib die Anmeldeinformationen ein.
  5. Befehl ausführen: Führe einen Befehl auf dem Remote-Server aus.
    Invoke-Command -Session $session -ScriptBlock { Get-Service Spooler }
  6. Interaktive Sitzung öffnen: Öffne eine interaktive Sitzung auf dem Remote-Server.
    Enter-PSSession -ComputerName "RemoteServerName" -Credential "AdminUser"
    Die Eingabeaufforderung ändert sich und zeigt an, dass du dich auf dem Remote-Server befindest.

Dateiintegritätsprüfung mit AIDE unter Linux

Das `Advanced Intrusion Detection Environment` (AIDE) ist ein kostenloses Tool zur Überwachung der Dateiintegrität. Es erstellt eine Datenbank mit Hashes wichtiger Systemdateien und Verzeichnissen und kann diese regelmäßig auf Änderungen überprüfen.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. AIDE installieren:
    sudo apt install aide -y
  2. Erste Datenbank erstellen: Dies ist die Basis, mit der alle zukünftigen Überprüfungen verglichen werden. Führe den Befehl direkt nach der Installation des Systems oder nach der Härtung aus.
    sudo aide --init
  3. Datenbank umbenennen: Benenne die erstellte Datenbank um, damit AIDE sie bei der nächsten Überprüfung verwendet.
    sudo mv /var/lib/aide/aide.db.new /var/lib/aide/aide.db
  4. AIDE-Datenbank überprüfen: Starte einen Scan, um das System mit der gespeicherten Datenbank zu vergleichen.
    sudo aide --check
    Die Ausgabe zeigt alle Hinzufügungen, Löschungen und Änderungen an Dateien und Verzeichnissen.
  5. AIDE-Datenbank aktualisieren: Wenn du bewusst Änderungen vorgenommen hast, musst du die Datenbank aktualisieren.
    sudo aide --update
    Danach musst du die neue Datenbank erneut umbenennen: `sudo mv /var/lib/aide/aide.db.new /var/lib/aide/aide.db`.
  6. Automatisierung mit Cron: Du kannst die Prüfung automatisieren, indem du einen Cronjob erstellst.
    sudo crontab -e
    Füge eine Zeile hinzu, um die Überprüfung täglich auszuführen und das Ergebnis per E-Mail zu versenden.
    0 5 * * * /usr/bin/aide --check | mail -s "AIDE Report" your@email.com

Virtuelle Entwicklungsumgebungen mit Vagrant

Vagrant ist ein Tool zum Aufbau und zur Verwaltung von portablen virtuellen Entwicklungsumgebungen. Es automatisiert die Erstellung von VMs (z.B. mit VirtualBox oder Hyper-V) und deren Konfiguration, um eine konsistente Arbeitsumgebung für alle Teammitglieder zu gewährleisten.

Voraussetzungen:

  • Ein Linux-, macOS- oder Windows-System
  • Ein Virtualisierungsanbieter installiert (z.B. VirtualBox oder Hyper-V)
  • Vagrant installiert (vagrantup.com/downloads)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Vagrantfile erstellen: Erstelle eine neue Datei namens `Vagrantfile` im Projektverzeichnis.
    vagrant init ubuntu/focal64
    Dies erstellt eine Standard-Konfigurationsdatei für eine Ubuntu 20.04-VM.
  2. Vagrantfile bearbeiten:
    nano Vagrantfile
    Passe die Konfiguration an, um z. B. eine Portweiterleitung oder ein Provisioning-Skript hinzuzufügen.
    
    Vagrant.configure("2") do |config|
      config.vm.box = "ubuntu/focal64"
      config.vm.network "forwarded_port", guest: 80, host: 8080
      config.vm.provision "shell", inline: "sudo apt update && sudo apt install -y nginx"
    end
    
  3. VM starten: Navigiere in das Verzeichnis mit dem Vagrantfile und starte die VM.
    vagrant up
    Vagrant lädt die Box (das VM-Image) herunter, startet die VM und führt das Provisioning-Skript aus.
  4. VM verwalten:
    vagrant ssh # Mit der VM verbinden
    vagrant halt # VM herunterfahren
    vagrant reload # VM neu starten und Provisioning erneut ausführen
    vagrant destroy # VM löschen
    
  5. VM-Zustand überprüfen:
    vagrant status

Leichter Kubernetes-Cluster mit K3s

K3s ist eine leichtgewichtige, produktionsreife Kubernetes-Distribution, die speziell für Edge-Computing, IoT und kleine Umgebungen entwickelt wurde. Die Installation erfolgt über ein einziges Binärfile, was den Einstieg in Kubernetes erheblich vereinfacht.

Voraussetzungen:

  • Ein Linux-Server (z.B. Debian, Ubuntu) als Master-Knoten
  • Optional: Weitere Linux-Server als Agent-Knoten
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. K3s auf dem Master-Knoten installieren: Führe diesen One-Liner-Befehl aus, um K3s zu installieren.
    curl -sfL https://get.k3s.io | sh -
  2. Clusterstatus überprüfen: Überprüfe, ob der K3s-Server läuft und der Master-Knoten als `Ready` gemeldet wird.
    sudo kubectl get nodes
  3. Agent-Knoten hinzufügen (optional): Führe auf dem Master-Knoten diesen Befehl aus, um das Token zu erhalten.
    sudo cat /var/lib/rancher/k3s/server/node-token
    Kopiere das Token und die IP des Master-Knotens. Führe dann auf dem Agent-Knoten die Installation mit den entsprechenden Werten aus.
    curl -sfL https://get.k3s.io | K3S_URL=https://MASTER_IP:6443 K3S_TOKEN=TOKEN_DES_MASTER sh -
  4. Agent-Knoten verifizieren: Führe auf dem Master-Knoten erneut den Befehl `kubectl get nodes` aus. Der Agent-Knoten sollte nun ebenfalls erscheinen.
  5. Pod bereitstellen: Erstelle eine einfache Pod-Definition (`nginx-pod.yml`) und wende sie an.
    
    apiVersion: v1
    kind: Pod
    metadata:
      name: nginx-pod
    spec:
      containers:
      - name: nginx-container
        image: nginx:latest
        ports:
        - containerPort: 80
    
    sudo kubectl apply -f nginx-pod.yml
    sudo kubectl get pods

Web Application Firewall (WAF) mit ModSecurity für Apache

ModSecurity ist ein Open-Source Web Application Firewall (WAF) Modul, das deine Webanwendungen vor einer Vielzahl von Angriffen schützt (z. B. SQL Injection, Cross-Site Scripting). Es fungiert als eine zusätzliche Sicherheitsschicht vor deinem Webserver.

Voraussetzungen:

  • Ein Linux-Server mit installiertem Apache2
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. ModSecurity installieren:
    sudo apt install libapache2-mod-security2 -y
  2. ModSecurity-Modul aktivieren:
    sudo a2enmod security2
    sudo systemctl restart apache2
  3. Standard-Regeln aktivieren: ModSecurity wird standardmäßig mit den Core Rule Set (CRS) Regeln ausgeliefert.
    sudo mv /etc/modsecurity/modsecurity.conf-recommended /etc/modsecurity/modsecurity.conf
  4. Konfiguration anpassen: Bearbeite die Hauptkonfigurationsdatei, um den Modus von `DetectionOnly` auf `On` zu ändern.
    sudo nano /etc/modsecurity/modsecurity.conf
    Suche nach der Zeile `SecRuleEngine DetectionOnly` und ändere sie in:
    SecRuleEngine On
  5. Apache neuladen:
    sudo systemctl reload apache2
  6. Testen: Versuche, einen einfachen Testangriff in deinem Browser durchzuführen (z. B. `http://deinserver.de/?testparam=`). Der Webserver sollte den Zugriff verweigern und einen Fehler 403 zurückgeben.

Netzwerkkonfiguration mit netplan unter Debian/Ubuntu

netplan ist ein modernes Tool zur einfachen Konfiguration von Netzwerkschnittstellen unter Debian und Ubuntu. Es verwendet YAML-Dateien zur Definition der Konfiguration, die dann von `networkd` oder `NetworkManager` angewendet wird.

Voraussetzungen:

  • Ein Debian- oder Ubuntu-System (ab Version 17.10)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Konfigurationsdatei finden: Die Standard-Konfigurationsdatei befindet sich in ` /etc/netplan/`.
    ls /etc/netplan/
  2. Konfiguration bearbeiten: Bearbeite die YAML-Datei, um eine statische IP-Adresse zu konfigurieren.
    sudo nano /etc/netplan/01-netcfg.yaml
    Füge die folgende Konfiguration ein (ersetze die Werte durch deine Netzwerk-Details):
    
    network:
      version: 2
      renderer: networkd
      ethernets:
        eth0:
          dhcp4: no
          addresses:
            - 192.168.1.100/24
          routes:
            - to: default
              via: 192.168.1.1
          nameservers:
            addresses: [8.8.8.8, 8.8.4.4]
    
  3. Konfiguration anwenden: Überprüfe zuerst die Konfiguration auf Syntaxfehler.
    sudo netplan try
    Wenn der Test erfolgreich ist, wende die Konfiguration dauerhaft an.
    sudo netplan apply
  4. Status überprüfen:
    ip a
    Die neue statische IP-Adresse sollte nun auf der Schnittstelle `eth0` sichtbar sein.

Erweiterte Protokollierung mit syslog-ng

syslog-ng ist ein flexibler und leistungsstarker Logging-Daemon, der eine Alternative zum standardmäßigen `rsyslog` darstellt. Er ermöglicht die effiziente Sammlung, Filterung und Weiterleitung von Log-Nachrichten aus verschiedenen Quellen.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. syslog-ng installieren:
    sudo apt install syslog-ng -y
    Stoppe und deaktiviere den standardmäßigen `rsyslog`-Dienst.
    sudo systemctl stop rsyslog
    sudo systemctl disable rsyslog
  2. Konfiguration bearbeiten: Öffne die Hauptkonfigurationsdatei und füge eine neue Filter- und Destinationsregel hinzu.
    sudo nano /etc/syslog-ng/syslog-ng.conf
    Füge am Ende eine Regel hinzu, um alle SSH-Authentifizierungs-Logs in eine eigene Datei zu schreiben.
    
    ...
    filter f_sshauth { facility(auth, authpriv); };
    destination d_sshauth { file("/var/log/sshauth.log"); };
    log { source(s_src); filter(f_sshauth); destination(d_sshauth); };
    ...
    
  3. Dienst starten:
    sudo systemctl start syslog-ng
    sudo systemctl enable syslog-ng
  4. Log-Datei überprüfen: Sieh dir die neu erstellte Log-Datei an.
    sudo tail -f /var/log/sshauth.log
  5. Logs an einen Remote-Server senden: Füge in der Konfiguration eine Remote-Destination hinzu.
    
    ...
    destination d_remotelog { syslog("192.168.1.200" transport(udp) port(514)); };
    log { source(s_src); destination(d_remotelog); };
    ...
    

PostgreSQL-Datenbankserver einrichten

PostgreSQL ist ein leistungsstarkes Open-Source-Objekt-relationales Datenbanksystem (ORDBMS), das für seine Stabilität, Datenintegrität und umfangreichen Features bekannt ist. Es ist eine beliebte Wahl für komplexe Anwendungen.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. PostgreSQL installieren:
    sudo apt install postgresql -y
  2. PostgreSQL-Dienst überprüfen:
    sudo systemctl status postgresql
  3. Passwort für den `postgres`-Benutzer festlegen: Wechsle zum `postgres`-Benutzer und setze ein neues Passwort.
    sudo -i -u postgres
    psql -c "ALTER USER postgres WITH PASSWORD 'mein_passwort';"
    exit
  4. Neue Datenbank und Benutzer erstellen:
    sudo -i -u postgres
    createdb meinedb
    createuser meinuser
    psql -c "ALTER USER meinuser WITH PASSWORD 'user_passwort';"
    psql -c "GRANT ALL PRIVILEGES ON DATABASE meinedb TO meinuser;"
    exit
  5. Remote-Zugriff konfigurieren (optional): Bearbeite die Konfigurationsdatei, um von anderen Hosts auf die Datenbank zuzugreifen.
    sudo nano /etc/postgresql/13/main/postgresql.conf
    Ändere `listen_addresses` zu `listen_addresses = '*'`.
    sudo nano /etc/postgresql/13/main/pg_hba.conf
    Füge eine Regel für den Remote-Zugriff hinzu: `host meinedb meinuser 192.168.1.0/24 md5`.
  6. Firewall-Port öffnen und Dienst neu starten:
    sudo ufw allow 5432/tcp
    sudo systemctl restart postgresql

Windows Server Core über `sconfig` verwalten

`Windows Server Core` ist eine minimale Serverinstallation ohne grafische Benutzeroberfläche (GUI). Das Tool `sconfig` ist das zentrale Hilfsprogramm zur einfachen Konfiguration der wichtigsten Systemeinstellungen über die Kommandozeile.

Voraussetzungen:

  • Ein installierter Windows Server Core
  • Kommandozeilen-Zugriff (z. B. via SSH oder RDP nach der Einrichtung)

Schritt-für-Schritt-Anleitung:

  1. `sconfig` starten: Nach dem Login wird `sconfig` automatisch gestartet. Falls nicht, gib einfach `sconfig` ein und drücke Enter.
  2. Domäne oder Arbeitsgruppe ändern (Option 1): * Wähle `1` und drücke Enter. * Wähle `D` für Domäne oder `W` für Arbeitsgruppe. * Gib den Namen der Domäne/Arbeitsgruppe ein und folge den Anweisungen.
  3. Computername ändern (Option 2): * Wähle `2` und gib den neuen Namen des Servers ein. * Starte den Server neu, wenn du dazu aufgefordert wirst.
  4. Netzwerkeinstellungen konfigurieren (Option 8): * Wähle `8`. Es erscheint eine Liste der Netzwerkschnittstellen. * Wähle den Index der Schnittstelle, die du konfigurieren möchtest. * Wähle `1` für die IP-Einstellungen und gib an, ob du eine statische IP oder DHCP verwenden möchtest. * Wähle `2` für DNS-Einstellungen.
  5. Remotedesktop aktivieren (Option 7): * Wähle `7` und aktiviere Remotedesktop für Administratoren oder alle Benutzer.
  6. Updates konfigurieren (Option 6): * Wähle `6` und konfiguriere, ob du automatische oder manuelle Updates möchtest. * Wähle `6` erneut, um nach Updates zu suchen oder installiere sie.
  7. **`sconfig` beenden und PowerShell starten (Option 15):** * Wähle `15` und bestätige. Du wirst zur PowerShell-Kommandozeile zurückgeleitet, um weitere administrative Aufgaben durchzuführen.

VM- und Container-Templates in Proxmox erstellen

Templates in Proxmox sind Vorlagen von virtuellen Maschinen (VMs) oder Containern (LXC). Sie sparen Zeit bei der Bereitstellung neuer Instanzen, da sie eine vorgefertigte Konfiguration und ein Basis-Betriebssystem enthalten.

Voraussetzungen:

  • Ein laufender Proxmox-Server
  • Eine bereits installierte VM oder ein Container, der als Template dienen soll

Schritt-für-Schritt-Anleitung:

  1. VM als Template vorbereiten: Melde dich in der Proxmox-Web-Oberfläche an. * Wähle die VM aus, die du in ein Template umwandeln möchtest. * Deinstalliere oder lösche alle spezifischen Informationen (z. B. SSH-Schlüssel, Netzwerkkonfigurationen). * Fahre die VM sauber herunter.
  2. VM in ein Template konvertieren: * Rechtsklick auf die vorbereitete VM und wähle **Convert to Template**. * Bestätige die Aktion. Die VM wird nun als Template markiert und kann nicht mehr gestartet werden. Das Symbol ändert sich.
  3. Template klonen: Erstelle aus dem Template eine neue VM. * Rechtsklick auf das Template und wähle **Clone**. * Gib der neuen VM einen Namen und eine ID. * Wähle **Full Clone** (empfohlen, da es eine unabhängige Kopie erstellt) oder **Linked Clone** (platzsparend, aber abhängig vom Original-Template). * Klicke **Clone**.
  4. LXC-Container-Template erstellen: Für LXC-Container ist der Prozess einfacher. * Wähle den Container aus, den du als Template verwenden möchtest. * Klicke auf **Mehr** > **Template**. * Bestätige die Erstellung. Das Symbol ändert sich.
  5. Container aus dem Template erstellen: * Rechtsklick auf das Template > **Clone**. * Gib die neue ID, den Hostnamen und die Netzwerkeinstellungen an. * Klicke **Clone**.

Single Sign-On (SSO) mit Keycloak einrichten

Keycloak ist eine Open-Source-Software für Identity and Access Management, die SSO-Funktionalität (Single Sign-On) für deine Anwendungen und Dienste bietet. Einmal angemeldet, können Benutzer auf alle verbundenen Anwendungen zugreifen, ohne sich erneut authentifizieren zu müssen.

Voraussetzungen:

  • Ein Linux-Server mit Java und Docker/Podman
  • Internetzugang
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Keycloak-Container starten: Starte einen Keycloak-Container und konfiguriere das Admin-Passwort.
    sudo docker run -d --name keycloak -p 8080:8080 -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=dein_passwort quay.io/keycloak/keycloak:latest start-dev
  2. Admin-Konsole aufrufen: Öffne den Browser und navigiere zur Admin-Konsole.
    http://IP_DEINES_SERVERS:8080
    Melde dich mit dem Admin-Benutzer und dem Passwort an.
  3. Realm erstellen: Ein Realm ist ein Bereich, in dem Benutzer, Rollen und Anwendungen verwaltet werden. * Klicke oben links auf den Dropdown-Pfeil und wähle **Add realm**. * Gib einen Namen (z. B. `myrealm`) an und klicke **Create**.
  4. Benutzer und Rollen erstellen: * Gehe zu **Users** > **Add user**. * Gehe zu **Roles** > **Add role**.
  5. Client-Anwendung registrieren: Eine Client-Anwendung ist eine Anwendung, die Keycloak zur Authentifizierung nutzt. * Gehe zu **Clients** > **Create**. * Gib eine Client-ID (z. B. `my-app`) und die Redirect-URI an (z. B. `http://meine-app.de/*`). * Klicke **Save**.
  6. Integration: Abhängig von deiner Anwendung (Web-App, VPN etc.) musst du die Client-ID, das Client-Secret und die Keycloak-URL in der Anwendung konfigurieren, um SSO zu nutzen.

RAID-Array mit mdadm unter Linux

mdadm ist das Standard-Tool in Linux, um Software-RAID-Arrays (Redundant Array of Independent Disks) zu erstellen und zu verwalten. RAID verbessert die Leistung oder die Ausfallsicherheit von Speichermedien, indem es mehrere Festplatten logisch miteinander verbindet.

Voraussetzungen:

  • Ein Linux-System
  • Mindestens zwei freie Festplatten oder Partitionen
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. mdadm installieren:
    sudo apt install mdadm -y
  2. RAID 1-Array erstellen: Ein RAID 1-Array (Spiegelung) erfordert mindestens zwei Festplatten.
    sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1
    (Ersetze `/dev/sdb1` und `/dev/sdc1` durch deine Partitionsnamen).
  3. Status überprüfen: Überprüfe den Status und den Fortschritt des Arrays.
    sudo cat /proc/mdstat
  4. Dateisystem erstellen: Erstelle ein Dateisystem auf dem neuen RAID-Array.
    sudo mkfs.ext4 /dev/md0
  5. RAID-Konfiguration speichern: Damit das Array nach einem Neustart automatisch erkannt wird, speichere die Konfiguration.
    sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
  6. Mountpoint erstellen und eintragen: Erstelle ein Verzeichnis und mounte das Array. Füge es zur `fstab` hinzu, um es automatisch zu mounten.
    sudo mkdir /mnt/raid1
    sudo mount /dev/md0 /mnt/raid1
    sudo nano /etc/fstab
    /dev/md0 /mnt/raid1 ext4 defaults,nofail 0 2

System-Auditing mit auditd unter Linux

Der `auditd`-Dienst ist ein mächtiges Überwachungssystem, das Systemereignisse basierend auf konfigurierbaren Regeln aufzeichnet. Es wird häufig für Sicherheitsaudits und die Compliance-Überwachung eingesetzt, um festzustellen, wer wann auf welche Dateien zugegriffen hat.

Voraussetzungen:

  • Ein Linux-System (z.B. Debian, Ubuntu)
  • auditd installiert (sudo apt install auditd)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Audit-Regeln definieren: Editiere die Regeldatei, um zu überwachen, wer auf eine bestimmte Datei zugreift.
    sudo nano /etc/audit/rules.d/audit.rules
    Füge am Ende die Regel hinzu:
    
    -w /etc/shadow -p rwxa -k shadow-access # Überwacht Lese-, Schreib-, Ausführungs- und Attributänderungen auf die /etc/shadow
    -w /etc/passwd -p rwa -k passwd-access
    -a always,exit -F arch=b64 -S open -F exit=-EACCES -k access_denied # Überwacht Zugriffe, die mit "Access Denied" fehlschlagen
    
  2. Audit-Dienst neu starten: Damit die Regeln angewendet werden.
    sudo systemctl restart auditd
  3. Ereignisse provozieren: Versuche, eine der überwachten Dateien als normaler Benutzer zu bearbeiten.
    echo "test" >> /etc/shadow
    Der Versuch wird fehlschlagen, aber `auditd` hat das Ereignis aufgezeichnet.
  4. Logs überprüfen: Verwende das Tool `ausearch`, um die aufgezeichneten Ereignisse zu durchsuchen.
    sudo ausearch -k shadow-access
    sudo ausearch -k access_denied
    Die Ausgabe zeigt detaillierte Informationen über den Benutzer, die Uhrzeit und den versuchten Zugriff.

Samba 4 als Active Directory Domain Controller einrichten

Samba 4 ermöglicht es einem Linux-Server, als vollständiger Active Directory Domain Controller zu fungieren und Windows-Clients, Benutzern und Gruppen zu verwalten. Dies bietet eine leistungsstarke und kostengünstige Alternative zu einem Windows Server AD.

Voraussetzungen:

  • Ein Debian-Server mit einer statischen IP-Adresse
  • Ein installierter DNS-Server (oder der Samba-eigene)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Samba installieren: Installiere Samba und andere notwendige Pakete.
    sudo apt update && sudo apt install samba krb5-user winbind libnss-winbind libpam-winbind -y
  2. Samba als AD DC provisionieren: Konfiguriere Samba als Domain Controller. Du wirst nach einem Realm-Namen, dem Domain NetBIOS-Namen und dem Administrator-Passwort gefragt.
    sudo samba-tool domain provision --use-rfc2307 --interactive
  3. DNS konfigurieren: Wenn du Samba den internen DNS-Server betreiben lässt, ändere die ` /etc/resolv.conf`, um den Server selbst als Nameserver zu nutzen.
    nameserver 127.0.0.1
  4. Dienst starten und überprüfen: Stoppe alle alten Samba-Dienste und starte den neuen.
    sudo systemctl stop smbd nmbd
    sudo systemctl unmask samba-ad-dc
    sudo systemctl enable samba-ad-dc
    sudo systemctl start samba-ad-dc
    sudo systemctl status samba-ad-dc
  5. Windows-Clients in die Domäne aufnehmen: Auf einem Windows-Client, gehe in die Systemeinstellungen und füge den Computer der neuen Samba-Domäne hinzu, indem du die Domänen-IP als DNS-Server verwendest.

Webserver mit Caddy einrichten

Caddy ist ein moderner Webserver, der sich durch seine einfache Konfiguration und seine Fähigkeit auszeichnet, automatisch HTTPS-Zertifikate von Let's Encrypt zu erhalten und zu verwalten. Er ist eine leistungsstarke und sichere Alternative zu Nginx und Apache.

Voraussetzungen:

  • Ein Linux-Server mit einer Domain, die auf die IP des Servers zeigt
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Caddy installieren: Füge das Caddy-Repository hinzu und installiere Caddy.
    sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
    curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
    curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
    sudo apt update
    sudo apt install caddy -y
  2. Webseiten-Verzeichnis erstellen:
    sudo mkdir /var/www/meine-webseite
    sudo chown -R caddy:caddy /var/www/meine-webseite
  3. Caddyfile erstellen: Caddy verwendet eine Konfigurationsdatei namens `Caddyfile`.
    sudo nano /etc/caddy/Caddyfile
    Füge den folgenden Inhalt hinzu (ersetze `meine-webseite.de` durch deine Domain):
    meine-webseite.de {
        root * /var/www/meine-webseite
        file_server
    }
  4. Dienst neu starten:
    sudo systemctl restart caddy
    Caddy erhält jetzt automatisch ein SSL-Zertifikat für deine Domain.

Fortschrittliches Dateisystem ZFS unter Linux einrichten

ZFS ist ein fortschrittliches Dateisystem, das Datenintegrität, Snapshots, Copy-on-Write-Klonen und integriertes Volume-Management bietet. Es ist eine robuste Lösung für Server mit hohen Anforderungen an die Datensicherheit und -verwaltung.

Voraussetzungen:

  • Ein Linux-Server (z.B. Debian, Ubuntu)
  • Mindestens eine oder mehrere freie Festplatten
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. ZFS installieren:
    sudo apt install zfsutils-linux -y
  2. ZFS-Pool erstellen: Erstelle einen neuen ZFS-Pool namens `meinpool` mit zwei Festplatten im RAID 1-Modus.
    sudo zpool create meinpool mirror /dev/sdb /dev/sdc
  3. Dateisystem erstellen: Erstelle ein ZFS-Dateisystem, das auf dem Pool liegt.
    sudo zfs create meinpool/daten
  4. Snapshot erstellen: Erstelle einen Snapshot des Dateisystems.
    sudo zfs snapshot meinpool/daten@backup_2025
  5. Snapshot zurückspielen: Um den Snapshot zurückzuspielen, hänge das Dateisystem aus und spiele es zurück.
    sudo zfs rollback meinpool/daten@backup_2025
  6. Pool in die fstab eintragen: Damit der Pool nach einem Neustart gemountet wird, füge einen Eintrag zur fstab hinzu.
    sudo nano /etc/fstab
    meinpool/daten /mnt/meinpool/daten zfs defaults 0 0

Echtzeit-Webserver-Monitoring mit GoAccess

GoAccess ist ein Open-Source-Analyse-Tool für Webserver-Logs, das eine interaktive Echtzeit-Ansicht direkt im Terminal oder in einem Webbrowser bietet. Es hilft dir, schnell Traffic-Statistiken, Top-Besucher und Fehlercodes zu identifizieren.

Voraussetzungen:

  • Ein Linux-Server mit Webserver (Apache oder Nginx)
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. GoAccess installieren:
    sudo apt install goaccess -y
  2. Analyse im Terminal: Gib GoAccess an, welche Log-Datei analysiert werden soll.
    sudo goaccess /var/log/nginx/access.log -c
    GoAccess öffnet eine interaktive Ansicht im Terminal.
  3. Echtzeit-Analyse: Überwache die Log-Datei in Echtzeit.
    sudo tail -f /var/log/nginx/access.log | goaccess -c -
  4. HTML-Bericht generieren: Generiere einen statischen HTML-Bericht, den du im Browser öffnen kannst.
    sudo goaccess /var/log/nginx/access.log -o /var/www/html/report.html --log-format=COMBINED
  5. Web-Interface erstellen: Verwende GoAccess im Webserver-Modus.
    sudo goaccess /var/log/nginx/access.log -o /var/www/html/report.html --log-format=COMBINED --real-time-html --daemonize
    Du kannst den Bericht nun unter der URL deines Servers mit `report.html` sehen.

IoT-Geräte absichern mit separatem VLAN

IoT-Geräte (Smart Home, Kameras) sind oft anfällig für Sicherheitslücken. Um dein Hauptnetzwerk zu schützen, ist es ratsam, diese Geräte in ein separates VLAN (Virtual Local Area Network) zu isolieren und den Datenverkehr strikt zu kontrollieren.

Voraussetzungen:

  • Ein verwalteter Switch, der VLANs unterstützt
  • Ein Router oder Firewall-Gerät, das VLANs und Inter-VLAN-Routing beherrscht (z. B. pfSense, OPNsense, Ubiquiti)
  • Benutzer mit Admin-Rechten für alle Geräte

Schritt-für-Schritt-Anleitung:

  1. VLAN erstellen: Erstelle auf deinem Router/Firewall-Gerät ein neues VLAN mit einer eigenen Subnetz-ID (z. B. VLAN 20 mit Subnetz 192.168.20.0/24).
  2. Firewall-Regeln definieren: Erstelle Firewall-Regeln, die den Datenverkehr zwischen dem IoT-VLAN und deinem Hauptnetzwerk blockieren. Erlaube nur den Verkehr, der unbedingt notwendig ist (z. B. Zugriff auf deinen MQTT-Broker).
  3. Switch-Ports konfigurieren: Konfiguriere auf deinem Switch die Ports, an die deine IoT-Geräte angeschlossen sind, als "Access-Ports" für das neue IoT-VLAN (z. B. PVID 20).
  4. WLAN-SSID zuweisen: Wenn deine IoT-Geräte per WLAN verbunden sind, erstelle eine neue WLAN-SSID auf deinem Access Point und weise sie dem IoT-VLAN zu.
  5. Testen: Verbinde ein Gerät mit dem IoT-Netzwerk und überprüfe, ob es eine IP-Adresse aus dem richtigen Subnetz erhält und ob der Zugriff auf dein Hauptnetzwerk blockiert ist.

Infrastruktur als Code mit Terraform verwalten

Terraform ist ein Open-Source-Tool, das "Infrastruktur als Code" (IaC) ermöglicht. Du kannst Ressourcen in der Cloud (z. B. AWS, Azure) oder in Virtualisierungsumgebungen (z. B. Proxmox) mithilfe von Konfigurationsdateien definieren und automatisch bereitstellen.

Voraussetzungen:

  • Ein Linux-, macOS- oder Windows-System
  • Terraform installiert (terraform.io/downloads)
  • Zugangsdaten für einen Cloud-Anbieter (z. B. AWS CLI konfiguriert)

Schritt-für-Schritt-Anleitung:

  1. Konfigurationsdatei (`main.tf`) erstellen: Definiere in einer `.tf`-Datei die Infrastruktur, die du erstellen möchtest.
    sudo nano main.tf
    Beispiel für eine AWS EC2-Instanz:
    
    provider "aws" {
      region = "eu-central-1"
    }
    
    resource "aws_instance" "my_server" {
      ami           = "ami-0123456789abcdef0"
      instance_type = "t2.micro"
      tags = {
        Name = "MyTerraformServer"
      }
    }
    
  2. Terraform initialisieren: Initialisiere das Arbeitsverzeichnis, um die erforderlichen Plugins zu installieren.
    terraform init
  3. Plan erstellen: Überprüfe, welche Änderungen Terraform vornehmen wird, ohne sie tatsächlich auszuführen.
    terraform plan
  4. Ressourcen anwenden: Erstelle die in der Konfiguration definierten Ressourcen.
    terraform apply
    Bestätige die Änderungen mit `yes`.
  5. Ressourcen zerstören: Lösche alle von Terraform erstellten Ressourcen.
    terraform destroy

Netzwerkweiter Ad-Blocker mit Pi-hole einrichten

Pi-hole ist ein DNS-Sinkhole, das Werbung, Tracker und schädliche Inhalte auf Netzwerkebene blockiert. Wenn du es als DNS-Server in deinem Heim- oder Firmennetzwerk einsetzt, profitieren alle verbundenen Geräte (PCs, Smartphones, IoT) vom Ad-Blocking.

Voraussetzungen:

  • Ein Raspberry Pi (oder ein Linux-System in einer VM/Container)
  • Eine statische IP-Adresse
  • Benutzer mit sudo-Rechten

Schritt-für-Schritt-Anleitung:

  1. Pi-hole installieren: Führe den Installations-One-Liner aus.
    curl -sSL https://install.pi-hole.net | bash
  2. Installations-Assistent durchlaufen: Folge dem grafischen Assistenten: * Wähle einen Upstream-DNS-Anbieter (z. B. Cloudflare, Google). * Wähle die zu verwendende Netzwerkschnittstelle. * Wähle die Ad-Block-Listen aus. * Bestätige, dass du die statische IP-Adresse verwenden möchtest. * Notiere dir am Ende das Passwort für das Web-Interface.
  3. Web-Interface aufrufen:
    http://IP_DEINES_PI-HOLE/admin
    Logge dich mit dem bei der Installation vergebenen Passwort ein.
  4. Netzwerk-Konfiguration ändern: Konfiguriere deinen DHCP-Server (meistens dein Router), um die IP-Adresse des Pi-hole als primären DNS-Server an alle Clients zu verteilen.
  5. Funktion testen: Besuche eine Webseite mit viel Werbung auf einem Client in deinem Netzwerk. Die Werbung sollte nicht mehr geladen werden, und du siehst in der Pi-hole-Konsole die geblockten Domains.

WMI (Windows Management Instrumentation) mit PowerShell

WMI ist eine Kerntechnologie von Microsoft, die es dir ermöglicht, detaillierte Informationen über die Hardware, das Betriebssystem und die Dienste von Windows-Systemen abzufragen und zu verwalten. Mit PowerShell kannst du WMI-Abfragen einfach durchführen.

Voraussetzungen:

  • Ein Windows-System mit PowerShell
  • Administratorrechte (für einige Abfragen)

Schritt-für-Schritt-Anleitung:

  1. Klassen anzeigen: Verwende den Befehl `Get-CimClass`, um eine Liste aller verfügbaren WMI-Klassen zu erhalten.
    Get-CimClass | Select-Object -First 10
  2. Prozessor-Informationen abrufen: Verwende `Get-CimInstance`, um die Informationen über den Prozessor abzurufen.
    Get-CimInstance -ClassName Win32_Processor
  3. System-Uptime anzeigen:
    (Get-CimInstance -ClassName Win32_OperatingSystem).LastBootUpTime
  4. Festplatteninformationen filtern: Frage nur die Informationen zu den physischen Festplatten ab.
    Get-CimInstance -ClassName Win32_DiskDrive | Select-Object Model, Size, Partitions
  5. Remote-WMI-Abfragen: Führe Abfragen auf einem Remote-Computer aus.
    Get-CimInstance -ClassName Win32_OperatingSystem -ComputerName "RemoteServer" -Credential "AdminUser"
  6. WMI-Daten verarbeiten: Speichere die WMI-Informationen in einer Variable und verarbeite sie weiter.
    $services = Get-CimInstance -ClassName Win32_Service
    $services | Where-Object {$_.State -eq "Running"}

Container-Images auf Sicherheitslücken scannen

Das Scannen von Container-Images auf bekannte Sicherheitslücken ist ein wesentlicher Bestandteil einer sicheren CI/CD-Pipeline. Tools wie `Trivy` helfen dir, Schwachstellen in deinem Image-Layer zu identifizieren, bevor du die Container bereitstellst.

Voraussetzungen:

Schritt-für-Schritt-Anleitung:

  1. Trivy installieren:
    # Ubuntu
    sudo apt-get install wget apt-transport-https gnupg
    wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | sudo apt-key add -
    echo deb https://aquasecurity.github.io/trivy-repo/deb $(lsb_release -sc) main | sudo tee -a /etc/apt/sources.list.d/trivy.list
    sudo apt-get update
    sudo apt-get install trivy -y
  2. Ein Container-Image scannen: Scanne ein Image, das du lokal gespeichert hast.
    sudo trivy image nginx:latest
    Trivy lädt zuerst die Schwachstellen-Datenbank herunter und scannt dann das Image auf bekannte CVEs (Common Vulnerabilities and Exposures).
  3. Ergebnis filtern: Filtere das Ergebnis, um nur Schwachstellen mit hohem oder kritischem Schweregrad anzuzeigen.
    sudo trivy image --severity HIGH,CRITICAL nginx:latest
  4. Formatierte Ausgabe: Gib das Ergebnis im JSON-Format aus, um es maschinell verarbeiten zu können.
    sudo trivy image --format json nginx:latest

Komplette Web-Hosting-Umgebung einrichten: Vom Server bis zur Webseite

Diese umfassende Anleitung führt dich durch die Einrichtung einer kompletten und sicheren Web-Hosting-Umgebung auf einem einzigen Linux-Server. Du beginnst mit der Basis-Installation, konfigurierst die Netzwerkinfrastruktur, installierst einen LEMP-Stack (Nginx, MariaDB, PHP), sicherst die Umgebung ab und automatisierst grundlegende Aufgaben. Dies ist ein typisches End-to-End-Projekt für einen Fachinformatiker für Systemintegration.

Teil 1: Basis-Server einrichten

Der erste Schritt ist die saubere Installation eines Linux-Systems und die Absicherung des Zugangs.

  1. Debian oder Ubuntu installieren: Installiere die Server-Version deiner Wahl. Wähle eine minimale Installation ohne grafische Oberfläche.
  2. Statische IP-Adresse konfigurieren: Bearbeite die Netzwerkkonfiguration, um eine statische IP-Adresse festzulegen. (Siehe Anleitung "Netzwerkkonfiguration mit netplan").
  3. System aktualisieren:
    sudo apt update && sudo apt upgrade -y
  4. SSH-Zugriff absichern: Deaktiviere den Root-Login und verwende stattdessen einen normalen Benutzer mit sudo-Rechten. Richte SSH-Key-Authentifizierung ein, um die Sicherheit weiter zu erhöhen. (Siehe Anleitung "SSH-Zugriff absichern").
  5. Basis-Firewall einrichten: Installiere und konfiguriere die Uncomplicated Firewall (UFW), um nur die notwendigen Ports (SSH, HTTP, HTTPS) zu erlaubieren.
    sudo apt install ufw -y
    sudo ufw allow OpenSSH
    sudo ufw enable

Teil 2: Netzwerk & DNS konfigurieren

Damit der Webserver im Internet erreichbar ist, musst du die DNS-Einträge bei deinem Domain-Registrar konfigurieren und sicherstellen, dass die Firewall den Web-Traffic durchlässt.

  1. DNS-A-Record erstellen: Erstelle bei deinem Domain-Anbieter einen A-Record für deine Domain (z.B. meinedomain.de) und einen für die Subdomain `www`, die beide auf die öffentliche IP-Adresse deines Servers zeigen.
  2. DNS-Record prüfen: Überprüfe, ob die DNS-Auflösung korrekt funktioniert.
    dig meinedomain.de
  3. Firewall-Ports für Webserver öffnen: Erlaube HTTP (Port 80) und HTTPS (Port 443).
    sudo ufw allow 80/tcp
    sudo ufw allow 443/tcp
    sudo ufw reload

Teil 3: Der Webserver-Stack (LEMP)

Jetzt installierst du den Webserver-Stack, bestehend aus Nginx, MariaDB und PHP, der die dynamische Webseite bereitstellt und verwaltet.

  1. Nginx installieren:
    sudo apt install nginx -y
    sudo systemctl enable nginx && sudo systemctl start nginx
  2. MariaDB installieren und absichern:
    sudo apt install mariadb-server -y
    sudo mysql_secure_installation
    Folge dem Assistenten, um ein Root-Passwort zu setzen und die Standard-Sicherheitseinstellungen zu übernehmen.
  3. PHP-FPM installieren: Installiere PHP und die für Webanwendungen notwendigen Module.
    sudo apt install php-fpm php-mysql php-cli -y

Teil 4: Webseiten-Bereitstellung und Sicherheit

In diesem Schritt richtest du die Webseite ein, sorgst für eine sichere HTTPS-Verbindung und schützt sie vor den häufigsten Angriffen.

  1. Nginx-Server-Block konfigurieren: Erstelle eine Nginx-Konfigurationsdatei für deine Domain.
    sudo nano /etc/nginx/sites-available/meinedomain.conf
    Füge die folgende Basis-Konfiguration hinzu und erstelle das Root-Verzeichnis der Webseite.
    
    server {
        listen 80;
        listen [::]:80;
        server_name meinedomain.de www.meinedomain.de;
        root /var/www/meinedomain.de;
        index index.php index.html;
    
        location / {
            try_files $uri $uri/ =404;
        }
    
        location ~ \.php$ {
            include snippets/fastcgi-php.conf;
            fastcgi_pass unix:/run/php/php-fpm.sock;
        }
    }
    
    sudo mkdir -p /var/www/meinedomain.de
    sudo chown -R www-data:www-data /var/www/meinedomain.de
    sudo ln -s /etc/nginx/sites-available/meinedomain.conf /etc/nginx/sites-enabled/
    sudo nginx -t && sudo systemctl reload nginx
  2. SSL-Zertifikat mit Certbot einrichten: Installiere Certbot und erstelle das kostenlose SSL-Zertifikat.
    sudo apt install certbot python3-certbot-nginx -y
    sudo certbot --nginx -d meinedomain.de -d www.meinedomain.de
    Folge den Anweisungen und wähle die Weiterleitung auf HTTPS. Certbot aktualisiert deine Nginx-Konfiguration automatisch.
  3. Webserver härten und Fail2ban einrichten: Füge Sicherheits-Header hinzu, um gängige Angriffe abzuwehren. (Siehe Anleitung "Webserver-Härtung"). Schütze den Server vor Brute-Force-Angriffen. (Siehe Anleitung "Webserver absichern mit Fail2ban").

Teil 5: Automatisierung und Überwachung

Um die Umgebung wartbar zu halten, automatisierst du Updates und richtest eine einfache Überwachung ein.

  1. Tägliche System-Updates automatisieren: Installiere `unattended-upgrades`, um Sicherheitsupdates automatisch zu installieren.
    sudo apt install unattended-upgrades -y
    sudo dpkg-reconfigure --priority=low unattended-upgrades
    Wähle im Assistenten "Ja", um automatische Updates zu aktivieren.
  2. Backup-Skript erstellen: Erstelle ein einfaches Bash-Skript, das deine Webseite und Datenbank sichert.
    
    #!/bin/bash
    DATE=$(date +%Y-%m-%d-%H-%M-%S)
    BACKUP_DIR="/var/backups/meinedomain"
    WEB_DIR="/var/www/meinedomain.de"
    DB_NAME="deine_datenbank"
    DB_USER="dein_user"
    DB_PASS="dein_passwort"
    
    mkdir -p $BACKUP_DIR
    tar -zcvf $BACKUP_DIR/web_backup_$DATE.tar.gz $WEB_DIR
    mysqldump -u$DB_USER -p$DB_PASS $DB_NAME > $BACKUP_DIR/db_backup_$DATE.sql
    
  3. Überwachung mit Glances: Installiere Glances, um die Systemressourcen in Echtzeit zu überwachen.
    sudo apt install python3-pip -y
    sudo pip3 install glances
    sudo glances -w
    Die Überwachung ist jetzt unter http://IP_DEINES_SERVERS:61208 im Browser sichtbar.

Du hast nun eine komplette Web-Hosting-Umgebung aufgebaut, die von Grund auf konfiguriert und abgesichert ist und die wichtigsten Wartungs- und Überwachungsmechanismen enthält.

Hochverfügbarer PostgreSQL-Cluster mit Patroni und etcd

Die Einrichtung eines hochverfügbaren Datenbank-Clusters ist entscheidend, um die Datenintegrität und Verfügbarkeit von Diensten sicherzustellen. Patroni ist ein leistungsstarkes Tool zur Verwaltung von PostgreSQL-Replikationsclustern, das eine automatische Failover-Funktion ermöglicht. Es nutzt ein Distributed Configuration Store (DCS) wie etcd, um den Cluster-Zustand zu verwalten und den Leader (Master) zu wählen.

Voraussetzungen:

  • Mindestens zwei Linux-Server (z.B. Debian, Ubuntu)
  • PostgreSQL installiert auf beiden Servern
  • Benutzer mit sudo-Rechten
  • Feste IP-Adressen für alle Server
  • Passwortloser SSH-Zugriff zwischen den Knoten

Schritt-für-Schritt-Anleitung:

  1. etcd installieren und konfigurieren:

    etcd dient als zentraler Datenspeicher für Patroni. Installiere etcd auf beiden Knoten und konfiguriere es als Cluster.

    sudo apt install etcd -y

    Bearbeite die Konfigurationsdatei /etc/etcd/etcd.conf.yml auf dem ersten Knoten (node1):

    name: node1
    listen-client-urls: http://0.0.0.0:2379
    advertise-client-urls: http://192.168.1.10:2379
    listen-peer-urls: http://192.168.1.10:2380
    initial-advertise-peer-urls: http://192.168.1.10:2380
    initial-cluster-token: etcd-cluster-1
    initial-cluster: node1=http://192.168.1.10:2380,node2=http://192.168.1.11:2380
    initial-cluster-state: new

    Bearbeite die Konfiguration auf dem zweiten Knoten (node2) entsprechend.

    sudo systemctl enable etcd && sudo systemctl start etcd
  2. Patroni-Installation und -Konfiguration:

    Installiere Patroni und das psycopg2-Paket auf beiden Knoten.

    sudo apt install patroni python3-psycopg2 -y

    Erstelle eine Patroni-Konfigurationsdatei /etc/patroni/patroni.yml auf dem ersten Knoten:

    scope: meine_db
    name: node1
    restapi:
      listen: 192.168.1.10:8008
      connect_address: 192.168.1.10:8008
    postgresql:
      listen: 192.168.1.10:5432
      connect_address: 192.168.1.10:5432
      data_dir: /var/lib/postgresql/13/main
      authentication:
        replication:
          username: repluser
          password: repl_pass
        superuser:
          username: admin
          password: admin_pass
    etcd:
      hosts: ['192.168.1.10:2379', '192.168.1.11:2379']

    Passe die Konfiguration auf dem zweiten Knoten an (name: node2, listen- und connect_address auf 192.168.1.11 ändern).

  3. Cluster starten:

    Erstelle das Patroni-Systemd-File /etc/systemd/system/patroni.service auf beiden Knoten:

    [Unit]
    Description=Patroni
    After=network.target etcd.service
    
    [Service]
    Type=simple
    User=postgres
    Group=postgres
    ExecStart=/usr/bin/python3 /usr/bin/patroni /etc/patroni/patroni.yml
    Restart=on-failure
    
    [Install]
    WantedBy=multi-user.target

    Starte den Patroni-Dienst auf beiden Knoten.

    sudo systemctl enable patroni && sudo systemctl start patroni
  4. Cluster-Status überprüfen:

    Nachdem Patroni auf beiden Knoten läuft, kannst du den Cluster-Status abfragen. Einer der Knoten sollte als Master, der andere als Replica gelistet werden.

    patronictl -c /etc/patroni/patroni.yml list
  5. Failover testen:

    Stoppe den PostgreSQL-Dienst auf dem Master-Knoten, um den automatischen Failover-Mechanismus von Patroni zu testen.

    sudo systemctl stop postgresql

    Überprüfe den Cluster-Status. Patroni wird den Replica-Knoten automatisch zum neuen Master befördern.

CI/CD-Pipeline mit Jenkins, Git und Docker einrichten

Der Aufbau einer Continuous Integration (CI) und Continuous Delivery (CD)-Pipeline automatisiert den gesamten Prozess von der Code-Änderung bis zur Bereitstellung einer Anwendung. Diese Anleitung beschreibt, wie du eine grundlegende Pipeline mit Jenkins, einem Git-Repository (z. B. GitHub) und Docker erstellst, um eine Web-Anwendung zu bauen, zu testen und bereitzustellen.

Voraussetzungen:

  • Ein Linux-Server (z.B. Debian, Ubuntu) mit mindestens 4 GB RAM
  • Docker und Docker Compose installiert
  • Benutzer mit sudo-Rechten und SSH-Zugriff
  • Ein GitHub-Konto und ein Repository mit einer einfachen Anwendung (z.B. eine statische HTML-Seite)
  • Offene Ports: 8080 (Jenkins), 22 (SSH), 5000 (Docker Registry, falls verwendet)

Schritt-für-Schritt-Anleitung:

  1. Jenkins-Server installieren: Füge das Jenkins-Repository hinzu und installiere Jenkins.
    sudo apt update && sudo apt install openjdk-11-jdk -y
    curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee /usr/share/keyrings/jenkins-keyring.asc > /dev/null
    echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] https://pkg.jenkins.io/debian-stable binary/ | sudo tee /etc/apt/sources.list.d/jenkins.list
    sudo apt update
    sudo apt install jenkins -y
  2. Jenkins-Setup abschließen: * Navigiere im Browser zu http://IP_DEINES_SERVERS:8080. * Gib das initial generierte Admin-Passwort ein, das du aus der Datei /var/lib/jenkins/secrets/initialAdminPassword lesen kannst. * Klicke auf **Install suggested plugins**. * Erstelle den ersten Admin-Benutzer.
  3. Jenkins mit Docker und Git integrieren: Füge den Jenkins-Benutzer zur Docker-Gruppe hinzu, damit er Docker-Befehle ausführen kann.
    sudo usermod -aG docker jenkins
    sudo systemctl restart jenkins
    Installiere das Git-Plugin in Jenkins über die **Plugin-Verwaltung**.
  4. Jenkinsfile (Pipeline-Skript) erstellen: Füge eine Datei namens Jenkinsfile zu deinem Git-Repository hinzu. Dieses Skript definiert die CI/CD-Pipeline.
    
    pipeline {
        agent any
        tools {
            git 'Default'
        }
        stages {
            stage('Checkout') {
                steps {
                    git branch: 'main', url: 'https://github.com/dein_user/dein_repo.git'
                }
            }
            stage('Build') {
                steps {
                    script {
                        sh 'docker build -t meine-app:1.0 .'
                    }
                }
            }
            stage('Test') {
                steps {
                    echo 'Führe Tests aus...'
                }
            }
            stage('Deploy') {
                steps {
                    sh 'docker stop meine-app || true'
                    sh 'docker rm meine-app || true'
                    sh 'docker run -d --name meine-app -p 80:80 meine-app:1.0'
                }
            }
        }
    }
    
  5. Pipeline in Jenkins konfigurieren: * Klicke in Jenkins auf **Neues Element**. * Wähle **Pipeline**, gib einen Namen ein und klicke auf **OK**. * Unter **Pipeline** wähle **Pipeline-Skript aus SCM** aus. * Wähle **Git** und gib die URL deines Git-Repositories an. * Gib an, dass das Skript aus dem `Jenkinsfile` im Root-Verzeichnis gelesen werden soll.
  6. Pipeline ausführen und testen: * Klicke auf **Jetzt bauen**. * Jenkins klont dein Repository, führt das `Jenkinsfile`-Skript aus, baut das Docker-Image, führt den Testschritt aus und stellt den Container bereit. * Der Build-Verlauf zeigt den Status und die Ergebnisse der Pipeline. * Bei einer Änderung im Code in deinem Git-Repository kann die Pipeline entweder manuell oder automatisch per Webhook neu gestartet werden.

Private Cloud mit Kubernetes, Rancher und Longhorn: Enterprise-Cluster-Management aufbauen

Diese Anleitung führt dich durch die Einrichtung einer kompletten und robusten Private-Cloud-Plattform für Container. Du installierst Rancher als zentrales Management-Tool, um einen Kubernetes-Cluster zu orchestrieren. Zusätzlich integrierst du Longhorn als verteilte Storage-Lösung, um Containern persistenten und hochverfügbaren Speicher bereitzustellen. Dieses Setup ermöglicht dir, komplexe Anwendungen mit wenigen Klicks zu deployen und zu verwalten.

Teil 1: Basis-Server vorbereiten (auf allen Knoten)

Du benötigst mindestens einen Master-Knoten für Rancher und einen Worker-Knoten für deine Anwendungen. Für den Master-Knoten empfehlen wir eine VM mit mindestens 4 GB RAM, für die Worker-Knoten mindestens 2 GB RAM.

  1. Debian oder Ubuntu Server installieren: Installiere die Server-Version deiner Wahl auf allen Maschinen.
  2. Docker installieren: Installiere Docker auf allen Knoten.
    sudo apt update && sudo apt install docker.io -y
    sudo usermod -aG docker $USER
    sudo systemctl enable docker && sudo systemctl start docker
    Melde dich ab und wieder an, damit die Gruppenänderung wirksam wird.
  3. Feste IP-Adressen vergeben: Stelle sicher, dass alle Knoten statische IP-Adressen haben.

Teil 2: Rancher-Server auf einem Master-Knoten einrichten

Der Rancher-Server wird auf dem Master-Knoten als Docker-Container gestartet und verwaltet alle weiteren Cluster.

  1. SSL-Zertifikat vorbereiten: Für eine sichere Installation benötigst du ein SSL-Zertifikat. Du kannst ein Zertifikat von Let's Encrypt verwenden (installiere Certbot und erhalte es) oder ein selbstsigniertes Zertifikat erstellen.
    # Beispiel für ein selbstsigniertes Zertifikat
    openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=deine.rancher-domain.de"
    mkdir -p /opt/rancher/certs
    mv tls.crt /opt/rancher/certs/
    mv tls.key /opt/rancher/certs/
    
  2. Rancher-Container starten: Starte den Rancher-Container mit einem Volume für die persistenten Daten und den Zertifikaten.
    sudo docker run -d --restart=unless-stopped \
        -p 80:80 -p 443:443 \
        --privileged \
        -v /opt/rancher:/var/lib/rancher \
        -v /opt/rancher/certs/tls.crt:/etc/rancher/ssl/cert.pem \
        -v /opt/rancher/certs/tls.key:/etc/rancher/ssl/key.pem \
        rancher/rancher:latest
    Nach dem Start kannst du die Rancher-Web-Oberfläche unter https://deine.rancher-domain.de aufrufen.
  3. Initial-Setup abschließen: * Navigiere zur Rancher-URL. Beim ersten Start wirst du aufgefordert, ein Passwort für den Admin-Benutzer zu erstellen. * Lege ein sicheres Passwort fest und speichere die Server-URL.

Teil 3: Cluster-Knoten (Worker) hinzufügen

Jetzt bindest du weitere Server in deinen Rancher-Kubernetes-Cluster ein.

  1. Cluster-Erstellung starten: Klicke in der Rancher-Oberfläche auf **Create** (im Bereich **Cluster**). * Wähle **Custom**. * Gib dem Cluster einen Namen und wähle die gewünschte Kubernetes-Version. * Klicke auf **Next**.
  2. Knoten-Rollen wählen: Wähle die Rollen, die die Worker-Knoten übernehmen sollen (z. B. Worker, etcd, Control Plane). Für die Worker-Knoten reicht die Rolle **Worker**.
  3. Befehl ausführen: Rancher generiert einen Befehl. Kopiere diesen Befehl und führe ihn auf jedem Worker-Knoten aus.
    curl --insecure -sfL https://deine.rancher-domain.de/t/xxxxxxx/rancher-agent --insecure | sudo sh -
    Die Knoten werden sich automatisch mit Rancher verbinden und in das Cluster integriert. Der Prozess kann einige Minuten dauern.
  4. Cluster-Status überprüfen: In der Rancher-Oberfläche siehst du, wie die Knoten zum Cluster hinzugefügt werden und den Status **Active** erreichen.

Teil 4: Persistenter Speicher mit Longhorn einrichten

Container-Daten sind flüchtig. Longhorn bietet eine Speicherlösung, die Daten sicher und persistent auf den Knoten ablegt und Replikate erstellt, um Datenverlust vorzubeugen.

  1. Longhorn-Repository hinzufügen: Klicke in Rancher auf **Apps & Marketplace** > **Repositories** > **Create**. * Gib einen Namen (z. B. `longhorn`) und die URL https://charts.longhorn.io an. * Klicke **Create**.
  2. Longhorn installieren: Gehe zu **Apps & Marketplace** > **Charts**. * Wähle **Longhorn**. * Klicke **Install**. Die Standardeinstellungen sind für die meisten Zwecke ausreichend.
  3. Überprüfen der Installation: In der Rancher-Oberfläche erscheint ein neuer Bereich **Longhorn**. Dort siehst du den Status der Installation und die verfügbaren Speichervolumes. Longhorn erstellt automatisch Replikate der Volumes auf den Cluster-Knoten.

Teil 5: Eine Test-Anwendung bereitstellen

Um die Funktionalität des Clusters und des persistenten Speichers zu demonstrieren, stellen wir eine einfache Anwendung (z. B. WordPress) bereit.

  1. Projekt anlegen: Klicke in der Rancher-Oberfläche auf **Projekte/Namespaces** > **Projekte** > **Create**. Erstelle ein neues Projekt (z. B. `web-apps`).
  2. Workload bereitstellen: Klicke in deinem Projekt auf **Workloads** > **Create**. * Gib einen Namen (z. B. `wordpress-app`) an. * Wähle das Docker-Image (z. B. `wordpress:latest`). * Klicke auf **Persistenter Speicher** und erstelle ein neues Volume, das von Longhorn bereitgestellt wird. * Klicke auf **Port-Mapping** und definiere die Port-Weiterleitung (z. B. Port 80 des Containers auf einen beliebigen Port des Host-Servers). * Klicke **Launch**.
  3. Anwendung überprüfen: Nach dem Deployment ist deine Anwendung über die IP-Adresse eines Cluster-Knotens auf dem konfigurierten Port erreichbar. Die Daten sind im Longhorn-Volume persistent und hochverfügbar gespeichert.

Mit diesem Setup hast du eine leistungsstarke und skalierbare Plattform für die Bereitstellung von Containern geschaffen, die die Komplexität von Kubernetes und die Herausforderungen der Speichermanagement elegant löst.