Verwendung von GNU Screen zum Anhängen und Trennen von Konsolensitzungen

GNU Screen ist ein Terminal-Multiplexer, mit dem Sie mehrere unabhängige Shell-Sitzungen über eine einzige Terminalverbindung erstellen, verwalten und dauerhaft fortsetzen können. Wenn Sie eine Screen-Sitzung trennen, wird jeder darin laufende Prozess im Hintergrund weiter ausgeführt – er übersteht SSH-Trennungen, Netzwerkausfälle und Terminal-Schließungen – bis Sie die Sitzung explizit wieder verbinden oder beenden.

Diese Fähigkeit ist für Systemadministratoren, die Remote-Server über SSH verwalten, unverzichtbar. Ob Sie einen großen Quellcode kompilieren, eine Datenbankmigration durchführen, Logs überwachen oder einen mehrstündigen Backup-Job ausführen – Screen stellt sicher, dass die Arbeit unabhängig davon fortgesetzt wird, was mit Ihrer Client-Verbindung passiert.

Warum GNU Screen in moderner Infrastruktur noch immer relevant ist

Tools wie `tmux` haben an Popularität gewonnen, aber GNU Screen ist in Enterprise-Linux-Umgebungen, eingebetteten Systemen und Legacy-Infrastrukturen nach wie vor allgegenwärtig. Es wird auf den meisten Server-Distributionen als Standard- oder Beinahe-Standard-Paket mitgeliefert, erfordert keinerlei Konfiguration, um sofort nützlich zu sein, und sein Sitzungs-Persistenzmodell ist absolut zuverlässig. Auf einem VPS oder dedizierten Server, wo Betriebszeit und ununterbrochene Aufgabenausführung entscheidend sind, ist Screen oft der schnellste Weg zu einer zuverlässigen persistenten Sitzung.

Wesentliche betriebliche Vorteile:

• Sitzungspersistenz bei Verbindungsunterbrechungen — Prozesse überstehen SSH-Timeouts und Netzwerkunterbrechungen
• Multi-Window-Multiplexing — parallele Aufgaben innerhalb einer einzigen SSH-Verbindung ausführen
• Geringer Ressourcenverbrauch — vernachlässigbarer CPU- und Speicherbedarf im Vergleich zu GUI-basierten Alternativen
• Skriptfähiges Sitzungsmanagement — Sitzungserstellung und Befehlsinjektion über Shell-Skripte automatisieren
• Breite Kompatibilität — auf nahezu jedem POSIX-konformen System verfügbar

GNU Screen vs. tmux: Den richtigen Multiplexer wählen

Beide Tools lösen dasselbe Kernproblem, unterscheiden sich jedoch wesentlich in Architektur, Konfigurationstiefe und Scripting-Ergonomie.

Für einfache Sitzungspersistenz auf einem Remote-Server – der häufigste Sysadmin-Anwendungsfall – ist Screens Einfachheit ein Vorteil, keine Einschränkung.

GNU Screen installieren

Überprüfen Sie zunächst, ob Screen bereits vorhanden ist:

“`bash

screen –version

“`

Falls es nicht installiert ist, verwenden Sie den entsprechenden Paketmanager für Ihre Distribution.

Debian / Ubuntu:

“`bash

sudo apt-get update && sudo apt-get install screen

“`

CentOS / RHEL 7 und früher:

“`bash

sudo yum install screen

“`

CentOS Stream / RHEL 8+ / Fedora:

“`bash

sudo dnf install screen

“`

Arch Linux:

“`bash

sudo pacman -S screen

“`

macOS (über Homebrew):

“`bash

brew install screen

“`

Überprüfung:

“`bash

screen –version

Output example: Screen version 4.09.00 (GNU) 30-Jan-22

“`

Eine Screen-Sitzung starten

Einfacher Sitzungsstart

“`bash

screen

“`

Dies öffnet eine neue Screen-Sitzung mit einer Standard-Shell-Eingabeaufforderung. Der Sitzung wird automatisch eine numerische PID-basierte Kennung zugewiesen.

Benannte Sitzungen (dringend empfohlen)

Benennen Sie Ihre Sitzungen in Produktionsumgebungen immer. Benannte Sitzungen sind wesentlich einfacher zu identifizieren und wieder zu verbinden, wenn mehrere gleichzeitige Jobs laufen:

“`bash

screen -S session_name

“`

Praktische Beispiele:

“`bash

screen -S db_migration

screen -S log_monitor

screen -S build_job

“`

Die Benennung ist besonders wertvoll bei der Verwaltung mehrerer Workloads auf einem dedizierten Server, auf dem mehrere Administratoren gleichzeitig arbeiten können.

Eine Sitzung mit einem Befehl starten

Sie können Screen starten und sofort einen Befehl darin ausführen:

“`bash

screen -S backup_job bash -c 'rsync -avz /data/ /backup/ && echo "Done"'

“`

Die Sitzung bleibt auch nach Abschluss des Befehls bestehen, sodass Sie sich wieder verbinden und die Ausgabe prüfen können.

Von einer Screen-Sitzung trennen

Das Trennen ist der zentrale Workflow, der Screen wertvoll macht. Es unterbricht Ihre Ansicht der Sitzung, während alles darin weiterläuft.

Tastenkombination:

“`

Ctrl + A, then D

“`

• `Ctrl + A` — das Screen-Befehlspräfix (alle Screen-Befehle beginnen damit)
• `D` — trennen

Nach dem Trennen kehrt Ihr Terminal zur ursprünglichen Shell-Eingabeaufforderung zurück. Die Screen-Sitzung und alle darin enthaltenen Prozesse laufen weiterhin im Hintergrund. Sie sehen eine Bestätigungsmeldung:

“`

[detached from 12345.db_migration]

“`

Wichtiger Fallstrick: Verwechseln Sie das Trennen (`Ctrl+A, D`) nicht mit dem Schließen eines Fensters (`Ctrl+A, K` beendet das aktuelle Fenster). Das Schließen aller Fenster beendet die Sitzung vollständig.

Aktive Screen-Sitzungen auflisten

“`bash

screen -ls

“`

Beispielausgabe:

“`

There are screens on:

18423.db_migration (Detached)

18891.log_monitor (Attached)

19204.build_job (Detached)

3 Sockets in /var/run/screen/S-root.

“`

Die Statusindikatoren sind aussagekräftig:

• Detached — kein Terminal ist derzeit verbunden; die Sitzung läuft im Hintergrund
• Attached — ein Terminal ist aktiv mit dieser Sitzung verbunden
• Dead — der Sitzungsprozess ist beendet, aber die Socket-Datei wurde nicht bereinigt (verwenden Sie `screen -wipe`, um tote Sitzungen zu entfernen)

Wieder mit einer Screen-Sitzung verbinden

Verbindung über Sitzungsname herstellen

“`bash

screen -r db_migration

“`

Verbindung über Sitzungs-PID herstellen

“`bash

screen -r 18423

“`

Verbindung herstellen, wenn nur eine Sitzung vorhanden ist

“`bash

screen -r

“`

Screen stellt die Verbindung automatisch wieder her, wenn nur eine getrennte Sitzung vorhanden ist.

Eine bereits verbundene Sitzung zwangsweise wieder verbinden

Dies ist das Szenario, das viele Administratoren überrascht. Wenn Ihre SSH-Verbindung ungünstig unterbrochen wurde, kann die Sitzung noch als Attached erscheinen, weil das vorherige Terminal nicht sauber getrennt wurde. Ein normaler `screen -r`-Versuch schlägt fehl mit:

“`

There is a screen on: 18891.log_monitor (Attached)

There is no screen to be resumed.

“`

Die Lösung besteht darin, das alte Terminal zwangsweise zu trennen und sofort wieder zu verbinden:

“`bash

screen -d -r log_monitor

“`

• `-d` — die Sitzung von dem Terminal, das sie derzeit hält, remote trennen
• `-r` — mit dem aktuellen Terminal wieder verbinden

Alternative mit expliziter Sitzungs-ID:

“`bash

screen -d -r 18891

“`

Dies ist einer der betrieblich wichtigsten Screen-Befehle und wird häufig nach unerwarteten Verbindungsabbrüchen von einem VPS benötigt.

Multi-Window-Verwaltung innerhalb einer Sitzung

Eine der leistungsstärksten Funktionen von Screen ist die Möglichkeit, mehrere unabhängige Fenster (virtuelle Terminals) innerhalb einer einzigen Sitzung auszuführen. Jedes Fenster verfügt über eine eigene Shell, einen eigenen Prozessbaum und einen eigenen Scrollback-Puffer.

Ein neues Fenster erstellen

“`

Ctrl + A, then C

“`

Zwischen Fenstern navigieren

Ein Fenster benennen

“`

Ctrl + A, then A

“`

Sie werden aufgefordert, einen Namen für das aktuelle Fenster einzugeben. Benannte Fenster erscheinen in der Fensterliste und der Statusleiste, was die Navigation erheblich erleichtert, wenn fünf oder mehr parallele Aufgaben laufen.

Ein Fenster schließen

Geben Sie `exit` in der Shell ein oder drücken Sie `Ctrl + D`. Wenn das letzte Fenster einer Sitzung geschlossen wird, wird die Screen-Sitzung selbst beendet.

Um das aktuelle Fenster zwangsweise zu beenden, ohne die Shell zu verlassen:

“`

Ctrl + A, then K

“`

Den Screen aufteilen (Regionen)

GNU Screen unterstützt grundlegende Terminal-Aufteilung, die weniger flexibel als tmux ist, aber für die Überwachung nebeneinander funktional ist.

Horizontal aufteilen (oben/unten):

“`

Ctrl + A, then S

“`

Vertikal aufteilen (links/rechts):

“`

Ctrl + A, then |

“`

Fokus zur nächsten Region verschieben:

“`

Ctrl + A, then Tab

“`

Aktuelle Region entfernen (ohne das Fenster zu schließen):

“`

Ctrl + A, then X

“`

Alle Regionen außer der aktuellen entfernen:

“`

Ctrl + A, then Q

“`

Nach der Aufteilung ist jede Region zunächst leer. Navigieren Sie mit `Tab` zu einer Region und öffnen Sie dann ein Fenster darin mit `Ctrl + A, N` oder `Ctrl + A, "`.

Eine Screen-Sitzung zwischen mehreren Benutzern teilen

Screen unterstützt die Freigabe von Sitzungen für mehrere Benutzer, was für kollaboratives Debugging oder gemeinsame Administration nützlich ist. Dies erfordert, dass Screen mit setuid-Berechtigungen installiert ist.

Multi-Benutzer-Modus innerhalb einer Sitzung aktivieren:

“`

Ctrl + A, then :multiuser on

“`

Einem anderen Benutzer Zugriff gewähren:

“`

Ctrl + A, then :acladd username

“`

Der andere Benutzer kann sich dann mit Ihrer Sitzung verbinden:

“`bash

screen -x your_username/session_name

“`

Sicherheitshinweis: Screen-Sitzungen mit mehreren Benutzern erfordern sorgfältige Zugriffskontrolle. Gewähren Sie `acladd`-Berechtigungen nur vertrauenswürdigen Konten. In Shared-Hosting-Umgebungen ist diese Funktion in der Regel eingeschränkt.

Befehle an eine getrennte Sitzung senden

Eine unterschätzte Fähigkeit von Screen ist die Möglichkeit, Befehle in eine laufende Sitzung einzuspeisen, ohne sich wieder zu verbinden:

“`bash

screen -S db_migration -X stuff "tail -f /var/log/app.logn"

“`

Der `-X stuff`-Befehl sendet Tastenanschläge an die Sitzung, als wären sie eingetippt worden. Das `n` simuliert das Drücken der Eingabetaste. Dies ist äußerst nützlich für Automatisierungsskripte, die mit einer laufenden Screen-Sitzung interagieren müssen.

Screen mit .screenrc konfigurieren

Die `.screenrc`-Datei in Ihrem Home-Verzeichnis steuert das Standardverhalten von Screen. Eine minimale, aber praktische Konfiguration:

“`bash

~/.screenrc

Disable the startup message

startup_message off

Set scrollback buffer to 10,000 lines

defscrollback 10000

Enable UTF-8

defutf8 on

Show a status bar at the bottom

hardstatus alwayslastline

hardstatus string '%{= kG}[ %{G}%H %{g}][%= %{= kw}%?%-Lw%?%{r}(%{W}%n*%f%t%?(%u)%?%{r})%{w}%?%+Lw%?%?%= %{g}][%{B} %m-%d %{W}%c %{g}]'

Set default shell

shell -$SHELL

“`

Die `defscrollback 10000`-Einstellung ist besonders wichtig – der Standard-Scrollback-Puffer beträgt nur 100 Zeilen, was für die Überwachung lang laufender Prozesse unzureichend ist.

Vollständige Screen-Befehlsreferenz

Screen-Sitzungsausgabe protokollieren

Screen kann alles, was in einem Fenster ausgegeben wird, in eine Datei protokollieren – unverzichtbar für die Überwachung lang laufender Jobs:

Protokollierung für das aktuelle Fenster umschalten:

“`

Ctrl + A, then H

“`

Dadurch wird eine Datei namens `screenlog.N` (wobei N die Fensternummer ist) im aktuellen Verzeichnis erstellt. Sie können die Protokollierung auch über die Befehlszeile beim Starten einer Sitzung aktivieren:

“`bash

screen -L -S monitored_job

“`

Oder geben Sie eine benutzerdefinierte Protokolldatei in `.screenrc` an:

“`bash

logfile /var/log/screen/session_%t_%Y%m%d.log

“`

Praktische Anwendungsfälle auf Remote-Servern

Lang laufende Datenbankmigrationen: Starten Sie eine Migration in einer benannten Screen-Sitzung, trennen Sie die Verbindung und überwachen Sie den Fortschritt durch regelmäßiges Wiederverbinden. Wenn die SSH-Verbindung abbricht, wird die Migration ohne Unterbrechung fortgesetzt.

Kontinuierliche Log-Überwachung: Führen Sie `tail -f` oder `multitail` in einem Screen-Fenster aus. Trennen Sie die Verbindung und verbinden Sie sich wieder, wann immer Sie den aktuellen Status prüfen möchten.

Kompilierungsjobs: Große C++- oder Kernel-Kompilierungen können Stunden dauern. Screen stellt sicher, dass der Build abgeschlossen wird, auch wenn Ihr Laptop die Verbindung verliert.

Interaktive Prozesse, die nicht in den Hintergrund verschoben werden können: Einige Tools – Datenbank-CLIs, interaktive Python-Sitzungen, textbasierte Installer – können nicht einfach mit `&` in den Hintergrund geschickt werden. Screen kapselt sie sauber in einer persistenten Sitzung.

Koordination mehrerer Administratoren: Mit `screen -x` können zwei Administratoren dieselbe Sitzung gleichzeitig beobachten, was bei der Incident-Response auf einem dedizierten Server nützlich ist.

Wenn Sie Web-Infrastruktur zusammen mit persistenten Sitzungen verwalten, bietet die Kombination von Screen mit einem gut konfigurierten VPS mit cPanel sowohl eine grafische Verwaltungsoberfläche als auch vollständige Terminal-Multiplexing-Funktionalität. Für Teams, die SSL-Erneuerungen und Zertifikatsbereitstellungen über die Befehlszeile verwalten, können SSL-Zertifikate in Kombination mit Screen-basierten Automatisierungsskripten den Prozess vollständig automatisieren.

Häufige Fallstricke und wie man sie vermeidet

Ansammlung verwaister Sitzungen: Administratoren vergessen häufig, Sitzungen nach Abschluss von Jobs zu beenden. Führen Sie `screen -ls` regelmäßig aus und verwenden Sie `screen -wipe`, um tote Sockets zu bereinigen. Beenden Sie inaktive Sitzungen mit `screen -S session_name -X quit`.

Scrollback-Puffer zu klein: Der Standard-Puffer von 100 Zeilen bedeutet, dass Sie den Ausgabeverlauf schnell verlieren. Setzen Sie immer `defscrollback 10000` oder höher in `.screenrc`.

Verschachtelte Screen-Sitzungen: Wenn Sie von innerhalb einer Screen-Sitzung per SSH verbinden und eine weitere Screen-Sitzung auf dem Remote-Host starten, werden `Ctrl + A`-Befehle von der äußeren Sitzung abgefangen. Verwenden Sie `Ctrl + A, A`, um ein wörtliches `Ctrl + A` an die innere Sitzung zu senden, oder nutzen Sie `Ctrl + A, :sessionname` zur Unterscheidung.

Sitzung bleibt nach Verbindungsabbruch als Attached: Eine unterbrochene SSH-Verbindung kann eine Sitzung im Attached-Zustand hinterlassen. Verwenden Sie nach einem unerwarteten Verbindungsabbruch immer `screen -d -r` statt des einfachen `screen -r`.

Locale- und Kodierungsprobleme: Wenn Sie unleserliche Zeichen sehen, stellen Sie sicher, dass Ihr Terminal und Screen beide UTF-8 verwenden. Fügen Sie `defutf8 on` zu `.screenrc` hinzu und überprüfen Sie, ob Ihre `LANG`-Umgebungsvariable auf eine UTF-8-Locale gesetzt ist (z. B. `en_US.UTF-8`).

Entscheidungsmatrix: Wann Screen verwenden

Technische Checkliste der wichtigsten Erkenntnisse

• Benennen Sie Sitzungen immer mit `screen -S descriptive_name` — unbenannte Sitzungen werden im großen Maßstab unübersichtlich
• Setzen Sie `defscrollback 10000` in `.screenrc`, bevor Sie es benötigen, nicht nachdem Sie die Ausgabe verloren haben
• Verwenden Sie `screen -d -r` als Standard-Wiederverbindungsbefehl, um sowohl Attached- als auch Detached-Zustände ohne Nachdenken zu behandeln
• Aktivieren Sie die Sitzungsprotokollierung mit `screen -L` für jeden Job, dessen Ausgabe Sie möglicherweise später prüfen müssen
• Führen Sie `screen -wipe` regelmäßig aus, um tote Sitzungs-Sockets zu entfernen und die `screen -ls`-Ausgabe lesbar zu halten
• Injizieren Sie Befehle in getrennte Sitzungen mit `screen -X stuff`, um Interaktionen ohne Wiederverbinden zu automatisieren
• Konfigurieren Sie in Multi-Administrator-Umgebungen `.screenrc` mit `multiuser on` und expliziten ACLs, anstatt sich auf gemeinsamen Root-Zugriff zu verlassen
• Testen Sie Ihre `.screenrc`-Konfiguration auf einem Nicht-Produktionssystem, bevor Sie sie in kritischer Infrastruktur einsetzen

Häufig gestellte Fragen

Was passiert mit einer Screen-Sitzung, wenn der Server neu startet?

Alle Screen-Sitzungen gehen beim Neustart verloren. Screen-Sitzungen sind Prozesse, die im Arbeitsspeicher laufen – sie überstehen keinen Systemneustart. Für wirklich persistente Dienste verwenden Sie `systemd`-Unit-Dateien oder Init-Skripte. Screen dient der interaktiven Sitzungspersistenz bei Verbindungsunterbrechungen, nicht bei Neustarts.

Kann ich Screen auf einem Shared-Hosting-Konto verwenden?

Standard-Shared-Web-Hosting-Umgebungen schränken den SSH-Zugriff in der Regel ein und haben möglicherweise Screen nicht installiert oder zugänglich. Screen ist am effektivsten in VPS- oder dedizierten Server-Umgebungen, wo Sie vollständigen Shell-Zugriff und Root- oder sudo-Berechtigungen haben.

Was ist der Unterschied zwischen `screen -r` und `screen -x`?

`screen -r` stellt die Verbindung zu einer getrennten Sitzung wieder her und gewährt Ihnen exklusiven Zugriff. `screen -x` verbindet sich mit einer Sitzung, die bereits verbunden ist, und erstellt eine geteilte Ansicht, bei der mehrere Terminals dieselbe Sitzung gleichzeitig sehen – nützlich für kollaborative Fehlerbehebung.

Wie scrolle ich in einer Screen-Sitzung nach oben, um vorherige Ausgaben zu sehen?

Rufen Sie den Kopier-/Scrollback-Modus mit `Ctrl + A, [` auf. Verwenden Sie die Pfeiltasten oder Bild-auf/Bild-ab zur Navigation. Drücken Sie `Escape` oder `Q`, um den Kopiermodus zu verlassen. Stellen Sie sicher, dass Ihr Scrollback-Puffer groß genug ist, indem Sie `defscrollback` in `.screenrc` setzen.

Wird GNU Screen noch aktiv gepflegt?

Ja. GNU Screen wird aktiv unter dem GNU-Projekt gepflegt. Version 4.9.x wurde 2022 veröffentlicht. Obwohl es nicht die schnelle Funktionsentwicklung von tmux erhält, bekommt es Sicherheits-Patches und Fehlerbehebungen, was es für den Produktionseinsatz auf lang laufender Server-Infrastruktur zuverlässig macht.