Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: tmux II – Projekte, Popups, Persistenz

Ziel: Projekt-Sessions per Skript in Sekunden aufbauen, mit Layouts, synchronen Panes und Popups arbeiten, Sessions über Neustarts retten und tmux sauber über SSH nutzen. · Dauer: ca. 90 min · Voraussetzung: Tag 8

Briefing

  • Senior-Workflow: eine Session pro Projekt, immer gleich aufgebaut. Ein Befehl (tp) springt hin oder baut sie.
  • Layouts ordnen Panes auf Knopfdruck, synchronize-panes tippt in alle Panes gleichzeitig.
  • Popups (display-popup) legen Werkzeuge wie lazygit oder einen Projekt-Picker kurz über alles.
  • tmux-resurrect speichert Sessions auf Platte, tmux-continuum macht das automatisch.
  • Auf Servern läuft tmux dort, nicht lokal: ssh -t host tmux new -A -s main.
tp ~/term-lab/projekt
 └─ Session "projekt"
     ├─ 1:edit   $EDITOR .
     ├─ 2:run    ┌───────────────┬─────────┐   main-vertical
     │           │ Shell         │ Shell   │
     │           └───────────────┴─────────┘
     └─ 3:git    git status -sb

Alle Erweiterungen hängst du an ~/term-lab/tmux.conf aus Tag 8 an. Die fertige Datei liegt unter $BUCH/tmux/tmux.conf. Starte die Lab-Session wie gewohnt aus der Lab-Shell:

cd ~/term-lab/projekt
tl new -A -s lab

Drill 1: Layouts

Öffne ein neues Fenster (⌃a c) und teile es dreimal (⌃a |, ⌃a -, ⌃a -). Dann drücke mehrmals ⌃a Space: tmux schaltet durch die fünf Grundlayouts.

Taste Layout Wofür
⌃a ⌥1 even-horizontal Panes nebeneinander, gleich breit
⌃a ⌥2 even-vertical Panes untereinander
⌃a ⌥3 main-horizontal großes Pane oben, Rest unten
⌃a ⌥4 main-vertical großes Pane links (Editor), Rest rechts
⌃a ⌥5 tiled Raster, z. B. für vier Server
⌃a Space nächstes Layout durchblättern

Die ⌥-Tasten brauchen Option als Meta (Tag 1). Bequemer: eine eigene Taste für das Raster und ein breiteres Hauptpane:

cat >> ~/term-lab/tmux.conf <<'EOF'

# ============================ Tag 9 ==========================================
# --- Layouts und synchronize-panes -------------------------------------------
set -g main-pane-width 60%
bind = select-layout tiled
EOF
tmux source-file ~/term-lab/tmux.conf
tmux select-layout main-vertical
tmux list-panes -F '#{pane_index} #{pane_width}x#{pane_height}'

Erwartet (Größen abhängig vom Terminal):

1 71x39
2 48x13
3 48x12
4 48x12

Ein Layout lässt sich auch speichern und später wiederherstellen:

L=$(tmux display -p '#{window_layout}')
tmux select-layout tiled
tmux select-layout "$L"

Prozentwerte für main-pane-width verstehen aktuelle tmux-Versionen. Sehr alte wollen Spalten (120).

Fortschritt speichern? Kostenlos registrieren

Drill 2: Projekt-Session per Skript

Jedes Projekt bekommt dieselbe Session: Editor, zwei Shells, Git. Das Skript tp legt sie an, falls sie fehlt, und springt sonst nur hin. Es liegt fertig im Code-Ordner:

cp $BUCH/tmux/tp ~/term-lab/bin/tp && chmod +x ~/term-lab/bin/tp
shellcheck ~/term-lab/bin/tp && echo "✔ shellcheck"
sed -n '/^if ! tm has-session/,/^fi/p' ~/term-lab/bin/tp

Erwartet:

✔ shellcheck
if ! tm has-session -t "=$name" 2>/dev/null; then
  [[ -n $dir ]] || { echo "tp: '$target' ist weder Session noch Ordner" >&2; exit 1; }
  tm new-session -d -s "$name" -c "$dir" -n edit
  tm send-keys -t "=$name:edit" "${EDITOR:-vi} ." Enter
  tm new-window -d -t "=$name:" -n run -c "$dir"
  tm split-window -d -h -t "=$name:run" -c "$dir"
  tm select-layout -t "=$name:run" main-vertical
  tm new-window -d -t "=$name:" -n git -c "$dir"
  tm send-keys -t "=$name:git" "git status -sb" Enter
fi

Die Bausteine:

  • tm ist tmux -L lab -f ~/term-lab/tmux.conf. Das Skript trifft also immer den Lab-Server.
  • -d legt Sessions und Fenster an, ohne hinzuspringen. Erst am Ende wird gewechselt.
  • =projekt heißt „exakt dieser Name”. Ohne = passt tmux auch Präfixe wie proj. In der zsh musst du "=projekt" quoten, sonst sucht die Shell ein Programm projekt (Tag 5, =ls).
  • In tmux ($TMUX gesetzt) wechselt switch-client, außerhalb hängt sich attach an.

Ausprobieren:

tp ~/term-lab/projekt
tmux list-windows -F '#{window_index}:#{window_name} panes=#{window_panes}'
tmux ls

Erwartet (gekürzt):

1:edit panes=1
2:run panes=2
3:git panes=1
lab: 5 windows (created Sat Oct 10 08:51:12 2026)
projekt: 3 windows (created Sat Oct 10 08:55:03 2026) (attached)

Ein zweites tp ~/term-lab/projekt baut nichts neu, es springt nur hin. ⌃a ( bringt dich zurück in die Session lab.

Fortschritt speichern? Kostenlos registrieren

Drill 3: synchronize-panes – ein Befehl, alle Panes

Klassiker im Betrieb: vier SSH-Sessions, derselbe Befehl überall. Im Lab simulierst du das mit drei lokalen Panes:

cat >> ~/term-lab/tmux.conf <<'EOF'
bind S setw synchronize-panes \; display "Sync: #{?synchronize-panes,an,aus}"
setw -g window-status-current-format \
  " #I:#W#{?window_zoomed_flag, [Z],}#{?synchronize-panes, [SYNC],} "
EOF
tmux source-file ~/term-lab/tmux.conf

Neues Fenster (⌃a c), ⌃a |, ⌃a -, dann ⌃a = für das Raster. Jetzt ⌃a S und tippe einmal:

clear; echo "pane $TMUX_PANE"

Erwartet (gekürzt):

pane %17                          │pane %18
[lab] projekt %                   │[lab] projekt %
──────────────────────────────────┴──────────────────────────────────
pane %19
[lab] projekt %
 lab   1:zsh   2:logs   3:zsh   4:zsh   5:zsh [SYNC]              08:55

Alle drei Panes haben den Befehl bekommen, jedes mit seiner eigenen Pane-ID. ⌃a S schaltet wieder aus (Sync: aus).

Achtung: Vergiss nie, Sync wieder auszuschalten. Das [SYNC] in der Statuszeile ist dafür da. Ein reboot in einem synchronisierten Fenster trifft jeden Server darin.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Popups – Werkzeuge über allem

display-popup öffnet ein schwebendes Fenster. -E schließt es, sobald der Befehl endet. Drei Popups, die du täglich brauchst:

cat >> ~/term-lab/tmux.conf <<'EOF'

# --- Popups --------------------------------------------------------------------
bind f display-popup -E -w 70% -h 60% "$LAB/bin/tp"
bind g display-popup -E -w 90% -h 90% -d "#{pane_current_path}" lazygit
bind t display-popup -E -w 80% -h 60% -d "#{pane_current_path}"
EOF
tmux source-file ~/term-lab/tmux.conf
tmux list-keys -T prefix f

Erwartet (gekürzt):

bind-key  -T prefix f display-popup -E -h "60%" -w "70%" /Users/du/term-lab/bin/tp

$LAB setzt tmux beim Laden ein. Den vollen Pfad brauchst du, weil das Popup keine interaktive Shell mit deinem PATH startet.

⌃a t öffnet eine Wegwerf-Shell im aktuellen Pfad. Tippe pwd, dann exit:

           ┌─────────────────────────────────────────────────────────┐
           │[lab] projekt % pwd                                      │
           │/Users/du/term-lab/projekt                               │
           │[lab] projekt %                                          │

⌃a g legt lazygit über das ganze Fenster, q schließt es. Das ersetzt die Fenster-Lösung aus der Challenge von Tag 8. Lösche dort die Zeile bind g new-window …, sonst gewinnt die Bindung, die später in der Datei steht.

⌃a f ist ein Projekt-Picker im Stil von „sesh”: tp ohne Argument listet laufende Sessions und alle Ordner aus deiner zoxide-Datenbank (Tag 6). Tippe projekt$:

┌──────────────────────────────────────────────────────────────────────┐
│projekt> projekt$                 ╭───────────────────────────────╮   │
│  1/5 ─────────────────────────── │ cmd                           │   │
│▌ /Users/du/term-lab/projekt      │ config                        │   │
│                                  │ deploy                        │   │

Enter wechselt in die Session projekt, legt sie notfalls an und das Popup schließt sich. Die Vorschau zeigt bei Ordnern den Inhalt, bei Sessions den Bildschirm des aktiven Panes.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Persistenz mit tmux-resurrect und tmux-continuum

Ein tmux-Server überlebt kein Abmelden und keinen Neustart. tmux-resurrect schreibt Sessions, Fenster, Pfade, Layouts und laufende Programme (nvim, tail, less …) in eine Datei. tmux-continuum speichert alle 15 Minuten und stellt beim Serverstart wieder her.

Normalerweise installiert der Plugin-Manager tpm die Plugins. tpm sucht @plugin-Zeilen aber nur in ~/.tmux.conf oder ~/.config/tmux/tmux.conf. Unsere Lab-Datei per -f sieht er nicht. Darum klonst du im Lab selbst und lädst die Plugins mit run:

mkdir -p ~/term-lab/tmux/plugins
for p in tmux-resurrect tmux-continuum; do
  git clone -q --depth 1 https://github.com/tmux-plugins/$p \
    ~/term-lab/tmux/plugins/$p
done
cat >> ~/term-lab/tmux.conf <<'EOF'

# --- Persistenz: tmux-resurrect + tmux-continuum (ohne tpm, siehe Tag 9) -------
set -g @resurrect-dir "$LAB/tmux/resurrect"
set -g @resurrect-capture-pane-contents 'on'
set -g @continuum-save-interval '15'
set -g @continuum-restore 'on'
if "test -d $LAB/tmux/plugins/tmux-resurrect" \
  "run '$LAB/tmux/plugins/tmux-resurrect/resurrect.tmux'"
if "test -d $LAB/tmux/plugins/tmux-continuum" \
  "run '$LAB/tmux/plugins/tmux-continuum/continuum.tmux'"
EOF
tmux source-file ~/term-lab/tmux.conf
tmux list-keys -T prefix | rg -o 'C-[rs] .*scripts/\S+'

Erwartet:

C-r     run-shell /Users/du/term-lab/tmux/plugins/tmux-resurrect/scripts/restore.sh
C-s     run-shell /Users/du/term-lab/tmux/plugins/tmux-resurrect/scripts/save.sh

@resurrect-dir ist Pflicht im Lab. Ohne die Zeile schreibt resurrect nach ~/.local/share/tmux/resurrect und mischt sich mit einem echten Setup.

Der Härtetest. ⌃a ⌃s speichert (unten erscheint kurz Saving...). Dann ⌃a d und in der Lab-Shell außerhalb von tmux den Server abschießen und neu starten:

tl kill-server
tl new -d -s tmp
sleep 5; tl ls
tl list-windows -t lab \
  -F '#{window_index}:#{window_name} #{pane_current_command}' | head -2

Erwartet (gekürzt):

lab: 7 windows (created Sat Oct 10 08:59:38 2026)
tmp: 1 windows (created Sat Oct 10 08:59:40 2026)
1:zsh zsh
2:logs tail

continuum hat die Session lab beim Start automatisch zurückgeholt, samt tail -f im Fenster logs. Von Hand: ⌃a ⌃r. Die Sicherungen liegen als Textdateien in ~/term-lab/tmux/resurrect/, last zeigt auf die neueste.

Achtung: continuum speichert automatisch nur, wenn genau ein tmux-Server läuft. Läuft neben dem Lab dein normales tmux, bleibt Auto-Save aus (manuelles ⌃a ⌃s geht immer). @continuum-boot startet tmux beim Login per launchd. Das lässt du im Lab weg.

Für deine echte ~/.tmux.conf (Tag 13) ist tpm der Standard. Das sieht so aus:

set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'
set -g @continuum-restore 'on'
run '~/.tmux/plugins/tpm/tpm'      # immer die letzte Zeile

Installation dort: git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm, dann in tmux ⌃a I (großes i).

Fortschritt speichern? Kostenlos registrieren

Drill 6: tmux über SSH und verschachtelt

Auf einem Server läuft tmux auf dem Server. Verbindung weg, Arbeit bleibt:

ssh -t jump01 'tmux new -A -s main'

-t erzwingt ein Terminal, new -A hängt sich an main an oder legt sie an. Dauerhaft geht das in ~/.ssh/config mit RequestTTY yes und RemoteCommand tmux new -A -s main (Tag 12).

Läuft das in deinem lokalen tmux, hast du tmux in tmux. Welches tmux bekommt deine Tasten? Das simulierst du lokal mit einem zweiten Server, der „Remote” spielt:

tmux -L lab-remote -f /dev/null new -s remote \; set -g prefix C-a \; \
  set -g status-style bg=colour24

Jetzt hast du zwei Statuszeilen: blau unten innen ([remote]), orange außen (lab).

  • ⌃a c geht an das äußere tmux. Es fängt den Prefix zuerst ab.
  • ⌃a ⌃a c geht an das innere: Das erste ⌃a schickt per send-prefix ein ⌃a durch.
  • Hat der Server den Standard-Prefix ⌃b, tippst du dort einfach ⌃b c.

Bequemer bei langen Remote-Sitzungen: F12 schaltet das äußere tmux stumm, alle Tasten gehen nach innen. Noch einmal F12 schaltet zurück.

cat >> ~/term-lab/tmux.conf <<'EOF'

# --- Verschachteltes tmux (SSH): F12 schaltet das äußere tmux stumm --------------
bind -T root F12 set prefix None \; set key-table off \; \
  set status-style "bg=colour238,fg=colour244" \; refresh-client -S
bind -T off F12 set -u prefix \; set -u key-table \; set -u status-style \; \
  refresh-client -S
EOF
tmux source-file ~/term-lab/tmux.conf

Im inneren tmux: F12, dann ⌃a c. Das neue Fenster entsteht innen, die äußere Statuszeile ist grau. F12 macht sie wieder orange. Aufräumen: im inneren tmux exit tippen, bis es weg ist, oder tmux -L lab-remote kill-server.

Fortschritt speichern? Kostenlos registrieren

Shortcut-Tabelle

Taste / Befehl Wirkung Merkhilfe
⌃a Space nächstes Layout Leertaste = weiterblättern
⌃a ⌥1 … ⌥5 Layout direkt wählen 4 = Editor links
⌃a = Raster (tiled) „=” heißt gleich groß
⌃a S synchronize-panes an/aus Sync
⌃a f Projekt-Picker (tp) im Popup find project
⌃a g lazygit im Popup git
⌃a t Wegwerf-Shell im Popup terminal
⌃a ⌃s / ⌃a ⌃r Sessions speichern / wiederherstellen save, restore
⌃a ⌃a Prefix an inneres tmux doppelt = durchreichen
F12 äußeres tmux stumm/laut F12 = ganz weit weg
tp <dir> Projekt-Session anlegen oder hinspringen tmux projekt
ssh -t host 'tmux new -A -s main' tmux auf dem Server Attach oder anlegen

Kontrollpunkt

In der Lab-Shell, die Session projekt aus Drill 2 läuft:

c() { eval "$2" >/dev/null 2>&1 && echo "✔ $1" || echo "✘ $1"; }
c "tp im PATH"        'whence tp && shellcheck $LAB/bin/tp'
c "Session projekt" 'tl has-session -t "=projekt"'
c "edit run git" 'tl list-windows -t "=projekt" -F "#W" | xargs | rg -q "^edit run git"'
c "Raster-Taste ="    'tl list-keys -T prefix = | rg -q tiled'
c "Sync-Taste S"      'tl list-keys -T prefix S | rg -q synchronize-panes'
c "Popups f, g, t"    '(( $(tl list-keys -T prefix | rg -c display-popup) >= 3 ))'
c "resurrect im Lab"  '[[ $(tl show -gv @resurrect-dir) == */term-lab/tmux/resurrect ]]'
c "Sicherung da"      '[[ -e ~/term-lab/tmux/resurrect/last ]]'
c "F12 für Nesting"   'tl list-keys -T root F12 | rg -q key-table'

Erwartet: neun Zeilen mit ✔.

Challenge

Erweitere tp: Hat ein Projekt einen Ordner deploy/k8s, bekommt die Session ein viertes Fenster k8s in diesem Ordner. Darin ist die Lab-kubeconfig aus Tag 7 gesetzt und der aktuelle Kontext wird angezeigt.

Hinweis: Der neue Block gehört in das if ! tm has-session …, direkt vor dessen fi. Teste mit tl kill-session -t projekt und neuem tp.

Lösung

Füge in ~/term-lab/bin/tp nach der Zeile tm send-keys -t "=$name:git" … ein:

  if [[ -d $dir/deploy/k8s ]]; then
    tm new-window -d -t "=$name:" -n k8s -c "$dir/deploy/k8s"
    tm send-keys -t "=$name:k8s" \
      "export KUBECONFIG=$LAB/kube/config; kubectl config current-context" Enter
  fi

Dann:

shellcheck ~/term-lab/bin/tp && echo "✔ shellcheck"
tl kill-session -t projekt
tp ~/term-lab/projekt
tmux list-windows -F '#{window_index}:#{window_name}'
tmux capture-pane -p -t projekt:k8s | rg -v '^$' | tail -2

Erwartet (Kontext je nach Stand aus Tag 7):

✔ shellcheck
1:edit
2:run
3:git
4:k8s
lab-dev
[lab] k8s %

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • synchronize-panes auf Produktionsservern nur mit Vier-Augen-Prinzip. Für echte Flotten gehört so etwas in Ansible, Salt oder ein Runbook-Werkzeug, nicht in getippte Befehle.
  • Gemeinsame Jump-Hosts: eigene Session pro Person (tmux new -A -s $USER), nie fremde Sessions anhängen. Pairing bewusst über einen geteilten Socket mit Gruppenrechten.
  • resurrect sichert Pfade, Befehle und mit capture-pane-contents auch Bildschirminhalte. Darin können Secrets stehen. Das Verzeichnis gehört nicht in Backups ohne Verschlüsselung und nie in Git.
  • Projekt-Skripte wie tp gehören ins Dotfiles-Repo (Tag 13). Wer mehr will, schaut sich sesh, tmuxinator oder smug an. Das Prinzip bleibt dasselbe.
  • Auf Servern ohne deine Konfig gilt ⌃b. Übe beide Prefixe, damit du im Ernstfall nicht nach der Taste suchst.