Physical Address

304 North Cardinal St.
Dorchester Center, MA 02124

Linux Administration #1: Grundlagen der Linux-Administration

Linux Administration #1: Grundlagen der Linux-Administration
Navigation

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
  • Regelt die Ein- und Ausgabe von Daten
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

# Eingeloggte Benutzer anzeigen
who
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 eines 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.

Markdown
Berechtigungshierarchie:
┌─────────── Root (UID 0) ────────────┐
│ Vollständige Systemkontrolle        │
├─────────── System-User ─────────────┤
│ UIDs 1-999 (Dienste, Daemons)       │
├─────────── Normale User ────────────┤
│ UIDs 1000+ (Menschen)               │
└─────────────────────────────────────┘

Dateiberechtigungen:
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.Wichtig für Anfänger:

  • 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:
Bash
# 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).

Markdown
Gruppenstruktur:
┌─────────── Systemgruppen ────────────┐
│ sudo, adm, www-data, etc.            │
├─────────── Benutzergruppen ──────────┤
│ entwickler, marketing, support       │
└──────────────────────────────────────┘

Benutzer-Gruppen-Beziehung:
┌─── 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
  • 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:
# 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

Wichtige Tipps für Anfänger:

  1. Verwende immer die Option -a zusammen mit -G, um zu vermeiden, dass bestehende Gruppenmitgliedschaften
  2. Benutzer müssen sich abmelden und wieder anmelden, damit neue Gruppenmitgliedschaften wirksam werden
  3. Verwende den Befehl newgrp, um eine neue Gruppenmitgliedschaft zu aktivieren, ohne sich abzumelden
  4. Überprüfe die Gruppenmitgliedschaft mit dem Befehl groups, nachdem du Änderungen vorgenommen

hast.

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.

Markdown
Vollständige Berechtigungsstruktur:
Datei: beispiel.txt
-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):
Bash
# 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:
# Datei lesen
cat beispiel.txt
less beispiel.txt
head -n 5 beispiel.txt  # Erste 5 Zeilen
tail -n 5 beispiel.txt  # Letzte 5 Zeilen

# Datei kopieren
cp beispiel.txt kopie.txt

# In Datei suchen
grep "Suchbegriff" beispiel.txt

# 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:
ls -l verzeichnis/
ls -la verzeichnis/    # Zeigt auch versteckte Dateien
find verzeichnis/ -name "*.txt"

# Was passiert ohne Leserecht?
chmod u-r verzeichnis/
ls verzeichnis/
# Ausgabe: "Permission denied"
Schreiben (w = write):
Bash
# Für Dateien bedeutet Schreibrecht:
- Dateiinhalt ändern
- In Datei schreiben
- Datei löschen
- Datei umbenennen
- Datei verschieben
- Dateiattribute ändern
- Datei leeren

# Praktische Beispiele:
# Datei erstellen/überschreiben
echo "Neuer Text" > beispiel.txt

# An Datei anhängen
echo "Weiterer Text" >> beispiel.txt

# Mit Editor bearbeiten
nano beispiel.txt
vim beispiel.txt

# Datei umbenennen/verschieben
mv beispiel.txt neu.txt
mv neu.txt /tmp/

# Datei löschen
rm beispiel.txt

# 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

# Was passiert ohne Schreibrecht?
chmod u-w verzeichnis/
touch verzeichnis/test.txt
# Ausgabe: "Permission denied"
Ausführen (x = execute):
Bash
# Für Dateien bedeutet Ausführrecht:
- Datei als Programm/Skript ausführen
- Binärdateien starten
- Shell-Skripte ausführen
- Programme ausführen

# Praktische Beispiele:
# Shell-Skript erstellen
echo '#!/bin/bash' > skript.sh
echo 'echo "Hallo Welt"' >> skript.sh
chmod u+x skript.sh
./skript.sh

# 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

# 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 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 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.

Markdown
Spezielle Berechtigungen visualisiert:
┌─── 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'

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:

Markdown
- /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

ShellScript
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:

Markdown
/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
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:

Markdown
/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:

Markdown
System-Überprüfung:
/
├── Kernel ─────────────────┐
│ ├── Version     [ ]      │
│ ├── Module      [ ]      │
│ └── Parameter   [ ]      │
│                          │
├── Systemd ───────────────┤
│ ├── Status      [ ]      │
│ └── Services    [ ]      │
│                          │
└── Verzeichnisse ─────────┘
    ├── /etc       [ ]
    ├── /var/log   [ ]
    └── /home      [ ]

Berechtigungs-Überprüfung:
/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:

ShellScript
#!/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:

  1. Die Systemarchitektur analysieren
  2. Ein Verzeichnissystem mit korrekten Berechtigungen aufsetzen
  3. Erweiterte Berechtigungen implementieren
Teil 1: Systemanalyse
Markdown
Systemkomponenten-Checkliste:
┌─────────── Hardware ──────────────┐
│ [ ] CPU-Informationen             │
│ [ ] RAM-Status                    │
│ [ ] Festplatten                   │
├─────────── Kernel ────────────────┤
│ [ ] Version                       │
│ [ ] Module                        │
│ [ ] Parameter                     │
├─────────── Dateisystem ───────────┤
│ [ ] Mountpunkte                   │
│ [ ] Speichernutzung               │
│ [ ] Verzeichnisstruktur           │
└───────────────────────────────────┘

Teil 2: Berechtigungskonfiguration

Markdown
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:

Markdown
Berechtigungstest-Matrix:
┌─────────────────────────────────────┐
│ 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 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!

Schlagwörter

Ähnliche Beiträge

Kommentar verfassen