# SysAdmin Tools — Manual

> Alle sieben Tabs von SysAdmin Tools im Detail: Eingaben, Formeln, Grenzen und erzeugte Befehle für RAID, chmod, Transfer, Tuning, SLA, Backup, SSD und USV.

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

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/)

Dieses Manual beschreibt jeden Tab von SysAdmin Tools mit seinen Eingaben, Ergebnissen, Formeln und Grenzen. Die Oberfläche ist englisch; die Feld- und Kachelnamen stehen hier deshalb im Original, damit du sie im Tool wiederfindest. Konkrete Durchläufe findest du in den [Beispielen](https://www.jpkc.com/db/tools/sysadmin/examples/), Strategie und Stolperfallen in den [Tipps & Tricks](https://www.jpkc.com/db/tools/sysadmin/tips/).

## Aufbau und Bedienung

Die sieben Rechner liegen als Tabs nebeneinander: **RAID & Storage**, **Permissions**, **Transfer**, **Server Tuning**, **Availability**, **Backup** und **SSD & UPS**. Alle arbeiten nach demselben Muster:

- **Eingaben oben, Ergebnis sofort darunter.** Es gibt keinen „Berechnen“-Knopf — jede Änderung rechnet live neu.
- **Ergebniskacheln** zeigen den Wert groß, darüber die Bezeichnung, darunter eine kurze Erklärung, woraus er entsteht. Auffällige Werte sind farbig markiert (Warnung oder Fehler).
- **Aufklappbare Erklärungen** unter den Ergebnissen („Formulas & assumptions“, „Model“, „Rules …“) enthalten die Formeln, Annahmen und Quellen. Faustregeln heißen dort ausdrücklich **Heuristic**.
- **Codeblöcke** mit Befehlen oder Konfiguration haben einen **Copy**-Knopf.
- Oben rechts in jedem Tab: **Copy link** kopiert einen Link, der die Eingaben dieses Tabs enthält; **Reset** stellt die Vorgabewerte wieder her.

Zahlen darfst du mit Dezimalpunkt oder Dezimalkomma eintippen: `1,5`, `1.234,5`, `1,234.5` und `1 234` werden verstanden. Stehen Punkt und Komma in einer Zahl, ist das letzte Zeichen das Dezimaltrennzeichen und davor müssen echte Tausendergruppen stehen. Ein einzelnes Trennzeichen gilt immer als Dezimalzeichen — `1.234` ist also 1,234 und nicht 1234.

Der aktive Tab steht in der Adresse hinter dem `#` (`#raid`, `#perms`, `#transfer`, `#tuning`, `#sla`, `#backup`, `#hardware`), du kannst also direkt auf einen Tab verlinken. Deine Eingaben speichert das Tool pro Tab im Local Storage des Browsers. Ein geteilter Link überträgt die Eingaben eines Tabs als Base64-kodiertes JSON nach `#<tab>=`; öffnet jemand den Link, übernimmt sein Browser diese Werte und speichert sie ebenfalls. Danach kürzt das Tool die Adresse wieder auf den reinen Tab-Anker.

## RAID & Storage

Der umfangreichste Tab: Er rechnet ein Plattenset in einem gewählten Layout durch und zeigt Kapazität, Ausfalltoleranz, Rebuild, Leistung, Kosten, einen Vergleich aller Layouts und die Befehle zum Anlegen.

### Drives: die Platten eingeben

- **Drive type** — `3.5" HDD (7,200 rpm)`, `2.5" HDD (5,400 rpm)`, `SATA SSD` oder `NVMe SSD`. Der Typ setzt die Vorgaben für Leistungsaufnahme, IOPS, MB/s, Rebuild-Rate, URE-Klasse und Ausfallrate (AFR). Eine 3,5-Zoll-HDD startet etwa mit 5 W idle, 8,5 W aktiv, 150 IOPS, 250 MB/s, 150 MB/s Rebuild-Rate, URE 10^14 und 1,5 % AFR; eine NVMe-SSD mit 2/7 W, 500.000 IOPS, 5.000 MB/s, 1.500 MB/s Rebuild-Rate, URE 10^15 und 1 % AFR. Alle diese Werte kannst du weiter unten überschreiben.
- **Plattenzeilen** mit **Count**, **Size per drive** (TB, TiB oder GB) und **Price per drive**. Über **Add drives** kommt eine weitere Zeile dazu — für gemischte Größen legst du je Größe eine Zeile an. Erlaubt sind bis zu 16 Zeilen und 64 Platten, je Platte zwischen 1 GB und 1 PB; ein leerer Preis zählt als 0.
- Die **Reihenfolge zählt**: Spiegelpaare, RAID-50/60-Gruppen und ZFS-vdevs bekommen aufeinanderfolgende Platten aus der Liste.

Die Vorgabe beim ersten Öffnen ist ein RAID 6 aus sechs 8-TB-Platten à 180 €.

### Layout und Parameter

Das **Layout**-Menü gliedert 23 Layouts in vier Gruppen:

| Gruppe | Layouts (Mindestanzahl Platten) |
|---|---|
| Classic RAID (Linux md / hardware) | JBOD / Span (1), RAID 0 (2), RAID 1 (2), RAID 5 (3), RAID 6 (4), RAID 10 (3), RAID 50 (6), RAID 60 (8) |
| ZFS | ZFS stripe (1), ZFS mirror vdevs (2), RAIDZ1 (3), RAIDZ2 (4), RAIDZ3 (5) |
| Btrfs | raid1 (2), raid1c3 (3), raid1c4 (4), raid10 (2), raid5 (2), raid6 (3) — raid5/raid6 mit dem Zusatz „not for production“ |
| NAS | Synology SHR-1 (2), SHR-2 (4), Unraid (1 parity) (2), Unraid (2 parity) (3) |

Unter dem Menü beschreibt ein Satz das gewählte Layout. Zwei Mindestwerte weichen von der Lehrbuchtabelle ab, weil das Tool echtes Linux-Verhalten abbildet: md-RAID 10 im „near“-Layout funktioniert schon mit 3 Platten, Btrfs raid10 seit Linux 5.15 mit 2. Bei RAIDZ verlangt das Tool dagegen bewusst mindestens Parität + 2 Platten.

Je nach Layout erscheinen weitere Parameter:

- **Copies per block** (RAID 10): 2- oder 3-fach-Spiegel.
- **Groups** (RAID 50/60): Anzahl der RAID-5- bzw. RAID-6-Gruppen, 2 bis 16.
- **Drives per vdev** (RAIDZ): Breite eines vdevs; `0` bedeutet ein vdev aus allen Platten. Übrige Platten, die kein weiteres vdev füllen, bleiben außerhalb des Pools — das Tool schlägt vor, sie als Hot Spare einzubinden.
- **Drives per mirror** (ZFS mirror vdevs): 2, 3 oder 4.
- **ashift** (ZFS): 9 (512-B-Sektoren), 12 (4 KiB, Vorgabe), 13 oder 14.
- **recordsize** (RAIDZ): 4K bis 16M, Vorgabe 128K.

### Capacity: was nutzbar bleibt

Die Kacheln zeigen **Usable** (bei ZFS nach Abzug des Slop Space, bei Btrfs ohne Metadaten), **Raw**, **Efficiency** (nutzbar ÷ roh), **Unused** (Platz, der wegen unterschiedlicher Größen oder übriger Platten brachliegt) und **Tolerates** (garantierte Ausfälle, dazu der günstigste Fall). Kapazitäten stehen immer in TB **und** TiB. Darunter folgen die Rechnung als Formelzeile, Hinweise zum Layout und die Tabelle **Drive usage** mit Größe, Rolle, genutztem und ungenutztem Anteil jeder Platte.

So rechnet das Tool, je nach System:

- **Klassisches RAID (md/Hardware):** Jedes Mitglied zählt mit der kleinsten Platte — des ganzen Arrays bei RAID 1/5/6/10, jeder Gruppe bei RAID 50/60. RAID 5 = (n − 1) × kleinste, RAID 6 = (n − 2) × kleinste, RAID 10 = n × kleinste ÷ Kopien. Bei RAID 0 nennt die Hauptzahl n × kleinste Platte; ein Hinweis ergänzt, dass Linux md den Überhang größerer Platten in Zonen trotzdem nutzt, Hardware-Controller dagegen nicht.
- **ZFS:** Jedes vdev zählt mit seiner kleinsten Platte. Für RAIDZ rechnet das Tool das Padding nach Matt Ahrens: B = recordsize ÷ 2^ashift, Parität = p · ⌈B ÷ (w − p)⌉, belegt = ⌈(B + Parität) ÷ (p + 1)⌉ · (p + 1), Datenanteil = B ÷ belegt. `zfs list` rechnet immer mit dem Anteil eines 128-KiB-Blocks. Weicht der Datenanteil vom Nominalwert ab, sagt ein Hinweis, wie viel Prozent das vdev tatsächlich speichert. Zusätzlich zeigt das Tool den Datenanteil eines 4-KiB-Blocks (kleine Dateien, Metadaten). Der **Slop Space** von OpenZFS ≥ 2.0 (1/32 des Pools, höchstens 128 GiB, mindestens 128 MiB) ist abgezogen; Kompression ist nicht eingerechnet.
- **Btrfs:** eine Simulation des Chunk-Allocators im Kernel. Jeder Chunk geht an die Geräte mit dem meisten freien Platz — bei raid1/raid1c3/raid1c4 an die 2/3/4 leersten, bei raid10 an alle Geräte mit Platz (gerade Anzahl, zwei Kopien), bei raid5/raid6 an alle Geräte mit Platz mit dem Datenanteil (k − 1)/k bzw. (k − 2)/k. Was sich mangels weiterer freier Geräte nicht zuteilen lässt, meldet ein Hinweis. Metadaten- und System-Chunks (typisch 1–2 %) zählen nicht mit.
- **Synology SHR:** Die Platten werden an jeder vorkommenden Größe in Schichten geschnitten, jede Schicht ist ein md-RAID über die Platten, die sie erreichen. SHR-1 = Summe − größte Platte, SHR-2 = Summe − zwei größte.
- **Unraid:** Die größte(n) Platte(n) tragen die Parität, jede andere behält ihr eigenes Dateisystem: nutzbar = Summe der Datenplatten.

Mischst du Plattengrößen in einem klassischen RAID oder ZFS-vdev, warnt das Tool, wie viel ungenutzt bleibt. Bei RAID 1, 5, 6 und 10 verweist es zusätzlich auf Btrfs, SHR oder Unraid; bei RAID 50/60 und ZFS erinnert es daran, dass die Platten in Listenreihenfolge zu Gruppen, vdevs bzw. Mirrors zusammengefasst werden. Dazu kommen Hinweise wie: vdevs breiter als etwa 12 Platten resilvern langsam und liefern die IOPS einer einzelnen Platte; Btrfs raid5/raid6 ist wegen des Write Hole nicht für die Produktion gedacht; Unraid verteilt nicht über mehrere Platten, eine Datei liegt immer auf einer Datenplatte.

Der Abschnitt „Units“ in den Formeln erinnert an die Einheiten: Plattenhersteller rechnen in TB (10^12 Byte), `df -h` zeigt TiB (2^40 Byte). Partitionstabellen, md-Superblöcke und ZFS-Labels kosten pro Platte ein paar MiB, ext4 reserviert standardmäßig 5 % für root (`tune2fs -m`).

### Fault Tolerance: welche Ausfälle überlebt werden

Neben den Kacheln steht eine Tabelle mit **Failed drives**, **Surviving combinations** und **Chance the data survives**: Für jede Zahl ausgefallener Platten zählt das Tool alle Kombinationen durch und gibt an, welcher Anteil die Daten überlebt — unter der Annahme, dass jede Platte gleich wahrscheinlich ausfällt.

**Guaranteed** heißt: jede beliebige Kombination dieser Größe wird überlebt. **Best case** heißt: so viele Ausfälle gehen gut, wenn sie die richtigen Platten treffen — etwa eine Platte pro Spiegel in RAID 10 oder eine pro Gruppe in RAID 50. Btrfs verteilt seine Chunks über wechselnde Gerätekombinationen; dort zählt jeder weitere Ausfall über das Profil hinaus als Datenverlust. Bei Unraid gehen über die Paritätszahl hinaus nur die ausgefallenen Datenplatten verloren, die übrigen bleiben lesbar.

### Rebuild & Risk

Eingaben: **Rebuild rate** (MB/s), **Pool fill** (Füllgrad in %, nur für ZFS und Btrfs), **Delay until start** (Stunden bis zum Start, etwa bis die Ersatzplatte da ist), **AFR per drive** (jährliche Ausfallrate) und **URE class** — 10^14 (Desktop-/NAS-HDD), 10^15 (Enterprise-HDD, Client-SSD), 10^16 (Enterprise-SSD), 10^17 oder ein eigener Exponent.

Die Kacheln:

- **Rebuild time** — Datenmenge ÷ Rate. Eine eingetragene Verzögerung steht als Hinweis unter dem Wert und verlängert das Zeitfenster, in dem weitere Ausfälle gerechnet werden (**Another drive fails**). md und Hardware-RAID synchronisieren das ganze Mitglied neu; ein ZFS-Resilver und ein Btrfs-Replace kopieren nur belegte Daten (× Füllgrad). Gezeigt wird die ungünstigste Platte bzw. Gruppe.
- **URE risk** — 1 − e^(−Bits ÷ URE) über die Daten, die **ohne** verbleibende Redundanz gelesen werden müssen: alle übrigen Platten einer RAID-5-/RAIDZ1-/SHR-1-Gruppe, der Spiegelpartner bei RAID 1/10. Bleibt nach einem Ausfall Redundanz übrig (RAID 6, RAIDZ2 …), steht hier „≈ 0“.
- **Another drive fails** — Wahrscheinlichkeit, dass während des Rebuild-Fensters eine der relevanten Platten ausfällt: 1 − (1 − AFR)^(h ÷ 8760) je Platte.
- **Data loss by failures** — Wahrscheinlichkeit, dass so viele weitere Platten ausfallen, wie das Layout nicht mehr verträgt.
- **Rebuild risk** — alles kombiniert. Bei Layouts mit zwei oder mehr Redundanzen zählt hier auch der Fall „ein Ausfall weniger, gefolgt von einem URE ohne Redundanz“ — laut Tool meist der größte Anteil bei RAID 6/RAIDZ2.
- **After N failures** (nur ab doppelter Redundanz) — das URE-Risiko des Rebuilds nach dem letzten noch tolerierten Ausfall, wenn nichts Redundantes mehr übrig ist.

Ohne Redundanz (JBOD, RAID 0, ZFS stripe) meldet die Kachel „Rebuild: not possible“ — eine ausgefallene Platte heißt dann Restore aus dem Backup. Die Erklärung „Formulas & why the URE numbers look scary“ ordnet die Zahlen ein: URE-Klassen sind Obergrenzen aus dem Datenblatt, reale Platten sind meist deutlich besser; Ausfälle häufen sich (gleiche Charge, gleiches Alter, Stress beim Rebuild), die Ausfallwerte sind also eher eine Untergrenze; ZFS und Btrfs melden einen URE dank Prüfsummen als eine beschädigte Datei, md kann den Rebuild abbrechen. Und: RAID ist kein Backup.

### Performance (theoretical)

Aus **Sequential per drive** (MB/s) und **Random IOPS per drive** rechnet das Tool obere Grenzen: **Sequential read**, **Sequential write**, **Random read**, **Random write** und **Write penalty** (Platten-I/Os pro zufälligem Schreibzugriff). Lesen kann alle Mitglieder nutzen, sequentielles Schreiben die Datenplatten, zufälliges Schreiben wird durch den Write Penalty geteilt (RAID 1/10: einer pro Kopie, RAID 5: 4, RAID 6: 6). RAIDZ liefert für Random-I/O ungefähr die IOPS einer Platte pro vdev. Controller, CPU, Caches, Netzwerk und Dateisystem sind nicht berücksichtigt — das Tool empfiehlt, mit `fio` nachzumessen, bevor du dich auf die Werte verlässt.

### Power & Cost

Eingaben: **Idle** und **Active** (Watt je Platte), **Time active** (Anteil in %, Vorgabe 20), **Currency** (EUR, USD, GBP, CHF) und **Electricity price** pro kWh (Vorgabe 0,30). Ergebnisse: **Power** (mittlere Leistung), **Energy per year** (24/7), **Electricity per year** (mit Monatswert), **Heat** in BTU/h, **Drives** (Summe der Plattenpreise) und **Price per usable TB** (dazu je TiB).

Gerechnet wird: Platten × (idle × (1 − aktiver Anteil) + aktiv × aktiver Anteil), über alle Platten der Liste inklusive ungenutzter; kWh pro Jahr = W × 8.760 h ÷ 1.000; 1 W = 3,412 BTU/h. Es geht nur um die Platten — Controller, Backplane, Lüfter und Netzteilverluste kommen obendrauf.

### Layout Comparison

Eine Tabelle aller Layouts, die mit deinen Platten möglich sind, mit **Usable**, **Efficiency**, **Tolerates**, **Rebuild**, **Rebuild risk**, **Read / write** und **Price / TB** — gerechnet mit deinen Rebuild- und Preis-Einstellungen. Mit **Use** übernimmst du ein Layout, die aktuelle Zeile trägt die Marke „current“. Der Schalter **Show impossible layouts** blendet auch Layouts ein, für die die Platten nicht reichen. Parameter, die nicht zu den Platten passen, fallen in der Tabelle auf einen Standard zurück (RAIDZ: ein vdev aus allen Platten). „Rebuild risk“ meint hier das Risiko nach **einem** ausgefallenen Laufwerk.

### Commands

Unter **Device names** trägst du die Gerätepfade in Plattenreihenfolge ein (durch Leerzeichen oder Zeilen getrennt), dazu **Pool name / label** (Vorgabe `tank`) und für md das **File system** (ext4 oder XFS). Fehlende Namen ersetzt das Tool durch Platzhalter `/dev/disk/by-id/DISK-01`, `DISK-02` … Ein roter Hinweis und der Kopf des Skripts warnen, dass die Befehle **alle Daten** auf den Geräten löschen, und empfehlen `lsblk -o NAME,SIZE,MODEL,SERIAL` sowie Pfade unter `/dev/disk/by-id/`.

- **md:** `mdadm --create /dev/md0 --level=… --raid-devices=…` mit 512 KiB Chunk (mdadm-Standard), bei RAID 10 mit `--layout=n2`/`n3`; RAID 50/60 als verschachteltes md (je Gruppe ein Array, darüber RAID 0). Danach `mkfs.ext4` mit passendem `-E stride=…,stripe-width=…` oder `mkfs.xfs` (liest die md-Geometrie selbst), das Eintragen in `mdadm.conf` samt `update-initramfs -u` (Debian/Ubuntu-Pfad; bei RHEL `/etc/mdadm.conf`) und `cat /proc/mdstat` zum Beobachten der Erstsynchronisation.
- **ZFS:** `zpool create -o ashift=12 -O compression=lz4 tank raidz2 …` (recordsize nur, wenn abweichend von 128K), übrige Platten per `zpool add … spare`, danach `zpool status` und `zfs list`.
- **Btrfs:** `mkfs.btrfs -L tank -d <Profil> -m <Profil>` — Metadaten bekommen mindestens die Redundanz der Daten (raid1c3 bei raid6-Daten, raid1c4 bei raid1c4), dann Mounten und `btrfs filesystem usage`.
- **SHR und Unraid** haben keinen Shell-Befehl: Das Tool nennt stattdessen den Weg in Synology DSM (Storage Manager → Create → Storage Pool → SHR) bzw. in der Unraid-Weboberfläche (Main → Array Devices: erst Parität, dann Datenplatten).

## Permissions

Der Tab „Permissions: chmod, umask & ls -l“ rechnet Dateirechte in alle Richtungen. Modell ist GNU coreutils `chmod` 9.4 — nicht ein abstraktes POSIX —, inklusive der Eigenheiten bei Verzeichnissen.

### Mode: Rechte setzen und lesen

- **Applies to** — **File** oder **Directory**. Die Wahl ändert Erklärungen, Warnungen und die Befehle.
- **Bit-Raster** mit den Zeilen Owner (`u`), Group (`g`), Others (`o`) und den Spalten **Read 4**, **Write 2**, **Exec 1** und **Special** (setuid, setgid, sticky); die Spalte „Digit“ zeigt die Oktalziffer je Klasse.
- **Octal** (z. B. `0644`), **Symbolic (as in ls -l)** (z. B. `rw-r--r--`) und **Read an `ls -l` line** — alle drei Felder sind mit dem Raster verbunden. Eine `ls -l`-Zeile liefert zusätzlich Typ, Besitzer, Gruppe, Linkzahl und Name; ein `+` am Modus meldet eine ACL („getfacl shows more rights“), ein `.` einen SELinux-Kontext, ein `@` macOS-Attribute. Bei Symlinks weist das Tool darauf hin, dass deren Modus nie benutzt wird.
- **Presets** mit Erklärung im Tooltip: `644` (normale Dateien), `755` (Verzeichnisse und Programme), `600` (private Dateien wie SSH-Keys, `.env`), `700` (private Verzeichnisse wie `~/.ssh`), `640` (Konfiguration für eine Dienstgruppe wie `www-data`), `750`, `775`, `2775` (gemeinsames Projektverzeichnis, setgid), `1777` (wie `/tmp`), `4755` (setuid-Programm wie `/usr/bin/passwd`), `400` (Zertifikate, `.pem`-Keys) und `0444`. Die Presets `2775` und `1777` stellen den Typ auf **Directory**, `4755` auf **File**; alle anderen lassen die Auswahl bei **Applies to** stehen.

### Result: Bedeutung und Warnungen

Die Kacheln **Octal** (mit der Form von `stat -c %a`) und **ls -l** zeigen den Modus. Darunter stehen Warnungen, abgestuft nach Schwere. Beispiele: `777` („It rarely fixes the real problem“ — besser Besitzer und Gruppe per `chown` richtig setzen und 755/775 bzw. 644/664 nehmen), ein world-writable Verzeichnis ohne Sticky-Bit, eine world-writable Datei, ein setuid-/setgid-Programm, das andere beschreiben dürfen, setuid-Programme allgemein (mit dem Suchbefehl `find / -xdev -perm -4000 -type f`), ein großes `S` (setuid/setgid ohne x), setuid auf Verzeichnissen (ignoriert Linux), r ohne x auf einem Verzeichnis oder ein Besitzer mit weniger Rechten als Gruppe oder andere.

„What each bit does here“ erklärt jedes gesetzte Bit für den gewählten Typ — etwa, dass Linux setuid auf Skripten (`#!`) ignoriert. „How the kernel checks“ fasst die Prüflogik zusammen: Es greift genau eine Klasse (Besitzer, dann Gruppe, dann andere — Bits werden nie addiert), root überspringt die r/w-Prüfung und braucht zum Ausführen mindestens ein x-Bit, und Löschen oder Umbenennen ist ein Schreibzugriff auf das **Verzeichnis**.

### Commands: genau diesen Modus setzen

Mit einem optionalen **Path** (sonst Platzhalter `FILE` bzw. `DIR`, Pfade werden für die Shell gequotet) erzeugt „This mode, exactly“ vier Zeilen: den numerischen `chmod`, den gleichwertigen symbolischen `chmod`, eine `install`-Variante (`install -m … SOURCE FILE` bzw. `install -d -m … DIR`) und `stat -c '%a %A %n'` zur Kontrolle.

Für Verzeichnisse schreibt das Tool den numerischen Modus mit **fünf Ziffern** (`chmod 00755`, `chmod 02775`) und hängt an die symbolische Form `,-s` bzw. `,u-s` an. Grund: GNU `chmod` lässt setuid/setgid auf Verzeichnissen bei vierstelligen Modi stehen; nur so setzt der Befehl den Modus wirklich exakt. Bei Dateien mit setuid/setgid erinnert ein Hinweis daran, `chown` vor `chmod` auszuführen, weil ein Besitzerwechsel diese Bits löscht.

Darunter baust du mit **Tree: directories** und **Tree: files** (Vorgabe 755/644) Befehle für einen ganzen Baum: `find … -type d -exec chmod … {} +` und `find … -type f -exec chmod … {} +`. Wo es geht, ergänzt das Tool die Ein-Durchgang-Variante `chmod -R u=rwX,g=rX,o=rX …` (das große `X` setzt Ausführen nur für Verzeichnisse und Dateien, die schon ein x haben). Die Baum-Befehle nutzen bewusst vier Ziffern, damit setgid auf gemeinsamen Verzeichnissen erhalten bleibt; sie folgen keinen Symlinks, und `-type f` überspringt Geräte, Sockets und Pipes. Warnungen gibt es für world-writable Bäume, Verzeichnisse ohne r+x für den Besitzer (dann kann `find` nicht mehr absteigen), x auf allen Dateien und setuid/setgid auf allen Dateien.

### Apply a chmod Expression

Hier simulierst du einen `chmod`-Aufruf: **Start mode**, **Type** (File/Directory), **Expression** und **umask**, dazu der Schalter „Clauses without u/g/o/a are filtered by the umask“. Beispiel-Knöpfe füllen gängige Ausdrücke ein: `u+x`, `go-w`, `a+X`, `u=rwX,g=rX,o=`, `g=u`, `+x`, `-w`, `g+s`, `o+t`, `=755`, `00755`.

Ergebnisse: **Result** (Modus und `ls -l`-Form), **Changed** (hinzugefügte und entfernte Bits), bei Bedarf **umask filtered**, **Directory rule** und **Note**. Eine Schritttabelle zeigt nach jeder Klausel den Zwischenstand. Ungültige Ausdrücke quittiert das Tool mit derselben Meldung wie `chmod` („invalid mode“). Mit **Load result into the mode editor** übernimmst du das Ergebnis nach oben.

Die Regeln aus „Rules (GNU coreutils chmod)“:

- Syntax `[ugoa]*([-+=]([rwxXst]*|[ugo]))+`, mehrere Klauseln mit Komma, oder eine Oktalzahl. `u`/`g`/`o` hinter dem Operator kopieren die aktuellen Bits dieser Klasse (`g=u`).
- Ohne `u`/`g`/`o`/`a` filtert die umask die Änderung — auch bei `-` und `=`. Unter umask 022 entfernt `chmod -w f` nur das w des Besitzers. `a` wird nicht gefiltert, Sonderbits auch nicht.
- `X` setzt Ausführen nur auf Verzeichnissen und Dateien, die schon ein x-Bit haben — geprüft an genau dieser Stelle des Ausdrucks.
- `s` wirkt mit `u`/`g`, `t` mit `o` (oder ohne Klasse); `o+s` und `u+t` tun nichts.
- Verzeichnisse: `chmod 755 dir`, `chmod 0755 dir` und `chmod u=rwx,g=rx,o=rx dir` lassen setgid stehen; `g-s`, `-s`, fünf oder mehr Ziffern (`00755`) oder `=755` löschen es. BSD- oder BusyBox-`chmod` können sich anders verhalten; dass der Kernel setgid löschen kann, wenn du nicht in der Gruppe der Datei bist, ist nicht modelliert.

### umask

Ins Feld **umask** gibst du eine oktale (`022`) oder symbolische umask (`u=rwx,g=rx,o=`) ein; die Knöpfe `022`, `002`, `027` und `077` decken die üblichen Fälle ab (Standard der meisten Distributionen, User Private Groups, Server, privat). Die Kacheln zeigen **umask** mit der Form von `umask -S`, **New files** (aus angeforderten 0666) und **New directories** (aus 0777) sowie Hinweise, wenn die umask dem Besitzer Rechte nimmt oder alles world-writable macht. Eine symbolische Eingabe wird auf 022 angewendet, wie die Shell es mit der aktuellen umask täte — das Tool unterstützt dabei nur die Schreibweisen, die dash und bash gleich verstehen.

„Set it“ liefert die passenden Zeilen: `umask 0022` (diese Shell; dauerhaft in `~/.profile`), `UMask=0022` (systemd-Unit, Abschnitt `[Service]`), `UMASK 022` (`/etc/login.defs`, für Logins über pam_umask) und `umask -S` zur Kontrolle. Die Formel: neuer Modus = angeforderter Modus UND NICHT umask. Die meisten Programme fordern 0666 bzw. 0777 an, manche weniger (`ssh-keygen` 0600) — die umask nimmt nur Bits weg, ein x auf Dateien fügt sie nie hinzu. Eine Default-ACL im Elternverzeichnis ersetzt die umask.

### Read an ls -l Listing

In das Textfeld fügst du die Ausgabe von `ls -la` ein (bis zu 200 Einträge). Das Tool zeigt eine Tabelle mit **Name**, **Type**, **ls -l**, **Octal**, **Owner:group** und **Notes** — dort landen Markierungen wie ACL, SELinux, setuid, setgid, sticky, world-writable, beschreibbares setuid/setgid oder „owner < group/others“. Über den Pfeil-Knopf einer Zeile lädst du ihren Modus in den Editor. Das Listing wird nicht gespeichert und nicht in Links übernommen.

## Transfer

Der Tab „Transfer & Bandwidth“ rechnet mit Datenmengen und Raten. Für Größen stehen dezimale (kB … PB) und binäre Einheiten (KiB … PiB) zur Wahl, für Raten bit/s bis Tbit/s sowie B/s, kB/s, MB/s, GB/s, KiB/s, MiB/s und GiB/s.

### Transfer Time, Rate & Amount

Unter **Calculate** wählst du, was gesucht ist: **Time**, **Rate** oder **Amount**. Die beiden anderen Felder — **Amount**, **Line rate** und **Time** (als `h:mm:ss`, Sekunden, Minuten, Stunden oder Tage) — sind die Eingaben; Knöpfe setzen gängige Raten von 100 Mbit/s bis 25 Gbit/s. Die Ergebnisse zeigen den gesuchten Wert mit Protokoll-Overhead und zum Vergleich **Without overhead**.

Die Formeln: Zeit = Menge × 8 ÷ (Leitungsrate × Effizienz), Rate = Menge × 8 ÷ (Zeit × Effizienz), Menge = Rate × Effizienz × Zeit ÷ 8. Die Effizienz kommt aus dem Abschnitt **Protocol Overhead**. Es gelten durchgehend dezimale Präfixe: 1 Gbit/s = 10^9 bit/s = 125 MB/s = 119,2 MiB/s. Platten, CPU (Verschlüsselung, Kompression), die Gegenstelle und das Netz dazwischen sind nicht eingerechnet — das Langsamste davon bestimmt das echte Tempo.

### Protocol Overhead

- **Overhead model**: **TCP over Ethernet** (Vorgabe), **None (raw line rate)** oder **Custom efficiency** (eigener Prozentwert, etwa iperf3-Ergebnis ÷ Leitungsrate).
- Für TCP: **MTU** (576 bis 9216, bei IPv6 ab 1280; Knöpfe 1500 und „Jumbo 9000“), **IP version** (IPv4/IPv6) und die Schalter **TCP timestamps** (12 Byte, unter Linux standardmäßig an), **802.1Q VLAN tag** (4 Byte außerhalb der MTU) und **PPPoE** (8 Byte innerhalb der MTU, etwa bei DSL).

Die Tabelle „One full-size frame on the wire“ schlüsselt einen vollen Frame Byte für Byte auf: Präambel + SFD, Ethernet-Header, ggf. VLAN-Tag und PPPoE, IP-Header, TCP-Header, Timestamps, Nutzdaten, Prüfsumme und Interframe Gap. Pro Frame kosten Präambel, Header, FCS und Lücke 38 Byte außerhalb der MTU; innerhalb kommen IP (20 bzw. 40 Byte), TCP (20 Byte) und ggf. 12 Byte Timestamps dazu. Mit IPv4, MTU 1500 und Timestamps kommen so 94,15 % der Leitungsrate als Daten an, mit Jumbo-Frames rund 99 %, mit IPv6 92,85 %. Nicht enthalten sind Retransmissions, TLS (≈ 0,1–0,2 %), SSH- oder VPN-Kapselung (WireGuard: 60 Byte pro Paket bei IPv4, 80 bei IPv6) und Slow Start.

### Link Comparison

Eine Tabelle mit der Übertragungsdauer der oben eingegebenen Menge über gängige Verbindungen: Ethernet von Fast Ethernet bis 100 GbE, Internetanschlüsse (50/100/250 Mbit/s, Glasfaser 1 Gbit/s), Wi-Fi 5 und 6, USB 2.0 bis USB4/Thunderbolt, SATA II/III, NVMe PCIe 3.0 bis 5.0 und eine 3,5-Zoll-HDD. Die Spalten:

- **Nominal** — der verkaufte Wert: bei Ethernet die MAC-Datenrate, bei USB, SATA und PCIe die Signalrate, bei Wi-Fi die PHY-Rate.
- **Ceiling** — die harte Obergrenze nach Leitungscodierung (8b/10b = 80 %, 128b/130b = 98,5 %) oder Framing.
- **Realistic** — bei Ethernet und Internet nominal × TCP-Effizienz von oben; mit ≈ markierte Zeilen sind typische Richtwerte, keine Messung deiner Hardware (etwa ≈ 40 MB/s für einen USB-2.0-Datenträger oder ≈ 50 % der PHY-Rate nahe am Access Point bei Wi-Fi).
- **Time** — die Dauer für deine Menge.

### Units: Decimal ↔ Binary, Bits ↔ Bytes

Ein Wert in einer beliebigen Einheit (Bytes dezimal oder binär, Bits dezimal oder binär) erscheint in vier Tabellen umgerechnet, dazu ein Satz wie „4 TB = …“. Die Spalte **Larger by** zeigt, um wie viel die binäre Einheit größer ist — 2,4 % bei Kilo, 9,95 % bei Tera. Die Erklärung „Why a 4 TB drive shows “3.7T” (or less)“: `ls -lh`, `df -h` und `du -h` rechnen in Zweierpotenzen, schreiben aber nur den Buchstaben — und runden **auf**. `df -H` rechnet dezimal. Das Dateisystem nimmt sich zusätzlich seinen Anteil.

### Monthly Traffic

Zwei Richtungen: **Rate → traffic** und **Traffic → rate**. Eingaben sind **Average rate** (Dauerrate rund um die Uhr), **Traffic per month** und **Month length** — Durchschnittsmonat (365,25 ÷ 12 = 30,44 Tage) oder 30 Tage, wie viele Hoster abrechnen. Formel: Traffic = Rate ÷ 8 × Sekunden pro Monat (30 Tage = 2.592.000 s, Durchschnitt = 2.629.800 s); 1 Mbit/s rund um die Uhr ergibt 324 GB in einem 30-Tage-Monat. Das Ergebnis ist ein Mittelwert — echter Verkehr hat eine Tageskurve, die Spitze liegt deutlich höher.

### 95th Percentile (Burstable Billing)

Für Abrechnung nach dem 95. Perzentil fügst du Messwerte ein, einen pro Zeile — Raten, keine Bytezähler. **Example** füllt Beispieldaten ein, **Clear** leert das Feld. Optionen: **Bare numbers are** (Einheit für Zahlen ohne Einheit), **Value column** (letzte Zahl der Zeile oder Spalte 1–8), **Decimal mark** (Auto, Punkt, Komma), **Percentile** (Vorgabe 95) und **Interval** (1, 5, 15 oder 60 Minuten).

Die Methode ist „Nearest Rank“: aufsteigend sortieren, Rang = ⌈p ÷ 100 × n⌉, abgerechnet wird der Wert auf diesem Rang — die obersten 5 % fallen weg. Bei 30 Tagen mit 5-Minuten-Werten sind das 8.640 Messpunkte, von denen 432 (36 Stunden Spitzenlast) nicht zählen. Einheiten hinter Zahlen (`Mbit/s`, `Mbps`, `MB/s`, `MiB/s`, `1.2G` …) werden beachtet, `b` ist Bit, `B` Byte. Unbekannte Einheiten, Leerzeilen, `#`-Kommentare, Kopfzeilen und `nan` überspringt das Tool und listet sie auf — es liest eine Zahl mit unbekannter Einheit nie stillschweigend in der Standard-Einheit. Mehr als 8.000 Zeichen Messwerte speichert das Tool weder im Browser noch im Link.

### Bandwidth-Delay Product & TCP Window

Eingaben: **Line rate**, **Round-trip time** (ms, Knöpfe von „LAN 0.3 ms“ bis „Worldwide 250 ms“), **TCP window** und optional **Packet loss** (%). Die Kacheln zeigen **Bandwidth-delay product** (Rate × RTT ÷ 8 — so viele Bytes müssen unterwegs sein, damit die Leitung ausgelastet ist), **Buffer (2 × BDP)**, **Window limit** (höchstens ein Fenster pro Round Trip), **Without window scaling** (Fenster bei 65.535 Byte), mit Paketverlust **Loss limit (Mathis)** und als Fazit **One TCP stream ≤**.

Der Block „sysctl for this BDP“ liefert eine Datei `/etc/sysctl.d/90-tcp-buffers.conf`. Linux braucht etwa den doppelten Puffer als Fenster, deshalb rundet das Tool 2 × BDP auf volle MiB auf. Der Schnipsel hebt nur Maxima an und senkt nie die Kernel-Vorgaben (`tcp_rmem` bis 6 MiB, seit Linux 6.16 32 MiB; `tcp_wmem` 4 MiB): `tcp_rmem` setzt er nie unter 32 MiB, und reicht 2 × BDP für die Vorgaben, steht dort nur „Nothing to change“. „Apply, check & measure“ enthält `sysctl -p`, die Abfrage der aktuellen Werte sowie `ping` und `iperf3` zum Messen. Die Mathis-Grenze (≤ MSS × 8 ÷ RTT × 1,22 ÷ √Verlust) gilt für Reno-artige Staukontrolle; CUBIC schneidet etwas besser ab, BBR folgt dem Modell nicht. Parallele Streams (`iperf3 -P`, `rclone --transfers`) vervielfachen alle Grenzen.

## Server Tuning

Der Tab dimensioniert einen Webserver als Ganzes: Ein Speicherplan verteilt das RAM, die Abschnitte für PHP-FPM, OPcache, MySQL/MariaDB, nginx und Apache rechnen darauf auf und liefern Konfigurationsschnipsel.

### Server & Memory Plan

- **RAM** (GiB/MiB), **CPU threads** (wie `nproc`), **Reserve: OS & other services** (Kernel, Mindest-Page-Cache, sshd, Monitoring, Redis …).
- **Web stack**: `nginx + PHP-FPM`, `Apache event + PHP-FPM` oder `Apache prefork + mod_php`. Abschnitte, die nicht zum gewählten Stack gehören, markiert das Tool mit einem Hinweis als inaktiv (die nginx-Zahlen bleiben trotzdem nutzbar, etwa für nginx als Reverse Proxy vor Apache).
- **Paths for**: `Debian / Ubuntu` oder `RHEL / Alma / Rocky` — bestimmt die Dateipfade in den Schnipseln (z. B. `/etc/php/8.3/fpm/pool.d/www.conf` gegenüber `/etc/php-fpm.d/www.conf`).
- **PHP version**: 8.1 bis 8.5.
- Schalter „The database runs on this server“: Ist er an, reserviert der Plan den Worst Case der Datenbank aus dem MySQL/MariaDB-Abschnitt.

Die Tabelle zieht vom RAM die Reserve, ggf. den Datenbank-Worst-Case und beim Event-Stack die Apache-Prozesse ab. Übrig bleibt **Available for PHP-FPM workers** (bzw. für Apache + mod_php); darunter steht, wie viel unter Volllast belegt ist und was übrig bleibt. Bleibt nichts übrig, meldet der Plan das als Fehler.

### PHP-FPM Pool

Eingaben: **Ø RSS** (mittlerer Speicher eines Workers in MiB), **Pools**, **Pool name**, **Traffic** („Varies, with daily peaks“, „Steady and busy“, „Low or occasional“), **Process manager `pm`** (Empfehlung oder fest `dynamic`/`static`/`ondemand`), **min_spare**, **max_spare**, **start** (leer = automatisch), **max_requests**, **idle** (Sekunden, für ondemand) und **memory_limit**. Bei `Apache prefork + mod_php` ist der Abschnitt inaktiv, PHP läuft dann in den Apache-Prozessen.

- `pm.max_children = floor(verfügbar ÷ Pools ÷ Ø RSS)`.
- Die Empfehlung für `pm`: `ondemand` bei wenig Traffic oder ab vier Pools (Leerlauf-Pools geben Speicher zurück), `static` bei gleichmäßiger Last und einem Pool, sonst `dynamic`. Die Begründung steht unter den Kacheln („Why dynamic: …“).
- **Heuristic:** min_spare ≈ 10 %, max_spare ≈ 30 % von max_children (mindestens 1). `pm.start_servers` lässt das Tool beim PHP-Default min + (max − min) ÷ 2. Es prüft dieselbe Bedingung wie php-fpm, das sonst nicht startet: 0 < min_spare ≤ start ≤ max_spare ≤ max_children — die Meldungen sind die von php-fpm.
- **Heuristic:** `pm.max_requests = 500` recycelt Worker mit Speicherlecks (PHP-Default 0 = nie).
- **Worst case** = memory_limit × alle Worker — nur, wenn jede Anfrage gleichzeitig ans Limit geht. Übersteigt das den verfügbaren Speicher, erscheint ein Hinweis.

Der Block „Measure the average RSS of the workers“ liefert einen `ps`/`pgrep`-Einzeiler, der nur die Worker misst (das Muster `php-fpm: poo[l]` lässt den Master und den eigenen Befehl außen vor), und eine PSS-Variante über `/proc/<pid>/smaps_rollup`. RSS zählt den gemeinsam genutzten OPcache in jedem Worker mit; das Ergebnis liegt also auf der sicheren Seite, PSS ist näher an der Wahrheit. „Pool configuration“ ist der fertige Pool-Abschnitt mit `pm`, `pm.max_children`, je nach Modus den Spare- bzw. Idle-Werten, `pm.max_requests` und `pm.status_path = /fpm-status`.

### OPcache

Eingaben: **Document roots** (für den Zählbefehl), **PHP files**, **Headroom** (%, Vorgabe 20), **KiB / file** (Vorgabe 32), **memory** und **interned** (MB, leer = automatisch), **Changed files** („Check timestamps (edits go live)“ oder „Never check (deploy resets cache)“) und **revalidate** (Sekunden). „Count the PHP files“ erzeugt `find … -type f -name '*.php' | wc -l`.

- **Max. files** = Dateien + Headroom; **Hash slots** = die erste Primzahl ≥ dieser Einstellung aus der Tabelle in PHPs `zend_accelerator_hash.c` (…, 7963, 16229, 32531, 65407, 130987 …), denn genau so groß legt PHP die Tabelle an.
- Erlaubt sind 200 bis 1.000.000. Ein Wert außerhalb wird von PHP **verworfen**, nicht gekappt: Es bleibt beim Default 10.000 mit 16.229 Slots (laut Tool getestet mit PHP 8.2 bis 8.5).
- **Heuristic** für den Speicher: Dateien × KiB pro Datei × 1,25 plus Interned-Strings-Puffer, aufgerundet auf 32 MB, mindestens 128. Gemessene Richtwerte mit PHP 8.4: WordPress-Core 33 KiB pro Datei, WordPress mit Plugins 20, TYPO3 14 14, Joomla 6 12.
- **Heuristic** für den Interned-Strings-Puffer: etwa 3 KiB pro Datei, mindestens 8 MB. Er wird **aus** `memory_consumption` genommen — ist er genauso groß, startet OPcache nicht.

Der Block „php.ini (drop-in file)“ enthält `opcache.enable`, `memory_consumption`, `interned_strings_buffer`, `max_accelerated_files` und je nach Wahl `validate_timestamps = 1` mit `revalidate_freq` oder `validate_timestamps = 0` mit dem Hinweis, dass Deploys den Cache zurücksetzen müssen. Darunter steht, wie du die Änderung anwendest (`systemctl reload` für PHP-FPM, bei mod_php ein Apache-Neustart) — und dass das den Cache leert. Zur Kontrolle unter Last empfiehlt das Tool `opcache_get_status()` aus einer Web-Anfrage (die CLI hat einen eigenen Cache): `oom_restarts` und `hash_restarts` sollten bei 0 bleiben.

### MySQL / MariaDB (InnoDB)

Eingaben: **Server** (`MySQL 8.4`, `MySQL 8.0 (≥ 8.0.30)`, `MariaDB 10.11 / 11.4 / 11.8`, `MariaDB 10.5 / 10.6`), **Buffer pool size** (Anteil am RAM, „Dedicated database server“ oder feste Größe), **chunk**, **instances**, **max_connections**, Schalter **Binary log on** und **Redo log size** („Dedicated-server rule“ oder „1 hour of measured writes“ mit der gemessenen Redo-Menge pro Stunde). Im aufklappbaren Bereich „Per-connection and global buffers“ überschreibst du bei Bedarf die Puffer (`sort_buffer_size`, `join_buffer_size`, `read_buffer_size`, `read_rnd_buffer_size`, `thread_stack`, `binlog_cache_size`, `net_buffer_length`, `tmp_table_size`, `max_heap_table_size`, `key_buffer_size`, `innodb_log_buffer_size`, `query_cache_size`, `aria_pagecache_buffer_size`, `temptable_max_ram` und „other“); leer heißt Server-Default.

Das Tool bildet die Rundungsregeln der Server nach:

- **MySQL 8.0/8.4 und MariaDB 10.5/10.6** runden den Buffer Pool **auf** ein Vielfaches von `chunk_size × instances` auf (ist das Produkt größer als der Pool, wird vorher die Chunk-Größe gesenkt). **MariaDB 10.11/11.x** rundet nicht mehr auf Chunks, sondern **ab** auf ganze MiB.
- **Instanzen** gibt es nur bei MySQL (MariaDB hat seit 10.5 einen Pool): unter 1 GiB immer 1; MySQL 8.0: 8; MySQL 8.4: min(Pool ÷ (2 × Chunk), CPU-Threads ÷ 4), 1 bis 64 — bei genau 1 GiB nimmt der Server laut Tool 2, obwohl das Handbuch 1 nennt.
- **Dedicated server** entspricht `innodb_dedicated_server`: unter 1 GiB RAM 128 MiB, bis 4 GiB 50 %, darüber 75 % (MySQL 8.4 zählt nur ganze GiB). Für MariaDB, die diese Option nicht kennt, dient die MySQL-8.0-Regel als Heuristik. Auf einem Server, den sich die Datenbank mit PHP teilt, nennt das Tool 25–50 % als üblichen Startwert.
- **Redo Log**: MySQL 8.4 dediziert = CPU-Threads ÷ 2 GiB (höchstens 16 GiB), MySQL 8.0 aus der Pool-Größe; die gemessene Variante dimensioniert für eine Stunde Spitzenlast. Ein größeres Log heißt weniger erzwungene Checkpoints, aber längere Crash-Recovery.
- **Worst case** wie bei mysqltuner: globale Puffer (Pool, key_buffer, innodb_log_buffer, query_cache, aria_pagecache) + max_connections × (sort + join + read + read_rnd + thread_stack + binlog_cache + net_buffer + min(tmp_table, max_heap)). Bei MySQL deckelt `temptable_max_ram` die In-Memory-Temp-Tabellen aller Verbindungen. `net_buffer_length` rechnet das Tool anders als mysqltuner mit ein.

Ausgabe ist ein `[mysqld]`-Drop-in (unter Debian etwa `/etc/mysql/mysql.conf.d/zz-tuning.cnf`, für MariaDB `…/mariadb.conf.d/99-tuning.cnf`, unter RHEL `/etc/my.cnf.d/tuning.cnf`) und ein Befehl, der die Redo-Schreibmenge über 60 Sekunden Spitzenlast misst. Laut Tool sind alle Rundungsregeln gegen echte Server geprüft (MySQL 8.0 und 8.4, MariaDB 10.6, 10.11 und 11.8).

### nginx

Eingaben: **worker_processes** (`auto` oder Zahl), **worker_connections**, **Role** („Reverse proxy / FastCGI“ oder „Static files only“) und **worker_rlimit_nofile** (leer = 2 × worker_connections). Kacheln: **Worker processes** (`auto` = CPU-Kerne), **Max. clients** (Worker × Verbindungen, als Proxy ÷ 2, weil jeder Client eine zweite Verbindung zum Upstream braucht), **Open files / worker** und **LimitNOFILE**.

Ausgegeben werden der `nginx.conf`-Ausschnitt, ein systemd-Override mit `LimitNOFILE` (über `systemctl edit nginx`) und ein Befehl, der das Limit eines laufenden Workers aus `/proc/<pid>/limits` liest. Warnungen erscheinen, wenn `worker_rlimit_nofile` unter worker_connections liegt (nginx meldet dann „worker_connections exceed open file resource limit“), wenig Luft lässt, über 1.048.576 liegt (dann muss erst `fs.nr_open` steigen) oder wenn du mehr Worker als Kerne einträgst.

### Apache httpd

Eingaben: **MPM** (`event (+ PHP-FPM)` oder `prefork (+ mod_php)`, durch den Web-Stack vorgegeben), **Ø RSS**, **MaxConn./Child** (MaxConnectionsPerChild), **ServerLimit**, **ThreadsPerChild** und **Async factor** (AsyncRequestWorkerFactor).

- **prefork + mod_php:** `MaxRequestWorkers = floor(verfügbar ÷ Ø RSS)`; über 256 muss `ServerLimit` mitwachsen (hartes Limit 200.000).
- **event + PHP-FPM:** `MaxRequestWorkers = ServerLimit × ThreadsPerChild`; über 64 Threads pro Kind braucht es `ThreadLimit`. Der Speicher ist ServerLimit × Ø RSS eines Kindprozesses (PHP läuft im FPM-Pool). Verbindungen mit allen Threads im Leerlauf: (AsyncRequestWorkerFactor + 1) × MaxRequestWorkers. Belegt Apache mehr als ein Viertel des RAMs, weist das Tool darauf hin.

Apache korrigiert widersprüchliche Werte beim Start; die Warnungen im Tool entsprechen laut Erklärung denen, die `httpd -t` ausgibt. Dazu kommen ein RSS-Messbefehl und der MPM-Konfigurationsblock. ServerLimit sollte auf vollen Servern etwas Luft für Prozesse lassen, die nach einem Reload noch auslaufen.

## Availability

Der Tab „Availability & SLA“ rechnet Verfügbarkeiten in fünf Abschnitten.

### SLA → Allowed Downtime

Aus dem **Availability target** (Knöpfe von 99 % bis 99,999 %) entsteht eine Tabelle mit der erlaubten Ausfallzeit pro Tag, Woche, Monat, Quartal und Jahr — gerundet und in der Spalte **Exact** genau. Das Jahr hat 365,25 Tage; bei **Month length** wählst du zwischen dem Durchschnittsmonat (Jahr ÷ 12 = 30,44 Tage) und dem 30-Tage-Monat (Quartal = 90 Tage). Eine Zeile darunter nennt die Zahl der „Neunen“. Bei 99,9 % sind das im Durchschnittsmonat 43 min 49,8 s, im Jahr 8 h 45 min 57,6 s. Intern rechnet das Tool direkt mit der Unverfügbarkeit, damit auch 99,9999 % keine Stellen verliert.

### Downtime → Availability

Umgekehrt: **Downtime** (Sekunden bis Tage) **per** Tag, Woche, Monat, Quartal oder Jahr ergibt die **Availability** samt Neunen und den Wert **Per year** bei gleicher Rate. Ist die Ausfallzeit länger als der Zeitraum, meldet das Tool 0 %.

### MTBF & MTTR

Verfügbarkeit = MTBF ÷ (MTBF + MTTR), beide in Stunden. Die Kacheln zeigen **Availability** und **Downtime per year** mit der Zahl der Ausfälle pro Jahr. Das ist ein Gleichgewichtswert — über die Verteilung der Ausfälle sagt er nichts.

### Composite Availability

Stufen in Reihe, die jede Anfrage durchläuft (über **Add tier** fügst du welche hinzu). Jede Stufe hat **Nodes n**, davon **Required k** und eine **Node availability %**; 2 Knoten mit 1 benötigtem sind ein Aktiv/Passiv-Paar, 3 mit 2 benötigten ein Quorum-Cluster. Vorgabe ist Load balancer (1 von 1, 99,99 %) → Web servers (1 von 2, 99,9 %) → Database (primary + replica) (1 von 2, 99,95 %).

Eine Stufe fällt aus, wenn weniger als k ihrer n Knoten laufen: U = Σ_{i<k} C(n,i)·a^i·(1−a)^(n−i). Stufen in Reihe multiplizieren sich: A = Π (1 − U). Die Kacheln zeigen **Total availability**, **Downtime per year** (mit Monatswert) und die **Weakest tier** samt ihrem Anteil an der Ausfallzeit. Angenommen sind unabhängige Ausfälle und ein sofortiger Failover — gemeinsame Stromversorgung, Netz, Deployments oder ein scheiternder Failover machen die echte Verfügbarkeit kleiner.

### Error Budget

Aus **SLO**, **Period** (Tage), **Elapsed** (bisher vergangene Tage) und **Downtime so far** (Minuten) entstehen **Budget**, **Used**, **Remaining** und **Burn rate** = (Ausfallzeit ÷ vergangene Zeit) ÷ (1 − SLO). Bei 1 reicht das Budget genau bis zum Ende des Zeitraums, bei 2 ist es nach der Hälfte aufgebraucht. Die Erklärung verweist auf das SRE Workbook von Google, das bei schnellem Verbrauch alarmiert (etwa 14,4 über eine Stunde bei einem 30-Tage-Budget).

## Backup

Der Tab „Backup Retention & Storage“ beantwortet, welche Snapshots deine Aufbewahrungsregeln behalten, wie viel Platz das kostet und ob das Backup ins Nachtfenster passt.

### Retention Rules

Unter **Tool** wählst du **restic**, **rustic** oder **borg**. Presets füllen typische Regeln ein: `7 d · 4 w · 12 m · 3 y` (Vorgabe), `24 h · 14 d · 8 w · 12 m`, `10 last · 7 d · 4 w · 6 m` und `30 d only`. Die Regelfelder heißen **Last**, **Hourly**, **Daily**, **Weekly** (pro ISO-Woche), **Monthly**, **Quarter-yearly** und **Half-yearly** (nur rustic) und **Yearly**; dazu **Keep within** mit Stunden, Tagen, Wochen, Monaten oder Jahren („everything newer than this“). Leer oder 0 schaltet eine Regel ab, −1 heißt unbegrenzt. Jede Regel behält den neuesten Snapshot eines Zeitraums, für so viele Zeiträume, die überhaupt Snapshots haben — Lücken zählen nicht mit.

### Snapshots: simulieren oder einfügen

- **Simulate a schedule**: **Backup runs** alle 1, 2, 3, 4, 6, 8 oder 12 Stunden, täglich, Montag bis Freitag, wöchentlich (Wochentag wählbar) oder monatlich (Tag des Monats; kürzere Monate nehmen ihren letzten Tag), dazu die Uhrzeit **At** und **Backups running for** (wie lange schon gesichert wird, höchstens 30 Jahre).
- **Paste snapshot list**: die Ausgabe von `restic snapshots` (auch `--json`), `rustic snapshots --json`, `borg list` (auch `--json`) oder einfach ein Zeitstempel pro Zeile. Sehr lange Listen (über 12.000 Zeichen) bleiben bis zum Neuladen erhalten, werden aber nicht gespeichert und nicht in Links übernommen.
- **Forget / prune runs on** — Datum und Uhrzeit des `forget`- bzw. `prune`-Laufs; **Today** setzt das heutige Datum.

### Kept Snapshots

Die Kacheln zeigen **Kept** (behalten von insgesamt, Zahl der entfernten), **Oldest restore point** mit Alter, **Newest**, **Last 7 / 31 / 365 days** (Wiederherstellungspunkte je Zeitraum) und **Other tools keep** — wie viele Snapshots die beiden anderen Programme mit denselben Regeln behalten würden. Eine Zeitleiste markiert die behaltenen Snapshots, die Tabelle nennt je Snapshot ISO-Woche, die Regel(n), die ihn behalten („Kept by“), und sein Alter.

„How the tools decide (and where they differ)“ beschreibt die Algorithmen. Alle drei gehen vom neuesten zum ältesten Snapshot und behalten den neuesten jeder Stunde, jedes Tages, jeder ISO-Woche (Montag bis Sonntag), jedes Monats oder Jahres, bis der Zähler aufgebraucht ist. Die Unterschiede:

- **restic** (portiert von 0.16.4, laut Tool verglichen mit `restic forget --dry-run --json` an 425 Snapshots und 26 Regelsätzen): Regeln überlappen — ein Snapshot kann gleichzeitig für daily, weekly und monthly zählen. Solange eine Regel noch Zähler übrig hat, bleibt auch der älteste Snapshot. `--keep-within` rechnet vom neuesten Snapshot zurück in Kalendermonaten.
- **rustic** (portiert aus `forget.rs` von rustic_core, ohne Vergleich mit einem rustic-Binary): wie restic, aber eine Woche ist „gleiches Kalenderjahr und gleiche ISO-Wochennummer“ — die Tage der ISO-Woche 1, die noch im Dezember liegen, bilden eine eigene Woche. Dazu kommen die Quartals- und Halbjahresregeln. `--keep-within` rechnet von jedem Snapshot vorwärts, mit abgeschnittenem Tag (31. Januar + 1 Monat = 28./29. Februar).
- **borg** (portiert von `prune_split` aus borg 1.4, verglichen mit borgs eigenem Python-Code an 405 Fällen): Regeln überlappen **nicht** — ein Snapshot, den schon `--keep-daily` behält, zählt nicht für `--keep-weekly`. 7 daily + 4 weekly behalten also bis zu 11. Kann eine Regel ihren Zähler nicht erreichen, behält sie das älteste Archiv. `--keep-within` rechnet ab jetzt, 1 Monat = 31 Tage, 1 Jahr = 365 Tage.

Simulierte Zeiten sind Uhrzeiten in einer Zeitzone ohne Sommerzeitwechsel. Bei eingefügten Listen mit UTC-Offset kann eine `--keep-within`-Grenze über einen Sommerzeitwechsel um eine Stunde abweichen — das Tool erklärt den Fall im Text.

### Commands

Für alle drei Programme stehen die Befehle mit deinen Regeln bereit, jeweils zuerst als Probelauf: `restic -r /srv/restic-repo forget --dry-run …` und danach mit `--prune`, `rustic -r /srv/rustic-repo --dry-run forget …` und `… forget … --prune`, für borg 1.2/1.4 `borg prune --dry-run --list …`, `borg prune --list …` und `borg compact`. Die Repository-Pfade sind Platzhalter. „Notes on the flags“ erklärt: restic und rustic wenden die Regeln pro Gruppe aus Host und Pfaden an (`--group-by host,paths`); „unbegrenzt“ heißt in restic `unlimited`, in rustic und borg `-1`; die `--keep-within`-Schreibweisen unterscheiden sich (restic `y`/`m`/`d`/`h` ohne Wochen, rustic `mo` für Monat und `m` für Minute, borg eine Zahl mit `H`/`d`/`w`/`m`/`y`); borg prunt das ganze Repository, wenn du nicht per `-a 'host-*'` einschränkst, und gibt seit 1.2 Platz erst mit `borg compact` frei.

### Storage Estimate

Eingaben: **Source data** (GB, TB, GiB, TiB), **Changes per day** (%), **Compression** (Faktor, z. B. 1,5 : 1 = zwei Drittel der Größe; 1 für bereits komprimierte Daten), **Full backup every** (Tage) und **Restore window** (Tage). Die Tabelle vergleicht sechs Strategien mit **Restore points**, **Storage** und **× source**:

- **Full backups only**, **Full + incremental**, **Full + differential** und **Deduplicated** — jeweils mit einer Sicherung pro Tag über das Wiederherstellungsfenster.
- **Deduplicated, kept snapshots** und **Full copies of the kept snapshots** — mit den Snapshots, die die Aufbewahrungssimulation oben behält.

Die Annahme: Jeden Tag wird ein zufälliger Anteil c der Daten überschrieben; zwischen zwei Sicherungen im Abstand g Tagen ist der geänderte Anteil 1 − (1 − c)^g. Dedupliziert: S · (1 + Σ (1 − (1 − c)^g)) über die Abstände der behaltenen Snapshots. Bei Voll + inkrementell darf eine Kette erst weg, wenn ihr letzter Tag aus dem Fenster gefallen ist (gerechnet wird der ungünstigste Moment davor); bei Voll + differenziell fallen alte Differenzen Tag für Tag weg. Alle Werte gelten nach dem Aufräumen; während eine Sicherung läuft, braucht sie den Platz einer weiteren. Echte Daten ändern sich meist an denselben Stellen und wachsen langsamer; Wachstum der Quelle selbst ist nicht eingerechnet.

### Backup Window

Mit **Throughput**, **Nightly window** (Stunden) und der Frage, was begrenzt — „the upload — compressed data (offsite, cloud)“ oder „reading the source — uncompressed data (local disk)“ —, rechnet das Tool **First backup** (ganze Quelle), **Daily backup** (geänderte Daten) und die Rate, die das tägliche Backup im Fenster bräuchte. Kompression zählt nur, wenn die Leitung der Engpass ist (die drei Programme komprimieren vor dem Senden). Nicht eingerechnet sind das Durchsuchen unveränderter Dateien (schnell mit intaktem Cache, langsam nach Cache-Verlust), viele kleine Dateien und Protokoll-Overhead.

### 3-2-1-1-0 Check

Eingaben: **Copies in total** (inklusive Original), **Media types**, **Offsite copies**, **Offline / immutable**, **Last restore test** (nie, vor über einem Jahr, innerhalb eines Jahres, innerhalb von drei Monaten) und der Schalter für regelmäßige `check`-Läufe. Das Tool prüft fünf Regeln — 3 Kopien, 2 Medientypen, 1 offsite, 1 offline oder unveränderlich, 0 Fehler — und vergibt „3-2-1-1-0 met“, „3-2-1 met“ oder „At risk“. Die Null-Fehler-Regel gilt nur als erfüllt, wenn der letzte Restore-Test höchstens drei Monate her ist **und** `check` regelmäßig läuft. Unveränderlich meint etwa Object Lock/WORM, ein append-only borg-Repository oder eine rotierte, abgesteckte USB-Platte. Das Fazit des Tools: „A backup that was never restored is a hope, not a backup.“

## SSD & UPS

### SSD Endurance

Eingaben: **Capacity**, **Warranty** (Jahre), **Endurance rating (datasheet)** als **TBW** oder **DWPD**, **Your writes** (GB/Tag, TB/Tag oder MB/s im Mittel) und **Extra write amplification**. Das Tool rechnet TBW = DWPD × Kapazität × 365 × Garantiejahre (und umgekehrt) und daraus **Years until TBW** = TBW ÷ (Schreibmenge pro Tag × WAF × 365) sowie die Schreibmenge, die genau bis zum Garantieende reicht.

Wichtig ist der WAF-Faktor: Die TBW-Angabe bezieht sich auf Host-Schreibzugriffe unter der Testlast des Herstellers (JEDEC JESD219, Client oder Enterprise), deren eigene Write Amplification schon eingepreist ist. Der Faktor im Tool ist deshalb **relativ** zu dieser Testlast — 1 heißt „wie im Test“. Höher setzt du ihn nur für Lasten, die den Flash stärker beanspruchen, etwa viele kleine zufällige oder synchrone Schreibzugriffe auf einer Client-SSD. Und: TBW ist eine Garantiegrenze, nicht der Punkt, an dem die SSD stirbt.

### SMART → Data Written & Wear

Optional fügst du die Ausgabe von `smartctl` oder `nvme smart-log` ein und klickst **Read values** — der Text wird nur im Browser gelesen und nicht gespeichert. Sonst trägst du die Werte von Hand ein:

- **NVMe**: **Data Units Written**, optional **Data Units Read** und **Percentage Used**. Eine Data Unit sind immer 1000 × 512 = 512.000 Byte, unabhängig vom LBA-Format.
- **SATA / SAS-SATA**: **Write counter (RAW_VALUE)**, die **Attribute**-Art (`Total_LBAs_Written` in Sektoren, `Host_Writes_32MiB`, `…_Writes_MiB` oder `…_Writes_GiB`) und die **Logical sector size** (512 oder 4096 Byte, laut `smartctl -i` „Sector Size“).
- **Power-on hours** (optional) für Raten und Restlaufzeit.

Ergebnisse sind unter anderem die geschriebene (und gelesene) Datenmenge, der verbrauchte Anteil der TBW aus dem Abschnitt darüber, die mittlere Schreibmenge pro Betriebstag und Schätzungen bis zur TBW bzw. bis 100 % „Percentage Used“. Mit **Use this rate as “Your writes”** übernimmst du die gemessene Rate in die Lebensdauerrechnung. „Pro Tag“ meint Tage **Betriebszeit** — ein Rechner, der nachts aus ist, braucht für dieselben Stunden mehr Kalendertage. Für das eingetragene **Device** erzeugt das Tool die passenden Befehle: `smartctl -a`, `nvme smart-log` und `smartctl -j -a` für NVMe, `smartctl -i -A`, die USB-Variante mit `-d sat` und eine Schleife über alle `/dev/sd?` für SATA.

### UPS Sizing

In der Geräteliste trägst du **Device**, **Watts** und **Qty** ein (**Add device** für weitere Zeilen); darunter steht die **Total load**. Das Tool empfiehlt gemessene Werte (Strommessgerät, PDU, `ipmitool dcmi power reading`) — Netzteil-Etiketten nennen das Maximum, nicht den Verbrauch.

Zur USV gehören **UPS rating (VA)**, die Wirkleistung wahlweise in **Watts** oder als **UPS power factor**, der **Load power factor**, **Max. load** (Vorgabe 80 %) und die Netzspannung **Mains** (230, 240, 120 oder 100 V). Eine USV hat zwei Grenzen, Scheinleistung (VA) und Wirkleistung (W); die Last-VA sind Watt ÷ Leistungsfaktor der Last, der Lastanteil ist der größere der beiden Quotienten. Bei Servern und PCs mit aktiver PFC (Leistungsfaktor 0,95–0,99) ist meist die Watt-Angabe die Grenze. Unter 80 % bleibt Luft für Einschaltströme und Wachstum, und die Laufzeit wird länger. Der Strom ist Last-VA ÷ Netzspannung, ohne Ladestrom und Verluste der USV.

Die Kacheln: **Load** (Watt und VA), **UPS load** (Anteil, mit der begrenzenden Größe W oder VA), **Headroom** bzw. **Over the limit** (wie viel Watt bis zur Lastgrenze noch dazukommen dürfen oder weg müssen), **Recommended rating** (nötige Watt und VA für deine Last bei der gewählten Grenze) und **Mains current**.

### Battery Runtime (estimate)

Die Last übernimmt dieser Abschnitt aus der Geräteliste von **UPS Sizing**. Eingaben: **Battery type** (Blei AGM/VRLA k ≈ 1,15, Gel 1,2, Nass 1,25, LiFePO4 1,05 oder eigener Exponent), **Peukert k**, **Battery** (Volt), **Capacity** (Ah), **Batteries** (Anzahl), **Rated at** (Nenn-Entladezeit in Stunden, bei Blei meist 20 h), **Inverter eff.**, **Usable DoD** und **Health**.

Die Kacheln zeigen **Estimated runtime** (bei mehr als 80 % Gesundheit zusätzlich den Wert bei 80 %), **Without Peukert**, **Usable capacity** (nutzbarer Anteil der Nenn-Ah bei diesem Strom) und **Battery power** mit dem Strom pro Batterie. Eine Tabelle ergänzt die Laufzeit mit und ohne Peukert für die aktuelle Last und für 25, 50, 75 und 100 % der Watt-Nennleistung der USV. Über **Target runtime** (Minuten) rechnet das Tool aus, wie viele Ah jede Batterie für diese Laufzeit bräuchte (**Needed per battery**), und sagt, ob die vorhandenen reichen.

Die Formel: Batterieleistung P = Last ÷ Wechselrichter-Wirkungsgrad, Strom je Batterie I = (P ÷ Anzahl) ÷ Spannung, Peukert t = H × (C ÷ (I × H))^k, Laufzeit = t × DoD × Gesundheit; „Without Peukert“ = V × Ah × Anzahl × DoD × Gesundheit ÷ P. Unterhalb des Nennstroms deckelt das Tool auf die Nennkapazität. Weil eine USV in Minuten entlädt, weit weg von der 20-Stunden-Kalibrierung, ist das Ergebnis eine Extrapolation — das Tool sagt deutlich: Die Laufzeitkurve des Herstellers schlägt diese Rechnung. Bleiakkus gelten bei etwa 80 % Gesundheit als verschlissen (typisch nach 3–5 Jahren in einer USV).

### Power, Cost & Heat

**Power draw** (oder per Häkchen **Use the UPS load total**), **Hours per day**, **UPS efficiency** (100 % = keine USV; line-interactive etwa 95–98 %, online 88–96 %), **Electricity price** und **Currency** ergeben **Wall power**, **Energy per year**, **Cost per year**, die Verluste der USV und **Heat** in BTU/h. Formeln: Wandleistung = W ÷ USV-Wirkungsgrad, kWh pro Jahr = Wandleistung × Stunden × 365 ÷ 1000, Wärme = Wandleistung × 3,412142 BTU/h — praktisch die gesamte elektrische Leistung endet als Wärme im Raum, die USV-Verluste eingeschlossen. Trag eine mittlere Leistung ein, keine Spitze.

## Architektur, Datenschutz und Grenzen

- **Rein clientseitig:** Alle Rechnungen laufen als JavaScript im Browser. Es gibt keinen Server-Endpunkt, kein API und keine Telemetrie; die PHP-Seite rendert nur das Tab-Gerüst. Jeder Tab besteht aus einem DOM-freien Rechenkern und einer dünnen Oberflächenschicht — ein Fehler in einem Tab legt die anderen nicht lahm.
- **Speicherung:** Eingaben liegen pro Tab im Local Storage deines Browsers. Ist er nicht verfügbar (etwa bei blockierten Website-Daten), funktioniert das Tool trotzdem, merkt sich nur nichts. Eingefügte Rohdaten bleiben außen vor: Das `ls -la`-Listing und die `smartctl`-Ausgabe werden nie gespeichert, Messwerte für das 95. Perzentil über 8.000 Zeichen und Snapshot-Listen über 12.000 Zeichen ebenfalls nicht.
- **Share-Links enthalten deine Eingaben:** Alles, was du in einen Tab tippst — Gerätenamen, Pfade, Poolnamen —, steht kodiert im Link von **Copy link**. Werte aus einem fremden Link prüft das Tool wie Fremdeingaben (Auswahllisten nur aus erlaubten Werten, Zahlen begrenzt, Texte gekürzt).
- **Modelle, keine Messungen:** Leistungswerte, URE-Risiken, Akkulaufzeiten und Speicherschätzungen sind ausdrücklich Modelle mit offengelegten Annahmen. Wo es ein echtes Programm gibt, gilt dessen Verhalten — und vor dem Einsatz eines Befehls deine eigene Prüfung.
- **Bewusst nicht enthalten:** Subnetzrechner, Cron, SSH-Befehle, Docker und Zeitzonen haben eigene Tools (siehe [Übersicht](https://www.jpkc.com/db/tools/sysadmin/)); ZFS dRAID, Ceph/Erasure Coding und ACLs (`setfacl`) rechnet SysAdmin Tools nicht.

Für den Einstieg siehe die [Übersichtsseite](https://www.jpkc.com/db/tools/sysadmin/), konkrete Durchläufe stehen in den [Beispielen](https://www.jpkc.com/db/tools/sysadmin/examples/), 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/).

