---
title: "Was passt auf 1 GB RAM? Die Bilanz der Mini-Server-Reihe"
date: 2026-11-15T18:11:59+01:00
modified: 2026-11-15T18:11:59+01:00
category: cloud
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/mini-server-1gb-ram-bilanz-empfehlung
keywords:
  - Mini-Server
  - Docker
  - Swap
  - Speichergrenzen
  - WordPress
  - Nextcloud
  - Lasttest
  - netcup
reading_time: 12
---

# Was passt auf 1 GB RAM? Die Bilanz der Mini-Server-Reihe

Was passt auf einen Server mit 1 GB RAM und einer vCPU, und wie richtet man ihn ein, damit er unter Last nicht umfällt? Sieben Teile lang wurde ein netcup VPS piko G11s vermessen, zuletzt mit so vielen Diensten, bis er brach. Diese Anleitung fasst die Einstellungen zusammen, die sich bewährt haben, und prüft sie in einem Bestätigungslauf: WordPress, fünf kleine Dienste und Nextcloud, je eine Stunde unter Last.

**Dies ist Teil 8 und der letzte Teil der Reihe „Mini-Server“.**

**Kurzfassung:** Auf 1 GB RAM passen eine statische Website, WordPress mit Seiten-Cache und eine Handvoll kleiner Dienste. Dafür braucht der Server fünf Einstellungen: unnötige Systemdienste entfernen, eine Swapdatei mit 1 GiB, Speichergrenzen für jeden Dienst, höchstens 8 Apache-Prozesse je PHP-Container und Anmeldungen per Token oder App-Passwort statt Kontopasswort. Im Bestätigungslauf hielt der Server so zweimal eine Stunde Mischlast mit WordPress, Nextcloud und fünf kleinen Diensten durch, dazu eine Gegenprobe ohne Grenzen für die kleinen Dienste, alle ohne OOM-Kill und ohne Bruch. Nur bei Aufrufen aus der ersten Lastminute nach einem frischen Start liefen einige Aufrufe in die Zeitüberschreitung. Nicht geholfen haben zram mit voller RAM-Größe, ein Schutz der Datenbank per `oom_score_adj` und Speichergrenzen ohne Prozesslimit.

## Was Sie brauchen

- [ ] Einen Linux-Server mit 1 GB RAM, Ubuntu 24.04 und [Docker mit Compose](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage), hier der Mini-Server aus [Teil 1](https://s-edv.com/anleitungen/mini-server-1gb-ram-leerlauf-docker-messung).
- [ ] Root-Zugang per SSH.
- [ ] Für eigene Messungen einen zweiten Rechner mit k6 als Lastgenerator wie in [Teil 2](https://s-edv.com/anleitungen/mini-server-caddy-statische-website-lasttest-k6). Lasttests nur auf eigenen Systemen.

## Schritt 1: Ubuntu verschlanken

Von 1.024 MiB sieht Ubuntu nur 957 MiB, frisch installiert waren davon 663 MiB verfügbar. snapd, multipathd, udisks2 und ModemManager braucht ein VPS nicht. Ohne sie kam der Server in [Teil 1](https://s-edv.com/anleitungen/mini-server-1gb-ram-leerlauf-docker-messung) auf 714 MiB. Prüfen Sie vorher mit `snap list`, ob Snap-Pakete installiert sind, sie verschwinden mit snapd:

```bash
# snap list
# apt-get purge snapd multipath-tools modemmanager udisks2
# apt-get autoremove --purge
# rm -rf /snap /var/snap /var/lib/snapd /var/cache/snapd
# reboot
```

> **Prüfen:** **Verifizieren:** `free -m` zeigt in der Spalte `available` rund 50 MiB mehr als vorher. Im Dauerbetrieb lagen auf dem Testserver mit Docker und einem Container 576 bis 623 MiB verfügbar, weil der Kernel Zwischenspeicher aufbaut und fwupd später startet. apt entfernt dabei auch die Metapakete ubuntu-server und ubuntu-server-minimal.

## Schritt 2: Swapdatei mit 1 GiB anlegen

In [Teil 5](https://s-edv.com/anleitungen/mini-server-swap-zram-1gb-ram-messung) schlug die Swapdatei zram und den Betrieb ohne Swap: Ein ruhender Speicherfresser wurde ohne Swap schon bei 384 bis 512 MiB beendet, mit Swapdatei erst bei 1.408 bis 1.536 MiB. Bei Überlast blieb der Server mit Swapdatei per SSH erreichbar, und der OOM-Killer griff nicht ein.

```bash
# fallocate -l 1G /swapfile
# chmod 600 /swapfile
# mkswap /swapfile
# echo '/swapfile none swap sw 0 0' >> /etc/fstab
# reboot
```

Den Wert `vm.swappiness` lassen Sie auf dem Standard 60, alle Messungen der Reihe liefen damit.

> **Prüfen:** **Verifizieren:** Nach dem Neustart zeigt `swapon --show` die Datei `/swapfile` mit 1 GiB.

## Schritt 3: WordPress mit Grenzen, 8 Prozessen und Seiten-Cache

Das offizielle WordPress-Image erlaubt bis zu 150 Apache-Prozesse. In [Teil 3](https://s-edv.com/anleitungen/mini-server-wordpress-1gb-ram-lasttest-oom) startete Apache bei 6 Aufrufen pro Sekunde 77 Prozesse, der Server war minutenlang nicht erreichbar, am Ende beendete der Kernel die Datenbank. Eine Speichergrenze allein half in [Teil 6](https://s-edv.com/anleitungen/mini-server-docker-speichergrenzen-oom-1gb-ram) nicht: Der Kernel beendete im Container 305-mal Apache-Prozesse, auch 21 Minuten nach Lastende war die Seite noch nicht zurück. Erst Grenze und höchstens 8 Prozesse zusammen brachten den Server ohne einen einzigen Kill durch die Überlast. Legen Sie dafür neben die `compose.yaml` eine Datei `mpm8.conf`:

Datei: `mpm8.conf`

```apache
<IfModule mpm_prefork_module>
	StartServers		 2
	MinSpareServers		 2
	MaxSpareServers		 8
	MaxRequestWorkers	 8
	MaxConnectionsPerChild   500
</IfModule>
```

Ergänzen Sie in der `compose.yaml` bei WordPress und MariaDB je eine Grenze, bei WordPress zusätzlich die neue Datei. Die übrigen Einstellungen der Dienste bleiben wie bisher:

Datei: `compose.yaml`

```yaml
services:
  wp:
    mem_limit: 384m
    volumes:
      - ./html:/var/www/html
      - ./mpm8.conf:/etc/apache2/mods-available/mpm_prefork.conf:ro
  db:
    mem_limit: 256m
```

Installieren Sie danach in WordPress das Plugin Cache Enabler. Ohne Seiten-Cache schaffte WordPress in [Teil 3](https://s-edv.com/anleitungen/mini-server-wordpress-1gb-ram-lasttest-oom) sauber 4 Aufrufe pro Sekunde, mit Cache 50.

> **Prüfen:** **Verifizieren:** Nach `docker compose up -d` zeigt `docker compose exec wp grep MaxRequestWorkers /etc/apache2/mods-available/mpm_prefork.conf` den Wert 8.

## Schritt 4: Jedem Dienst eine Speichergrenze geben

Ohne Grenze riss in [Teil 6](https://s-edv.com/anleitungen/mini-server-docker-speichergrenzen-oom-1gb-ram) ein einziger undichter Container WordPress mit, jeder zweite Aufruf scheiterte. Mit Grenze traf es nur noch den Container selbst. Für die übrigen Dienste liegen die Grenzen mit Reserve über dem höchsten Wert aus [Teil 7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch), sowohl beim RAM allein als auch bei RAM plus Swap. Nextcloud bekam 384 MiB wie im Gegenlauf aus Teil 7. Im Bestätigungslauf galten diese Grenzen, als eigene Datei `grenzen.yaml`:

Datei: `grenzen.yaml`

```yaml
services:
  kuma:
    mem_limit: 256m
  vaultwarden:
    mem_limit: 96m
  ntfy:
    mem_limit: 96m
  adguard:
    mem_limit: 128m
  forgejo:
    mem_limit: 256m
  nextcloud:
    mem_limit: 384m
    volumes:
      - ./mpm8.conf:/etc/apache2/mods-available/mpm_prefork.conf:ro
```

Ohne `memswap_limit` darf jeder Container zusätzlich zur Grenze noch einmal so viel Swap belegen. Das ist gewollt: Selten genutzter Speicher wandert in die Swapdatei, statt dass der Kernel den Dienst beendet. Hängen Sie die Datei an die Variable `COMPOSE_FILE` in der `.env` aus [Teil 7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch), Schritt 1 an, damit Compose sie bei jedem Befehl als letzte Datei mitliest:

```bash
# sed -i 's/^COMPOSE_FILE=.*/&:grenzen.yaml/' .env
# grep COMPOSE_FILE .env
# docker compose up -d
```

> **Prüfen:** **Verifizieren:** `docker inspect` zeigt für jeden Container die Grenze in Byte, im Bestätigungslauf so (Projektname angepasst):
>
> ```bash
> # docker inspect -f '{{.Name}} {{.HostConfig.Memory}}' $(docker compose ps -q)
> ```
>
> ```plaintext
> /server-adguard-1 134217728
> /server-caddy-1 0
> /server-db-1 268435456
> /server-forgejo-1 268435456
> /server-kuma-1 268435456
> /server-nextcloud-1 402653184
> /server-ntfy-1 100663296
> /server-vaultwarden-1 100663296
> /server-wp-1 402653184
> ```
>
> Ein Container mit `0` hat keine Grenze. Das war im Test nur Caddy.

## Schritt 5: Anmelden mit Token und App-Passwort

Zweimal in der Reihe kippte nicht der Speicher, sondern die Anmeldung. Jedes Kontopasswort prüfen die Dienste mit einem absichtlich teuren Hash, und auf einer einzigen vCPU kostet das spürbar Zeit. ntfy brach in [Teil 4](https://s-edv.com/anleitungen/mini-server-uptime-kuma-vaultwarden-ntfy-adguard-1gb-ram) mit Passwort schon bei 10 Nachrichten pro Sekunde ein, mit Zugriffstoken stellte es rund 70 pro Sekunde zu. Nextcloud mit Kontopasswort brachte in [Teil 7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch) den ganzen Server zum Stehen, mit App-Passwort lief dieselbe Stufe ohne Bruch. Legen Sie für Skripte und Clients deshalb Tokens an:

```bash
# docker compose exec ntfy ntfy token add admin
# docker compose exec -u www-data nextcloud php occ user:auth-tokens:add admin
```

Der Nextcloud-Befehl fragt nach dem Anmeldepasswort des Kontos und gibt danach das App-Passwort aus. Begrenzen Sie bei Nextcloud außerdem die Apache-Prozesse wie bei WordPress, das Image erlaubt ebenfalls 150. Im Bestätigungslauf hatte Nextcloud eine Grenze von 384 MiB und dieselbe `mpm8.conf` wie WordPress.

> **Prüfen:** **Verifizieren:** Eine WebDAV-Abfrage mit App-Passwort dauerte auf dem ruhigen Server 0,15 bis 0,19 Sekunden, mit Kontopasswort 0,64 bis 0,71 Sekunden.

## Schritt 6: Swap und Speicherdruck im Blick behalten

Auf einem Mini-Server mit Swap sagt der freie Speicher allein wenig. Wichtig sind der belegte Swap und der Speicherdruck:

```bash
# free -m
# cat /proc/pressure/memory
```

In [Teil 7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch) antwortete WordPress unter 700 ms, solange der Swap unter rund 400 MiB blieb. Ab 900 MiB wurde es eng. Der Wert `some avg10` in `/proc/pressure/memory` blieb in den ruhigen Stufen unter 15 %. Beachten Sie, dass `docker stats` nur den Teil eines Containers zeigt, der im RAM liegt, den Swap zählt es nicht mit.

> **Prüfen:** **Verifizieren:** So sah `free -m` am Ende der Laststunde in Lauf 2 aus:
>
> ```plaintext
>                total        used        free      shared  buff/cache   available
> Mem:             957         799          67          35         262         157
> Swap:           1023         447         576
> ```

## So wurde gemessen

Der Server war wie in den Schritten 1 bis 5 eingerichtet und startete vor jedem Lauf neu. Danach kamen im Minutenabstand Uptime Kuma, Vaultwarden, ntfy, AdGuard Home, Forgejo und Nextcloud dazu, neun Container mit WordPress, MariaDB und Caddy. Nach drei weiteren Minuten Warmlauf schickte k6 vom zweiten Server eine Stunde lang die Mischlast aus [Teil 7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch), mit WordPress bei 2 Aufrufen pro Sekunde und 20 DNS-Anfragen pro Sekunde an AdGuard Home. Nach 20 Minuten Pause folgten zehn Minuten Last für den Anlauf. Ein Skript auf dem Server schrieb etwa alle 2 Sekunden Speicher, Swap, Druck und den Speicher jedes Containers mit.

Als Bruch galt wie in Teil 7: ein OOM-Kill, WordPress-Antwortzeit p95 über 2 Sekunden, ein Dienst mit mehr als 5 % Fehlern oder ein Ausfall von SSH. AdGuard Home verliert wie in Teil 7 in jedem Messfenster rund 4,5 % der DNS-Anfragen, dieser Grundwert fließt nicht in die Wertung ein. Gemessen wurde zweimal mit allen Grenzen (Lauf 1 und 2) und einmal als Gegenprobe ohne Grenzen für Uptime Kuma, Vaultwarden, ntfy, AdGuard Home und Forgejo (Lauf 3). WordPress, MariaDB und Nextcloud hatten in allen drei Läufen ihre Grenze.

## Ergebnis: drei Läufe über je eine Stunde

![Diagramm: WordPress-Antwortzeit je Minute und belegter Swap in drei einstündigen Läufen unter Mischlast, Fehler nur in der ersten Minute](https://s-edv.com/uploads/2026/11/e0e3b48625f4e8cc10465c79ae50c9737f66a30bf240651a9ed18e99872d5244-1024.png)
*Bestätigungslauf: WordPress-Antwortzeit und Swap über eine Stunde Last und den Anlauf nach 20 Minuten Pause*

| Messfenster | WordPress p95 | Fehler gesamt | Verfügbar (Median) | Swap belegt (Median, Höchstwert) | OOM-Kills |
| --- | --- | --- | --- | --- | --- |
| Lauf 1, 60 min | 661 ms | 73 von 14.388 (0,51 %) | 157 MiB | 465 MiB, höchstens 503 MiB | 0 |
| Lauf 1, nach 20 min Pause | 565 ms | 0 von 2.402 (0,00 %) | 201 MiB | 485 MiB, höchstens 538 MiB | 0 |
| Lauf 2, 60 min | 538 ms | 26 von 14.390 (0,18 %) | 157 MiB | 420 MiB, höchstens 457 MiB | 0 |
| Lauf 2, nach 20 min Pause | 569 ms | 0 von 2.405 (0,00 %) | 187 MiB | 467 MiB, höchstens 485 MiB | 0 |
| Lauf 3 (kleine Dienste ohne Grenze), 60 min | 497 ms | 15 von 14.393 (0,10 %) | 160 MiB | 409 MiB, höchstens 444 MiB | 0 |
| Lauf 3, nach 20 min Pause | 653 ms | 0 von 2.406 (0,00 %) | 186 MiB | 466 MiB, höchstens 511 MiB | 0 |

Keiner der drei Läufe brach: kein OOM-Kill, SSH blieb erreichbar, WordPress antwortete über die Stunde bei 95 % der Aufrufe in 497 bis 661 ms. Alle Fehler betrafen Aufrufe aus der ersten Lastminute, dort liefen 68, 23 und 14 WordPress-Aufrufe in die Zeitüberschreitung von 10 Sekunden, dazu 5, 3 und 1 bei Nextcloud. In dieser Minute schob der Kernel rund 120 bis 180 MiB in den Swap, und der CPU-Druck (`some avg10` in `/proc/pressure/cpu`) stieg auf 87 bis 98 %. Der Anlauf nach 20 Minuten Pause lief in allen drei Läufen ohne Fehler, in seiner ersten Minute blieb der CPU-Druck unter 45 %. Die Gegenprobe ohne Grenzen für die kleinen Dienste zeigte dasselbe Bild, die Startfehler kommen also nicht von den Grenzen der kleinen Dienste. Der Swap pendelte sich bei 409 bis 465 MiB ein, weit unter den rund 900 MiB, ab denen es in Teil 7 eng wurde. In Lauf 1 lagen drei einzelne Minuten bei 1,6 bis 2,5 Sekunden, ohne erkennbaren Anlass im Speicher.

## Was auf 1 GB RAM passt

| Was | Ergebnis in der Reihe | Teil |
| --- | --- | --- |
| Statische Website mit Caddy | passt mühelos, bis rund 1.450 Aufrufe pro Sekunde ohne Fehler, die CPU ist die Grenze | [2](https://s-edv.com/anleitungen/mini-server-caddy-statische-website-lasttest-k6) |
| WordPress ohne Cache | passt, sauber bis 4 Aufrufe pro Sekunde | [3](https://s-edv.com/anleitungen/mini-server-wordpress-1gb-ram-lasttest-oom) |
| WordPress mit Cache Enabler | passt, 50 Aufrufe pro Sekunde ohne Fehler | [3](https://s-edv.com/anleitungen/mini-server-wordpress-1gb-ram-lasttest-oom) |
| Uptime Kuma, Vaultwarden, ntfy, AdGuard Home | passen zusammen neben WordPress, im Leerlauf rund 240 MiB mit Caddy | [4](https://s-edv.com/anleitungen/mini-server-uptime-kuma-vaultwarden-ntfy-adguard-1gb-ram) |
| dazu Forgejo | passt, WordPress unter 400 ms | [7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch) |
| dazu Nextcloud | passt nur mit App-Passwörtern; mit Kontopasswort ohne Grenze Zusammenbruch, mit Grenze und 8 Prozessen scheiterten 9,5 % der WordPress-Aufrufe | [7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch) |
| dazu Paperless-ngx | Grenze erreicht, Swap fast voll, in einem von zwei Läufen nach Ruhe ein bis zwei Minuten fast nur Fehler | [7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch) |
| dazu Jellyfin | zu viel, Swap voll, 27 % der WordPress-Aufrufe scheiterten | [7](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch) |

## Was nicht geholfen hat

- **zram mit voller RAM-Größe:** Unter Überlast fing sich der Server in [Teil 5](https://s-edv.com/anleitungen/mini-server-swap-zram-1gb-ram-messung) nach 32 Minuten nicht und brauchte einen harten Neustart. zram mit halber RAM-Größe brachte weniger zusätzlichen Platz als die Swapdatei.
- **Datenbank per `oom_score_adj` schützen:** In [Teil 6](https://s-edv.com/anleitungen/mini-server-docker-speichergrenzen-oom-1gb-ram) kam der Server in zwei von zwei Läufen nach der Überlast nicht mehr zurück.
- **Speichergrenze ohne Prozesslimit:** Mit 150 Apache-Prozessen in 384 MiB beendete der Kernel Prozess um Prozess, auch 21 Minuten nach Lastende war die Seite noch nicht zurück.
- **Swap gegen CPU-Überlast:** Kommen mehr Aufrufe, als die eine vCPU schafft, rettet kein Swap die Website. In [Teil 5](https://s-edv.com/anleitungen/mini-server-swap-zram-1gb-ram-messung), noch ohne Grenze für Apache, war die Seite bei 10 WordPress-Aufrufen pro Sekunde ohne Cache in jeder Swap-Variante minutenlang weg.

## Typische Fehler

**Der Server ist minutenlang nicht per SSH erreichbar, danach wurde die Datenbank neu gestartet**

Apache hat den Speicher aufgebraucht, und der Kernel hat MariaDB beendet. Im Kernel-Protokoll steht dann `Out of memory: Killed process … (mariadbd)`. Setzen Sie die 8 Apache-Prozesse und Grenzen aus Schritt 3 und legen Sie die Swapdatei aus Schritt 2 an.

**`docker inspect` zeigt `OOMKilled false`, trotzdem startet ein Container ständig neu**

Nach einem Neustart durch die Restart-Policy steht der Wert wieder auf `false`. Zählen Sie mit `docker inspect -f '{{.RestartCount}}' NAME` und lesen Sie `dmesg` nach `Memory cgroup out of memory`.

**Nach einer ruhigen Phase sind die ersten Aufrufe sehr langsam**

Der Kernel hat Teile der Dienste ausgelagert und muss sie erst zurückholen. Mit fast vollem Swap dauerte das in Teil 7 ein bis zwei Minuten. Prüfen Sie den belegten Swap wie in Schritt 6 und nehmen Sie einen Dienst weg, wenn er dauerhaft über rund 900 MiB liegt.

**Direkt nach einem Neustart scheitern die ersten Aufrufe mit Zeitüberschreitung**

Kommt Last, kurz nachdem alle Dienste gestartet sind, lagert der Kernel noch kräftig aus, und die eine vCPU ist voll belegt. Im Bestätigungslauf traf das nur Aufrufe aus der ersten Lastminute. Nach einer Stunde Betrieb und 20 Minuten Pause lief der Anlauf ohne Fehler. Planen Sie Neustarts deshalb in ruhige Zeiten.

## Häufige Fragen

### Reicht 1 GB RAM für Nextcloud allein?

Für Nextcloud mit App-Passwort, einem Benutzer und einer WebDAV-Abfrage alle zwei Sekunden reichte es im Test, auch neben WordPress und fünf kleinen Diensten. Vorschauen, Volltextsuche und viele gleichzeitige Synchronisationen wurden nicht gemessen.

### Wann lohnt sich ein größerer Server?

Sobald der Swap dauerhaft über rund 900 MiB liegt, oder wenn Dienste wie Paperless-ngx und Jellyfin dazukommen sollen. Auch wenn WordPress ohne Cache mehr als 4 Aufrufe pro Sekunde bekommt, ist die eine vCPU die Grenze, nicht der Speicher.

### Warum nicht einfach mehr Swap?

Swap hilft nur bei Speicher, der ruht. Mit Jellyfin war in Teil 7 der Swap voll, der Speicherdruck stieg auf bis zu 37 %, und 27 % der WordPress-Aufrufe scheiterten. Wird ausgelagerter Speicher ständig gebraucht, muss der Kernel ihn immer wieder zurückholen, und daran ändert auch eine größere Swapdatei nichts.

## Fazit

Ein Server mit 1 GB RAM und einer vCPU trägt mehr, als die Zahl vermuten lässt: WordPress mit Seiten-Cache, fünf kleine Dienste und Nextcloud liefen in allen drei Läufen eine Stunde unter Mischlast ohne Bruch. Entscheidend sind das Prozesslimit für Apache, die Swapdatei und Tokens statt Kontopasswörtern. Die Grenzen je Dienst machten die Antwortzeiten nicht besser, die Gegenprobe ohne sie war über die Stunde etwas schneller und im Anlauf etwas langsamer. Sie schützen aber wie in Teil 6 die übrigen Dienste, wenn ein Container undicht wird. Schwach bleibt die erste Minute nach einem Neustart, und für Paperless-ngx oder Jellyfin reicht der Speicher nicht mehr. Wer mehr braucht, nimmt den nächstgrößeren Server statt mehr Swap.

## Weiterführende Anleitungen und Quellen

- [Mini-Server Teil 1: Was bleibt von 1 GB RAM übrig?](https://s-edv.com/anleitungen/mini-server-1gb-ram-leerlauf-docker-messung)
- [Mini-Server Teil 2: Wie viele Aufrufe schafft ein Kern?](https://s-edv.com/anleitungen/mini-server-caddy-statische-website-lasttest-k6)
- [Mini-Server Teil 3: WordPress auf 1 GB RAM](https://s-edv.com/anleitungen/mini-server-wordpress-1gb-ram-lasttest-oom)
- [Mini-Server Teil 4: Vier kleine Dienste auf 1 GB RAM](https://s-edv.com/anleitungen/mini-server-uptime-kuma-vaultwarden-ntfy-adguard-1gb-ram)
- [Mini-Server Teil 5: Swap, zram oder nichts?](https://s-edv.com/anleitungen/mini-server-swap-zram-1gb-ram-messung)
- [Mini-Server Teil 6: Speichergrenzen für Docker-Container](https://s-edv.com/anleitungen/mini-server-docker-speichergrenzen-oom-1gb-ram)
- [Mini-Server Teil 7: Neun Dienste bis zum Bruch](https://s-edv.com/anleitungen/mini-server-dienste-1gb-ram-bis-zum-bruch)
- [Docker Compose: mem_limit](https://docs.docker.com/reference/compose-file/services/#mem_limit)
- [Linux-Kernel: Pressure Stall Information](https://docs.kernel.org/accounting/psi.html)
- [Apache: MaxRequestWorkers](https://httpd.apache.org/docs/2.4/mod/mpm_common.html#maxrequestworkers)
