# SysAdmin Tools — Beispiele

> SysAdmin Tools in der Praxis: NAS mit gemischten Platten, RAID 6 gegen RAIDZ2, setgid-Projektordner, Servermigration, PHP-FPM-Sizing und Backup-Plan.

Source: https://www.jpkc.com/db/tools/sysadmin/examples/

Zurück zur Übersicht: [SysAdmin Tools](https://www.jpkc.com/db/tools/sysadmin/) · Tool live öffnen: [www.jpkc.com/tools/sysadmin/](https://www.jpkc.com/tools/sysadmin/)

Diese Seite spielt typische Admin-Aufgaben in SysAdmin Tools durch. Plattengrößen, Pfade, Preise und Lastwerte sind Beispiele — setz deine eigenen ein. Die Zahlen in den Ergebnissen sind das, was das Tool für genau diese Eingaben ausgibt; wo ein Wert vom Tagesdatum abhängt, steht das dabei. Was jedes Feld bedeutet, erklärt das [Manual](https://www.jpkc.com/db/tools/sysadmin/manual/).

## Beispiel 1: Ein NAS mit gemischten Platten planen

Ausgangslage: Im Schrank liegen zwei 4-TB- und zwei 8-TB-Platten (3,5-Zoll-HDDs). Du willst daraus ein NAS mit einer Platte Ausfallsicherheit bauen und möglichst viel Platz behalten.

1. Tab **RAID & Storage**, **Drive type** = `3.5" HDD (7,200 rpm)`.
2. In der ersten Plattenzeile **Count** `2`, **Size per drive** `4` TB, Preis z. B. `100`. Über **Add drives** eine zweite Zeile mit `2` × `8` TB, Preis `180`.
3. **Layout** = `RAID 5`.

**Ergebnis:** **Usable** 12 TB, **Unused** 8 TB — der Hinweis darunter erklärt, dass bei klassischem RAID jedes Mitglied nur mit der kleinsten Platte zählt, und verweist auf Btrfs, SHR oder Unraid. Die Tabelle **Drive usage** zeigt das Problem direkt: Von jeder 8-TB-Platte liegen 4 TB brach.

Jetzt lohnt der Blick nach unten in **Layout Comparison**. Mit denselben Platten und den Vorgabewerten für Rebuild und URE-Klasse stehen dort unter anderem:

| Layout | Usable | Tolerates | Rebuild risk |
|---|---|---|---|
| RAID 5 | 12 TB | 1 | ≈ 62 % |
| Btrfs raid1 | 12 TB | 1 | ≈ 27 % |
| Synology SHR-1 | 16 TB | 1 | ≈ 72 % |
| Unraid (1 parity) | 16 TB | 1 | ≈ 72 % |

**Interpretation:** SHR-1 und Unraid holen mit 16 TB den ganzen Überhang heraus — SHR, weil es die Platten in Schichten schneidet, Unraid, weil die größte Platte nur die Parität trägt. Btrfs raid1 bleibt bei 12 TB, nutzt aber ebenfalls jede Platte voll aus und muss beim Rebuild nur die zweite Kopie lesen; deshalb ist sein Rebuild-Risiko deutlich kleiner. Die hohen Prozentwerte bei SHR-1 und Unraid sind das URE-Risiko der Datenblattklasse 10^14 beim Lesen der übrigen Platten — eine Obergrenze, keine Prognose (mehr dazu in den [Tipps](https://www.jpkc.com/db/tools/sysadmin/tips/)). Mit **Use** übernimmst du ein Layout. Für SHR und Unraid erzeugt das Tool keinen Shell-Befehl, sondern nennt den Weg in der jeweiligen Weboberfläche.

## Beispiel 2: Sechs 8-TB-Platten — RAID 5, RAID 6 oder RAIDZ2?

Ausgangslage: ein Server mit sechs gleichen 8-TB-HDDs, die Vorgabe des Tabs. Die Frage ist, ob eine Parität reicht.

1. Tab **RAID & Storage** öffnen (oder **Reset**): 6 × 8 TB, Layout `RAID 6`.
2. Abschnitt **Rebuild & Risk** ansehen, dann das Layout auf `RAID 5` und danach auf `ZFS RAIDZ2` stellen.

**Ergebnis** mit den Vorgaben (150 MB/s Rebuild-Rate, URE 10^14, 1,5 % AFR, 50 % Füllgrad):

- **RAID 5:** 40 TB nutzbar, **URE risk** ≈ 96 % — der Rebuild liest 40 TB ohne jede Redundanz.
- **RAID 6:** 32 TB nutzbar (29,1 TiB), **Rebuild time** knapp 15 Stunden, **URE risk** „≈ 0“, weil nach einem Ausfall noch eine Parität übrig ist. Die kombinierte **Rebuild risk** liegt bei rund 0,01 %; die Kachel **After 2 failures** zeigt, was passiert, wenn erst die zweite Platte ausfällt: dann liegt das URE-Risiko bei rund 92 %.
- **RAIDZ2:** 31,86 TB nach Abzug des Slop Space, der Resilver kopiert bei 50 % Füllung nur die belegte Hälfte und dauert rund 7,4 Stunden.

Für das ZFS-Layout trägst du unter **Commands** die Pfade aus `ls -l /dev/disk/by-id/` ein. Ohne Eingabe sieht der Befehl so aus:

```bash title="zpool create (RAIDZ2, 6 Platten)"
# WARNING: this ERASES ALL DATA on the listed devices.
# Check every name first: lsblk -o NAME,SIZE,MODEL,SERIAL and ls -l /dev/disk/by-id/
# Use /dev/disk/by-id/ names: /dev/sdX can change between boots.

zpool create -o ashift=12 -O compression=lz4 tank \
  raidz2 /dev/disk/by-id/DISK-01 /dev/disk/by-id/DISK-02 /dev/disk/by-id/DISK-03 /dev/disk/by-id/DISK-04 /dev/disk/by-id/DISK-05 /dev/disk/by-id/DISK-06

zpool status tank
zfs list tank
```

**Interpretation:** Die Faustregel „RAID 5 ist bei großen Platten tot“ siehst du hier als Zahl — mit der Einschränkung, dass die URE-Klasse eine Datenblatt-Obergrenze ist. Der eigentliche Unterschied steckt in der Redundanz während des Rebuilds: RAID 6 und RAIDZ2 sind nach einem Ausfall noch geschützt. Ein Vorteil von RAIDZ2 gegenüber md-RAID 6 ist der kürzere Resilver bei halb vollem Pool. Bei sechs Platten hat RAIDZ2 übrigens kein Padding-Problem; mit sieben Platten im selben vdev meldet das Tool, dass bei 128K-Records nur 66,7 % statt nominal 71,4 % Daten gespeichert werden.

## Beispiel 3: Ein gemeinsames Projektverzeichnis mit setgid

Ausgangslage: Unter `/srv/projekt` soll ein Team gemeinsam arbeiten. Neue Dateien sollen automatisch der Gruppe des Verzeichnisses gehören und für die Gruppe beschreibbar sein.

1. Tab **Permissions**, Preset **2775** klicken — der Typ springt auf **Directory**, im Raster ist setgid gesetzt, **ls -l** zeigt `drwxrwsr-x`.
2. Unter **Commands** als **Path** `/srv/projekt` eintragen.
3. **Tree: directories** = `2775`, **Tree: files** = `664`.

**Ergebnis** „This mode, exactly“:

```bash
chmod 02775 /srv/projekt
chmod u=rwx,g=rwxs,o=rx,u-s /srv/projekt
install -d -m 02775 /srv/projekt
stat -c '%a %A %n' /srv/projekt
```

und „Recursive (whole tree)“:

```bash
find /srv/projekt -type d -exec chmod 2775 {} +
find /srv/projekt -type f -exec chmod 0664 {} +
```

Der Hinweis darunter bestätigt, dass setgid auf den Verzeichnissen neue Dateien und Unterverzeichnisse die Gruppe erben lässt.

**Interpretation:** Die fünfstellige Form `02775` ist kein Tippfehler. GNU `chmod` behält setuid und setgid auf Verzeichnissen bei, solange der Modus sie nicht ausdrücklich nennt — fünf Ziffern bzw. `,u-s` sorgen dafür, dass am Ende exakt `2775` steht, auch wenn vorher ein setuid-Bit gesetzt war. Die `find`-Befehle bleiben bewusst vierstellig, damit ein gewolltes setgid nirgends verloren geht. Damit neue Dateien wirklich gruppenbeschreibbar entstehen, gehört noch die passende umask dazu: Im Abschnitt **umask** zeigt `002`, dass neue Dateien dann mit `664` und neue Verzeichnisse mit `775` angelegt werden.

## Beispiel 4: Eine Servermigration über 1 Gbit/s durchrechnen

Ausgangslage: 1 TB Daten sollen vom alten in ein neues Rechenzentrum, beide mit 1 Gbit/s angebunden, die Round-Trip-Zeit liegt bei 30 ms.

1. Tab **Transfer**, **Calculate** = `Time`, **Amount** `1` TB, **Line rate** `1` Gbit/s. **Protocol Overhead** auf `TCP over Ethernet`, MTU 1500, IPv4, Timestamps an.
2. Im Abschnitt **Bandwidth-Delay Product & TCP Window** die Rate auf 1 Gbit/s und den Knopf **Europe 30 ms** wählen.

**Ergebnis:** Die Übertragung dauert rund **2 h 21 min**, ohne Overhead wären es 2 h 13 min — mit IPv4, MTU 1500 und Timestamps kommen 94,15 % der Leitungsrate als Daten an. Das **Bandwidth-delay product** liegt bei 3,75 MB, als Puffer schlägt das Tool 8 MiB vor:

```ini title="/etc/sysctl.d/90-tcp-buffers.conf"
# /etc/sysctl.d/90-tcp-buffers.conf — buffer = 2 × BDP (3750000 bytes) → 8388608
# Raises maximums only (third value); autotuning stays on.
# Check first: keep any maximum that is already larger.
# tcp_rmem: never below 32 MiB, the default since Linux 6.16
net.ipv4.tcp_rmem = 4096 131072 33554432
net.ipv4.tcp_wmem = 4096 16384 8388608
# Only for programs that set SO_RCVBUF/SO_SNDBUF themselves (e.g. iperf3 -w):
net.core.rmem_max = 33554432
net.core.wmem_max = 8388608
```

**Interpretation:** Bei 30 ms reicht ein TCP-Fenster von 4 MiB noch für die volle Leitung (die Kachel **Window limit** liegt über 1 Gbit/s). Liegt das Ziel auf der anderen Seite des Atlantiks (**Transatlantic 90 ms**), drückt dasselbe Fenster einen einzelnen Stream auf rund 373 Mbit/s, und der Puffervorschlag steigt auf 22 MiB. Dann helfen größere Puffer oder mehrere parallele Streams. Bevor du den Schnipsel einspielst, prüfst du mit dem Befehl aus „Apply, check & measure“ die aktuellen Werte — der Schnipsel hebt nur an, aber ein bereits größerer Wert auf deinem System sollte bleiben. Für die echte Messung liefert derselbe Block `iperf3 -c <host> -t 30`.

## Beispiel 5: PHP-FPM und OPcache für einen 8-GiB-Server

Ausgangslage: ein VPS mit 8 GiB RAM und 4 Threads, nginx mit PHP 8.3 unter Debian, die Datenbank läuft auf einem eigenen Server. Die Last schwankt über den Tag.

1. Tab **Server Tuning**: **RAM** `8` GiB, **CPU threads** `4`, **Reserve** `1` GiB, **Web stack** `nginx + PHP-FPM`, **Paths for** `Debian / Ubuntu`, **PHP version** `PHP 8.3`. Den Schalter „The database runs on this server“ **aus**.
2. Im Abschnitt **PHP-FPM Pool** das gemessene **Ø RSS** eintragen — hier 64 MiB (den Messbefehl liefert der Block „Measure the average RSS of the workers“). **Traffic** = „Varies, with daily peaks“, **Process manager** auf der Empfehlung lassen.
3. Unter **OPcache** die Zahl der PHP-Dateien eintragen, die der Befehl aus „Count the PHP files“ meldet — im Beispiel 10.000.

**Ergebnis:** Der Speicherplan lässt 7 GiB für PHP-FPM übrig. Daraus werden `pm.max_children = 112`, das Tool empfiehlt `dynamic` und liefert:

```ini title="/etc/php/8.3/fpm/pool.d/www.conf"
; /etc/php/8.3/fpm/pool.d/www.conf
[www]
pm = dynamic
pm.max_children = 112
pm.start_servers = 22
pm.min_spare_servers = 11
pm.max_spare_servers = 34
pm.max_requests = 500
; see "server reached pm.max_children" in the FPM log and the status page
pm.status_path = /fpm-status
```

Die Kachel **Worst case** ist als Warnung markiert: Erreichten alle 112 Worker gleichzeitig ihr `memory_limit` von 256M, bräuchten sie 28 GiB. Für OPcache ergeben 10.000 Dateien plus 20 % Reserve `opcache.max_accelerated_files = 12000` (PHP legt dafür 16.229 Hash-Slots an), dazu 448 MB `memory_consumption` und 32 MB Interned-Strings-Puffer.

**Interpretation:** Die 112 Worker sind die Obergrenze, die der Speicher hergibt — mit nur 4 Threads bringen so viele Worker nur etwas, solange Anfragen auf Datenbank oder externe APIs warten. Der Worst-Case-Hinweis ist meist unkritisch, weil im Alltag die RSS zählt; er erinnert dich aber daran, `memory_limit` realistisch zu halten. Schaltest du die lokale Datenbank ein, zieht der Plan ihren Worst Case ab, und `pm.max_children` sinkt entsprechend. Der nginx-Abschnitt rechnet für dieselbe Maschine mit 4 Workern und 1.024 Verbindungen 2.048 gleichzeitige Clients als FastCGI-Frontend.

## Beispiel 6: Einen Backup-Plan mit restic durchrechnen

Ausgangslage: 500 GB Daten, tägliches Backup um 02:00 Uhr mit restic seit drei Jahren, Upload offsite über 100 Mbit/s. Du willst wissen, was die Aufbewahrung behält, wie viel Platz das kostet und ob die erste Sicherung über Nacht durchläuft.

1. Tab **Backup**, **Tool** = `restic`, Preset `7 d · 4 w · 12 m · 3 y` (die Vorgabe).
2. **Simulate a schedule**: **Backup runs** = `daily`, **At** `02:00`, **Backups running for** `3` years. **Forget / prune runs on** = heute (Knopf **Today**).
3. Unter **Storage Estimate** die Vorgaben stehen lassen: 500 GB, 1 % Änderungen pro Tag, Kompression 1,5 : 1, Vollsicherung alle 7 Tage, 30 Tage Wiederherstellungsfenster.
4. **Backup Window**: 100 Mbit/s, Fenster 6 h, „the upload — compressed data“.

**Ergebnis** (Stichtag 20. November 2026): **Kept** 21 von 1.096 Snapshots; **Other tools keep** meldet „rustic 21 · borg 26“. Die Befehle stehen fertig da:

```bash
restic -r /srv/restic-repo forget --dry-run --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --keep-yearly 3
restic -r /srv/restic-repo forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --keep-yearly 3 --prune
```

Die Speicherschätzung zeigt für 30 Tage mit täglicher Sicherung: nur Vollsicherungen 10 TB, Voll + inkrementell rund 2,1 TB, Voll + differenziell rund 2,3 TB, dedupliziert 430 GB; die 21 behaltenen restic-Snapshots belegen dedupliziert rund 1,6 TB. Im **Backup Window** braucht die erste Sicherung rund 7,4 Stunden — zwei Nachtfenster —, jede weitere dagegen nur knapp 4,5 Minuten.

**Interpretation:** borg behält mit denselben Regeln fünf Snapshots mehr, weil seine Regeln sich nicht überlappen: Ein Tages-Snapshot zählt nicht zugleich als Wochen-, Monats- oder Jahres-Snapshot, also reichen 7 + 4 + 12 + 3 Plätze weiter in die Vergangenheit. Die Tabelle zeigt das in der Spalte **Kept by** — bei borg findet die Jahresregel nur noch zwei ältere Jahre und belegt ihren dritten Platz mit dem ältesten Archiv („yearly (oldest)“). Wechselst du von restic auf borg und übernimmst die Flags eins zu eins, bekommst du also nicht dieselbe Aufbewahrung. Die erste Vollsicherung planst du übers Wochenende oder lokal vor; danach passt das tägliche Delta locker ins Fenster.

Zum Schluss der **3-2-1-1-0 Check**: Mit den Vorgaben (3 Kopien, 2 Medientypen, 1 offsite, keine Offline-Kopie, Restore-Test innerhalb eines Jahres) meldet das Tool „3-2-1 met“, 3 von 5 Regeln. Erst eine unveränderliche Kopie (etwa Object Lock beim Cloud-Speicher) und ein Restore-Test innerhalb der letzten drei Monate machen daraus „3-2-1-1-0 met“.

---

Die vollständige Beschreibung aller Felder steht im [Manual](https://www.jpkc.com/db/tools/sysadmin/manual/), Strategie und Stolperfallen in den [Tipps & Tricks](https://www.jpkc.com/db/tools/sysadmin/tips/). Ausprobieren kannst du alles direkt im [Tool](https://www.jpkc.com/tools/sysadmin/).

