Linux Administration #3: Prozesse und Ressourcenverwaltung

Willkommen zum dritten Teil unserer technischen Wiki-Serie über Linux-Administration!

Nachdem wir in den vorherigen Artikeln die Grundlagen der Systemadministration und die fortgeschrittene Benutzerverwaltung behandelt haben, widmen wir uns heute einem weiteren fundamentalen Aspekt:

Der Verwaltung von Prozessen und Systemressourcen.

Als Linux-Administrator ist es wichtig zu verstehen, wie Prozesse funktionieren und wie du Systemressourcen effektiv verwaltest. Stell dir dein Linux-System wie ein großes Unternehmen vor, in dem viele verschiedene Mitarbeiter (Prozesse) unterschiedliche Aufgaben erledigen und Ressourcen (CPU, RAM, etc.) teilen müssen.

Hinweis: In diesem Artikel verwenden wir Ubuntu/Debian als Beispiel-Distribution. Die grundlegenden Konzepte sind auf allen Linux-Systemen gleich, aber die Installation von Paketen und einige Konfigurationspfade können sich je nach Distribution unterscheiden. Wenn du eine andere Distribution verwendest, konsultiere bitte die entsprechende Dokumentation für die spezifischen Installationsbefehle und Pfade.

Was ist ein Prozess?

Ein Prozess ist ein laufendes Programm in deinem System. Um das besser zu verstehen, hier eine Analogie:

Ein Programm ist wie ein Mitarbeiterhandbuch mit Arbeitsanweisungen
Ein Prozess ist wie ein aktiver Mitarbeiter, der diese Anweisungen ausführt
Jeder Prozess hat eine eindeutige ID (PID), wie eine Personalnummer
Prozesse können miteinander kommunizieren, wie Mitarbeiter in Teams

Arten von Prozessen

In Linux gibt es verschiedene Arten von Prozessen, ähnlich wie in einem Unternehmen verschiedene Mitarbeitertypen existieren. Lass uns die wichtigsten Prozesstypen kennenlernen:

Markdown

Prozess-Typen:
┌─────────── Systemdienste ───────────┐
│ - Laufen im Hintergrund             │
│ - Starten beim Systemstart          │
│ - Beispiel: Druckerdienst           │
├─────────── Benutzerprozesse ────────┤
│ - Von dir gestartet                 │
│ - Laufen unter deinem Namen         │
│ - Beispiel: Firefox                 │
├─────────── Kernel-Prozesse ─────────┤
│ - Vom System verwaltet              │
│ - Wichtig für Basisfunktionen       │
│ - Beispiel: Gerätetreiber           │
└─────────────────────────────────────┘

System-Prozesse (Daemons)

Markdown

Eigenschaften von System-Prozessen:
┌─────────── Startverhalten ─────────┐
│ - Starten beim Systemstart         │
│ - Laufen im Hintergrund            │
│ - Keine Terminal-Verbindung        │
├─────────── Beispiele ──────────────┤
│ - Apache (Webserver)               │
│ - MySQL (Datenbank)                │
│ - SSH (Secure Shell)               │
└────────────────────────────────────┘

Benutzerprozesse

Markdown

Eigenschaften von Benutzerprozessen:
┌─────────── Interaktiv ────────────┐
│ - Von Benutzern gestartet         │
│ - Terminal-basiert                │
│ - Vordergrund oder Hintergrund    │
├─────────── Beispiele ─────────────┤
│ - Firefox (Browser)               │
│ - LibreOffice (Bürosoftware)      │
│ - Terminal-Befehle                │
└───────────────────────────────────┘

Kernel-Prozesse

Markdown

Eigenschaften von Kernel-Prozessen:
┌─────────── Systemebene ───────────┐
│ - Vom Kernel verwaltet            │
│ - Höchste Priorität               │
│ - Direkter Hardware-Zugriff       │
├─────────── Beispiele ─────────────┤
│ - kthreadd (Thread-Manager)       │
│ - kswapd (Speicherverwaltung)     │
│ - ksoftirqd (Interrupt-Handler)   │
└───────────────────────────────────┘

Wie ein Prozess entsteht und arbeitet

Wenn du ein Programm startest, passieren im Hintergrund viele wichtige Schritte. Lass uns verstehen, wie ein Prozess von der Entstehung bis zum Ende funktioniert.

Der Lebenszyklus eines Prozesses

Markdown

Prozess-Lebenszyklus:
┌─────────── Programm starten ────────┐
│ 1. Programm wird in RAM geladen     │
│ 2. PID wird zugewiesen              │
│ 3. Ressourcen werden reserviert     │
├─────────── Prozess läuft ───────────┤
│ 4. CPU-Zeit wird zugeteilt          │
│ 5. Speicher wird genutzt            │
│ 6. Ein-/Ausgaben werden ausgeführt  │
├─────────── Prozess endet ───────────┤
│ 7. Ressourcen werden freigegeben    │
│ 8. Exitstatus wird zurückgegeben    │
│ 9. Prozess wird beendet             │
└─────────────────────────────────────┘

Praktisches Beispiel: Firefox starten

Bash

# Firefox im Vordergrund starten
firefox

# Firefox im Hintergrund starten
firefox &

Was passiert dabei?

Shell erstellt einen neuen Prozess
Firefox-Programm wird in den RAM geladen
Neue PID wird zugewiesen
Prozess startet die Ausführung

Prozess-Status überprüfen

Ein Prozess durchläuft während seiner Lebensdauer verschiedene Zustände. Lass uns verstehen, welche Stati es gibt und wie sie zusammenhängen:

Markdown

Prozess-Zustände:
┌─────────── Running ──────────────┐
│ - Prozess wird ausgeführt        │
│ - Nutzt aktiv CPU-Zeit           │
├─────────── Sleeping ─────────────┤
│ - Wartet auf Ereignis/Ressource  │
│ - Gibt CPU frei                  │
├─────────── Stopped ──────────────┤
│ - Angehalten (z.B. durch SIGSTOP)│
│ - Kann fortgesetzt werden        │
├─────────── Zombie ───────────────┤
│ - Prozess beendet                │
│ - Wartet auf Elternprozess       │
└──────────────────────────────────┘

Detaillierte Prozessinformationen

Bash

# Status eines Prozesses anzeigen
ps -l

Ausgabe:
F S   UID   PID  PPID  C PRI   NI ADDR SZ WCHAN  TTY          TIME     CMD
0 S  1000  1234  1000  0  80   0  -    234 -     pts/0        00:00:01 bash

# Bedeutung der Status-Codes:
# R = Running (läuft)
# S = Sleeping (schlafend)
# T = Stopped (angehalten)
# Z = Zombie (beendet, wartet)

Lass uns diese Informationen verstehen:

UID: Benutzer, der den Prozess gestartet hat
PID: Eindeutige Prozess-ID
PPID: ID des Elternprozesses
C: CPU-Auslastung in Prozent
SZ: Größe im Speicher
RSS: Tatsächlich genutzter Arbeitsspeicher
PSR: Genutzter Prozessorkern
STIME: Startzeit
TTY: Verbundenes Terminal
TIME: Verbrauchte CPU-Zeit
CMD: Ausgeführter Befehl

Prozess-Kommunikation und Signale

Prozesse in Linux müssen häufig miteinander kommunizieren. Das funktioniert ähnlich wie in einem Unternehmen, wo Mitarbeiter verschiedene Kommunikationswege nutzen. Lass uns die wichtigsten Kommunikationsmethoden verstehen.

1. Prozess-Signale verstehen

Markdown

Signal-Arten:
┌─────────── Steuerungssignale ───────┐
│ SIGTERM (15) - Beenden              │
│ SIGKILL (9)  - Sofort beenden       │
│ SIGSTOP (19) - Anhalten             │
├─────────── Fehlersignale ───────────┤
│ SIGSEGV (11) - Speicherfehler       │
│ SIGFPE (8)   - Arithmetikfehler     │
│ SIGABRT (6)  - Abbruch              │
├─────────── Infosignale ─────────────┤
│ SIGUSR1 (10) - Benutzerdefiniert 1  │
│ SIGUSR2 (12) - Benutzerdefiniert 2  │
└─────────────────────────────────────┘

2. Signale in der Praxis

Ein Prozess kann verschiedene Signale empfangen und darauf reagieren:

Bash

# Prozess normal beenden (empfohlen)
kill -TERM 1234    # oder: kill -15 1234
# Der Prozess kann noch aufräumen

# Prozess sofort beenden (nur im Notfall!)
kill -KILL 1234    # oder: kill -9 1234
# Der Prozess wird sofort beendet

# Prozess anhalten und fortsetzen
kill -STOP 1234    # Prozess anhalten
kill -CONT 1234    # Prozess fortsetzen

Inter-Prozess-Kommunikation (IPC)

In einem Linux-System müssen Prozesse häufig miteinander kommunizieren, ähnlich wie Mitarbeiter in einem Unternehmen. Hier lernst du die verschiedenen Kommunikationsmethoden kennen.

1. Kommunikationsmethoden verstehen

Markdown

IPC-Methoden:
┌─────────── Pipes ──────────────────┐
│ - Datenübertragung zwischen        │
│   verwandten Prozessen             │
│ - Wie ein Rohr für Daten           │
├─────────── Signale ────────────────┤
│ - Kurze Nachrichten                │
│ - Wie Handzeichen zwischen         │
│   Prozessen                        │
├─────────── Shared Memory ──────────┤
│ - Gemeinsamer Speicherbereich      │
│ - Wie eine gemeinsame Pinnwand     │
└────────────────────────────────────┘

2. Pipes in der Praxis

Pipes sind wie Rohre, durch die Daten von einem Prozess zum anderen fließen:

Einfache Pipe-Beispiele

Bash

ls -l | grep ".txt"    # Listet nur .txt Dateien

Was passiert hier?

ls -l erzeugt eine Liste aller Dateien
Die Pipe (|) leitet diese Liste weiter
grep filtert nach „.txt“

Mehrfache Pipes

Bash

cat logfile.txt | grep "Error" | sort | uniq

# 1. Liest die Logdatei
# 2. Filtert nach "Error"
# 3. Sortiert die Zeilen
# 4. Entfernt Duplikate

Weitere Inter-Prozess-Kommunikationsmethoden

Neben Pipes gibt es noch weitere wichtige Methoden, wie Prozesse miteinander kommunizieren können. Lass uns diese im Detail anschauen.

1. Shared Memory (Gemeinsamer Speicher)

Markdown

Shared Memory Konzept:
┌─────────── Prozess A ────────────┐
│ Liest und schreibt Daten         │
├─────────── Shared Memory ────────┤
│ Gemeinsamer Speicherbereich      │
│ Schneller Datenaustausch         │
├─────────── Prozess B ────────────┤
│ Liest und schreibt Daten         │
└──────────────────────────────────┘

Shared Memory ist wie eine gemeinsame Pinnwand, auf die mehrere Prozesse zugreifen können:

Shared Memory Segment erstellen

Bash

ipcs -m    # Zeigt alle Shared Memory Segmente

Beispielausgabe

Bash

key        shmid      owner      perms      bytes      nattch     status
0x00000000 0          root       644        16384      2          dest

Shared Memory Status überprüfen

Bash

ipcs -m -i [shmid] # Zeigt detaillierte Informationen

2. Message Queues (Nachrichtenwarteschlangen)

Markdown

Message Queue Konzept:
┌─────────── Sender ───────────────┐
│ Prozess schickt Nachrichten      │
├─────────── Queue ────────────────┤
│ 1. Nachricht                     │
│ 2. Nachricht                     │
│ 3. Nachricht                     │
├─────────── Empfänger ────────────┤
│ Prozess empfängt Nachrichten     │
└──────────────────────────────────┘

Semaphoren und Inter-Prozess-Synchronisation

Semaphoren sind wie Ampeln im Straßenverkehr – sie regeln den Zugriff auf gemeinsam genutzte Ressourcen. Lass uns verstehen, wie sie funktionieren und wie du sie in der Praxis einsetzt.

1. Semaphoren verstehen

Markdown

Semaphoren-Typen:
┌─────────── Binäre Semaphoren ──────┐
│ - Wie eine Ampel: Rot oder Grün    │
│ - Nur zwei Zustände: 0 oder 1      │
│ - Für einfache Synchronisation     │
├─────────── Zähl-Semaphoren ────────┤
│ - Wie ein Parkhaus mit Counter     │
│ - Mehrere Ressourcen verfügbar     │
│ - Zählt verfügbare Einheiten       │
└────────────────────────────────────┘

2. Praktische Anwendung

Semaphore erstellen und initialisieren

Bash

ipcs -s    # Zeigt alle Semaphoren im System

Beispielausgabe

Bash

key        semid      owner      perms      nsems     
0x00000000 0          root       600        1

Semaphore-Status überprüfen

Bash

ipcs -s -i [semid] # Zeigt detaillierte Informationen über eine Semaphore

Beispiel: Gemeinsame Ressourcennutzung

Bash

# Python-Beispiel für Semaphoren-Nutzung
from multiprocessing import Semaphore

# Semaphore für 3 gleichzeitige Zugriffe
sem = Semaphore(3)

def geschuetzter_bereich():
    sem.acquire()    # "Ampel auf Rot schalten"
    try:
        # Hier kommt der geschützte Code
        print("Zugriff auf Ressource")
    finally:
        sem.release()    # "Ampel wieder auf Grün"

Praktische Anwendungsfälle

Prozess- und Ressourcenverwaltung

Lass uns anhand von realen Beispielen lernen, wie du Prozesse und Ressourcen in typischen Situationen verwaltest. Diese Szenarien begegnen dir häufig im Alltag eines Linux-Administrators.

Markdown

Typisches Szenario:
┌─────────── Apache/Nginx ───────────┐
│ - Hohe Besucherzahlen              │
│ - Viele parallele Verbindungen     │
│ - Begrenzte Serverressourcen       │
├─────────── Optimierung ────────────┤
│ - Prozess-Priorität anpassen       │
│ - CPU-Kerne zuweisen               │
│ - Ressourcenlimits setzen          │
└────────────────────────────────────┘

Webserver-Prozesse optimieren

1. Höhere Priorität setzen

Bash

sudo renice -n -5 $(pgrep apache2)

2. Dedizierte CPU-Kerne zuweisen

Bash

sudo taskset -pc 4-7 $(pgrep mysqld)

3. I/O-Priorität setzen

Bash

sudo ionice -c 1 -n 0 -p $(pgrep mysqld)

Webserver-Optimierung

Stell dir vor, du betreibst einen Apache-Webserver, der unter hoher Last läuft:

Markdown

Optimierungsziele:
┌─────────── Performance ───────────┐
│ - Schnelle Antwortzeiten          │
│ - Effiziente Ressourcennutzung    │
│ - Stabile Verfügbarkeit           │
├─────────── Maßnahmen ─────────────┤
│ - Prozess-Priorisierung           │
│ - CPU-Affinität                   │
│ - Ressourcenlimits                │
└───────────────────────────────────┘

1. Apache-Prozesse identifizieren

Bash

ps aux | grep apache2

# Zeigt alle Apache-Prozesse und ihre PIDs

Beispielausgabe

Bash

www-data  1234  2.5  1.2  ... /usr/sbin/apache2
www-data  1235  1.8  1.1  ... /usr/sbin/apache2

2. Prozess-Priorität optimieren

Bash

sudo renice -n -5 $(pgrep apache2)

# Gibt Apache höhere Priorität

3. CPU-Affinität setzen

Bash

sudo taskset -pc 0-2 $(pgrep apache2)

# Bindet Apache an die ersten drei CPU-Kerne

Datenbank-Server optimieren

Bei einer MySQL/MariaDB-Datenbank ist die Performance besonders wichtig:

1. MySQL-Prozess identifizieren

Bash

ps aux | grep mysql

# Zeigt den MySQL-Prozess und seine PID

2. Ressourcen überwachen

Bash

top -p $(pgrep mysqld)

# Zeigt Echtzeit-Ressourcennutzung

3. I/O-Priorität setzen

Bash

ionice -c 1 -n 0 -p $(pgrep mysqld)

# Gibt MySQL höchste I/O-Priorität

Ressourcenverwaltung

Als Linux-Administrator ist es wichtig zu verstehen, wie du Systemressourcen effektiv verwaltest. Stell dir dein System wie ein großes Unternehmen vor, in dem verschiedene Abteilungen (Prozesse) die verfügbaren Ressourcen (CPU, RAM, etc.) teilen müssen.

Systemressourcen verstehen

Markdown

Ressourcen-Arten:
┌─────────── Prozessor (CPU) ─────────┐
│ - Rechenzeit                        │
│ - Prozessorkerne                    │
│ - Auslastung                        │
├─────────── Arbeitsspeicher ─────────┤
│ - Physischer RAM                    │
│ - Swap-Speicher                     │
│ - Cache & Buffer                    │
├─────────── Ein/Ausgabe (I/O) ───────┤
│ - Festplattenzugriffe               │
│ - Netzwerkbandbreite                │
│ - Systembus                         │
└─────────────────────────────────────┘

CPU-Ressourcen überwachen

Die CPU ist das Herzstück deines Systems. Eine effektive Überwachung hilft dir, Performance-Probleme frühzeitig zu erkennen und zu beheben.

CPU-Informationen verstehen

Markdown

CPU-Metriken:
┌─────────── Auslastung ─────────────┐
│ %user   - Benutzeranwendungen      │
│ %system - Kernelprozesse           │
│ %iowait - Warten auf I/O           │
│ %idle   - CPU im Leerlauf          │
├─────────── Load Average ───────────┤
│ 1 min   - Letzte Minute            │
│ 5 min   - Letzte 5 Minuten         │
│ 15 min  - Letzte 15 Minuten        │
└────────────────────────────────────┘

CPU-Überwachung in der Praxis

Bash

# Grundlegende CPU-Informationen
cat /proc/cpuinfo
# Zeigt:
# - Prozessortyp
# - Anzahl der Kerne
# - Taktfrequenz
# - Cache-Größen

# CPU-Auslastung in Echtzeit
top
# Wichtige Zeilen:
# - Load Average: 0.15, 0.25, 0.30
# - %Cpu(s): 5.1 us, 2.3 sy, 0.0 ni, 91.3 id

# Detaillierte CPU-Statistiken
mpstat -P ALL 1
# Zeigt Auslastung pro CPU-Kern

# CPU-Temperatur überwachen
sensors
# Zeigt aktuelle CPU-Temperatur

CPU-Load verstehen

Die Load Average ist wie ein Thermometer für dein System:

< 1: System ist nicht ausgelastet
= 1: System ist optimal ausgelastet

System könnte überlasstet sein

Load Average anzeigen

Bash

uptime

Beispielausgabe:

Bash

14:30:05 up 5 days, load average: 0.15, 0.25, 0.30
                                    │     │     └── 15 min
                                    │     └──────  5 min
                                    └────────────  1 min

Speicherverwaltung und Ressourcenlimits

Die effektive Verwaltung des Arbeitsspeichers ist entscheidend für die Stabilität und Performance deines Systems. Lass uns lernen, wie du den Speicher überwachst und kontrollierst.

Speichertypen verstehen

Markdown

Speicher-Arten:
┌─────────── Physischer RAM ──────────┐
│ - Arbeitsspeicher                   │
│ - Schneller Zugriff                 │
│ - Begrenzte Größe                   │
├─────────── Swap-Speicher ───────────┤
│ - Auslagerungsspeicher              │
│ - Auf Festplatte                    │
│ - Langsamer als RAM                 │
├─────────── Cache & Buffer ──────────┤
│ - Temporärer Schnellspeicher        │
│ - Automatisch verwaltet             │
│ - Verbessert Performance            │
└─────────────────────────────────────┘

Speichernutzung überwachen

Gesamten Speicherstatus anzeigen

Bash

free -h

Beispielausgabe:

Bash

              total       used       free     shared    buffers     cache
Mem:          15Gi       5.2Gi      6.8Gi    1.2Gi      428Mi      2.3Gi
Swap:         4.0Gi      128Mi      3.9Gi

Was bedeutet das?

total: Gesamter verfügbarer RAM
used: Aktuell genutzter Speicher
free: Komplett freier Speicher
shared: Von mehreren Prozessen gemeinsam genutzter Speicher
buffers/cache: Vom System als Zwischenspeicher genutzt

Speicher-Limits und Ressourcenverwaltung

Die Kontrolle des Speicherverbrauchs ist entscheidend für die Stabilität deines Systems. Hier lernst du, wie du Speicherlimits setzt und überwachst.

Speicherlimits verstehen

Markdown

Speicher-Arten und Limits:
┌─────────── Physischer RAM ──────────┐
│ - Arbeitsspeicher-Begrenzung        │
│ - Prozess-spezifische Limits        │
│ - System-weite Limits               │
├─────────── Virtueller Speicher ─────┤
│ - Swap-Nutzung                      │
│ - Virtuelle Speichergrenzen         │
│ - Overcommit-Einstellungen          │
├─────────── OOM-Killer ──────────────┤
│ - Out-of-Memory Management          │
│ - Prozess-Priorisierung             │
│ - Schutz wichtiger Dienste          │
└─────────────────────────────────────┘

Speicherlimits setzen

Systemweite Limits anzeigen

Bash

ulimit -a

# Zeigt alle aktuellen Limits:
# - max memory size
# - max stack size
# - max open files
# - etc.

Prozess-spezifische Limits setzen

Beispiel: MySQL-Server

Bash

sudo nano /etc/security/limits.conf

Füge diese Zeilen hinzu:

TypeScript

mysql soft memlock 524288    # Soft-Limit: 512MB
mysql hard memlock 524288    # Hard-Limit: 512MB

OOM-Killer verstehen und konfigurieren

Der OOM-Killer (Out Of Memory Killer) ist ein wichtiger Schutzmechanismus in Linux. Er verhindert, dass dein System durch Speichermangel komplett einfriert. Lass uns verstehen, wie er funktioniert und wie du ihn konfigurierst.

OOM-Killer Grundlagen

Markdown

OOM-Killer-Funktion:
┌─────────── Überwachung ───────────┐
│ - Beobachtet Speicherverbrauch    │
│ - Erkennt kritische Situationen   │
│ - Bewertet Prozesse               │
├─────────── Bewertung ─────────────┤
│ - Prozess-Größe                   │
│ - Laufzeit                        │
│ - Wichtigkeit (Score)             │
├─────────── Aktion ────────────────┤
│ - Wählt Prozess zum Beenden       │
│ - Beendet Prozess                 │
│ - Protokolliert Aktion            │
└───────────────────────────────────┘

OOM-Score verstehen und anpassen

OOM-Score eines Prozesses anzeigen

Bash

cat /proc/1234/oom_score

# Höherer Wert = wird eher beendet

OOM-Score-Anpassung anzeigen

Bash

cat /proc/1234/oom_score_adj

# Wertebereich: -1000 bis 1000

Wichtigen Dienst schützen

Bash

echo -1000 > /proc/$(pgrep mysql)/oom_score_adj

# -1000 = Prozess wird nie beendet

Unwichtigen Prozess markieren

Bash

echo 500 > /proc/$(pgrep firefox)/oom_score_adj

# Positive Werte = wird eher beendet

I/O-Limits und Ressourcenkontrolle

Die Kontrolle der Ein- und Ausgabe (I/O) ist entscheidend für die Systemleistung. Hier lernst du, wie du I/O-Limits setzt und überwachst.

I/O-Scheduling und Limits verstehen

Markdown

I/O-Kontrolle:
┌─────────── I/O-Scheduler ──────────┐
│ - Verwaltet Festplattenzugriffe    │
│ - Priorisiert Anfragen             │
│ - Optimiert Performance            │
├─────────── I/O-Limits ─────────────┤
│ - Begrenzt Durchsatz               │
│ - Kontrolliert Bandbreite          │
│ - Verhindert Überlastung           │
├─────────── Monitoring ─────────────┤
│ - Überwacht Aktivität              │
│ - Erkennt Engpässe                 │
│ - Protokolliert Zugriffe           │
└────────────────────────────────────┘

I/O-Limits in der Praxis

I/O-Priorität für Prozesse setzen

Bash

ionice -c 2 -n 7 -p $(pgrep firefox)

Klassen:

1 = Realtime (nur root)
2 = Best-Effort (Standard)
3 = Idle (niedrigste)

I/O-Statistiken anzeigen

Bash

iostat -x 1

# Zeigt:
# - Festplattenauslastung in Echtzeit
# - Durchsatz und Wartezeiten
# - Auslastung pro Gerät

Praktische Beispiele für I/O-Limits

In der Praxis ist es oft wichtig, die I/O-Nutzung zu kontrollieren, besonders wenn mehrere Dienste oder Benutzer das System gemeinsam nutzen.

I/O-Scheduling und Prioritäten verstehen

Markdown

I/O-Scheduling-Klassen:
┌─────────── Realtime ──────────────┐
│ - Höchste Priorität               │
│ - Für kritische Systemprozesse    │
│ - Nur für root-Benutzer           │
├─────────── Best-Effort ───────────┤
│ - Standard-Priorität              │
│ - Für normale Anwendungen         │
│ - Faire Ressourcenverteilung      │
├─────────── Idle ──────────────────┤
│ - Niedrigste Priorität            │
│ - Für unwichtige Prozesse         │
│ - Nur wenn System frei ist        │
└───────────────────────────────────┘

I/O-Limits in der Praxis anwenden

I/O-Priorität für Backup-Prozess setzen

Bash

ionice -c 3 ./backup.sh

# Klasse 3 (Idle) bedeutet:
# - Läuft nur, wenn keine anderen I/O-Anfragen
# - Ideal für Backups und Archivierung
# - Stört andere Prozesse nicht

I/O-Statistiken überwachen

Bash

iostat -x 1

# Zeigt:
# - Festplattenauslastung in Echtzeit
# - Durchsatz und Wartezeiten
# - Auslastung pro Gerät

Systemüberwachung

Als Linux-Administrator ist es wichtig, dein System kontinuierlich zu überwachen. Stell dir das wie eine Schaltzentrale vor, in der du alle wichtigen Messwerte im Blick behältst.

Grundlegende Systemüberwachung

Markdown

Überwachungsbereiche:
┌─────────── System-Ressourcen ───────┐
│ - CPU-Auslastung                    │
│ - Speichernutzung                   │
│ - Festplattenauslastung             │
├─────────── Prozesse ────────────────┤
│ - Laufende Prozesse                 │
│ - Prozess-Status                    │
│ - Ressourcenverbrauch               │
├─────────── System-Logs ─────────────┤
│ - Systemereignisse                  │
│ - Fehlermeldungen                   │
│ - Sicherheitswarnungen              │
└─────────────────────────────────────┘

Wichtige Monitoring-Tools

Das wichtigste Werkzeug für die Systemüberwachung ist top. Es zeigt dir in Echtzeit, was auf deinem System passiert:

Bash

top

# Systemüberwachung mit top starten

Beispielausgabe:

Bash

top - 19:09:30 up  9:46,  2 users,  load average: 1,39, 1,30, 1,35
Tasks: 282 total,   1 running, 281 sleeping,   0 stopped,   0 zombie
%CPU(s):  8,3 us,  4,0 sy,  0,0 ni, 87,2 id,  0,0 wa,  0,4 hi,  0,1 si,  0,0 st

MiB Spch:  23930,2 total,   2294,4 free,  11825,2 used,  10645,2 buff/cache     
MiB Swap:  50253,9 total,  50253,9 free,      0,0 used.  12105,0 avail Spch

PID   USER   PR  NI   VIRT    RES    SHR    S   %CPU  %MEM     ZEIT+    BEFEHL                                                                                                                                                                                                      16377 demo+  20   0   28,2g   1,1g   506144 S   5,3   4,6      71:37.38 firefox

# Was bedeuten die wichtigsten Zeilen?
# Erste Zeile: Systemzeit, Uptime, Benutzer, Load Average
# Zweite Zeile: Prozess-Zusammenfassung
# Dritte Zeile: CPU-Nutzung
# Vierte/Fünfte Zeile: Speichernutzung

Erweiterte Monitoring-Funktionen

Als Linux-Administrator brauchst du detaillierte Einblicke in dein System. Die erweiterten Monitoring-Funktionen helfen dir dabei, Probleme frühzeitig zu erkennen und zu beheben.

Systemüberwachung mit SAR (System Activity Reporter)

Markdown

SAR-Funktionen:
┌─────────── CPU-Monitoring ─────────┐
│ - Prozessorauslastung              │
│ - System/User/IO-Wait              │
│ - Prozess-Statistiken              │
├─────────── Speicher-Monitoring ────┤
│ - RAM-Nutzung                      │
│ - Swap-Aktivität                   │
│ - Page Faults                      │
├─────────── I/O-Monitoring ─────────┤
│ - Festplattenaktivität             │
│ - Netzwerk-Traffic                 │
│ - System-Load                      │
└────────────────────────────────────┘

SAR in der Praxis

SAR installieren und aktivieren

Bash

sudo apt install sysstat
sudo systemctl enable sysstat
sudo systemctl start sysstat

CPU-Auslastung überwachen

Bash

sar -u 1 5    # Alle 1 Sekunde, 5 Messungen

Beispielausgabe:

Bash

19:16:27        CPU      %user     %nice     %system   %iowait   %steal   %idle
19:16:28        all      4,00      0,00      2,00      0,00      0,00     94,00
19:16:29        all      4,02      0,00      1,76      0,00      0,00     94,22
19:16:30        all      4,04      0,00      1,77      0,00      0,00     94,19
19:16:31        all      5,00      0,00      3,00      0,00      0,00     92,00
19:16:32        all      3,50      0,00      1,50      0,00      0,00     95,00
Durchschn.:     all      4,11      0,00      2,01      0,00      0,00     93,88

# - %user (Benutzeranwendungen)
# - %system (Kernelprozesse)
# - %iowait (Wartezeit auf I/O)
# - %idle (CPU im Leerlauf)

Speichernutzung überwachen

Bash

sar -r    # RAM-Statistiken
sar -S    # Swap-Statistiken

Troubleshooting

Als Linux-Administrator wirst du häufig mit Performance-Problemen konfrontiert. Hier lernst du, wie du systematisch Probleme erkennst, analysierst und behebst.

Systematische Problemanalyse

Markdown

Troubleshooting-Schritte:
┌─────────── Problem erkennen ─────────┐
│ - Symptome identifizieren            │
│ - Betroffene Ressourcen finden       │
│ - Auswirkungen dokumentieren         │
├─────────── Analyse ──────────────────┤
│ - Systemlast überprüfen              │
│ - Ressourcenverbrauch messen         │
│ - Logs auswerten                     │
├─────────── Lösung ───────────────────┤
│ - Ursache beheben                    │
│ - Maßnahmen dokumentieren            │
│ - Prävention planen                  │
└──────────────────────────────────────┘

Häufige Probleme und Lösungen

CPU-Probleme erkennen und beheben:

1. CPU-Auslastung prüfen

Bash

top

# Hohe Werte bei %us oder %sy deuten auf Probleme hin

2. Problematische Prozesse identifizieren

Bash

ps aux --sort=-%cpu | head -5

# Zeigt die 5 CPU-intensivsten Prozesse

3. Prozess-Priorität anpassen

Bash

renice +10 $(pgrep firefox)

# Gibt Firefox niedrigere Priorität

Speicherprobleme diagnostizieren:

1. Speichernutzung überprüfen

Bash

free -h

# Wichtige Indikatoren:
# - Wenig freier RAM
# - Hohe Swap-Nutzung

2. Speicherfresser finden

Bash

ps aux --sort=-%mem | head -5

# Zeigt die 5 speicherintensivsten Prozesse

3. Cache leeren (wenn nötig)

Bash

sync && echo 3 > /proc/sys/vm/drop_caches

I/O-Probleme erkennen und beheben

I/O-Probleme verstehen

Markdown

I/O-Problem-Indikatoren:
┌─────────── Performance ──────────┐
│ - System reagiert träge          │
│ - Hohe Festplattenaktivität      │
│ - Programme "frieren ein"        │
├─────────── Diagnose ─────────────┤
│ - I/O-Wait beobachten            │
│ - Durchsatz messen               │
│ - Warteschlangen prüfen          │
└──────────────────────────────────┘

1. I/O-Probleme diagnostizieren

Bash

iostat -x 1

# Wichtige Werte:
# %util   - Auslastung des Geräts
# await   - Durchschnittliche Wartezeit
# svctm   - Durchschnittliche Bedienzeit

2. Top I/O-Verursacher finden

Bash

iotop

# Zeigt:
# - Prozesse mit höchster I/O-Last
# - Lese- und Schreibraten
# - I/O-Prioritäten

3. I/O-Probleme beheben

Bash

# I/O-Scheduler optimieren
echo deadline > /sys/block/sda/queue/scheduler
# Deadline ist oft besser für Server

# I/O-Priorität anpassen
ionice -c 2 -n 7 -p $(pgrep backup)
# Backup-Prozess bekommt niedrige Priorität

Übungen

Lass uns das Gelernte durch praktische Übungen vertiefen. Hier sind reale Szenarien, die dir in deinem Alltag als Linux-Administrator begegnen können.

Übung 1: Webserver-Optimierung

Szenario: Du betreust einen Apache-Webserver, der unter hoher Last läuft. Benutzer beschweren sich über langsame Ladezeiten, und das Monitoring zeigt eine hohe CPU- und Speicherauslastung.

Anforderungen:

Apache-Prozesse identifizieren
Ressourcenverbrauch analysieren
Performance optimieren
Prozess-Priorität anpassen
Ressourcenlimits setzen

Mögliche Lösung:

Bash

# 1. Apache-Prozesse identifizieren
ps aux | grep apache2
# Zeigt alle Apache-Prozesse und ihre PIDs

# 2. Ressourcenverbrauch analysieren
top -p $(pgrep -d',' apache2)
# Beobachte CPU und RAM-Nutzung

# 3. Prozess-Priorität optimieren
sudo renice -5 $(pgrep apache2)
# Gibt Apache höhere Priorität

# 4. Ressourcenlimits setzen
sudo nano /etc/security/limits.conf
# Füge hinzu:
www-data soft nproc 150    # Maximale Prozessanzahl
www-data soft nofile 8192  # Maximale offene Dateien

Übung 2: Performance-Optimierung eines Datenbank-Servers

Szenario: Du betreust einen MySQL-Datenbankserver, der die Kundendatenbank eines Online-Shops verwaltet. In Spitzenzeiten kommt es zu Performance-Einbrüchen und langsamen Antwortzeiten.

Anforderungen:

MySQL-Prozesse identifizieren
Ressourcenverbrauch analysieren
CPU- und I/O-Priorität optimieren
Speicherlimits anpassen
Performance überwachen

Mögliche Lösung:

Bash

# 1. MySQL-Prozesse identifizieren
ps aux | grep mysql
# Zeigt alle MySQL-Prozesse und ihre PIDs

# 2. Ressourcen analysieren
top -p $(pgrep mysqld)
# Beobachte:
# - CPU-Auslastung
# - Speicherverbrauch
# - Load Average

# 3. CPU-Priorität optimieren
sudo renice -10 $(pgrep mysqld)
# Gibt MySQL höhere Priorität

# 4. I/O-Priorität setzen
sudo ionice -c 1 -n 0 -p $(pgrep mysqld)
# Höchste I/O-Priorität für MySQL

# 5. OOM-Killer-Schutz aktivieren
echo -1000 > /proc/$(pgrep mysqld)/oom_score_adj
# Schützt MySQL vor dem OOM-Killer

Übung 3: Prozess-Priorisierung und Ressourcenkontrolle

Szenario: Du betreust ein Linux-System, auf dem mehrere Entwickler gleichzeitig arbeiten. Ein rechenintensiver Kompilierungsprozess (gcc) eines Entwicklers belastet das System so stark, dass andere Benutzer über langsame Reaktionszeiten klagen.

Anforderungen:

Kompilierungsprozesse identifizieren
Prozess-Priorität anpassen
CPU-Ressourcen fair verteilen
System-Performance für andere Benutzer sicherstellen
OOM-Killer richtig konfigurieren

Mögliche Lösung:

Bash

# 1. Kompilierungsprozesse identifizieren
ps aux | grep gcc
# Zeigt alle gcc-Prozesse und ihre PIDs

# 2. Prozess-Priorität anpassen
renice +10 $(pgrep gcc)
# Gibt Kompilierung niedrigere Priorität

# 3. CPU-Limits setzen
# Prozess auf bestimmte CPU-Kerne beschränken
taskset -cp 2,3 $(pgrep gcc)
# Beschränkt gcc auf Kerne 2 und 3

# 4. OOM-Score anpassen
echo 500 > /proc/$(pgrep gcc)/oom_score_adj
# Prozess wird bei Speichermangel eher beendet

Fazit

In diesem dritten Teil unserer Linux-Administrations-Serie hast du gelernt, wie Prozesse und Systemressourcen in Linux funktionieren und verwaltet werden. Du kennst jetzt die grundlegenden Konzepte der Prozessverwaltung, verstehst wie Ressourcen zugewiesen und überwacht werden, und weißt, wie du Performance-Probleme diagnostizieren und beheben kannst.

Die Verwaltung von Prozessen und Ressourcen ist eine Kernaufgabe in der Linux-Administration. Mit dem Wissen aus diesem Artikel kannst du Systemprozesse effektiv überwachen, Ressourcen optimal zuteilen und typische Performance-Probleme lösen. Besonders wichtig ist das Verständnis der Prozess-Prioritäten und der verschiedenen Monitoring-Tools, die dir bei der täglichen Arbeit helfen.

Im nächsten Artikel der Serie werden wir uns mit der Netzwerkkonfiguration und -verwaltung beschäftigen. Du lernst, wie du Netzwerkverbindungen einrichtest, konfigurierst und überwachst.

Bis dahin, happy administrating!