---
id: 2024-10-31-linux-administration-prozesse-und-ressourcenverwaltung
slug: linux-administration-prozesse-und-ressourcenverwaltung
title: "Linux Administration #3: Prozesse und Ressourcenverwaltung"
excerpt: "In diesem dritten Teil unserer Linux-Administrations-Serie lernst du alles über Prozesse und Ressourcenverwaltung. Von grundlegenden Konzepten bis zur praktischen Anwendung."
date: "2024-10-31T09:00:00+01:00"
updated: "2024-10-31T10:00:00+01:00"
author:
name: "Sebastian Palencsar"
handle: "AdminDocs"
category: "linux-administration"
tags: ["process-management", "top", "htop", "kill", "nice", "jobs", "background-processes", "linux-administration"]
toc: true
reading_time: 45
---
**Willkommen zum dritten Teil unserer technischen Wiki-Serie über Linux-Administration!**
Nachdem wir in den vorherigen Artikeln die [NGrundlagen der Systemadministration](/de/linux-administration/linux-administration-fortgeschrittene-benutzerverwaltung){.badge-link-text} 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:
**Prozess-Typen:**
```markdown
┌─────────── 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)
**Eigenschaften von System-Prozessen:**
```markdown
┌─────────── Startverhalten ──────────────────────────────────┐
│ • Starten beim Systemstart │
│ • Laufen im Hintergrund │
│ • Keine Terminal-Verbindung │
├─────────── Beispiele ───────────────────────────────────────┤
│ • Apache (Webserver) │
│ • MySQL (Datenbank) │
│ • SSH (Secure Shell) │
└─────────────────────────────────────────────────────────────┘
```
### Benutzerprozesse
**Eigenschaften von Benutzerprozessen:**
```markdown
┌─────────── Interaktiv ──────────────────────────────────────┐
│ • Von Benutzern gestartet │
│ • Terminal-basiert │
│ • Vordergrund oder Hintergrund │
├─────────── Beispiele ───────────────────────────────────────┤
│ • Firefox (Browser) │
│ • LibreOffice (Bürosoftware) │
│ • Terminal-Befehle │
└─────────────────────────────────────────────────────────────┘
```
### Kernel-Prozesse
**Eigenschaften von Kernel-Prozessen:**
```markdown
┌─────────── 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
**Prozess-Lebenszyklus:**
```markdown
┌─────────── 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:
**Prozess-Zustände:**
```markdown
┌─────────── 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)
```
**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
**Signal-Arten:**
```markdown
┌─────────── 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
**IPC-Methoden:**
```markdown
┌─────────── 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)
**Shared Memory Konzept:**
```markdown
┌─────────── 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**
* 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)
**Message Queue Konzept:**
```markdown
┌─────────── 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
**Semaphoren-Typen:**
```markdown
┌─────────── 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**
* 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.
**Typisches Szenario:**
```markdown
┌─────────── 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:
**Optimierungsziele:**
```markdown
┌─────────── 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**
* 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
**Ressourcen-Arten:**
```markdown
┌─────────── 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
**CPU-Metriken:**
```markdown
┌─────────── 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**
* 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
**Speicher-Arten:**
```markdown
┌─────────── 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
* free -h
**Beispielausgabe**:
* 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
**Speicher-Arten und Limits:**
```markdown
┌─────────── 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
🔧 **Praktisches Beispiel: MySQL-Server-Prozess**
* sudo nano /etc/security/limits.conf
**Füge diese Zeilen hinzu:**
```bash
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
**OOM-Killer-Funktion:**
```markdown
┌─────────── Ü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
**I/O-Kontrolle:**
```markdown
┌─────────── 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
**I/O-Scheduling-Klassen:**
```markdown
┌─────────── 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
**Überwachungsbereiche:**
```markdown
┌─────────── 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)
**SAR-Funktionen:**
```markdown
┌─────────── 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
* 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
**Troubleshooting-Schritte:**
```markdown
┌─────────── 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
**I/O-Problem-Indikatoren:**
```markdown
┌─────────── 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
```
## Befehlsreferenz (Cheatsheet)
Für den schnellen Zugriff bei der Analyse, Überwachung und Steuerung von Prozessen fasst die folgende Referenztabelle die wichtigsten Linux-Kommandos zusammen:
| Befehl / Syntax | Kategorie | Funktion & Beschreibung |
|---|---|---|
| `ps aux` | Snapshot | Zeigt alle laufenden Prozesse im System im BSD-Format. |
| `ps aux --sort=-%cpu` | Snapshot | Sortiert Prozesse absteigend nach CPU-Auslastung. |
| `ps -ef --forest` | Prozessbaum | Visualisiert Eltern-Kind-Beziehungen von Prozessen im ASCII-Baum. |
| `top` / `htop` | Interaktiv | Echtzeit-Monitoring von CPU, RAM, Load Average und Prozessen. |
| `pgrep -l ` | Suche | Sucht Prozess-IDs (PIDs) passend zum angegebenen Namen. |
| `kill -15 ` | Signale | Sendet Standard-Terminierungssignal (SIGTERM) für geordnetes Beenden. |
| `kill -9 ` | Signale | Erzwingt sofortigen, nicht abfangbaren Prozessabschuss (SIGKILL). |
| `kill -1 ` | Signale | Sendet SIGHUP zum Neuladen von Daemon-Konfigurationen ohne Neustart. |
| `pkill -15 ` | Signale | Beendet Prozesse zielgerichtet nach Namensmuster. |
| `nice -n 10 ` | Priorität | Startet Programm mit reduzierter CPU-Priorität (höherer Nice-Wert). |
| `renice -n 5 -p ` | Priorität | Passt die Scheduling-Priorität eines laufenden Prozesses an. |
| `ionice -c 3 -p ` | I/O-Priorität | Setzt I/O-Scheduling-Klasse auf 'Idle' (nur bei freien Plattenressourcen). |
| `jobs -l` | Job-Control | Listet alle Hintergrund-Jobs der aktuellen Shell-Sitzung mit PID auf. |
| `nohup &` | Job-Control | Startet Prozess immun gegen SIGHUP beim Schließen der SSH-Session. |
| `systemd-cgtop` | cgroups | Echtzeit-Monitoring des Ressourcenverbrauchs pro systemd-CGroup. |
| `systemd-run --scope -p CPUQuota=30% ` | cgroups | Führt Befehl mit striktem CPU-Limit über systemd cgroups v2 aus. |
## Weiterführende Ressourcen
Die folgenden Leitfäden, Kernel-Dokumentationen und internen Kursmodule vertiefen das Prozess- und Ressourcenmanagement:
| Ressource | Beschreibung |
|---|---|
| [systemd Resource Control Guide](https://systemd.io/RESOURCE_MANAGEMENT/){.badge-link-text} | Offizieller Leitfaden zur systemd cgroups v2-Ressourcensteuerung. |
| [Linux Kernel Procfs Documentation](https://www.kernel.org/doc/html/latest/filesystems/proc.html){.badge-link-text} | Dokumentation der virtuellen Kernel-Schnittstellen unter `/proc/[PID]`. |
| [Linux Performance Tools (Brendan Gregg)](https://www.brendangregg.com/linuxperf.html){.badge-link-text} | Umfassende Methodik und Werkzeugübersicht zur Linux-Performance-Analyse. |
| [Linux Administration #2: Benutzerverwaltung](/de/linux-administration/linux-administration-fortgeschrittene-benutzerverwaltung){.badge-link-text} | Das vorherige Modul: PAM-Stacks, Quotas, POSIX-ACLs & Sudoers. |
| [Linux Administration #4: Netzwerk](/de/linux-administration/linux-administration-netzwerkkonfiguration-und-verwaltung){.badge-link-text} | Das nachfolgende Modul: IP-Routing, Netplan, nmcli, DNS & UFW. |
| [Befehlszeilenprozessor in Linux](/de/linux-neulinge/befehlszeilenprozessor-in-linux){.badge-link-text} | Fundamentales Wissen zu Shells, I/O-Streams und Pipes. |
## Fazit
Die Beherrschung des Prozess- und Ressourcenmanagements ist eine Kernkompetenz jedes Linux-Systemadministrators. Durch das Verständnis des Prozesslebenszyklus, den kontrollierten Einsatz von POSIX-Signalen, gezieltes CPU-Scheduling mit Nice-Werten und moderne Ressourcenlimits über systemd und cgroups v2 sorgst du dafür, dass deine Linux-Server auch unter extremen Lastspitzen stabil, reaktionsschnell und vorhersehbar performen.
💡 **Praxis-Tipp:** Nutze für ressourcenintensive periodische Hintergrundjobs (wie z. B. nächtliche Datenbank-Dumps oder Archivierungen) immer die Kombination aus `nice -n 19` und `ionice -c 3`. Dadurch läuft der Job mit niedrigster CPU- und Festplatten-Priorität und beeinträchtigt den regulären Produktivbetrieb zu keinem Zeitpunkt.
Im nächsten Modul unseres Kurses verbinden wir unsere Server mit der Außenwelt:
👉 **Weiter geht es mit:** [Linux Administration #4: Netzwerkkonfiguration und Verwaltung](/de/linux-administration/linux-administration-netzwerkkonfiguration-und-verwaltung){.badge-link-text}
👉 **Zur Kursübersicht:** [Alle Linux-Administrations-Artikel & Module](/de/category/linux-administration){.badge-link-text}