Verbinde dich zuerst mit ssh admin@192.168.1.50 auf den Server. Sobald du eingeloggt bist, prüfe den Inhalt der authorized_keys-Datei:

cat ~/.ssh/authorized_keys
# Du solltest eine Zeile sehen, die mit "ssh-ed25519" beginnt
# und mit deinem Kommentar "mein-laptop" endet

Anschließend Verbindung beenden:

exit

Der SSH-Server hat eine Konfigurationsdatei: /etc/ssh/sshd_config. Sie liegt auf dem Server -- öffne sie nach dem SSH-Login mit nano:

sudo nano /etc/ssh/sshd_config
# sudo ist nötig, weil die Datei root gehört
# Speichern: Ctrl+O → Enter · Schließen: Ctrl+X

Suche in der Datei die folgenden Einstellungen und passe sie an (oder füge sie hinzu, falls sie fehlen):

# Root-Login verbieten (immer als normaler User anmelden, dann sudo)
PermitRootLogin no

# Passwort-Anmeldung deaktivieren (nur noch Schlüssel erlauben)
PasswordAuthentication no

# Nur bestimmte Benutzer erlauben
AllowUsers admin deploy

# Port ändern (optional, reduziert automatisierte Angriffe)
Port 2222

# Leere Passwörter verbieten
PermitEmptyPasswords no

Nach Änderungen musst du den SSH-Dienst neu laden. Das reload statt restart ist wichtig -- bestehende Verbindungen bleiben so erhalten:

sudo systemctl reload sshd

Der Prompt zeigt dir immer, wer du bist und wo du dich befindest:

admin@server01:~$
# admin    = dein Benutzername
# server01 = Hostname des Servers
# ~        = aktuelles Verzeichnis (~ ist Abkürzung für dein Home-Verzeichnis)
# $        = normaler Benutzer (# bedeutet: du bist root)

pwd                     # Aktuelles Verzeichnis anzeigen (Print Working Directory)
ls                      # Inhalt des aktuellen Verzeichnisses auflisten
ls -la                  # Detailliert inkl. versteckter Dateien (beginnen mit .)
ls -lh                  # Mit lesbaren Dateigrößen (KB, MB, GB)
cd /var/log             # In ein anderes Verzeichnis wechseln
cd ..                   # Ein Verzeichnis nach oben gehen
cd                      # Immer zurück ins Home-Verzeichnis (~)
cd -                    # Ins zuletzt besuchte Verzeichnis wechseln

cat datei.txt            # Gesamten Inhalt anzeigen
less /var/log/syslog     # Große Datei seitenweise lesen (q = beenden)
head -20 datei.txt       # Erste 20 Zeilen anzeigen
tail -20 datei.txt       # Letzte 20 Zeilen anzeigen
tail -f /var/log/syslog  # Live: neue Zeilen in Echtzeit (Ctrl+C = beenden)

mkdir projekte            # Neuen Ordner erstellen
mkdir -p a/b/c           # Verschachtelte Ordner auf einmal erstellen
touch datei.txt          # Leere Datei erstellen
echo "Hallo" > datei.txt  # Text in Datei schreiben (überschreibt!)
echo "Mehr" >> datei.txt  # Text an Datei anhängen

cp datei.txt kopie.txt    # Datei kopieren
cp -r ordner/ backup/    # Ganzen Ordner rekursiv kopieren
mv datei.txt neu.txt      # Datei umbenennen
mv datei.txt /tmp/       # Datei in anderes Verzeichnis verschieben

grep "error" /var/log/syslog          # Zeilen mit "error" finden
grep -i "error" /var/log/syslog       # Groß-/Kleinschreibung ignorieren
grep -r "Port 22" /etc/              # Rekursiv in allen Dateien unter /etc/
grep -n "root" /etc/passwd           # Mit Zeilennummer
grep -v "#" /etc/ssh/sshd_config      # Zeilen OHNE Kommentare anzeigen

find /etc -name "*.conf"              # Alle .conf-Dateien unter /etc
find /var/log -name "*.log" -mtime -1   # Log-Dateien, geändert in den letzten 24h
find /home -size +100M               # Dateien größer als 100 MB
find /tmp -type f -empty             # Leere Dateien finden

# Lauschende Ports finden und nach SSH filtern
ss -tulpn | grep ":22"

# Wie viele Benutzer gibt es auf dem System?
cat /etc/passwd | wc -l

# Die 5 größten Dateien unter /var/log finden
du -ah /var/log | sort -rh | head -5

# Aktive Einstellungen aus sshd_config (ohne Kommentare und Leerzeilen)
grep -v "^#" /etc/ssh/sshd_config | grep -v "^$"

ls /var/log > logdateien.txt         # Ausgabe in Datei speichern (überschreibt)
echo "Neue Zeile" >> logdateien.txt   # An bestehende Datei anhängen
find /etc -name "*.conf" 2>/dev/null  # Fehlermeldungen verwerfen

# Befehlshistorie
history                   # Letzte Befehle anzeigen
history | grep "ssh"    # Nur SSH-Befehle aus der Historie

# In der Historie navigieren:
# Pfeiltaste hoch/runter = vorherige/nächste Befehle
# Ctrl+R = interaktive Rückwärtssuche in der Historie
# !! = letzten Befehl wiederholen
# !ssh = letzten Befehl, der mit "ssh" anfing, wiederholen

# Temporärer Alias (gilt nur in dieser Sitzung)
alias ll="ls -lah"
alias frei="df -h"

# Permanente Aliase: in ~/.bashrc eintragen
echo 'alias ll="ls -lah"' >> ~/.bashrc
source ~/.bashrc          # Änderungen sofort aktiv machen

vim datei.txt             # Datei öffnen (oder neu erstellen)

# Du startest im Normal-Modus
i                          # → Einfüge-Modus: jetzt kannst du tippen
Esc                        # → zurück zum Normal-Modus (immer dein Sicherheitsnetz)

# Speichern und Beenden (aus dem Normal-Modus, dann : drücken)
:w                         # Speichern (write)
:q                         # Beenden (quit) -- nur wenn keine ungespeicherten Änderungen
:wq                        # Speichern und beenden
:q!                        # Beenden OHNE Speichern (Änderungen verwerfen)

Rufe die man-Page eines Befehls auf, indem du man gefolgt vom Befehlsnamen eingibst:

man ls           # Handbuch für den Befehl ls
man grep         # Handbuch für grep
man ssh          # Handbuch für SSH

Die man-Page öffnet sich im Pager less -- den du bereits aus Modul 03 kennst. Navigiere so:

Ohne Sektionsnummer öffnet man immer die niedrigste passende Sektion. Mit einer Zahl davor wählst du gezielt:

man passwd          # Öffnet Sektion 1 -- der Befehl zum Passwort ändern
man 5 passwd        # Öffnet Sektion 5 -- Format der Datei /etc/passwd
man 5 sshd_config   # Alle Optionen der SSH-Server-Konfiguration
man 5 fstab         # Aufbau und Syntax von /etc/fstab

apropos password    # Alle Befehle, die mit Passwörtern zu tun haben
apropos network     # Alle Befehle zum Thema Netzwerk
apropos disk        # Alle Befehle rund um Festplatten

# man -k ist identisch mit apropos
man -k password     # Gleiches Ergebnis wie apropos password

# whatis: nur eine kurze Einzeiler-Beschreibung
whatis grep         # → grep (1) - print lines that match patterns
whatis passwd        # Zeigt alle Sektionen, in denen passwd vorkommt

Fast jeder Befehl kennt --help oder -h -- das gibt eine kurze Übersicht aller Optionen aus, ohne den Pager zu öffnen:

ls --help
grep --help
tar --help        # Kürzer als die man-Page, aber vollständig

tldr geht noch einen Schritt weiter: Es zeigt nur die häufigsten Anwendungsfälle mit kopierbaren Beispielen. Erst installieren, dann nutzen:

sudo apt install tldr
tldr --update         # Datenbank beim ersten Mal aktualisieren (braucht Internet)

tldr tar              # Die häufigsten tar-Befehle auf einen Blick
tldr find             # find-Beispiele -- deutlich übersichtlicher als man find
tldr ssh-keygen       # Bekannt aus Modul 02 -- sieh dir die Kurzfassung an

Zeige alle vorhandenen Netzwerk-Interfaces an:

ip link show
# Typische Ausgabe:
# 1: lo: <LOOPBACK,UP>       -- Loopback (127.0.0.1, nur intern)
# 2: eth0: <BROADCAST,UP>    -- Ethernet-Anschluss (Kabel)
# 3: ens18: <BROADCAST,UP>   -- Ethernet in VMs (z.B. Proxmox)

Mit UP in der Ausgabe ist das Interface aktiv. Zeige dann IP-Adressen und Routing-Tabelle:

ip addr show                  # Alle Interfaces mit IP-Adressen
ip addr show eth0             # Nur ein bestimmtes Interface
ip -4 addr show               # Nur IPv4-Adressen (übersichtlicher)
ip route show                 # Routing-Tabelle -- Gateway finden

Das Gateway steht in der Routing-Tabelle nach default via -- das ist die IP-Adresse deines Routers.

Zeige, welche Netplan-Dateien vorhanden sind und lies ihren Inhalt:

ls /etc/netplan/           # Welche Dateien gibt es?
cat /etc/netplan/*.yaml    # Inhalt der Konfiguration anzeigen

So sieht eine typische DHCP-Konfiguration aus -- der Server bezieht seine IP automatisch vom Router:

network:
  version: 2
  ethernets:
    eth0:          # Interface-Name -- bei dir vielleicht ens18 oder enp3s0
      dhcp4: true

Bearbeite die Netplan-Datei mit vim (aus Modul 03). Ersetze den DHCP-Block durch eine statische Konfiguration:

network:
  version: 2
  ethernets:
    eth0:
      dhcp4: false
      addresses:
        - 192.168.1.50/24     # Deine gewünschte IP + Subnetzmaske
      routes:
        - to: default
          via: 192.168.1.1    # IP-Adresse deines Routers (Gateway)
      nameservers:
        addresses:
          - 1.1.1.1           # Cloudflare DNS
          - 9.9.9.9           # Quad9 DNS (Backup)

Nach dem Bearbeiten die Konfiguration testen und anwenden:

# Syntax prüfen (zeigt Fehler, ändert noch nichts)
sudo netplan generate

# Änderungen testen -- 120 Sekunden Zeit zum Bestätigen
sudo netplan try
# Bei Verbindung OK: Enter drücken
# Bei Problemen: einfach 120 Sek. warten, automatischer Rollback

# Direkt anwenden (nur wenn du dir sicher bist)
sudo netplan apply

Prüfe, welchen DNS-Server dein System aktuell verwendet, und teste die DNS-Auflösung:

# Aktuell verwendete DNS-Server anzeigen (systemd-resolved)
resolvectl status

# Klassische Datei (auf Ubuntu oft ein Symlink, nicht direkt bearbeiten)
cat /etc/resolv.conf

# DNS-Auflösung testen
dig +short google.com     # Zeigt nur die IP-Adresse
ping -c 2 google.com       # Testet Verbindung + DNS gleichzeitig

Hostname anzeigen und dauerhaft ändern:

# Aktuellen Hostnamen anzeigen
hostname
hostnamectl            # Ausführlichere Informationen (Betriebssystem, Kernel)

# Hostnamen dauerhaft ändern
sudo hostnamectl set-hostname webserver01
# Wirkt sofort, im Prompt erst nach neuer SSH-Sitzung sichtbar

Bearbeite /etc/hosts mit vim (aus Modul 03):

sudo vim /etc/hosts

# Standardinhalt (nicht löschen):
127.0.0.1       localhost
127.0.1.1       webserver01     # Eigener Hostname -- hier anpassen

# Eigene Einträge für Geräte im Netzwerk hinzufügen:
192.168.1.1     router
192.168.1.50    webserver01
192.168.1.51    dbserver01
192.168.1.52    backupserver

Danach kannst du statt IP-Adressen die Namen verwenden:

ping -c 2 dbserver01         # statt: ping 192.168.1.51
ssh admin@dbserver01          # statt: ssh admin@192.168.1.51

Die wichtigsten nmcli-Befehle zum Prüfen und Konfigurieren:

# Alle Verbindungen anzeigen
nmcli connection show

# Details einer Verbindung anzeigen
nmcli connection show "Wired connection 1"

# Statische IP setzen
sudo nmcli connection modify "Wired connection 1" \
  ipv4.method manual \
  ipv4.addresses 192.168.1.50/24 \
  ipv4.gateway 192.168.1.1 \
  ipv4.dns "1.1.1.1,9.9.9.9"

# Verbindung neu starten (Änderungen aktivieren)
sudo nmcli connection down "Wired connection 1"
sudo nmcli connection up "Wired connection 1"

# Zurück auf DHCP
sudo nmcli connection modify "Wired connection 1" ipv4.method auto

Netzwerk-Diagnose von der untersten Ebene aufwärts:

# Schritt 1: Ist das Interface überhaupt aktiv?
ip link show
# "UP" muss in der Ausgabe stehen

# Schritt 2: Hat das Interface eine IP-Adresse?
ip addr show
# Nach "inet" suchen -- z.B. "inet 192.168.1.50/24"

# Schritt 3: Ist das Gateway (der Router) erreichbar?
ping -c 3 192.168.1.1
# IP deines Routers hier eintragen

# Schritt 4: Funktioniert die Internet-Verbindung (ohne DNS)?
ping -c 3 8.8.8.8

# Schritt 5: Funktioniert DNS-Auflösung?
ping -c 3 google.com

apt update lädt die aktuellen Paketlisten herunter -- es wird noch nichts installiert. Erst apt upgrade installiert die neueren Versionen.

sudo apt update
# APT schaut nach, was es Neues gibt -- noch nichts wird installiert
# Am Ende steht: "X packages can be upgraded."

sudo apt upgrade
# Alle veralteten Pakete auf die neueste Version bringen
# APT fragt nach Bestätigung -- mit "j" oder "Enter" bestätigen

# Oder beides in einem Zug (typische Kombination):
sudo apt update && sudo apt upgrade

# Ein Paket installieren
sudo apt install htop

# Mehrere Pakete auf einmal
sudo apt install htop curl wget tree

# Ohne Rückfrage (praktisch in Skripten)
sudo apt install -y htop

# Nach einem Paket suchen (Stichwortsuche)
apt search webserver

# Details zu einem Paket anzeigen (Version, Größe, Beschreibung)
apt show nginx

# Alle installierten Pakete auflisten
apt list --installed

# Prüfen ob ein bestimmtes Paket installiert ist
apt list --installed | grep nginx

# Paket entfernen -- Konfigurationsdateien bleiben erhalten
sudo apt remove htop

# Paket vollständig entfernen -- auch Konfiguration weg
sudo apt purge htop

# Nicht mehr benötigte Abhängigkeiten aufräumen
sudo apt autoremove

Aktuelle Paketquellen anzeigen:

# Klassische Paketquellen-Datei anzeigen
cat /etc/apt/sources.list

# Zusätzlich eingebundene Quellen anzeigen
ls /etc/apt/sources.list.d/

# Paket installieren
sudo apt install unattended-upgrades

# Aktivieren -- wähle "Ja" in der Dialogbox
sudo dpkg-reconfigure -plow unattended-upgrades

# Status prüfen: Läuft der Dienst?
systemctl status unattended-upgrades

Die Konfiguration findest du in /etc/apt/apt.conf.d/50unattended-upgrades. Standardmäßig werden nur Sicherheitsupdates automatisch installiert -- keine neuen Features, die etwas kaputt machen könnten.

# Lokale .deb-Datei installieren
sudo dpkg -i paket.deb

# Falls Abhängigkeiten fehlen, danach ausführen:
sudo apt install -f

# Prüfen ob und welche Version eines Pakets installiert ist
dpkg -s nginx

# Alle Dateien anzeigen, die ein Paket installiert hat
dpkg -L nginx

# Welches Paket stellt eine bestimmte Datei bereit?
dpkg -S /usr/bin/vim

Paketliste aktualisieren und XFCE installieren -- du kennst dieses Prinzip bereits aus Modul 06:

sudo apt update
sudo apt install xfce4 xfce4-goodies
# xfce4         = Basis-Desktop
# xfce4-goodies = nützliche Extras: Terminal, Dateimanager, Screenshot-Tool

Die Installation lädt 200--400 MB herunter und dauert einige Minuten. Danach ist XFCE auf dem Server bereit -- du kannst es aber noch nicht sehen, weil du per SSH ohne Bildschirm verbunden bist. Dafür brauchen wir xrdp.

sudo apt install xrdp

# Dienst starten und beim Boot automatisch starten:
sudo systemctl enable --now xrdp

# Status prüfen -- sollte "active (running)" zeigen:
sudo systemctl status xrdp

Jetzt teile xrdp mit, welchen Desktop es starten soll. Dafür schreibst du eine kurze Steuerdatei in dein Home-Verzeichnis:

echo "startxfce4" > ~/.xsession
# Prüfen, ob es geschrieben wurde:
cat ~/.xsession
# Ausgabe sollte sein: startxfce4

Prüfe, ob xrdp auf Port 3389 lauscht -- das kennst du schon aus Modul 01:

ss -tulpn | grep 3389
# Erwartete Ausgabe: tcp  LISTEN  ...  0.0.0.0:3389  ...  xrdp

# Aktuellen Firewall-Status prüfen:
sudo ufw status

# RDP nur aus dem lokalen Netz (192.168.1.0/24) erlauben:
sudo ufw allow from 192.168.1.0/24 to any port 3389

# Ergebnis prüfen:
sudo ufw status numbered

Passe den IP-Bereich (192.168.1.0/24) an dein Netz an. Bei Unsicherheit: ip addr show zeigt deine Server-IP -- der Netzbereich ist die IP ohne die letzte Zahl plus /24.

sudo apt install tigervnc-standalone-server

# VNC-Passwort setzen (wird beim Verbinden abgefragt):
vncpasswd

# VNC-Server starten (Display :1 = Port 5901):
vncserver :1

# Laufende Sitzungen prüfen:
vncserver -list

cat /etc/passwd
# Beispielzeile:
# max:x:1001:1001:Max Mustermann:/home/max:/bin/bash

# Empfohlener Weg: adduser (interaktiv, erstellt Home-Verzeichnis)
sudo adduser max
# → Fragt nach Passwort, vollem Namen usw.

# Alternativer Weg: useradd (low-level, mehr Kontrolle)
sudo useradd -m -s /bin/bash -c "Max Mustermann" max
# -m  → Home-Verzeichnis erstellen (/home/max)
# -s  → Login-Shell festlegen
# -c  → Kommentar (voller Name)

# Passwort setzen (bei useradd manuell nötig):
sudo passwd max

# Aktuellen Benutzer anzeigen:
whoami

# Alle Informationen über einen Benutzer:
id max
# Ausgabe: uid=1001(max) gid=1001(max) groups=1001(max),27(sudo)

# Alle normalen Benutzer auflisten (UID ab 1000):
awk -F: '$3 >= 1000 && $3 < 65534 {print $1}' /etc/passwd

# Wer ist gerade eingeloggt?
who
w     # ausführlicher: zeigt auch, was jeder Nutzer gerade tut

# Shell ändern:
sudo usermod -s /bin/zsh max

# Kommentar (voller Name) ändern:
sudo usermod -c "Max M. (Admin)" max

# Konto sperren (Login verhindern):
sudo usermod -L max

# Konto entsperren:
sudo usermod -U max

# Benutzer löschen (Home-Verzeichnis bleibt erhalten):
sudo userdel max

# Benutzer löschen MIT Home-Verzeichnis (Achtung: unwiderruflich!):
sudo userdel -r max

# Auf Debian/Ubuntu: benutzerfreundliche Alternative
sudo deluser --remove-home max

# Neue Gruppe erstellen:
sudo groupadd entwickler

# Benutzer einer sekundären Gruppe hinzufügen:
sudo usermod -aG entwickler max
# -a → append (wichtig! Ohne -a werden alle anderen Gruppen entfernt!)
# -G → sekundäre Gruppen

# Mehrere Gruppen auf einmal hinzufügen:
sudo usermod -aG entwickler,docker,www-data max

# Gruppen eines Benutzers anzeigen:
groups max
# Ausgabe: max : max entwickler docker

# Alle Mitglieder einer Gruppe anzeigen:
getent group entwickler

# Gruppe löschen:
sudo groupdel entwickler

# Einfachster Weg: Benutzer zur Gruppe 'sudo' hinzufügen
sudo usermod -aG sudo max

# Prüfen ob es geklappt hat:
groups max
# Ausgabe: max : max sudo

# Hinweis: Benutzer muss sich ab- und wieder anmelden,
# damit die neue Gruppenmitgliedschaft wirkt.

sudo visudo

# Wichtige Zeilen in der Datei:
# root    ALL=(ALL:ALL) ALL    → Root darf alles
# %sudo   ALL=(ALL:ALL) ALL    → Gruppe 'sudo' darf alles

# Einzelnen Benutzer einschränken (nur apt erlauben):
# max     ALL=(ALL) /usr/bin/apt

# sudo ohne Passwort (NUR für Automatisierung, nicht für normale Nutzer!):
# deploy  ALL=(ALL) NOPASSWD: ALL

# Passwort-Infos eines Benutzers anzeigen:
sudo chage -l max

# Passwort muss alle 90 Tage geändert werden:
sudo chage -M 90 max

# Mindestens 7 Tage zwischen Passwortänderungen:
sudo chage -m 7 max

# Benutzer muss beim nächsten Login das Passwort ändern:
sudo chage -d 0 max

Mit diesen Befehlen siehst du, welchen Kernel und welche Distribution dein Server nutzt:

# Kernel-Version anzeigen:
uname -r
# Ausgabe z.B.: 6.1.0-18-amd64

# Welche Shell nutzt du gerade?
echo $SHELL
# Ausgabe z.B.: /bin/bash

# Welche Distribution und Version?
cat /etc/os-release
lsb_release -a

# BIOS oder UEFI? (Verzeichnis vorhanden = UEFI)
ls /sys/firmware/efi/ && echo "UEFI" || echo "BIOS"

# Gesamte Bootzeit anzeigen:
systemd-analyze
# Ausgabe z.B.: Startup finished in 2.5s (kernel) + 8.3s (userspace) = 10.8s

# Die langsamsten Dienste beim Boot:
systemd-analyze blame | head -10

# Boot-Logs des aktuellen Starts:
journalctl -b --no-pager | tail -30

# Die erste Verzeichnisebene anzeigen:
ls /

# Was liegt in /etc?
ls /etc/ | head -20

# Wie viel Platz verbraucht jedes Verzeichnis?
sudo du -sh /* 2>/dev/null | sort -hr | head

# Hostnamen lesen:
cat /etc/hostname

# Alle laufenden Prozesse anzeigen:
ps aux
# USER   PID  %CPU %MEM  COMMAND
# root     1   0.0  0.5  /sbin/init  (= systemd)
# www-da 812   0.2  1.3  nginx: master process

# Nach CPU-Auslastung sortiert, Top 10:
ps aux --sort=-%cpu | head -10

# Interaktive Prozessübersicht (beenden mit 'q'):
top
# Noch besser – falls installiert:
htop

# PID eines bestimmten Programms finden:
pgrep nginx
pidof sshd

# Prozess geordnet beenden (SIGTERM, Standard):
kill 1234
# Ersetze 1234 durch die echte PID aus ps aux

# Prozess sofort abwürgen (SIGKILL, letzter Ausweg):
kill -9 1234

# Alle Prozesse eines Namens beenden:
pkill firefox
killall python3

# Status eines Dienstes anzeigen:
systemctl status ssh
# Zeigt: läuft/gestoppt, letzte Logs, PID

# Dienst starten / stoppen / neustarten:
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx

# Nur Konfiguration neu laden (ohne Neustart):
sudo systemctl reload nginx

# Dienst beim Boot automatisch starten:
sudo systemctl enable nginx

# Autostart wieder deaktivieren:
sudo systemctl disable nginx

# Alle laufenden Dienste auflisten:
systemctl list-units --type=service --state=running

# Aktuelles Standard-Target anzeigen:
systemctl get-default
# Auf Servern typisch: multi-user.target

# Standard-Target setzen (nur wenn nötig):
sudo systemctl set-default multi-user.target

# Alle Logs (neueste zuerst, 'q' zum Beenden):
journalctl -e

# Nur Logs des aktuellen Boots:
journalctl -b

# Nur Fehlermeldungen:
journalctl -b -p err

# Logs eines bestimmten Dienstes:
journalctl -u ssh
journalctl -u nginx -f
# -f = live mitlesen (wie tail -f), beenden mit Strg+C

# Logs der letzten Stunde:
journalctl --since "1 hour ago"

# Alle Umgebungsvariablen anzeigen:
env
printenv

# Eine bestimmte Variable lesen:
echo $PATH
echo $HOME
echo $USER

# Variable für die aktuelle Sitzung setzen:
export MEINE_VAR="hallo"
echo $MEINE_VAR
# Gilt nur in dieser Shell-Sitzung – nach logout weg

# Variable dauerhaft für alle Benutzer setzen:
sudo nano /etc/environment
# Dort eintragen: MEINE_VAR="hallo"
# Gilt nach dem nächsten Login systemweit

lsblk zeigt dir alle Blockgeräte (Festplatten, Partitionen, USB-Sticks) in einer Baumstruktur:

lsblk
# Ausgabe-Beispiel:
# NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
# sda      8:0    0   20G  0 disk
# ├─sda1   8:1    0   19G  0 part /
# └─sda2   8:2    0    1G  0 part [SWAP]
# sdb      8:16   0  500G  0 disk
# └─sdb1   8:17   0  500G  0 part

# Mit Dateisystem und UUID anzeigen:
lsblk -f

blkid zeigt dir die UUID und den Dateisystemtyp jeder Partition -- das brauchst du für die fstab:

sudo blkid
# Ausgabe-Beispiel:
# /dev/sda1: UUID="550e8400-e29b-41d4-a716-446655440000" TYPE="ext4"
# /dev/sdb1: UUID="a1b2c3d4-5678-90ab-cdef-1234567890ab" TYPE="ext4"

# Nur eine bestimmte Partition abfragen:
sudo blkid /dev/sdb1

Schritt 1: Erstelle einen Ordner als Einhängepunkt. Schritt 2: Hänge die Partition ein. Schritt 3: Prüfe das Ergebnis.

# Einhängepunkt erstellen (falls noch nicht vorhanden):
sudo mkdir -p /mnt/daten

# Partition einhängen:
sudo mount /dev/sdb1 /mnt/daten

# Prüfen ob es geklappt hat:
df -h /mnt/daten
ls /mnt/daten/

Zum Aushängen nimmst du umount. Das ist kein Tippfehler -- der Befehl heißt wirklich umount, nicht unmount:

# Partition aushängen:
sudo umount /mnt/daten

# Falls "target is busy" kommt -- wer nutzt die Partition noch?
sudo lsof /mnt/daten
# Zeigt alle Prozesse, die Dateien auf der Partition offen haben

# Nur-Lesen mounten (Partition kann nicht verändert werden):
sudo mount -o ro /dev/sdb1 /mnt/backup

# Mehrere Optionen kombinieren:
sudo mount -o rw,noexec,noatime /dev/sdb1 /mnt/daten

# ISO-Datei mounten (als Loop-Device):
sudo mount -o loop /tmp/debian.iso /mnt/iso

So sieht eine typische fstab aus:

# Feld 1: Gerät        Feld 2: Mountpoint  Feld 3: FS   Feld 4: Optionen          Feld 5  Feld 6
UUID=550e8400-e29b-41d4-a716-446655440000  /             ext4   errors=remount-ro  0  1
UUID=a1b2c3d4-5678-90ab-cdef-1234567890ab  /home         ext4   defaults           0  2
/dev/sdb1                                  /mnt/daten    ext4   defaults,nofail    0  2
# Swap-Partition:
UUID=dead1234-beef-5678-abcd-ef0123456789  none          swap   sw                 0  0

Das Vorgehen Schritt für Schritt:

# 1. UUID der Partition herausfinden:
sudo blkid /dev/sdb1
# Ausgabe: /dev/sdb1: UUID="a1b2c3d4-..." TYPE="ext4"

# 2. Einhängepunkt erstellen:
sudo mkdir -p /mnt/daten

# 3. fstab mit einem Editor öffnen und Zeile hinzufügen:
sudo nano /etc/fstab
# Neue Zeile einfügen (UUID durch echten Wert aus blkid ersetzen):
# UUID=a1b2c3d4-5678-90ab-cdef-1234567890ab  /mnt/daten  ext4  defaults,nofail  0  2

# 4. Testen ohne Neustart -- mountet alle fstab-Einträge:
sudo mount -a
# Kein Fehler = alles korrekt eingetragen

# 5. Ergebnis prüfen:
df -h /mnt/daten

# Aktuellen Swap-Status anzeigen:
swapon --show
free -h

# Swap-Datei erstellen (2 GB):
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# Dauerhaft in fstab eintragen (nach der letzten Zeile einfügen):
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# Prüfen ob Swap aktiv ist:
swapon --show

# NFS-Share einbinden (Modul 12 behandelt das ausführlich):
# 192.168.1.10:/export/daten  /mnt/nfs  nfs  defaults,_netdev,nofail  0  0

# Aktuell gemountete Netzlaufwerke anzeigen:
findmnt -t nfs,cifs

Diese Befehle helfen dir, Mount-Probleme zu diagnostizieren:

# Alle aktuell gemounteten Dateisysteme als Baum:
findmnt

# fstab auf Syntaxfehler prüfen (vor dem Neustart!):
findmnt --verify

# Alle fstab-Einträge neu mounten (Test ohne Neustart):
sudo mount -a

# Kernel-Meldungen zu Festplatten anzeigen:
dmesg | grep -i 'sd\|error\|fail' | tail -20

Mit ls -la siehst du alle Dateien inklusive ihrer Berechtigungen:

ls -la
# Beispiel-Ausgabe:
drwxr-xr-x  2 max  entwickler  4096 Jan 15 10:30 projekt/
-rw-r--r--  1 max  entwickler  2048 Jan 15 10:28 readme.txt
-rwxr-x---  1 root root        8192 Jan 14 09:00 backup.sh

So liest du die erste Zeile drwxr-xr-x:

Buchstaben-Syntax: u = Besitzer (user), g = Gruppe, o = Andere (others), a = Alle. Operator: + hinzufügen, - entfernen, = genau setzen.

# Besitzer darf ausführen:
chmod u+x script.sh

# Gruppe darf schreiben:
chmod g+w datei.txt

# Anderen alle Rechte entziehen:
chmod o-rwx geheim.txt

# Allen Lese-Recht geben:
chmod a+r public.html

# Besitzer: rwx, Gruppe: rx, Andere: nichts:
chmod u=rwx,g=rx,o= backup.sh

Die häufigsten Oktalwerte in der Praxis:

# 755 = rwxr-xr-x (Standard für Verzeichnisse und Skripte)
chmod 755 script.sh

# 644 = rw-r--r-- (Standard für normale Dateien)
chmod 644 config.txt

# 600 = rw------- (nur Besitzer darf lesen/schreiben – z.B. SSH-Schlüssel)
chmod 600 ~/.ssh/id_ed25519

# 700 = rwx------ (nur Besitzer, voller Zugriff)
chmod 700 ~/privat/

# Rekursiv für ein ganzes Verzeichnis und alle Inhalte:
chmod -R 755 /var/www/html/

# Besitzer ändern (braucht sudo):
sudo chown max datei.txt

# Besitzer und Gruppe in einem Schritt ändern:
sudo chown max:entwickler datei.txt

# Nur die Gruppe ändern:
sudo chgrp entwickler datei.txt

# Rekursiv für ein ganzes Verzeichnis:
sudo chown -R www-data:www-data /var/www/html/

# Aktuellen Besitzer prüfen:
ls -la datei.txt
# -rw-r--r-- 1 max entwickler 2048 Jan 15 datei.txt
#                ^ Besitzer   ^ Gruppe

# Aktuelle umask anzeigen:
umask
# Ausgabe: 0022

# umask für die aktuelle Sitzung ändern:
umask 027

# Dauerhaft ändern – in ~/.bashrc eintragen:
echo "umask 027" >> ~/.bashrc

Beispiele: SUID beim Programm passwd, SGID für Teamverzeichnisse, Sticky Bit beim Ordner /tmp:

# SUID-Beispiel: passwd läuft als root, auch wenn ein normaler User es startet:
ls -la /usr/bin/passwd
# -rwsr-xr-x 1 root root ... /usr/bin/passwd
#    ^ das 's' statt 'x' zeigt SUID an

# SGID auf Verzeichnis setzen (neue Dateien erben die Gruppe):
sudo chmod g+s /shared/projekt/
# oder mit Oktal: sudo chmod 2775 /shared/projekt/

# Sticky Bit anschauen – /tmp hat es standardmäßig:
ls -ld /tmp
# drwxrwxrwt  ← das 't' am Ende zeigt das Sticky Bit

# Sticky Bit manuell setzen:
sudo chmod +t /shared/uploads/

Zuerst SAMBA installieren und die Dienste starten:

sudo apt update
sudo apt install samba

# Status prüfen (smbd = Dateidienst, nmbd = Namensauflösung):
sudo systemctl status smbd nmbd

# Dienste beim Start automatisch aktivieren:
sudo systemctl enable smbd nmbd

# Firewall-Freigabe, falls ufw aktiv (aus Modul 14):
sudo ufw allow Samba

[global]
   workgroup = WORKGROUP
   server string = Mein Linux Server
   security = user
   map to guest = bad user

# Passwortgeschützte Freigabe (empfohlen):
[daten]
   comment = Gemeinsame Daten
   path = /srv/samba/daten
   browseable = yes
   read only = no
   valid users = admin
   create mask = 0660
   directory mask = 0770

# Öffentliche Freigabe -- nur lesen, kein Passwort:
[public]
   comment = Oeffentliche Dateien
   path = /srv/samba/public
   browseable = yes
   read only = yes
   guest ok = yes

Verzeichnisse anlegen und Berechtigungen setzen (aus Modul 11):

# Verzeichnisse erstellen:
sudo mkdir -p /srv/samba/daten /srv/samba/public

# Besitzer setzen:
sudo chown admin:admin /srv/samba/daten
sudo chmod 750 /srv/samba/daten

# Öffentliches Verzeichnis (alle dürfen lesen):
sudo chown nobody:nogroup /srv/samba/public
sudo chmod 755 /srv/samba/public

# Konfiguration prüfen (zeigt Fehler und aktive Einstellungen):
testparm

# SAMBA neu starten:
sudo systemctl restart smbd

# SAMBA-Passwort für bestehenden Linux-Benutzer setzen:
sudo smbpasswd -a admin
# Du wirst nach dem neuen SAMBA-Passwort gefragt (2x eingeben)

# Benutzer aktivieren (nach smbpasswd -a normalerweise automatisch):
sudo smbpasswd -e admin

# Aktive SAMBA-Benutzer anzeigen:
sudo pdbedit -L

# Verbindungen prüfen (wer ist gerade verbunden?):
sudo smbstatus

Nginx lässt sich direkt aus den Ubuntu-Paketquellen installieren:

sudo apt update
sudo apt install -y nginx

# Status prüfen:
sudo systemctl status nginx

# Nginx startet automatisch mit dem System:
sudo systemctl enable nginx

Nach der Installation läuft Nginx sofort. Öffne http://server-ip im Browser – du siehst die Nginx-Willkommensseite.

# Verzeichnis anlegen:
sudo mkdir -p /var/www/meinsite

# Einfache HTML-Seite erstellen:
echo '<h1>Hallo vom Webserver</h1>' | sudo tee /var/www/meinsite/index.html

# Berechtigungen setzen – nginx-Prozess läuft als www-data:
sudo chown -R www-data:www-data /var/www/meinsite
sudo chmod -R 755 /var/www/meinsite

server {
    listen 80;
    server_name meinsite.local 192.168.1.50;

    root /var/www/meinsite;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }

    # Logs:
    access_log /var/log/nginx/meinsite-access.log;
    error_log  /var/log/nginx/meinsite-error.log;
}

Jetzt aktivieren und testen:

# Symlink anlegen – aktiviert die Konfiguration:
sudo ln -s /etc/nginx/sites-available/meinsite /etc/nginx/sites-enabled/

# Konfiguration auf Fehler prüfen:
sudo nginx -t

# Nginx neu laden (ohne Unterbrechung):
sudo systemctl reload nginx

server {
    listen 80;
    server_name app.example.com;

    location / {
        proxy_pass http://127.0.0.1:3000;
        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;
    }
}

Caddy ist nicht im Standard-Ubuntu-Repository – du fügst das offizielle Caddy-Repository hinzu:

# Abhängigkeiten:
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl

# GPG-Schlüssel herunterladen:
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
  | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

# Repository eintragen:
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
  | sudo tee /etc/apt/sources.list.d/caddy-stable.list

# Caddy installieren:
sudo apt update
sudo apt install -y caddy

# Status prüfen:
sudo systemctl status caddy

# Statische Website (automatisches HTTPS bei echter Domain):
example.com {
    root * /var/www/example.com
    file_server
}

# Reverse Proxy zu einem internen Dienst:
app.example.com {
    reverse_proxy localhost:3000
}

# Mehrere Dienste auf einem Server:
grafana.example.com {
    reverse_proxy localhost:3001
}

# Lokal testen ohne echte Domain (kein automatisches HTTPS):
:8080 {
    root * /var/www/test
    file_server
}

Nach Änderungen Konfiguration prüfen und neu laden:

# Konfiguration validieren:
caddy validate --config /etc/caddy/Caddyfile

# Caddy neu laden (kein Neustart, keine Downtime):
sudo systemctl reload caddy

# Certbot installieren:
sudo apt install -y certbot python3-certbot-nginx

# Zertifikat für eine Domain holen und Nginx-Config anpassen:
sudo certbot --nginx -d example.com

# Zertifikat-Erneuerung testen (Certbot richtet Cronjob ein):
sudo certbot renew --dry-run

# Nginx-Logs:
sudo tail -f /var/log/nginx/access.log   # Live-Ansicht Anfragen
sudo tail -f /var/log/nginx/error.log    # Live-Ansicht Fehler

# Caddy-Logs (über systemd journal):
sudo journalctl -u caddy -f             # Live-Ansicht
sudo journalctl -u caddy -n 50          # Letzte 50 Zeilen

# Nur Fehler im Nginx-Error-Log zählen:
grep -c "error" /var/log/nginx/error.log

Eine typische Zeile im Nginx-Access-Log sieht so aus – so liest du sie:

192.168.1.5 - - [15/Mar/2026:14:23:01 +0100] "GET /index.html HTTP/1.1" 200 1234 "-" "Mozilla/5.0"

# HTTP und HTTPS freigeben:
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

# Alternativ – vordefiniertes Nginx-Profil nutzen:
sudo ufw allow 'Nginx Full'

# Status prüfen:
sudo ufw status

Installiere ufw, falls es noch nicht vorhanden ist, und richte die Grundkonfiguration ein.

# ufw installieren (auf Debian/Ubuntu meist schon dabei):
sudo apt install ufw

# Aktuellen Status prüfen:
sudo ufw status

# Standard-Richtlinien setzen -- IMMER als erstes:
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH erlauben -- VOR dem Aktivieren!
sudo ufw allow ssh

# ufw aktivieren:
sudo ufw enable

# Status mit allen Regeln anzeigen:
sudo ufw status verbose

Nach ufw enable fragt ufw noch einmal nach, ob du sicher bist. Bestätige mit y. Deine laufende SSH-Verbindung bleibt dabei erhalten -- nur neue Regeln greifen ab sofort.

# Dienste nach Name erlauben (ufw kennt die Standard-Ports):
sudo ufw allow ssh
sudo ufw allow http
sudo ufw allow https

# Ports direkt nach Nummer erlauben:
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 8080/tcp

# Nginx mit HTTP und HTTPS in einem Schritt:
sudo ufw allow 'Nginx Full'

# Port explizit sperren:
sudo ufw deny 3306/tcp

# Port-Bereich erlauben:
sudo ufw allow 6000:6100/tcp

# Nur eine bestimmte IP darf auf Port 22 (SSH) zugreifen:
sudo ufw allow from 192.168.1.100 to any port 22

# Ganzes internes Subnetz darf auf den Server zugreifen:
sudo ufw allow from 192.168.1.0/24

# Nur internes Netz darf auf MySQL (Port 3306) zugreifen:
sudo ufw allow from 192.168.1.0/24 to any port 3306

# Rate Limiting für SSH (max. 6 Versuche pro 30 Sekunden):
sudo ufw limit ssh

# Alle Regeln nummeriert anzeigen:
sudo ufw status numbered

# Regel nach Nummer löschen (Nummer aus obigem Befehl):
sudo ufw delete 3

# Regel nach Name/Port löschen:
sudo ufw delete allow 8080/tcp
sudo ufw delete allow http

# ufw vorübergehend deaktivieren (ohne Regeln zu löschen):
sudo ufw disable

# ufw wieder aktivieren:
sudo ufw enable

# Logging aktivieren:
sudo ufw logging on

# Logging-Stufe anpassen (low = wenig, high = viel):
sudo ufw logging medium
# Stufen: off, low, medium, high, full

# Geblockte Verbindungen in Echtzeit beobachten:
sudo journalctl -k --grep "UFW BLOCK" -f

# Oder im syslog nachschauen:
sudo grep "UFW BLOCK" /var/log/syslog | tail -20

Ein typischer Log-Eintrag sieht so aus:

# UFW BLOCK IN=eth0 SRC=185.220.101.34 DST=192.168.1.10 PROTO=TCP DPT=3306
# Das bedeutet: Jemand von 185.220.101.34 wollte auf Port 3306 (MySQL) -- geblockt!

# Aktuelle Regeln anzeigen (zeigt auch was ufw eingerichtet hat):
sudo iptables -L -n --line-numbers

# Regeln mit Paket-Statistiken:
sudo iptables -L -n -v

# Alle Regeln komplett exportieren:
sudo iptables-save

Zuerst prüfst du, ob Port 53 belegt ist:

ss -tlnp | grep :53
# Wenn eine Zeile erscheint: Port 53 ist belegt (oft systemd-resolved)
# Wenn keine Ausgabe: Port 53 ist frei → direkt zu Installation springen

Falls systemd-resolved läuft, deaktivierst du es zuerst:

sudo systemctl stop systemd-resolved
sudo systemctl disable systemd-resolved
# Temporären DNS-Server eintragen, damit der Server noch Namen auflösen kann:
sudo rm /etc/resolv.conf
echo "nameserver 1.1.1.1" | sudo tee /etc/resolv.conf

Jetzt installierst du dnsmasq:

sudo apt update
sudo apt install dnsmasq
sudo systemctl status dnsmasq
# Sollte "active (running)" zeigen
ss -tlnp | grep :53
# Jetzt sollte dnsmasq auf Port 53 lauschen

Erstelle deine eigene Konfigurationsdatei:

sudo nano /etc/dnsmasq.d/meinetz.conf

Füge folgenden Inhalt ein (passe die Netzwerkschnittstelle an – eth0 oder ens3 usw.):

# Welche Netzwerkschnittstelle dnsmasq nutzen soll:
interface=eth0

# Nur auf dieser Schnittstelle lauschen (Sicherheit):
bind-interfaces

# Upstream-DNS-Server – wohin externe Anfragen gehen:
server=1.1.1.1
server=8.8.8.8

# Lokale Domain – .local-Anfragen nicht nach außen schicken:
domain=local
local=/local/

# DNS-Cache-Größe (Standard: 150, höherer Wert = schneller):
cache-size=1000

# Logs für Debugging (optional, kann viel schreiben):
log-queries

Konfiguration prüfen und dnsmasq neu starten:

# Syntax prüfen – IMMER vor dem Neustart:
dnsmasq --test
# Ausgabe bei Erfolg: "dnsmasq: syntax check OK."

sudo systemctl restart dnsmasq
sudo systemctl status dnsmasq

Trage deine Netzgeräte in /etc/hosts ein:

sudo nano /etc/hosts

Füge deine Geräte unterhalb der bestehenden Einträge ein:

# Lokale Netzgeräte:
192.168.1.1     router.local router
192.168.1.10    server.local server
192.168.1.20    nas.local nas
192.168.1.30    drucker.local drucker
192.168.1.50    kamera1.local kamera1

Nach der Änderung reicht ein Reload – bestehende Verbindungen bleiben erhalten:

sudo systemctl reload dnsmasq

# Auflösung testen:
dig nas.local @127.0.0.1
# Im ANSWER SECTION siehst du die zugehörige IP

# Lokalen Namen auflösen:
dig nas.local @127.0.0.1
# Im "ANSWER SECTION" siehst du die IP

# Externe Domain auflösen (testet Upstream-Weiterleitung):
dig google.com @127.0.0.1
# Zweite Anfrage sollte "Query time: 0 msec" zeigen (Cache)
dig google.com @127.0.0.1

# Alternativ mit nslookup:
nslookup nas.local 127.0.0.1

# Reverse Lookup – IP zu Name:
dig -x 192.168.1.20 @127.0.0.1

# DNS-Anfragen live beobachten (mit log-queries in der Konfiguration):
sudo journalctl -u dnsmasq -f
# Strg+C zum Beenden

# Anfragen für eine Firmendomain an den Firmen-DNS-Server:
server=/firma.intern/10.0.0.1

# Anfragen für .local NICHT nach außen weiterleiten:
local=/local/

# Alle anderen Anfragen an Cloudflare:
server=1.1.1.1

# Domain komplett sperren (leere Antwort statt IP):
address=/werbung-example.com/0.0.0.0

# IP-Bereich für automatische Vergabe (von .100 bis .200, Lease-Zeit 24h):
dhcp-range=192.168.1.100,192.168.1.200,24h

# Standard-Gateway mitteilen (meist der Router):
dhcp-option=3,192.168.1.1

# DNS-Server mitteilen – dieser Server selbst:
dhcp-option=6,192.168.1.10

# Feste IP für ein bestimmtes Gerät (per MAC-Adresse):
dhcp-host=aa:bb:cc:dd:ee:ff,drucker.local,192.168.1.30,infinite

Aktuelle DHCP-Leases anzeigen:

cat /var/lib/misc/dnsmasq.leases
# Zeigt: Ablaufzeit, MAC-Adresse, vergebene IP, Hostname

# Server nutzt seinen eigenen dnsmasq:
echo "nameserver 127.0.0.1" | sudo tee /etc/resolv.conf

# Testen – lokaler Name sollte jetzt ohne @127.0.0.1 klappen:
ping -c 2 nas.local

Trage die IP des dnsmasq-Servers in die Netplan-Konfiguration ein:

network:
  version: 2
  ethernets:
    eth0:
      dhcp4: true
      nameservers:
        addresses: [192.168.1.10]

Konfiguration anwenden:

sudo netplan apply
# Testen: lokaler Name sollte jetzt auflösbar sein
nslookup nas.local
# Server: 192.168.1.10 ← zeigt, dass dnsmasq-Server genutzt wird