--- id: 2024-10-26-linux-administration-grundlagen-der-linux-administration slug: linux-administration-grundlagen-der-linux-administration title: "Linux Administration #1: Grundlagen der Linux-Administration" excerpt: "Grundlagen der Linux-Administration: Von der Systemarchitektur bis zur Rechteverwaltung - Lerne die fundamentalen Konzepte für den Einstieg in die Linux-Administration" date: "2024-10-26T09:00:00+01:00" updated: "2024-10-26T10:00:00+01:00" author: name: "Sebastian Palencsar" handle: "AdminDocs" category: "linux-administration" tags: ["linux-basics", "shell", "filesystem", "permissions", "history", "cli", "linux-administration"] toc: true reading_time: 45 --- **Willkommen zum ersten Teil unserer technischen Wiki-Serie über Linux-Administration!** In den kommenden acht Artikeln lernst du alle wichtigen Grundlagen, die du als Linux-Administrator benötigst. Wir beginnen mit den fundamentalen Konzepten und arbeiten uns Schritt für Schritt zu fortgeschrittenen Themen vor. ## Was ist ein Linux-Administrator? Als Linux-Administrator trägst du die Verantwortung für die Verwaltung, Wartung und Sicherheit von Linux-Systemen. Egal ob du dein eigenes Heimnetzwerk betreust oder in einem Unternehmen arbeitest – ein tiefes Verständnis der Linux-Administration ist heute wichtiger denn je. Die Grundlagen, die du in diesem Artikel lernst, bilden das Fundament für alle weiteren Administrationsaufgaben. Lass uns mit der Systemarchitektur beginnen – dem Herzstück jedes Linux-Systems. ### Grundlegende Systemkonzepte Systemarchitektur Bevor du mit der Administration beginnst, ist es wichtig zu verstehen, wie ein Linux-System aufgebaut ist. Stell dir das System wie ein mehrstöckiges Gebäude vor, bei dem jede Ebene eine bestimmte Aufgabe hat. **Linux-Systemarchitektur-Pyramide:** ```markdown ┌─────────── Benutzeranwendungen ─────────────────────────────┐ │ Firefox, LibreOffice, Terminal │ ├─────────── Shell (Bash, ZSH) ───────────────────────────────┤ │ Befehlsinterpreter & Skripte │ ├──────────── Systemdienste ──────────────────────────────────┤ │ systemd, Network Manager, CUPS │ ├─────────────── Kernel───────────────────────────────────────┤ │ Prozesse, Speicher, Treiber │ └─────────────── Hardware ────────────────────────────────────┘ ``` ### Systemarchitektur im Detail Die Linux-Systemarchitektur besteht aus mehreren Schichten, die aufeinander aufbauen. Jede Schicht hat spezifische Aufgaben: Hardware-Ebene * Physische Komponenten (CPU, RAM, Festplatten) * Firmware/BIOS/UEFI * Gerätetreiber Kernel-Ebene Der Kernel ist das Herzstück deines Linux-Systems. Er ist die erste Software, die nach dem Bootvorgang geladen wird und kontrolliert alles, was auf deinem System passiert. ```bash # Kernel-Version anzeigen uname -r # Beispielausgabe: 6.5.0-generic # Kernel-Parameter anzeigen sysctl -a # Kernel-Module verwalten lsmod # Liste aller geladenen Module modprobe bluetooth # Modul laden modprobe -r bluetooth # Modul entladen ``` **Wichtige Kernel-Aufgaben:** * Verwaltet den Zugriff auf die Hardware * Steuert die Prozesse und deren Prioritäten * Kontrolliert den Arbeitsspeicher Kernel-Module Kernel-Module sind wie Erweiterungen für deinen Kernel. Sie können bei Bedarf geladen und entladen werden: ```bash # Alle geladenen Module anzeigen lsmod # Spezifisches Modul laden sudo modprobe bluetooth # Modul-Informationen anzeigen modinfo bluetooth # Modul sicher entladen sudo modprobe -r bluetooth ``` Systemdienste-Ebene (systemd) Seit 2015 verwendet fast jede Linux-Distribution systemd als Init-System. Es ist verantwortlich für: * Den geordneten Start aller Systemdienste * Die Verwaltung von Diensten während des Betriebs * Das saubere Herunterfahren des Systems ```bash # Systemd-Status systemctl status # Alle aktiven Dienste anzeigen systemctl list-units --type=service --state=active # Boot-Zeit analysieren systemd-analyze systemd-analyze blame # Zeigt Boot-Zeit pro Dienst ``` **Wichtig für Anfänger:** * Der Kernel läuft immer im Hintergrund * Module können nach Bedarf geladen werden * Systemd verwaltet fast alle Systemdienste * Logging hilft bei der Fehlersuche Benutzerebene ```bash # Aktuelle Shell anzeigen echo $SHELL who # Eingeloggte Benutzer anzeigen w # Detailliertere Informationen # Prozesse des aktuellen Benutzers ps aux | grep $USER ``` ### Dateisystemhierarchie Unter Linux ist alles in einer hierarchischen Verzeichnisstruktur organisiert, beginnend mit dem Stammverzeichnis (‚`/`‚): ```markdown ┌─────────────────────────────────────────────────────────────┐ │ FILESYSTEM HIERARCHY STANDARD (FHS) │ ├─────────────────────────────────────────────────────────────┤ │ │ │ / │ │ ├── /bin → Grundlegende Systemprogramme │ │ ├── /boot → Linux-Kernel & Bootloader-Konfiguration │ │ ├── /dev → Gerätedateien (Block-/Zeichengeräte) │ │ ├── /etc → Systemweite Konfigurationsdateien │ │ ├── /home → Benutzer-Heimatverzeichnisse │ │ ├── /lib → Geteilte Systembibliotheken │ │ ├── /proc → Virtuelles Prozessdateisystem │ │ ├── /root → Heimatverzeichnis des Superusers │ │ ├── /sbin → Systemprogramme für die Administration │ │ ├── /tmp → Temporäre Dateien (flüchtig) │ │ ├── /usr → Sekundäre Hierarchie für Anwendungsdaten │ │ └── /var → Variable Daten (Logs, Spools, Caches) │ │ │ └─────────────────────────────────────────────────────────────┘ ``` **Wichtige Verzeichnisse im Detail:** ```bash # /etc - Systemkonfiguration ls -l /etc/ # Beispiele wichtiger Dateien: # - /etc/passwd (Benutzerinformationen) # - /etc/fstab (Dateisystem-Konfiguration) # - /etc/hosts (Hostname-Zuordnung) # /var - Variable Daten ls -l /var/ # Beispiele wichtiger Unterverzeichnisse: # - /var/log (Systemprotokolle) # - /var/spool (Drucker- und Mail-Warteschlangen) # - /var/www (Webserver-Dateien) ``` ### Dateisystemtypen Linux unterstützt verschiedene Dateisystemtypen für unterschiedliche Anforderungen: ```bash # Verfügbare Dateisysteme anzeigen cat /proc/filesystems # Aktuell gemountete Dateisysteme df -Th ``` **Häufig verwendete Dateisysteme:** * **ext4**: Standard für die meisten Linux-Distributionen * **xfs**: Gut für große Dateisysteme und Server * **btrfs**: Modern mit Snapshot-Funktionen * **tmpfs**: Temporäres Dateisystem im RAM Mount-Punkte verwalten ```bash # Alle Mount-Punkte anzeigen mount # Eine neue Festplatte mounten sudo mount /dev/sdb1 /mnt/dataplatte # Automatisches Mounten in fstab konfigurieren sudo nano /etc/fstab # Beispieleintrag: # /dev/sdb1 /mnt/dataplatte ext4 defaults 0 2 ``` ## Benutzer- und Rechteverwaltung Als Linux-Administrator ist eine deiner wichtigsten Aufgaben, Benutzer und deren Rechte zu verwalten. Stell dir das wie ein Gebäude vor, wo verschiedene Personen unterschiedliche Schlüssel und Zugangsberechtigungen haben. **Berechtigungshierarchie:** ```markdown ┌─────────── Root (UID 0) ────────────────────────────────────┐ │ Vollständige Systemkontrolle │ ├─────────── System-User ─────────────────────────────────────┤ │ UIDs 1-999 (Dienste, Daemons) │ ├─────────── Normale User ────────────────────────────────────┤ │ UIDs 1000+ (Menschen) │ └─────────────────────────────────────────────────────────────┘ ``` **Dateiberechtigungen:** ```markdown ┌─────────────────────────────────────────────────────────────┐ │ STRUKTUR DER LINUX-STANDARDRECHTE │ ├─────────────────────────────────────────────────────────────┤ │ │ │ rwx rwx rwx datei.txt │ │ │ │ └── Sonstige (Others) │ │ │ └─────────────── Gruppe (Group) │ │ └──────────────────────────── Eigentümer (User) │ │ │ │ r (read) = 4 (Lesen) │ │ w (write) = 2 (Schreiben / Ändern) │ │ x (execute) = 1 (Ausführen / Verzeichnis betreten) │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### Root-Benutzer Der Root-Benutzer (auch Superuser genannt) hat absolute Kontrolle über das System. Das ist wie ein Generalschlüssel, der alle Türen öffnet. **Häufig verwendete Dateisysteme:** * Root hat die Benutzer-ID `(UID) 0` * Root kann ALLES auf dem System tun * Mit großer Macht kommt große Verantwortung * Verwende Root-Rechte nur wenn nötig ### Normale Benutzer ```bash # Informationen über deinen Benutzer anzeigen id # Beispielausgabe: # uid=1000(max) gid=1000(max) groups=1000(max),27(sudo) ``` **Was bedeutet diese Ausgabe?** * `uid=1000`: Deine eindeutige Benutzer-ID * `gid=1000`: Deine primäre Gruppen-ID * `groups=...`: Alle Gruppen, in denen du Mitglied bist ### Benutzer erstellen und verwalten Lass uns das Schritt für Schritt durchgehen: **Neuen Benutzer anlegen** ```bash # Benutzer erstellen sudo useradd -m -s /bin/bash anna # Was bedeuten die Optionen? # -m: Erstellt ein Home-Verzeichnis (/home/anna) # -s: Legt die Standard-Shell fest (/bin/bash) ``` **Was bedeuten die Optionen?** * `-m`: Erstellt ein Home-Verzeichnis (`/home/anna`) * `-s`: Legt die Standard-Shell fest (`/bin/bash`) Home-Verzeichnis verstehen: ```bash ls -la /home/anna # Zeigt: # drwxr-xr-x 2 anna anna 4096 Feb 20 10:00 . # drwxr-xr-x 4 root root 4096 Feb 20 10:00 .. # -rw-r--r-- 1 anna anna 220 Feb 20 10:00 .bash_logout # -rw-r--r-- 1 anna anna 3526 Feb 20 10:00 .bashrc # -rw-r--r-- 1 anna anna 807 Feb 20 10:00 .profile ``` **Passwort setzen:** ```bash sudo passwd anna # Eingabe: Neues Passwort # Eingabe: Passwort wiederholen ``` **Wichtige Passwort-Regeln:** * Mindestens 8 Zeichen * Groß- und Kleinbuchstaben * Zahlen und Sonderzeichen * Nicht leicht zu erraten ### Benutzerinformationen prüfen: ```markdown ┌─────────────────────────────────────────────────────────────┐ │ AUFBAU VON /ETC/PASSWD-EINTRÄGEN │ ├─────────────────────────────────────────────────────────────┤ │ │ │ anna:x:1001:1001:Anna Schmidt:/home/anna:/bin/bash │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └─ Login-Shell │ │ │ │ │ │ │ └─ Home-Verzeichnis │ │ │ │ │ │ └─ Kommentar / Vollständiger Name │ │ │ │ │ └─ Primäre Gruppen-ID (GID) │ │ │ │ └─ Benutzer-ID (UID) │ │ │ └─ Passwort-Platzhalter (x = in /etc/shadow) │ │ └─ Benutzername / Account │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ## Gruppen und Berechtigungen ### Gruppenkonzept verstehen Stell dir ein Bürogebäude vor, in dem verschiedene Abteilungen arbeiten. Jede Abteilung (`Gruppe`) hat Zugang zu bestimmten Räumen (`Verzeichnissen`) und Dokumenten (`Dateien`). **Gruppenstruktur:** ```markdown ┌─────────── Systemgruppen ───────────────────────────────────┐ │ sudo, adm, www-data, etc. │ ├─────────── Benutzergruppen ─────────────────────────────────┤ │ entwickler, marketing, support │ └─────────────────────────────────────────────────────────────┘ ``` **Benutzer-Gruppen-Beziehung:** ```markdown ┌─── Anna ────────────────────────────────────────────────────┐ │ Primär: │──→ marketin g │ Sekundär: │──→ entwickler, suppor t └─────────────────────────────────────────────────────────────┘ ``` **Was sind Systemgruppen?** * `sudo`: Mitglieder dürfen Admin-Befehle ausführen * `adm`: Zugriff auf Systemprotokolle * `www-data`: Für Webserver-Prozesse * `etc.`: Andere Systemgruppen Diese Gruppen werden automatisch erstellt und vom System verwendet **Was sind Benutzergruppen?** * Von Administratoren erstellt * Für spezifische Zwecke (z.B. Projekte, Abteilungen) * Helfen bei der Organisation von Zugriffsrechten ### Gruppen erstellen und verwalten ```bash # Neue Gruppe erstellen sudo groupadd entwickler ``` **Was passiert im Hintergrund?** 1. Eintrag in `/etc/group`: ```markdown ┌─────────────────────────────────────────────────────────────┐ │ AUFBAU VON /ETC/GROUP-EINTRÄGEN │ ├─────────────────────────────────────────────────────────────┤ │ │ │ entwickler:x:1002:anna,ben,clara │ │ │ │ │ │ │ │ │ │ │ └─ Gruppenmitglieder (Komma-getrennt) │ │ │ │ └─ Gruppen-ID (GID) │ │ │ └─ Gruppenpasswort (x = meist ungenutzt) │ │ └─ Gruppenname │ │ │ └─────────────────────────────────────────────────────────────┘ ``` **Wichtig für Anfänger** * Gruppennamen sollten aussagekräftig sein * Keine Leerzeichen oder Sonderzeichen verwenden * Kleinbuchstaben bevorzugen * IDs über 1000 für eigene Gruppen verwenden ### Benutzer zu Gruppen hinzufügen ```bash # Anna zur Entwickler-Gruppe hinzufügen sudo usermod -aG entwickler anna # Was bedeuten die Optionen? # -a: append (hinzufügen, nicht überschreiben) # -G: sekundäre Gruppe(n) # Gruppenmitgliedschaft prüfen groups anna # Beispielausgabe: anna : anna entwickler ``` Häufige Fehler und Lösungen: ```bash # Fehler: Gruppe existiert nicht sudo groupadd entwickler # groupadd: group 'entwickler' already exists # Lösung: Gruppe prüfen getent group entwickler # Fehler: Benutzer nicht in Gruppe groups anna # anna : anna # Lösung: Benutzer zur Gruppe hinzufügen sudo usermod -aG entwickler anna ``` **Wichtig für Anfänger** * Verwende `-a` immer zusammen mit `-G`, sonst überschreibst du bestehende Gruppen * Neue Gruppenmitgliedschaften werden erst nach Ab- und Anmeldung aktiv * Alternativ aktiviert `newgrp` die neue Gruppe sofort * Änderungen anschließend mit `groups` überprüfen ️ **Best Practices:** * Verwenden Sie beschreibende Gruppennamen * Vermeiden Sie Leerzeichen und Sonderzeichen * Verwenden Sie vorzugsweise Kleinbuchstaben * Verwenden Sie IDs über 1000 für benutzerdefinierte Gruppen * Dokumentieren Sie die Zwecke und Mitglieder der Gruppe ## Dateiberechtigungen im Detail ### Das Linux-Berechtigungssystem verstehen Es ist wichtig zu verstehen, dass jede Datei und jedes Verzeichnis in Linux drei Arten von Berechtigungen für drei verschiedene Kategorien hat. **Vollständige Berechtigungsstruktur:** Datei: `beispiel.txt` ```markdown ┌─────────────────────────────────────────────────────────────┐ │ AUFBAU EINES DATEI-LISTINGS (LS -L) │ ├─────────────────────────────────────────────────────────────┤ │ │ │ -rw-r--r-- 1 anna entwickler 1024 Feb 20 14:30 app.txt │ │ │├──┤├──┤├──┤ │ │ │ │ └── Zeitstempel │ │ ││ ││ ││ │ │ │ │ └─ Größe in Bytes │ │ ││ ││ ││ │ │ │ └─ Besitzergruppe │ │ ││ ││ ││ │ │ └─ Eigentümer (User) │ │ ││ ││ ││ │ └─ Hardlink-Zähler │ │ ││ ││ │└──┴─ Sonstige Rechte (Others) │ │ ││ │└──┴─ Gruppenrechte (Group) │ │ │└──┴─ Eigentümerrechte (User) │ │ └─ Dateityp (- = Regulär, d = Verzeichnis, l = Link) │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### Berechtigungsarten im Detail Lesen (r = read): **Für Dateien bedeutet Leserecht:** * Dateiinhalt anzeigen mit cat, less, more * Datei kopieren * Datei öffnen und lesen * Nach Text suchen mit grep * Inhalt in Editor anzeigen (aber nicht speichern) Praktische Beispiele: ```bash # Datei lesen cat beispiel.txt less beispiel.txt head -n 5 beispiel.txt # Erste 5 Zeilen tail -n 5 beispiel.txt # Letzte 5 Zeilen ``` ```bash # Datei kopieren cp beispiel.txt kopie.txt ``` ```bash # In Datei suchen grep "Suchbegriff" beispiel.txt ``` ```bash # Was passiert ohne Leserecht? chmod u-r beispiel.txt cat beispiel.txt ``` **Ausgabe: "Permission denied"** **Für Verzeichnisse bedeutet Leserecht:** * Verzeichnisinhalt auflisten mit ls * Dateien im Verzeichnis sehen * Nach Dateien suchen * Metadaten der Dateien sehen (Größe, Datum, etc.) **Praktische Beispiele:** ```bash ls -l verzeichnis/ ls -la verzeichnis/ # Zeigt auch versteckte Dateien find verzeichnis/ -name "*.txt" ``` **Was passiert ohne Leserecht?** ```bash chmod u-r verzeichnis/ ls verzeichnis/ # Ausgabe: "Permission denied" ``` Schreiben (w = write): **Für Dateien bedeutet Schreibrecht:** * Dateiinhalt ändern * In Datei schreiben * Datei löschen * Datei umbenennen * Datei verschieben * Dateiattribute ändern * Datei leeren Praktische Beispiele: ```bash # Datei erstellen/überschreiben echo "Neuer Text" > beispiel.txt ``` ```bash # An Datei anhängen echo "Weiterer Text" >> beispiel.txt ``` ```bash # Mit Editor bearbeiten nano beispiel.txt vim beispiel.txt ``` ```bash # Datei umbenennen/verschieben mv beispiel.txt neu.txt mv neu.txt /tmp/ ``` ```bash # Datei löschen rm beispiel.txt ``` ```bash # Was passiert ohne Schreibrecht? chmod u-w beispiel.txt echo "Test" > beispiel.txt # Ausgabe: "Permission denied" ``` **Für Verzeichnisse bedeutet Schreibrecht:** * Neue Dateien erstellen * Bestehende Dateien löschen * Dateien umbenennen * Dateien verschieben * Unterverzeichnisse erstellen * Verzeichnisattribute ändern **Praktische Beispiele:** * mkdir verzeichnis/neuer_ordner * touch verzeichnis/neue_datei.txt * rm verzeichnis/alte_datei.txt * mv verzeichnis/datei1.txt verzeichnis/datei2.txt ```bash # Was passiert ohne Schreibrecht? chmod u-w verzeichnis/ touch verzeichnis/test.txt # Ausgabe: "Permission denied" ``` Ausführen (x = execute): **Für Dateien bedeutet Ausführrecht:** * Datei als Programm/Skript ausführen * Binärdateien starten * Shell-Skripte ausführen * Programme ausführen **Praktische Beispiele:** ```bash # Shell-Skript erstellen echo '#!/bin/bash' > skript.sh echo 'echo "Hallo Welt"' >> skript.sh chmod u+x skript.sh ./skript.sh ``` ```bash # Was passiert ohne Ausführrecht? chmod u-x skript.sh ./skript.sh # Ausgabe: "Permission denied" ``` **Für Verzeichnisse bedeutet Ausführrecht:** * In das Verzeichnis wechseln (cd) * Auf Dateien im Verzeichnis zugreifen * Verzeichnis durchqueren * Unterverzeichnisse aufrufen * Dateien im Verzeichnis ausführen (wenn zusätzlich ausführbar) **Praktische Beispiele:** * cd verzeichnis/ * ls -l verzeichnis/datei.txt * ./verzeichnis/programm ```bash # Was passiert ohne Ausführrecht? chmod u-x verzeichnis/ cd verzeichnis/ # Ausgabe: "Permission denied" ``` ### Wichtige Kombinationen: **Häufig verwendete Berechtigungskombinationen:** ```bash chmod 755 verzeichnis/ # drwxr-xr-x ``` **Bedeutung** * Besitzer kann alles (`rwx`) * Gruppe kann lesen und ausführen (`r-x`) * Andere können lesen und ausführen (`r-x`) **Typisch für:** Programm-Verzeichnisse, öffentliche Ordner ```bash chmod 644 datei.txt # -rw-r--r-- ``` **Bedeutung** * Besitzer kann lesen & schreiben (`rw-`) * Gruppe kann nur lesen (`r--`) * Andere kann nur lesen (`r--`) **Typisch für:** Programm-Verzeichnisse, öffentliche Ordner ```bash chmod 600 private.key # -rw------- ``` **Bedeutung:** * Besitzer kann lesen und schreiben (`rw-`) * Gruppe hat keine Rechte (`-`) * Andere haben keine Rechte (`-`) **Typisch für:** Sensitive Dateien, SSH-Keys ### Erweiterte Berechtigungen (SUID, SGID, Sticky Bit) In Linux gibt es neben den grundlegenden Berechtigungen (`rwx`) auch spezielle Berechtigungen, die für bestimmte Sicherheits- und Verwaltungsaufgaben wichtig sind. **Spezielle Berechtigungen visualisiert:** ```markdown ┌─────────────────────────────────────────────────────────────┐ │ SPEZIALBERECHTIGUNGEN IN LINUX │ ├─────────────────────────────────────────────────────────────┤ │ │ │ SUID (Oktal 4) SGID (Oktal 2) Sticky (Oktal 1)│ │ -rwsr-xr-x drwxrwsr-x drwxrwxrwt │ │ │ │ │ │ │ │ │ │ │ │ │ │ Nur Eigentümer │ │ │ │ │ darf löschen │ │ │ │ │ │ │ │ │ Erbt Gruppenbesitz des Ordners │ │ │ │ │ │ Ausführung mit Rechten des Dateieigentümers │ │ │ └─────────────────────────────────────────────────────────────┘ ``` SUID (Set User ID) im Detail **Was ist SUID?** * Programm läuft mit den Rechten des Dateibesitzers * Wird durch `S` in den Besitzer-Ausführrechten angezeigt * Numerischer Wert: 4000 **Praktische Beispiele:** ```bash # SUID anzeigen ls -l /usr/bin/passwd # Ausgabe: -rwsr-xr-x root root /usr/bin/passwd # Beachte das `s` im Besitzer-Ausführrechten ``` ️ **Warum ist das wichtig?** * Normaler Benutzer kann sein Passwort ändern * Programm läuft temporär mit root-Rechten * Zugriff auf /etc/shadow wird ermöglicht **SUID setzen** ```bash chmod u+s programm chmod 4755 programm # Numerische Methode ``` **Was passiert im Hintergrund?** * 1. Benutzer startet Programm * 2. Programm erhält Rechte des Besitzers * 3. Programm kann Aktionen mit höheren Rechten ausführen * 4. Nach Beendigung werden die Rechte zurückgesetzt **Häufige Anwendungsfälle:** ```bash - /usr/bin/passwd # Passwortänderung - /usr/bin/sudo # Temporäre root-Rechte - /usr/bin/ping # Netzwerk-Raw-Sockets ``` ### SGID (Set Group ID) **Was ist SGID?** * **Bei Verzeichnissen:** Neue Dateien erben die Gruppe des Verzeichnisses * **Bei Programmen:** Programm läuft mit den Rechten der Gruppe * Wird durch `s` in den Gruppen-Ausführrechten angezeigt * Hat den numerischen Wert 2000 ```markdown ┌─────────────────────────────────────────────────────────────┐ │ SGID-KENNZEICHNUNG IM DATEISYSTEM │ ├─────────────────────────────────────────────────────────────┤ │ │ │ Normales Verzeichnis: drwxr-xr-x │ │ SGID-Verzeichnis: drwxr-sr-x │ │ ▲ │ │ Gruppen-Execute 'x' wird zu 's' (SGID aktiv) │ │ │ └─────────────────────────────────────────────────────────────┘ ``` **SGID setzen** ```bash chmod g+s /shared/projekt/ # oder chmod 2775 /shared/projekt/ ``` **Was passiert dann?** * 1. Du erstellst eine neue Datei im Verzeichnis * 2. Die Datei erhält automatisch die Gruppe des Verzeichnisses * 3. Alle Teammitglieder können zusammenarbeiten **Beispiel für ein Projektverzeichnis:** `/shared/projekt/` (Gruppe: entwickler) * ── `dokumente/` (erbt Gruppe: entwickler) * ├── `konzept.txt` (erbt Gruppe: entwickler) * └── `planung.pdf` (erbt Gruppe: entwickler) * ── `source/` (erbt Gruppe: entwickler) └── `main.cpp` (erbt Gruppe: entwickler) ️ **Häufige Anwendungsfälle:** * Gemeinsame Projektverzeichnisse * Web-Server-Dokumentenverzeichnisse * Geteilte Entwicklungsordner * Gruppen-Dokumentensammlungen **Tipps für die Praxis:** * Kombiniere SGID mit passenden Gruppenrechten * Stelle sicher, dass die Gruppe die richtigen Mitglieder hat * Überprüfe die Vererbung nach dem Einrichten **Überprüfen der Einstellungen:** **Verzeichnis erstellen und SGID setzen:** * mkdir /shared/projekt * chmod 2775 /shared/projekt * ls -ld /shared/projekt **Neue Datei erstellen und Gruppe prüfen:** * touch /shared/projekt/test.txt * ls -l /shared/projekt/test.txt **Überprüfen der Einstellungen:** **Verzeichnis erstellen und SGID setzen:** * mkdir /shared/projekt * chmod 2775 /shared/projekt * ls -ld /shared/projekt **Neue Datei erstellen und Gruppe prüfen:** * touch /shared/projekt/test.txt * ls -l /shared/projekt/test.txt ### Sticky Bit **Was ist das Sticky Bit?** Ein Sicherheitsmerkmal, das hauptsächlich für Verzeichnisse verwendet wird: * Nur der Besitzer darf seine eigenen Dateien löschen oder umbenennen * Andere Benutzer können keine fremden Dateien löschen * Wird durch `t` in den anderen-Ausführrechten angezeigt * Hat den numerischen Wert 1000 **Visualisierung:** ```markdown ┌─────────────────────────────────────────────────────────────┐ │ STICKY BIT-KENNZEICHNUNG IM DATEISYSTEM │ ├─────────────────────────────────────────────────────────────┤ │ │ │ Normales Verzeichnis: drwxrwxrwx │ │ Verzeichnis mit Sticky Bit: drwxrwxrwt │ │ ▲ │ │ Others-Execute 'x' wird zu 't' (Sticky Bit aktiv) │ │ │ └─────────────────────────────────────────────────────────────┘ ``` **Sticky Bit setzen** ```bash chmod +t /shared/public/ # oder chmod 1777 /shared/public/ ``` **Beispiel-Szenario:** `/shared/public/` (Sticky Bit gesetzt) * ── `anna/` (Besitzer: anna) * └── `projekt.txt` Nur anna kann dies löschen * ── `bob/` (Besitzer: bob) * └── `notizen.txt` Nur bob kann dies löschen * ── `shared.txt` Nur der Ersteller kann dies löschen **Was passiert im Hintergrund?** * 1. Ein Benutzer erstellt eine Datei im Verzeichnis * 2. Die Datei behält ihren ursprünglichen Besitzer * 3. Nur der Besitzer (und root) können die Datei löschen * 4. Andere Benutzer können die Datei nicht löschen, auch wenn sie Schreibrechte haben ### Praktischer Test: Als Benutzer anna: * touch /shared/public/anna.txt **Als Benutzer bob (wird fehlschlagen):** * rm /shared/public/anna.txt
❗ Ausgabe: `Operation not permitted`
**Häufige Anwendungsfälle:** * `/tmp` Verzeichnis (temporäre Dateien) * Öffentliche Upload-Verzeichnisse * Gemeinsame Arbeitsverzeichnisse * Austauschverzeichnisse für Teams ️ **Sicherheitsaspekte:** * Verhindert versehentliches oder böswilliges Löschen * Ermöglicht gemeinsame Nutzung ohne Datenverlust * Wichtig für Multi-User-Systeme **Best Practices:** * Verwende Sticky Bit für öffentliche Verzeichnisse * Kombiniere es mit sinnvollen Zugriffsrechten * Überprüfe regelmäßig die Einstellungen **Überprüfen der Einstellungen:** Sticky Bit setzen und überprüfen: * mkdir /shared/public * chmod 1777 /shared/public * ls -ld /shared/public ## Zusammenfassende Übungen ### Übung 1: Grundlegende Systemkonfiguration In dieser praktischen Übung wirst du die gelernten Konzepte der Systemarchitektur und Rechteverwaltung anwenden. **Szenario:** Du bist als neuer Linux-Administrator eingestellt worden und sollst ein Entwicklungssystem für ein Team einrichten. Dabei musst du die Systemarchitektur verstehen und korrekte Berechtigungen setzen. ### Anforderungen **1. Systemverständnis** * Kernel-Informationen auslesen * Systemd-Status überprüfen * Wichtige Systemverzeichnisse identifizieren **2. Berechtigungsstruktur** * Entwicklergruppe erstellen * Projektverzeichnisse anlegen * Korrekte Berechtigungen setzen * Erweiterte Berechtigungen implementieren **Überprüfungsstruktur:** **System-Überprüfung:** ```markdown ──────────────────────────────────────────────────────────────/ ├── Kernel ───────────────────────────────────────────────────┐ │ ├── Version [ ] │ │ ├── Module [ ] │ │ └── Parameter [ ] │ │ │ ├── Systemd ──────────────────────────────────────────────────┤ │ ├── Status [ ] │ │ └── Services [ ] │ │ │ ├─── Verzeichnisse ───────────────────────────────────────────┤ │ ├── /etc [ ] │ │ ├── /var/log [ ] │ │ └── /home [ ] │ └─────────────────────────────────────────────────────────────┘ ``` **Berechtigungs-Überprüfung:** ```markdown ┌─────────────────────────────────────────────────────────────┐ │ PROJEKTVERZEICHNIS-RECHTESTRUKTUR │ ├─────────────────────────────────────────────────────────────┤ │ │ │ /srv/projekt/ │ │ ├── src/ drwxrwsr-x root:entwickler │ │ │ └── [Dateien erben Gruppe 'entwickler' automatisch] │ │ │ │ │ ├── docs/ drwxrwsr-x root:entwickler │ │ │ └── [Dokumentation für das gesamte Entwicklerteam] │ │ │ │ │ └── shared/ drwxrwxrwt root:root │ │ └── [Sticky Bit: Löschen nur durch Dateieigentümer] │ │ │ └─────────────────────────────────────────────────────────────┘ ``` **Mögliche Lösung für Aufgabe 1:** ```bash #!/bin/bash # 1. Systemüberprüfung echo "=== Systemüberprüfung ===" uname -a systemctl status ls -la /etc /var/log /home # 2. Berechtigungsstruktur erstellen echo "=== Berechtigungsstruktur erstellen ===" # Gruppe erstellen sudo groupadd dev # Verzeichnisstruktur sudo mkdir -p /proj/{src,docs,shared} # Grundberechtigungen sudo chown -R root:dev /proj/src /proj/docs sudo chown root:root /proj/shared # Erweiterte Berechtigungen sudo chmod 2775 /proj/src /proj/docs # SGID sudo chmod 1777 /proj/shared # Sticky Bit # 3. Überprüfung echo "=== Überprüfung ===" ls -la /proj/ getent group dev ``` Übung 2: Systemarchitektur und Berechtigungen In dieser praktischen Übung wirst du die grundlegenden Konzepte der Linux-Systemarchitektur und Berechtigungsverwaltung anwenden. **Szenario:** **Als neuer Linux-Administrator sollst du:** * Die Systemarchitektur analysieren * Ein Verzeichnissystem mit korrekten Berechtigungen aufsetzen * Erweiterte Berechtigungen implementieren Teil 1: Systemanalyse **Systemkomponenten-Checkliste:** ```markdown ┌─────────── Hardware ────────────────────────────────────────┐ │ [ ] CPU-Informationen │ │ [ ] RAM-Status │ │ [ ] Festplatten │ ├─────────── Kernel ──────────────────────────────────────────┤ │ [ ] Version │ │ [ ] Module │ │ [ ] Parameter │ ├─────────── Dateisystem ─────────────────────────────────────┤ │ [ ] Mountpunkte │ │ [ ] Speichernutzung │ │ [ ] Verzeichnisstruktur │ └─────────────────────────────────────────────────────────────┘ ``` **Teil 2: Berechtigungskonfiguration** **Projektstruktur:** `/projekt/` * ── `docs/` [2775] * ├── `intern/` [2770] * └── `public/` [2775] * ──────── `scripts/` [2771] * ──────── `shared/` [1777] **Berechtigungsmatrix:** * ────────────┬────────┬─────────┬────────┐ * Verzeichnis│ Owner │ Group │ Others │ * ────────────┼────────┼─────────┼────────┤ * docs │ rwx │ rwx │ r-x │ * intern │ rwx │ rwx │ --- │ * public │ rwx │ rwx │ r-x │ * scripts │ rwx │ rwx │ --x │ * shared │ rwx │ rwx │ rwx │ * ────────────┴────────┴─────────┴────────┘ **Mögliche Lösung:** ```bash #!/bin/bash # Teil 1: Systemanalyse echo "=== Systemanalyse ===" # Hardware echo "CPU Info:" lscpu | grep "Model name" echo "RAM Status:" free -h echo "Festplatten:" df -h # Kernel echo "Kernel Version:" uname -r echo "Geladene Module:" lsmod | head -n 5 # Dateisystem echo "Wichtige Verzeichnisse:" ls -l / | grep -E "^d" # Teil 2: Berechtigungskonfiguration echo "=== Berechtigungskonfiguration ===" # Projektstruktur erstellen sudo mkdir -p /projekt/{docs/{intern,public},scripts,shared} # Gruppe erstellen sudo groupadd projekt # Berechtigungen setzen sudo chown -R root:projekt /projekt sudo chmod 2775 /projekt/docs sudo chmod 2770 /projekt/docs/intern sudo chmod 2775 /projekt/docs/public sudo chmod 2771 /projekt/scripts sudo chmod 1777 /projekt/shared # Überprüfung echo "=== Überprüfung ===" ls -la /projekt/ ``` **Überprüfung:** **Berechtigungstest-Matrix:** ```markdown ┌─────────────────────────────────────────────────────────────┐ │ Test 1: Systemanalyse │ ├─────────────────┬─────────┬─────────────────────────────────┤ │ Komponente │ Status │ Check │ ├─────────────────┼─────────┼─────────────────────────────────┤ │ Hardware-Info │ [ ] │ [ ] │ │ Kernel-Details │ [ ] │ [ ] │ │ Dateisystem │ [ ] │ [ ] │ └─────────────────┴─────────┴─────────────────────────────────┘ ─────────────────────────────────────────────────────────────── ┌─────────────────────────────────────────────────────────────┐ │ Test 2: Berechtigungen │ ├─────────────────┬─────────┬─────────────────────────────────┤ │ Verzeichnis │ SGID │ Perm │ ├─────────────────┼─────────┼─────────────────────────────────┤ │ /projekt/docs │ [ ] │ [ ] │ │ intern │ [ ] │ [ ] │ │ public │ [ ] │ [ ] │ │ scripts │ [ ] │ [ ] │ │ shared │ [ ] │ [ ] │ └─────────────────┴─────────┴─────────────────────────────────┘ ``` ## Befehlsreferenz (Cheatsheet) Für den schnellen Zugriff bei der täglichen Systemarbeit fasst die folgende Referenztabelle die elementaren Grundkommandos der Linux-Administration zusammen: | Befehl / Syntax | Kategorie | Funktion & Beschreibung | |---|---|---| | `uname -a` | System | Zeigt Kernel-Version, Architektur und Hostname. | | `lsmod` | Kernel | Listet alle aktuell geladenen Kernel-Module auf. | | `sudo modprobe ` | Kernel | Lädt ein Kernel-Modul inklusive Abhängigkeiten. | | `sudo modprobe -r ` | Kernel | Entlädt ein Kernel-Modul sicher aus dem Kernel. | | `systemctl status ` | Init / systemd | Zeigt Zustand von Diensten und Systemd-Units. | | `systemd-analyze blame` | Boot | Zeigt Startdauer aller Dienste beim Bootvorgang. | | `df -Th` | Dateisystem | Zeigt gemountete Partitionen, FSType und Speicherplatz. | | `lsblk -f` | Dateisystem | Visualisiert Blockgeräte, UUIDs und Mountpunkte. | | `sudo mount /dev/sdX /mnt` | Dateisystem | Hängt ein Dateisystem an einem definierten Pfad ein. | | `sudo mount -a` | Dateisystem | Testet alle Einträge der `/etc/fstab` ohne Neustart. | | `sudo useradd -m -s /bin/bash ` | Benutzer | Erstellt neuen Benutzer mit Home-Verzeichnis und Shell. | | `sudo passwd ` | Benutzer | Ändert das Kennwort eines Benutzers. | | `sudo usermod -aG ` | Gruppen | Fügt Benutzer sicher zu einer sekundären Gruppe hinzu. | | `chmod 755 ` | Dateirechte | Setzt Standardrechte `rwxr-xr-x` (Besitzer voll, Rest lesen). | | `chmod 644 ` | Dateirechte | Setzt Dateirechte `rw-r--r--` für Standard-Dokumente. | | `chmod 2775 ` | Spezialbits | Setzt SGID: Automatische Gruppenvererbung für neue Dateien. | | `chmod 1777 ` | Spezialbits | Setzt Sticky Bit: Löschschutz in gemeinsamen Team-Ordnern. | | `sudo chown -R ` | Eigentümer | Ändert rekursiv Benutzer- und Gruppenbesitz. | | `umask` | Sicherheit | Zeigt die standardmäßige Berechtigungsmaske für neue Dateien. | ## Weiterführende Ressourcen Die folgenden offiziellen Standards, Dokumentationen und Vertiefungsartikel unterstützen dich beim fundierten Ausbau deiner Administrations-Kenntnisse: | Ressource | Beschreibung | |---|---| | [Filesystem Hierarchy Standard (FHS) 3.0](https://refspecs.linuxfoundation.org/FHS_3.0/fhs-3.0.html){.badge-link-text} | Offizielle FHS-Spezifikation der Linux Foundation. | | [systemd System & Service Manager](https://systemd.io/){.badge-link-text} | Offizielle Dokumentation und Referenz zum systemd-Ökosystem. | | [Linux Kernel Modul-Dokumentation](https://www.kernel.org/doc/html/latest/kbuild/modules.html){.badge-link-text} | Kernel.org-Dokumentation zur Linux-Modulverwaltung. | | [chmod & Dateiberechtigungen Leitfaden](/de/linux-neulinge/basics-bis-best-practices-alles-ueber-chmod-in-linux){.badge-link-text} | Fundamentale Vertiefung zu Berechtigungen, Bitmasken und Oktalwerten. | | [Befehlszeilenprozessor in Linux](/de/linux-neulinge/befehlszeilenprozessor-in-linux){.badge-link-text} | Architektur von Shell, TTY, Pipes und I/O-Streams. | | [Bash Grundkurs #1: Erstes Skript](/de/bash-grundlagen/bash-grundkurs-erstelle-dein-erstes-bash-shell-skript){.badge-link-text} | Fundamentaler Einstieg in die Bash-Skriptprogrammierung. | ## Fazit Mit dem Verständnis der 5-Schichten-Systemarchitektur, der Navigation im FHS-Verzeichnisbaum, der persistenten Speicherverwaltung über `/etc/fstab` sowie der präzisen Beherrschung von Standard- und Sonderberechtigungen (SUID, SGID, Sticky Bit) hast du das unverrückbare Fundament für deine Laufbahn als Linux-Administrator gelegt.
💡 **Praxis-Tipp:** Nutze bei gemeinsamen Team- und Projektordnern konsequent das **SGID-Bit** (`chmod 2775`), damit neu erstellte Dateien automatisch der gemeinsamen Gruppe gehören und Teammitglieder ohne manuelle Rechteanpassungen kollaborativ arbeiten können.
Im nächsten Modul unseres Administrationskurses widmen wir uns der tiefgreifenden Benutzerverwaltung, PAM-Authentifizierung und Zugriffskontrolle: 👉 **Weiter geht es mit:** [Linux Administration #2: Fortgeschrittene Benutzerverwaltung](/de/linux-administration/linux-administration-fortgeschrittene-benutzerverwaltung){.badge-link-text} 👉 **Zur Kursübersicht:** [Alle Linux-Administrations-Artikel & Module](/de/category/linux-administration){.badge-link-text}