---
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: "spalencsar"
category: "linux-administration"
tags: ["linux-basics", "shell", "filesystem", "permissions", "history", "cli", "linux-administration"]
toc: true
reading_time: 19
---
**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
/
├── /bin → Programme
├── /boot → Kernel & Bootloader
├── /dev → Gerätedateien
├── /etc → Konfiguration
├── /home → Benutzerverzeichnisse
├── /lib → Bibliotheken
├── /proc → Prozessinformationen
├── /root → Root-Verzeichnis
├── /sbin → Systemprogramme
├── /tmp → Temporäre Dateien
├── /usr → Programme & Daten
└── /var → Variable Daten
```
**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
rwx rwx rwx datei.txt
│ │ └── Others (Alle anderen)
│ └────── Group (Gruppe)
└────────── User (Besitzer)
r (read) = 4
w (write) = 2
x (execute) = 1
```
##### 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
# Detaillierte Informationen anzeigen
getent passwd anna
# anna:x:1001:1001::/home/anna:/bin/bash
# | | | | | | └─ Shell
# | | | | | └─ Home-Verzeichnis
# | | | | └─ Kommentar/Name
# | | | └─ Gruppen-ID
# | | └─ Benutzer-ID
# | └─ Verschlüsseltes Passwort (x = in /etc/shadow)
# └─ Benutzername
```
## 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: │──→ marketing
│ Sekundär: │──→ entwickler, support
└────────────┘
```
💡 **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
entwickler:x:1002:
│ │ │ └─ Gruppenmitglieder
│ │ └─ Gruppen-ID
│ └─ Gruppenkennwort (meist nicht verwendet)
└─ 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
-rw-r--r-- 1 anna entwickler 1024 Feb 20 14:30 beispiel.txt
│├─┤├─┤├─┤ │ │ │ │ │
││ │ │ │ │ │ │ └── Datum & Zeit
││ │ │ │ │ │ └──────── Größe in Bytes
││ │ │ │ │ └───────────────────── Gruppe
││ │ │ │ └────────────────────────── Besitzer
││ │ │ └──────────────────────────── Anzahl der Links
││ │ └────────────────────────────── Andere (Everyone)
││ └───────────────────────────────── Gruppe (Group)
│└──────────────────────────────────── Besitzer (User)
└───────────────────────────────────── Dateityp
```
##### 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:**
```Bash
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:**
```Bash
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
┌─── SUID ──┬─── SGID ──┬── Sticky ─┐
│ (4) │ (2) │ (1) │
│ │ │
s s t
│ │ │
│ │ └── Nur Besitzer darf löschen
│ └────────── Erbt Gruppenrechte
└─────────────────── Läuft als Besitzer
```
###### 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
Normales Verzeichnis: drwxr-xr-x
SGID-Verzeichnis: drwxr-sr-x
^
Beachte das 's' ─────────────┘
```
**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:**
```Bash
mkdir /shared/projekt
chmod 2775 /shared/projekt
ls -ld /shared/projekt
```
**Neue Datei erstellen und Gruppe prüfen:**
```Bash
touch /shared/projekt/test.txt
ls -l /shared/projekt/test.txt
```
**Überprüfen der Einstellungen:**
**Verzeichnis erstellen und SGID setzen:**
```Bash
mkdir /shared/projekt
chmod 2775 /shared/projekt
ls -ld /shared/projekt
```
**Neue Datei erstellen und Gruppe prüfen:**
```Bash
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
Normales Verzeichnis: drwxrwxrwx
Verzeichnis mit Sticky Bit: drwxrwxrwt
^
💡 Beachte das `t` ────────────────────┘
```
**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:
```Bash
touch /shared/public/anna.txt
```
**Als Benutzer bob (wird fehlschlagen):**
```Bash
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:
```Bash
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
/proj/
├── src/ drwxrwsr-x root:dev
│ └── [Dateien prüfen] [ ]
│
├── docs/ drwxrwsr-x root:dev
│ └── [Dateien prüfen] [ ]
│
└── shared/ drwxrwxrwt root:root
└── [Sticky Bit] [ ]
```
**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 │ [ ] │ [ ] │
└─────────────────┴─────────┴─────────┘
```
## Fazit:
In diesem ersten Teil des Linux Administration Grundkurses hast du die fundamentalen Konzepte der Linux-Systemarchitektur und Rechteverwaltung kennengelernt. Du verstehst nun, wie ein Linux-System von der Hardware bis zur Benutzerebene aufgebaut ist, wie die Dateisystemhierarchie funktioniert und wie Berechtigungen das System absichern. Diese Grundlagen sind essentiell für alle weiteren Administrationsaufgaben.
Im nächsten Artikel werden wir uns der [Benutzerverwaltung](/de/linux-administration/linux-administration-fortgeschrittene-benutzerverwaltung)widmen. Du lernst, wie du Benutzer und Gruppen erstellst, Passwort-Policies einrichtest und die Zugriffsrechte effektiv verwaltest. Die weiteren Artikel der Serie behandeln dann Paketverwaltung, Systemdienste, Netzwerkkonfiguration, Sicherheit, Monitoring und schließlich Virtualisierung – alles Bausteine, die dich zu einem kompetenten Linux-Administrator machen.
**Bis dahin, happy administrating!**