# FrankenPHP und Caddy: PHP im Webserver, Tempo, Sicherheit und Betrieb

> FrankenPHP und Caddy eingeordnet: was der Worker-Modus bringt, wie ernst die Lückenwelle ist und wie Container sauber neu starten.

Source: https://www.jpkc.com/db/blog/frankenphp-caddy/

Caddy läuft bei mir seit einigen Jahren als Proxy (ein Server, der Anfragen an andere Dienste weiterreicht) und als Server für statische Seiten, auf einem eigenen Linux-Root-Server. Caddy ist gut, kann selbst aber kein PHP. Genau das bringt FrankenPHP dazu. Für mich ist daraus eine sichere, performante und leicht zu verwaltende Lösung geworden, die zusammen mit Podman- und Docker-Projekten (Container, also abgeschottete Laufzeitumgebungen für einzelne Anwendungen) schnelle Lösungen für verschiedene Einsatzzwecke bietet, auch für Apps. Ich nutze FrankenPHP für Online- und Intranet-Apps, für eine WordPress-Management-Konsole und für eine Knowledge Base auf Grav CMS.

Ich setze es also gern ein, und trotzdem findest du hier keine Werbung. Die bekannten Tempo-Zahlen stehen mit ihren Testbedingungen da, und die Sicherheitslücken der letzten Wochen kommen offen zur Sprache. Falls du noch nie von FrankenPHP gehört hast: Jeder Abschnitt beginnt einfach und geht danach in die Tiefe.

## Die Kurzfassung

| Frage | Antwort |
| --- | --- |
| **Was ist es?** | Der Webserver Caddy mit eingebautem PHP: ein Programm statt Webserver plus PHP-FPM |
| **Wird PHP schneller?** | Im klassischen Modus etwa gleichauf mit nginx und PHP-FPM. Im Worker-Modus, bei dem die Anwendung zwischen den Anfragen im Speicher bleibt, in Messungen Dritter und aus dem Projektumfeld Faktor 1,5 bis 2,9, dafür muss die Anwendung passen |
| **WordPress und Grav?** | Kein kontrollierter Vergleich gefunden, WordPress hat keinen unterstützten Worker-Modus. Bei WordPress spricht für mich eher der einfachere Betrieb als das Tempo |
| **Wie steht es um die Sicherheit?** | 40 veröffentlichte Advisories (Sicherheitsmeldungen), 34 davon zwischen 4. Oktober und 5. November 2026. Unterstützt wird nur die neueste Version |
| **Was bringt die Bauart mit sich?** | Ein Prozess, ein Benutzer: Ein Absturz trifft alles, und PHP kommt an TLS-Schlüssel (die geheimen Schlüssel hinter HTTPS) und Admin-API (die Steuerschnittstelle von Caddy) |
| **Was hilft im Betrieb?** | Ein Projekt je Container, ein Health Check (ein regelmäßiger Selbsttest) gegen echtes PHP, ein Neustart bei Absturz und bei Hängern |
| **Für wen eher nicht?** | Klassisches Shared Hosting und alle, die Updates nicht zeitnah einspielen |

Alle Angaben beziehen sich auf FrankenPHP 1.13.5 und Caddy 2.11.9, Stand 9. November 2026. Die Wortwahl trennt dabei vier Dinge. „Laut Doku" und „laut Quelltext" heißt: dort nachgelesen. „Geprüft" heißt: Das Beispiel wurde in einem Wegwerf-Container gegen FrankenPHP 1.13.5 nachvollzogen, als reine Funktionsprüfung ohne Last. Alle Leistungszahlen stammen aus fremden Messungen, teils aus dem Projektumfeld, und stehen mit ihren Bedingungen da. Alles zu Podman stammt nur aus der Doku und ist nicht getestet.

## Was FrankenPHP ist

Eine PHP-Website läuft heute meist mit zwei Programmen: einem Webserver wie Apache oder nginx, der die Anfragen aus dem Netz annimmt, und PHP-FPM, einem eigenen Dienst, der die PHP-Skripte ausführt. Beide sprechen über eine Schnittstelle namens FastCGI miteinander, und beide willst du einrichten, aktualisieren und überwachen. [FrankenPHP](https://frankenphp.dev/) (englisch) baut PHP direkt in den Webserver Caddy ein. Du startest ein einziges Programm, und das nimmt Anfragen an, kümmert sich um HTTPS und führt PHP aus. Laut [Doku](https://github.com/php/frankenphp/blob/v1.13.5/docs/classic.md) (englisch) läuft das auch als direkter Ersatz für PHP-FPM oder das Apache-Modul mod_php, deine Anwendung muss dafür nicht umgeschrieben werden.

### Unter der Haube

Caddy ist in Go geschrieben, PHP in C. FrankenPHP verbindet beide über cgo, Gos Brücke zu C-Code, und tritt gegenüber PHP als eigene SAPI auf, also als die Schnittstelle, über die PHP mit seiner Umgebung spricht. Laut [Interna-Doku](https://github.com/php/frankenphp/blob/v1.13.5/docs/internals.md) (englisch) läuft jede PHP-Ausführung auf einem echten Betriebssystem-Thread, einem Ausführungsstrang innerhalb eines Prozesses: „Each PHP execution runs on a real POSIX thread (not a goroutine) because PHP's ZTS (Zend Thread Safety) model requires it."

ZTS ist die Bauvariante von PHP, die mehrere Threads im selben Prozess verkraftet. Ohne ZTS erzwingt FrankenPHP laut [Quelltext](https://github.com/php/frankenphp/blob/v1.13.5/frankenphp.go) (englisch) einen einzigen Thread und warnt. Unterstützt wird PHP ab 8.2, die [Docker-Images](https://github.com/php/frankenphp/blob/v1.13.5/docs/docker.md) (englisch) gibt es für 8.2 bis 8.5.

Aus dieser Bauart folgt fast alles, was in diesem Artikel zählt: Alle Anfragen teilen sich einen Prozess. Für Profis ein Detail: `umask()` und `setlocale()` wirken laut [Worker-Doku](https://github.com/php/frankenphp/blob/v1.13.5/docs/worker.md) (englisch) prozessweit, und das in jedem Modus: „in every mode they also affect requests running at the same time."

Das Projekt selbst hat einen festen Platz im PHP-Umfeld. Die PHP Foundation [kündigte](https://thephp.foundation/blog/2025/05/15/frankenphp/) (englisch) im Mai 2025 ihre Unterstützung an, seit Juni 2025 liegt der Code [in der PHP-Organisation](https://thephp.foundation/blog/2025/06/08/php-30/) (englisch) auf GitHub, unter MIT-Lizenz. Die Führung blieb laut der [Ankündigung vom Mai](https://thephp.foundation/blog/2025/05/15/frankenphp/) (englisch) bei den bisherigen Maintainern Kévin Dunglas, Robert Landers und Alexander Stecher: „The governance of the project remains unchanged." Der Docker-Namespace, also der Namensraum der Images, heißt bis heute `dunglas`. Alle Direktiven findest du im [Cheat-Sheet zu FrankenPHP](https://www.jpkc.com/db/cheatsheets/web-servers/frankenphp/).

## Caddy als Fundament

Caddy ist ein Webserver, dessen bekannteste Eigenschaft automatisches HTTPS ist. Du schreibst einen Domainnamen in die Konfiguration, und Caddy besorgt und erneuert das Zertifikat selbst. Dafür spricht es ACME, das Protokoll, über das Zertifikatsstellen wie Let's Encrypt automatisch Zertifikate ausstellen. Die Konfigurationsdatei heißt Caddyfile. Für eine PHP-Site reicht im einfachsten Fall das hier, Minimalform nach der [Doku](https://frankenphp.dev/docs/config/) (englisch):

```caddyfile
example.com {
	root /var/www/app/public
	php_server
}
```

Mir gefällt, dass dir Caddy beim HTTPS viel abnimmt, ein paar Stellschrauben solltest du aber selbst prüfen. Dazu gleich mehr. Was FrankenPHP von Caddy erbt:

- **TLS:** Version 1.2 bis 1.3, und laut [Quelltext](https://raw.githubusercontent.com/caddyserver/caddy/v2.11.9/modules/caddytls/values.go) (englisch) mit dem hybriden Post-Quantum-Verfahren X25519MLKEM768, das auch gegen künftige Quantenrechner schützen soll, als Standard, und das [seit 2.10.0](https://github.com/caddyserver/caddy/releases/tag/v2.10.0) (englisch).
- **HTTP/3:** Die neueste HTTP-Version läuft über UDP statt TCP und ist standardmäßig aktiv. Dafür muss UDP-Port 443 erreichbar sein, im Container also `443:443/udp`. Für hohe Bandbreiten empfiehlt das [Wiki von quic-go](https://github.com/quic-go/quic-go/wiki/UDP-Buffer-Sizes) (englisch), der von Caddy genutzten HTTP/3-Bibliothek, unter Linux größere UDP-Puffer (`net.core.rmem_max`, `net.core.wmem_max`). Automatisch schneller ist HTTP/3 nicht: Eine [Studie](https://arxiv.org/abs/2310.09423) (englisch) fand auf schnellen Links bis zu 45,2 % geringere Datenraten als TCP mit HTTP/2, allerdings bei Client-Stacks (Netzwerkbibliotheken der Clients) von 2023/24 und nicht bei Caddy.
- **Kompression:** Das [FrankenPHP-Caddyfile](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/caddy/frankenphp/Caddyfile) (englisch) komprimiert standardmäßig mit zstd, Brotli und gzip.
- **Laufzeiten:** Caddy erneuert laut [Doku](https://caddyserver.com/docs/caddyfile/options) (englisch) im letzten Drittel der Laufzeit. Die von [Let's Encrypt angekündigte Verkürzung](https://letsencrypt.org/2025/12/02/from-90-to-45) (englisch) auf 45 Tage ab 2028 sollte also keine Änderung an deiner Konfiguration verlangen, das ist in Teilen eine Schlussfolgerung.

Selbst prüfen solltest du diese Punkte:

- **HSTS:** Der Header, der Browser dauerhaft auf HTTPS festlegt, kommt nicht automatisch. Die [Caddy-Doku](https://caddyserver.com/docs/caddyfile/directives/header) (englisch) zeigt ihn nur als manuelles Beispiel.
- **Das Data-Verzeichnis:** Dort liegen Zertifikate und Schlüssel. „The data directory must not be treated as a cache", schreibt [Caddy](https://caddyserver.com/docs/conventions) (englisch). Im Container gehören `/data` und `/config` also auf ein Volume, also einen Speicher, der den Container überlebt.
- **Die Zertifikatsstelle:** Die [Doku](https://caddyserver.com/docs/automatic-https) (englisch) nennt zwei Stellen als Standard, laut [Quelltext](https://raw.githubusercontent.com/caddyserver/caddy/v2.11.9/modules/caddytls/automation.go) (englisch) kommt ZeroSSL aber nur mit hinterlegter E-Mail-Adresse dazu. Ohne sie gibt es nur Let's Encrypt, das ist aus dem Code gelesen.
- **OCSP:** Über diesen Dienst lässt sich abfragen, ob ein Zertifikat gesperrt ist, und beim Stapling liefert der Server die Antwort gleich mit. Let's Encrypt hat den Dienst [2025 abgeschaltet](https://letsencrypt.org/2025/08/06/ocsp-service-has-reached-end-of-life) (englisch), Stapling tut für solche Zertifikate also nichts mehr.

Bei der reinen Geschwindigkeit ist das Bild gemischt. In einem [Test von 2026](https://getmind.io/blog/caddy-vs-nginx/) (englisch) lag ein nicht optimiertes Caddy 2.10.2 bei statischen Dateien etwa bei der Hälfte eines optimierten nginx 1.24, gemessen über Loopback (Client und Server auf derselben Maschine) ohne TLS. Ein [besser kontrollierter Test von 2022](https://blog.tjll.net/reverse-proxy-hot-dog-eating-contest-caddy-vs-nginx/) (englisch) auf getrennten Maschinen sah bei großen statischen Dateien fast Gleichstand und bei kleinen ein gemischtes Bild. Als Proxy lag ein optimiertes nginx klar vorn, gegen nginx mit Standardwerten bei 10 und 200 Clients dagegen Caddy. Mehr zur Konfiguration steht im [Cheat-Sheet zu Caddy](https://www.jpkc.com/db/cheatsheets/web-servers/caddy/).

## Performance

Klassisch beginnt PHP bei jeder Anfrage von vorn: Die Anwendung startet, baut die Seite und räumt alles wieder weg. Der klassische Modus von FrankenPHP macht genau das, nur eben in einem Thread statt in einem FPM-Prozess. Der Worker-Modus lädt die Anwendung dagegen einmal, hält sie im Speicher und reicht ihr die Anfragen nacheinander durch. Das spart das wiederholte Starten, und deine Anwendung muss damit leben, dass zwischen den Anfragen nicht mehr alles aufgeräumt wird.

### Klassischer Modus: meist Gleichstand

Beim Durchsatz bringt der klassische Modus nach allem, was belastbar vorliegt, wenig. [Tideways](https://tideways.com/profiler/blog/testing-if-franken-php-classic-mode-is-faster-and-more-scalable-than-php-fpm) (englisch) hat FrankenPHP 1.9.1 gegen nginx 1.26.3 mit PHP-FPM getestet: Hetzner CCX33 mit 8 dedizierten virtuellen Kernen (vCores), Debian 13, Standard-Konfigurationen, Vegeta, einem Lastgenerator, mit 8 Clients über 60 Sekunden. Bei HTML mit gzip lagen beide rund 1,3 % auseinander, bei einem Hello World rund 0,4 %, und das Fazit lautet: „essentially no performance or throughput difference." Bei 100 Clients lag FrankenPHP beim Durchsatz 3,7 % vorn, beim 99. Perzentil der Antwortzeit (99 von 100 Anfragen waren schneller) aber deutlich hinten, 23,4 gegen 9,7 ms. Das war vor der Arbeit an der [Tail Latency](https://github.com/php/frankenphp/pull/2033) (englisch), den langsamsten Ausreißern, in 1.11.0, der heutige Wert dürfte also besser sein, eine Zahl dazu fehlt.

Ein Collaborator des Projekts schrieb in der [Diskussion](https://github.com/php/frankenphp/discussions/1981) (englisch) zunächst allgemein: „no performance difference between FrankenPHP (non-worker) and php-fpm." Bei einem späteren Lauf mit `wrk` und PHP 8.4.14 lag FrankenPHP je nach Codebeispiel zwischen rund 1 % zurück und 14 % vorn. Das ist keine unabhängige Quelle, passt aber grob zum Bild. Eine [Shopware-Messung](https://brocksi.net/blog/is-frankenphp-worth-it-for-shopware/) (englisch) vom Oktober 2026 sah PHP-FPM bei 520 und den klassischen Modus bei 559 Anfragen pro Sekunde, die Spannen überlappten sich aber, und die Laborbedingungen waren laut Autor kein isolierter Vergleich (FPM auf Alpine, einer besonders kleinen Linux-Distribution, FrankenPHP auf Debian, Apple-M4-VM).

Eine Falle bei jedem Vergleich: Tideways sah bei einem PDF, das keiner der beiden Server komprimierte, PHP-FPM mit 7.610 gegen 5.369 Anfragen pro Sekunde vorn, bei Zufallsdaten FrankenPHP mit 5.606 gegen 1.940, weil nginx mit nicht komprimierbaren Antworten schlecht zurechtkam. Ganz ohne Kompression lag FrankenPHP beim HTML mit 5.504 gegen 7.456 Anfragen pro Sekunde zurück, der Gleichstand ist also keine feste Größe. Wer Standardwerte gegeneinander stellt, misst deshalb zu einem guten Teil Encoder und nicht PHP.

Was der klassische Modus tatsächlich bringt, liegt im Betrieb: ein Prozess weniger, HTTP/3 und Kompression aus demselben Programm und [Early Hints](https://github.com/php/frankenphp/blob/v1.13.5/docs/early-hints.md) (englisch), dazu weiter unten mehr.

### Worker-Modus: echter Gewinn mit Bedingungen

Im Worker-Modus zeigen Messungen einen echten Abstand. Bei [Sylius](https://soyuka.github.io/sylius-benchmarks/) (englisch) kam der Worker-Modus auf das 2,7- bis 2,9-Fache von PHP-FPM, gemessen von einem Entwickler aus dem Umfeld des Projekts (Les-Tilleuls.coop), allerdings auf einer 2-vCPU-Maschine, in einem einzigen Lauf, mit 36 Workern gegen 15 FPM-Kinder (Arbeitsprozesse). Die erwähnte Shopware-Messung kam bei schreibfreien Admin-Suchen mit gzip auf das 1,75-Fache (911 gegen 520 Anfragen pro Sekunde), ohne Kompression auf das 1,5-Fache. Für die Storefront sagt das laut Autor nichts aus. Der Autor spricht ausdrücklich keine Produktionsempfehlung aus und warnt: „avoiding repeated initialization makes object lifetimes part of application correctness".

Das Gegenbeispiel kommt von [Oh Dear](https://ma.ttias.be/laravel-octane-vs-php-fpm-lessons-learned/) (englisch), einem Dienst, der viel auf ausgehende Anfragen wartet (360 bis 470 ms, 12 Stunden Produktionsverkehr, 2 vCPU, rund 20 Anfragen pro Sekunde). Dort blieb die durchschnittliche CPU-Last zwischen FPM und Laravel Octane auf FrankenPHP praktisch gleich (21 gegen 22 %, 25 gegen 22 %), nur die Spitzen sanken deutlich (49 auf 28 %, 33 auf 26 %). Die Worker belegten zusammen 600 bis 670 MB, mehr als PHP-FPM, und das Team ging zurück auf FPM. Daraus lässt sich schließen: Wer vor allem auf andere Systeme wartet, spart am Starten der Anwendung wenig.

Nötig ist eine Anwendung, die dafür gebaut ist. Symfony unterstützt den Worker-Modus [seit 7.4 nativ](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/symfony.md) (englisch), Laravel über [Octane](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/laravel.md) (englisch). Der Worker-Modus lohnt sich aus meiner Sicht vor allem, wenn dein Framework ihn offiziell unterstützt und du bereit bist, auf Zustandsfehler zu achten. Mehr dazu im Sicherheitsteil.

### Woher das „3,5x" kommt

Auf der Startseite von FrankenPHP steht: „According to our benchmarks, 3.5x faster than FPM on API Platform apps." Die zugehörigen [Testdateien](https://github.com/dunglas/frankenphp-demo/tree/main/benchmark) (englisch) stammen vom Oktober 2022, also aus der Zeit vor Version 1.0. Getestet wurde mit dem Lasttest-Werkzeug k6 gegen localhost, mit einer Sekunde Pause je Iteration und ohne Angabe zu Hardware oder Version. Gemessen wurde damit die Latenz bei rund 10 und 100 Anfragen pro Sekunde, keine Durchsatzgrenze.

| 100 virtuelle Nutzer | Mittlere Latenz |
| --- | --- |
| PHP-FPM | 9,45 ms |
| FrankenPHP mit Worker | 2,53 ms |
| FrankenPHP ohne Worker | 12,72 ms |

Bei 100 Nutzern ergibt das nachgerechnet Faktor 3,7, bei 10 Nutzern 2,8. Die Werte ohne Worker stehen nicht auf der Startseite. Aktuell ist dieser Rückstand nicht mehr, die jüngeren Messungen sehen Gleichstand. [DevClass](https://devclass.com/2024/05/30/frankenphp-and-caddy-double-performance-claims-caddy-creator-but-only-some-apps-benefit/) (englisch) beschrieb denselben Benchmark zudem als Hello-World-Symfony. Das 3,5x von der Startseite würde ich dir nicht als Argument mitgeben. Die Testdateien stammen von 2022, und ohne Worker lag FrankenPHP dort hinter PHP-FPM.

### WordPress und Grav

Für WordPress oder Grav gibt es keinen kontrollierten Vergleich zwischen FrankenPHP im klassischen Modus und nginx mit PHP-FPM, jedenfalls war keiner zu finden. Einen unterstützten Worker-Modus hat WordPress nicht. Die [WordPress-Seite der Doku](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/wordpress.md) (englisch) kennt das Wort „worker" gar nicht, und Dunglas sagte laut [DevClass](https://devclass.com/2024/05/30/frankenphp-and-caddy-double-performance-claims-caddy-creator-but-only-some-apps-benefit/) (englisch) 2024, WordPress bringe „not many benefits in terms of performance". Die Aussage „up to 4x faster than with PHP-FPM" in Caddys [Doku-Beispielen](https://caddyserver.com/docs/caddyfile/patterns) (englisch) nennt keine Testbedingungen und passt nicht zu den Messungen oben, die allerdings nicht an WordPress entstanden sind. Zu Grav war keine Aussage über Worker-Tauglichkeit zu finden.

Mein Eindruck ist: WordPress und Grav laufen auch ohne Worker-Modus mindestens so gut wie mit nginx und PHP-FPM. Das ist ausdrücklich ein Gefühl und kein Messwert. Bei WordPress würde ich dir FrankenPHP eher wegen des einfacheren Betriebs empfehlen als wegen des Tempos.

Vollständig ist das Bild damit nicht. Issue [#1737](https://github.com/php/frankenphp/issues/1737) (englisch) beschreibt Abstürze mit mehreren WordPress-Sites durch eine Race Condition (zwei Threads kommen sich zeitlich in die Quere) rund um `opcache_reset`, gemeldet für 1.8.0 und offen am Stichtag. Seit 1.12.5 fängt FrankenPHP laut [PR #2364](https://github.com/php/frankenphp/pull/2364) (englisch) `opcache_reset()` ab und plant stattdessen einen Neustart der PHP-Threads ein. Ob das die gemeldeten Abstürze beseitigt, ist im Issue nicht bestätigt. Issue [#2553](https://github.com/php/frankenphp/issues/2553) (englisch) meldet stark verlangsamte Sites mit 1.12.x, Stand auf 1.13.x unbekannt.

### Stellschrauben

- **Threads:** Ohne Worker startet FrankenPHP laut [Quelltext](https://github.com/php/frankenphp/blob/v1.13.5/frankenphp.go) (englisch) mit 2 Threads je CPU, und ohne gesetztes `max_threads` skaliert es nicht nach oben. Die [Doku](https://github.com/php/frankenphp/blob/v1.13.5/docs/performance.md) (englisch) rät, die Standardwerte zu ändern („We strongly recommend changing these values.") und sie per Lasttest zu ermitteln, und nennt als Faustregel `max_threads x memory_limit < available_memory`. Seit [1.13.0](https://github.com/php/frankenphp/releases/tag/v1.13.0) (englisch) zählt `num_threads` nur noch Threads außerhalb der Worker, bestehende Konfigurationen können sich dadurch anders verhalten.
- **glibc statt musl:** Die Doku empfiehlt für die Produktion glibc. Alpine-Images und die Standard-Binaries nutzen musl, eine andere C-Bibliothek, unter der ZTS besonders viel kostet. Die Debian-Images sind deshalb die empfohlene Wahl, und statische `-gnu`-Binaries gibt es auch.
- **ZTS:** Marc Henderkes [schätzt](https://discourse.thephp.foundation/t/php-dev-pre-rfc-deprecating-nts-and-making-zts-the-default-build-mode/5754) (englisch) auf der PHP-Entwicklerliste die Kosten im schlechtesten Fall auf rund 5 % bei PHP 8.5 und 1,5 % bei 8.6. Ein Setup dazu ist nicht veröffentlicht.
- **OPcache:** Der Bytecode-Cache, der übersetzten PHP-Code zwischenspeichert, ist laut den [Dockerfiles der Basis-Images](https://raw.githubusercontent.com/docker-library/php/master/8.4/trixie/zts/Dockerfile) (englisch) aktiv, die Abstimmung bleibt bei dir. Muss der Cache seinen Speicher neu aufbauen, kann das laut [Metriken-Doku](https://github.com/php/frankenphp/blob/v1.13.5/docs/metrics.md) (englisch) unter ZTS den Prozess abstürzen lassen: „The counter should stay at zero". Beobachte `frankenphp_opcache_restarts` und vergrößere bei Bedarf `opcache.memory_consumption`.
- **`php_server`-Komfort:** Die Dateiprüfungen kosten etwas. Die Doku nennt verengtes `try_files` oder `file_server off` als Hebel, ohne Größenangabe.
- **Speicherlimit der Go-Laufzeit:** Caddy setzt `GOMEMLIMIT` laut [Quelltext](https://raw.githubusercontent.com/caddyserver/caddy/v2.11.9/cmd/main.go) (englisch) automatisch, mit dem [Standardfaktor 0,9](https://raw.githubusercontent.com/KimMachineGun/automemlimit/main/memlimit/memlimit.go) (englisch) der Bibliothek automemlimit also auf 90 % des verfügbaren Speichers, und das zählt [C-Speicher nicht mit](https://pkg.go.dev/runtime/debug#SetMemoryLimit) (englisch), also auch nicht den Speicher, den PHP belegt. Bei knappen Containerlimits ist ein OOM-Kill (der Kernel beendet den Prozess wegen Speichermangels) deshalb denkbar, das ist eine Schlussfolgerung.

Mit Early Hints (HTTP-Status 103) sagt der Server dem Browser schon vor der fertigen Seite, was er vorab laden kann. FrankenPHP liefert dafür eine eigene Funktion, in beiden Modi:

```php
<?php
header('Link: </style.css>; rel=preload; as=style');
headers_send(103);
```

Geprüft ist, dass der 103 auch durch ein vorgeschaltetes Caddy kommt, über HTTP/1.1 und HTTP/2. Die „30%" aus der Doku nennen keine Testbedingungen.

## Sicherheit

Ein Advisory ist eine veröffentlichte Sicherheitsmeldung zu einer Software. Zu FrankenPHP sind zuletzt viele solcher Meldungen erschienen, und die Zahlen klingen erst einmal bedrohlich. Hier kommen sie mit Einordnung.

### Die Welle in Zahlen

Das Repository [listet](https://github.com/php/frankenphp/security/advisories) (englisch) am Stichtag 40 veröffentlichte Advisories: 1 kritisch, 10 hoch, 20 mittel, 9 niedrig. 34 davon wurden zwischen dem 4. Oktober und dem 5. November 2026 veröffentlicht, verteilt auf die Releases 1.13.0, 1.13.2, 1.13.4 und 1.13.5. Allein [1.13.5](https://github.com/php/frankenphp/releases/tag/v1.13.5) (englisch) schloss 17.

Zur Einordnung gehört mehr als die Summe:

- Das einzige kritische Advisory [GHSA-x9p2](https://github.com/php/frankenphp/security/advisories/GHSA-x9p2-77v6-6vhf) (englisch) betrifft keine Lücke im Code, sondern die verzögerte Weitergabe von Fixes aus den Basis-Images, und ist seit Februar behoben.
- Die wiederkehrende Klasse mit der schwersten Folge ist die Pfadtrennung, also die Frage, welcher Teil einer URL das auszuführende Skript ist. Fünf Advisories von Februar bis November betreffen sie, zuletzt [GHSA-j99q](https://github.com/php/frankenphp/security/advisories/GHSA-j99q-3wr8-xj43) (englisch): „/uploads/photos.php.php/avatar.jpg ran avatar.jpg as PHP." Dort entstand ein Trigger durch den Fix einer früheren Meldung.
- Viele Meldungen betreffen die Grenze zwischen Go und C oder nur den Worker-Modus. Manche sind aber von außen und ohne Anmeldung erreichbar: [GHSA-5359](https://github.com/php/frankenphp/security/advisories/GHSA-5359-vg53-5464) (englisch) brachte den ganzen Prozess zum Absturz, und laut Advisory gilt: „A few dozen requests on two connections were enough in testing." Mit ermöglicht wurde das durch PHP-Standardwerte wie `display_errors=1`, also Docker ohne eigene `php.ini`. Behoben in 1.13.5.
- Schweregrade sind keine feste Größe. Bei Caddy gehen GitHub und die US-Schwachstellendatenbank NVD teils weit auseinander, „medium" gegen 9,1 von 10 Punkten auf der CVSS-Skala.

Woher kommt die Welle? Für den letzten Schub nennen die Release Notes zu 1.13.5 die Quelle: „Most of these vulnerabilities were found by Anthropic's OSS Scanner". Das muss ich offenlegen, denn auch ich arbeite mit KI von Anthropic: Claude unterstützt mich bei Erstellung, Korrektur und Verifikation, die Vorgaben und die redaktionelle Verantwortung liegen bei mir. Mehr dazu auf der Seite zur [KI-Transparenz](https://www.jpkc.com/db/ki-transparenz/). Alle 17 Advisories dieses Releases führen den Scanner als Fundstelle, zwei davon nennen daneben weitere Melder. In den 17 Advisories aus 1.13.0, 1.13.2 und 1.13.4 taucht Anthropics Scanner dagegen nicht auf. Caddy sieht dieselbe Lage von der anderen Seite. Die Notes zu [2.11.4](https://github.com/caddyserver/caddy/releases/tag/v2.11.4) (englisch) führen die Patch-Welle auf KI-Modelle zurück und schreiben, mehr als 75 % der Sicherheitsmeldungen hätten abgelehnt werden müssen, weil sie „AI slop spam" oder falsch waren. [Caddys Liste](https://github.com/caddyserver/caddy/security/advisories) (englisch) führt 23 Einträge, alle aus 2026. PHP/FastCGI gehört dort neben den Request-Matchern (den Caddy-Regeln, die Anfragen auswählen) zu den am häufigsten betroffenen Bereichen, und 2.11.9 nennt seine Fixes „mostly in FastCGI". Die Welle trifft also nicht nur FrankenPHP.

Die Welle an Advisories nehme ich ernst, und du solltest das auch tun. Für mich spricht sie aber eher dafür, dass gerade gründlich gesucht und repariert wird, als gegen das Projekt.

### Wie schnell die Projekte reagieren

Was ich an diesem Umfeld schätze, ist die enge und sehr aktive Zusammenarbeit der Communitys von PHP, FrankenPHP und Caddy, die schnell auf solche Probleme reagieren. Belegen lässt sich das so: FrankenPHP liegt in der PHP-Organisation und wird von der PHP Foundation unterstützt, Fixes an Caddy kommen [teils von Dunglas selbst](https://github.com/caddyserver/caddy/releases/tag/v2.11.9) (englisch), und Caddy 2.11.9 kam am selben Tag in FrankenPHP 1.13.5 an.

Die Spanne zwischen einem PHP-Sicherheitsrelease und dem ersten erhaltenen [Docker-Tag](https://hub.docker.com/r/dunglas/frankenphp/tags?name=php8.5.11) (englisch), also dem Versionsnamen eines Images, sieht zuletzt so aus:

| PHP-Release | Spanne (höchstens) |
| --- | --- |
| 8.5.6, 7. Mai 2026 | 7 Tage |
| 8.5.8, 2. Juli 2026 | 18 Tage |
| 8.5.9, 30. Juli 2026 | 8 Tage |
| 8.5.11, 24. September 2026 | 1 Tag |
| 8.5.12, 21. Oktober 2026 | selber Tag |

Docker Hub kennt nur den letzten Push eines Tags, die Werte von 7, 18 und 8 Tagen können also durch spätere Neu-Pushes zu hoch ausfallen. Beim Nachziehen von Caddy sind das nur die zwei jüngsten Fälle, rund ein Tag jeweils, und eine schriftliche Zusage dazu gibt es nicht. Wie schnell zuletzt die gepatchten Images da waren, rechne ich dem Projekt hoch an. Verlassen würde ich mich darauf nicht, du solltest also selbst hinschauen.

### PHP2Shell und FrankenPHP

Die Lücken, die unter dem Namen PHP2Shell bekannt wurden, beschreibt [ein eigener Artikel](https://www.jpkc.com/db/blog/php2shell/) ausführlich. FrankenPHP gehört zu den gefährdeten SAPIs: Das [PHP-Advisory](https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w) (englisch) nennt es in einer Quelltextanalyse neben mod_php, ein gezeigter Exploit gegen FrankenPHP liegt nicht vor. PHP 8.5.12 und die Parallelversionen kamen am 21. Oktober, [1.13.2](https://github.com/php/frankenphp/releases/tag/v1.13.2) (englisch) nennt den Fix als erstes Release. Praktische Untergrenze ist heute 1.13.5.

Der Fix selbst hat eine Nebenwirkung, die FrankenPHP besonders trifft: `memory_limit` ist seitdem weich, und oberhalb einer harten Grenze (standardmäßig das Doppelte, ab 1 GiB `memory_limit` plus 1 GiB) endet der Prozess. Die [Known Issues](https://frankenphp.dev/docs/known-issues/) (englisch) sagen dazu: „every in-flight request is lost and the server stops until it is restarted." Bei PHP-FPM stirbt in diesem Fall nur ein Kindprozess. Der Abschnitt über Neustarts weiter unten gehört deshalb zur Pflicht.

### Nur die neueste Version

Das Projekt sagt es in seiner [Sicherheitsrichtlinie](https://github.com/php/frankenphp/security/policy) (englisch) knapp: „Only the latest version is supported." Bei Caddy [gilt dasselbe](https://raw.githubusercontent.com/caddyserver/caddy/v2.11.9/.github/SECURITY.md) (englisch) für die neueste 2.x. FrankenPHP gehört für mich nur dorthin, wo du Updates wirklich zeitnah einspielst. Unterstützt wird nur die neueste Version, und ältere Tags bleiben stehen.

Tägliche Neubauten zielen laut [Build-Skript](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/.github/scripts/docker-compute-fingerprints.sh) (englisch) nur auf das neueste Release. Was bei dir ankommt, hängt deshalb vom Installationsweg ab:

| Weg | Was passiert | Worauf du achten musst |
| --- | --- | --- |
| **Docker, aktuelles Release** | Neubau bei jedem Release und täglich um 04:00 UTC, falls sich die PHP-Basis geändert hat | Pull allein reicht nicht bei abgeleiteten Images, also eigenen Images, die mit `FROM` auf dem offiziellen aufbauen. Bau deine eigenen neu |
| **Docker, ältere Tags** | Eingefroren. `1.12.7-php8.4` wurde zuletzt am 25. September gepusht, ohne PHP2Shell-Fix | Keine alten Linien stehen lassen |
| **Linux-Pakete (deb, rpm, apk)** | Repository eines Maintainers. PHP ist separat paketiert | Normale Paket-Updates einplanen |
| **Statische Binaries** | Nachts neu gebaut, nur PHP 8.5 | Prüfsummen, die du fest hinterlegt hast, können brechen, die signierten Herkunftsnachweise (Attestations) prüfen |
| **Eigenbau mit xcaddy**, dem Werkzeug, das Plugins in ein eigenes Binary kompiliert | Nichts kommt von selbst | Bei jedem Security-Release neu bauen |

Die Regel zu abgeleiteten Images stammt aus [GHSA-cj57](https://github.com/php/frankenphp/security/advisories/GHSA-cj57-c655-p798) (englisch): „pulling alone is not enough for images you have already derived." Ein fest gepinnter Tag wie `1.13.5` bleibt spätestens mit dem nächsten Release stehen, du musst ihn dann selbst anheben.

### Ein Prozess für alles

Bei PHP-FPM sind die einzelnen Sites durch Pools getrennt, also durch eigene Prozessgruppen mit eigenem Benutzer. FrankenPHP arbeitet anders, und das hat Folgen. Das [Sicherheitsmodell](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/security.md) (englisch) sagt es offen: PHP-Anwendungscode gilt dort als „Trusted *by provenance*", also als vom Betreiber eingesetzt. Läuft erst einmal fremder Code, etwa eine hochgeladene Web-Shell, also ein Skript, über das Angreifer Befehle ausführen, schützt dieses Modell nicht mehr.

| Thema | PHP-FPM mit Pools | FrankenPHP |
| --- | --- | --- |
| **Absturz** | Trifft einen Kindprozess | Trifft alle Anfragen und Sites des Prozesses |
| **Benutzer je Site** | Je Pool eigener User | Ein User je Deployment |
| **PHP-Einstellungen je Site** | `php_admin_value` je Pool | Nur global über `php_ini` |
| **TLS-Schlüssel** | Mit Caddy unter anderem User nicht lesbar | Für PHP lesbar, geprüft auch als Non-Root |
| **Admin-API** | Per Unix-Socket (eine lokale Verbindung über eine Datei, deren Rechte du setzen kannst) trennbar | Für PHP ohne Anmeldung erreichbar |

Geprüft ist das so: Ein PHP-Skript las in beiden Läufen die privaten Schlüssel im Data-Verzeichnis, auch mit `--user 1000:1000`, weil es dieselbe Benutzerkennung (UID) hat wie Caddy. `php_ini` in `php_server` führt zu einem Konfigurationsfehler, nur der globale `frankenphp`-Block kennt es. Threads können zudem laut [Maintainer-Aussage](https://github.com/php/frankenphp/issues/755) (englisch) nicht unter einem anderen Benutzer laufen als ihr Prozess. `open_basedir`, das PHP-Dateizugriffe auf bestimmte Verzeichnisse beschränkt, ist laut [PHP-Handbuch](https://www.php.net/manual/de/ini.core.php) ohnehin keine Sicherheitsgrenze.

Mit einem Container je Projekt halte ich den gemeinsamen Prozess für vertretbar, weil du den Absturzradius damit klein hältst, also das, was ein einzelner Absturz mitreißt. Die Nähe von PHP zu Admin-API und Schlüsseln solltest du aus meiner Sicht bewusst einplanen, etwa mit `admin off` oder einem Caddy davor. Statische Sites gehören als Schlussfolgerung daraus eher auf ein reines Caddy als in den FrankenPHP-Prozess.

### Webroot und Uploads

Das Webroot ist das Verzeichnis, das der Server ins Netz stellt, und ein typischer Stolperstein dort ist unspektakulär. `php_server` schickt `.php`-Dateien an PHP und gibt alles andere an einen Dateiserver. Ein Caddyfile nur mit `root` und `php_server` lieferte im Test `/.env`, `/.git/config` und `/.htaccess` mit Inhalt aus. Backups wie `wp-config.php.bak` kamen als Quelltext, inklusive Zugangsdaten. Jede `.php` im Webroot läuft, auch in `wp-content/uploads`, auch als `.PHP`.

Caddys eigene [WordPress-Regel](https://caddyserver.com/docs/caddyfile/patterns) (englisch) mit `/wp-content/uploads/*.php` greift nur eine Ebene tief. Unter `/wp-content/uploads/2026/11/x.php` lief das Skript weiter, und `/xmlrpc.php/foo` umgeht das exakte `path /xmlrpc.php`. Geprüft ist das an `php_server`. `.user.ini` wertet FrankenPHP nicht aus, ebenfalls geprüft, und Apache-Regeln aus `.htaccess` gelten unter Caddy nicht. Der [Docker-Schnellstart](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/docker.md) (englisch) mit `COPY . /app/public` kopiert zudem den ganzen Build-Kontext ins Webroot. Trenne deshalb `public/` von allem anderen.

### Risiken im Worker-Modus

Im Worker-Modus bleibt der PHP-Prozess zwischen den Anfragen am Leben, und damit bleibt auch Zustand erhalten. Zurückgesetzt werden laut [Release Notes zu 1.13.5](https://github.com/php/frankenphp/releases/tag/v1.13.5) (englisch) nur „superglobals (except $_ENV), the request body, response headers and output, the session and the URL rewriter." Alles andere bleibt, auch statische Variablen und globale Objekte. Frameworks mildern das laut [Worker-Doku](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/worker.md) (englisch): „Frameworks like Symfony and Laravel Octane take care of resetting most state for you, but you may still need to reset your own services."

Selbst der Zustand, den FrankenPHP zurücksetzen will, ist schon durchgerutscht. [GHSA-8qcf](https://github.com/php/frankenphp/security/advisories/GHSA-8qcf-v46r-g2mc) (englisch) beschreibt: „A client without any cookie could receive the body output and Set-Cookie headers emitted by the previous user's session objects." Und 1.13.5 nahm zwei veröffentlichte Fixes bewusst zurück: `error_get_last()`, `http_get_last_response_headers()` und libxml-Fehler bleiben im Worker wieder bestehen. Die Advisories gelten trotzdem als gepatcht, ein Scanner meldet also „behoben", und du musst in der Anwendung selbst aufräumen (`error_clear_last()`, `libxml_clear_errors()`, `http_clear_last_response_headers()`).

## Caddy absichern und betreiben

Ein Webserver lässt sich im laufenden Betrieb steuern, und Caddy bietet dafür eine Schnittstelle: die Admin-API. Das ist bequem und zugleich der wichtigste Punkt beim Absichern, weil jedes PHP-Skript auf derselben Maschine sie erreicht.

### Die Admin-API

Standardmäßig lauscht sie laut [Caddy-Doku](https://caddyserver.com/docs/caddyfile/options) (englisch) auf `localhost:2019`, ohne Anmeldung. Geprüft ist das Ergebnis: `file_get_contents('http://localhost:2019/config/')` aus PHP lieferte die gesamte Konfiguration, und ein `POST /load` aus PHP ersetzte sie. Die Site antwortete danach nur noch mit dem eingespielten Text, PHP lief nicht mehr. Die Doku empfiehlt einen berechtigten Unix-Socket, gegen PHP mit derselben UID hilft das aber nicht: Geprüft kam PHP auch per Socket an die Konfiguration, HTTP 200.

Bleibt `admin off`. Das hat Kosten: `frankenphp reload` funktioniert nicht mehr, die Endpunkte zum Worker-Neustart und zu `/frankenphp/threads` fallen weg, das im Image eingebaute `HEALTHCHECK` schlägt fehl (geprüft: dauerhaft `unhealthy`, du brauchst also einen eigenen Check), und Metriken brauchen die globale Option `metrics` plus einen eigenen [`metrics`-Block](https://caddyserver.com/docs/caddyfile/directives/metrics) (englisch) in einer Site. Ein Reload geht dann weiterhin per Signal `SIGUSR1`, geprüft, wobei eine Anfrage im Reload-Fenster fehlschlagen kann.

### Limits, Proxys und Header

Geprüfte Endfassung, mit Adresse `:8080` im Test:

```caddyfile
{
	admin off
	servers {
		trusted_proxies static 172.30.0.2/32
		trusted_proxies_strict
	}
	frankenphp {
		php_ini memory_limit 256M
		php_ini expose_php Off
		php_ini post_max_size 32M
		php_ini upload_max_filesize 32M
	}
}

example.com {
	root /var/www/app/public
	request_body {
		max_size 32MB
	}
	php_server
}
```

Was dieser Block leistet, und was nicht:

- **`request_body`:** Caddy kennt von sich aus kein Limit. Mit `max_size` und einem `post_max_size`, das nicht darunter liegt, kam geprüft 413, bei Content-Length ebenso wie bei Chunked, also bei Daten ohne vorab bekannte Länge. Bleibt `post_max_size` beim Standard von 8 MB, blieb das 413 bei Chunked fast immer aus, bei 33 MB kam 200 mit PHP-Warnung. Ohne die Direktive gab es bei einem zu großen Body ebenfalls 200 und eine PHP-Warnung im Text, `$_POST` blieb leer. `post_max_size` begrenzt `php://input` aber nicht: Leer war es im Test nur, wenn der Client `Expect: 100-continue` schickte, wie curl bei großen Bodys mit Content-Length. Ohne diesen Header kam der ganze Body an, ebenso bei Chunked. Setze `post_max_size` deshalb nicht unter `max_size`, bei Uploads gilt das auch für `upload_max_filesize`.
- **Timeouts:** `read_header` steht schon seit 2.9.0 auf 1 Minute, und je 1 Minute Leerlauf beim Lesen und Schreiben kam dazu, angekündigt in den [Notes zu 2.11.6](https://github.com/caddyserver/caddy/releases/tag/v2.11.6) (englisch). `php_server` setzt zusätzlich einen 60-Sekunden-Timeout auf Body-Reads. In 1.13.0 bis 1.13.4 hebelte Caddy ihn aus, [erst 1.13.5](https://github.com/php/frankenphp/security/advisories/GHSA-j45x-h238-h4xx) (englisch) behebt das. Bodies, die PHP nicht beim Start der Anfrage liest, etwa bei `PUT`, deckt das laut Advisory noch nicht vollständig ab.
- **`trusted_proxies`:** Ohne die Option vertraut Caddy niemandem. Trag die echte Adresse deines Proxys ein. Das ändert `{client_ip}` und die Logs, `$_SERVER['REMOTE_ADDR']` bleibt laut Test der Proxy. Deine Anwendung muss `X-Forwarded-For`, den Header mit der ursprünglichen Client-Adresse, also selbst auswerten, und auch die HTTPS-Erkennung hängt [am TLS-Zustand der Verbindung](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/cgi.go) (englisch). Der Matcher `client_ip` traf im Test die gefälschte Adresse, sobald der Absender als Proxy vertraut war.
- **Nicht abgedeckt:** `admin off` nimmt das API-Risiko, nicht die Lesbarkeit der Schlüssel durch PHP.

Noch drei Punkte. Der `Server`-Header verrät in den [offiziellen Docker-Builds](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/Dockerfile) (englisch) `FrankenPHP Caddy`. `expose_php Off` entfernt nur `X-Powered-By`. Und HTTP/3 erlaubt 0-RTT, also Anfragen schon beim Verbindungsaufbau, die sich laut [Doku](https://caddyserver.com/docs/caddyfile/matchers) (englisch) wiederholen lassen. PHP erfährt laut Quelltext nichts davon. Die Doku nennt `@early_data tls early_data` plus `respond @early_data 425 "Too Early"`. Mit dieser Reihenfolge antwortet Caddy aber, geprüft an einem Pfad-Matcher, mit 500 statt 425, weil das erste Argument als Body gilt. Richtig ist `respond @early_data "Too Early" 425`. Eine echte 0-RTT-Anfrage ist nicht getestet. Die praktische Ausnutzbarkeit ist nicht bewertet.

### Plugins kosten Updates

Wer Rate-Limiting (Begrenzung der Anfragen je Client), eine Web Application Firewall oder DNS-Module will, braucht einen eigenen Build. Der Standard-Build enthält neben Caddy nur die Module [Brotli, Mercure und Vulcain](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/craft.yml) (englisch). Eingebaut wird über `xcaddy`, das Plugins in ein eigenes Binary kompiliert, [mit dem `builder`-Image](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/docker.md) (englisch).

Das hat einen Preis, den dir Pakete und Images sonst abnehmen. Als Schlussfolgerung: Jedes Sicherheitsrelease verlangt einen Neubau, und jedes Plugin muss zur Caddy-Version passen. Die Web Application Firewall [coraza-caddy](https://github.com/corazawaf/coraza-caddy) (englisch) und der [CrowdSec-Bouncer](https://github.com/hslatman/caddy-crowdsec-bouncer) (englisch), der Caddy an das Sperrlisten-System CrowdSec anbindet, sind aktiv, ihre `go.mod` nannte am Stichtag Caddy 2.11.7. Ein Rückstand ist das nicht zwingend, denn Caddy bittet Plugin-Autoren, die Abhängigkeit nur bei API-Änderungen anzuheben. [caddy-ratelimit](https://github.com/mholt/caddy-ratelimit) (englisch) hat keine Releases und sagt von sich: „This is not an official repository of the Caddy Web Server organization." Beim Plugin caddy-security für zentrale Anmeldung (SSO) meldete [Trail of Bits](https://blog.trailofbits.com/2023/09/18/security-flaws-in-an-sso-plugin-for-caddy/) (englisch) 2023 zehn Lücken, der heutige Stand ist nicht geprüft.

### Caddy davor oder FrankenPHP allein

Der [Doku-Standard](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/production.md) (englisch) ist FrankenPHP als alleiniger Server mit Ports 80, 443 und 443/udp. Das ist einfach, und deine Zertifikate liegen dort, wo auch PHP läuft. Ein getrenntes, vorgeschaltetes Caddy hält die Schlüssel aus dem PHP-Container heraus und lässt statische Sites außerhalb des Absturzradius. Zu den Kosten der zusätzlichen Schicht war keine Primärmessung zu finden. Außen genügt das hier:

```caddyfile
example.com {
	reverse_proxy frankenphp:8080
}
```

Innen, ohne eigenes HTTPS und mit dem äußeren Caddy als vertrauenswürdigem Proxy:

```caddyfile
{
	auto_https off
	servers {
		trusted_proxies static 172.30.0.2/32
		trusted_proxies_strict
	}
}

:8080 {
	root /app/public
	php_server
}
```

Der äußere Block ist per `validate` geprüft, und der Aufbau aus beiden lief im Test, mit den Adressen des Testnetzes. Dabei verwarf das äußere Caddy einen gefälschten `X-Forwarded-For`, innen stimmte `client_ip`.

### HTTPS im Intranet

Interne Dienste haben oft keine öffentliche Domain. Caddy löst das mit einer eigenen, lokalen Zertifizierungsstelle. `skip_install_trust` sorgt dafür, dass ihr Root-Zertifikat nicht automatisch im Trust Store, der Liste vertrauenswürdiger Zertifikate des Systems, landet:

```caddyfile
{
	skip_install_trust
}

intranet.internal {
	tls internal
	root /var/www/app/public
	php_server
}
```

Geprüft: Ohne das Root-Zertifikat schlägt `curl` mit Exit 60 fehl, mit `--cacert root.crt` kommt HTTP 200 über HTTP/2. Das Blatt-Zertifikat, also das Zertifikat der Site selbst, lebt [12 Stunden](https://caddyserver.com/docs/caddyfile/directives/tls) (englisch), das Root rund 3.600 Tage. Für `.internal` wählte Caddy den lokalen Aussteller im Test auch ohne `tls internal`. Das Root-Zertifikat erzeugt Caddy beim ersten Start im Data-Verzeichnis, im Container also unter `/data/caddy/pki/authorities/local/root.crt`. Die [Verteilung](https://caddyserver.com/docs/automatic-https) (englisch) ist deine Aufgabe: „it is the system administrator's responsibility".

Für interne Dienste finde ich `tls internal` praktisch, solange du die Verteilung der Root-CA einplanst. Für öffentliche Namen im Intranet bleibt DNS-01, die ACME-Prüfung über einen DNS-Eintrag ohne offene Ports. Dafür braucht Caddy ein [Modul für deinen DNS-Anbieter](https://caddyserver.com/docs/automatic-https) (englisch), das dem Standard-Build fehlt, du brauchst also xcaddy. Mit [`acme_server`](https://caddyserver.com/docs/caddyfile/directives/acme_server) (englisch) kann Caddy zudem selbst Zertifikate für andere interne Server ausstellen.

## Praxisbausteine

Die folgenden Beispiele sind Auszüge. Jedes steht mit dem, was es nicht leistet.

### WordPress

Der [WordPress-Core](https://raw.githubusercontent.com/WordPress/WordPress/master/wp-includes/vars.php) (englisch) erkennt FrankenPHP, Permalinks laufen dadurch ohne `.htaccess`. Die Regeln brauchst du trotzdem. Dieser Block ist per `validate` und im Verhalten geprüft, mit `:8080` als Adresse:

```caddyfile
example.com {
	root /var/www/wordpress
	encode zstd br gzip

	@uploads_php path_regexp (?i)^/wp-content/uploads/.*\.php
	respond @uploads_php 403

	@uploads_dir path_regexp (?i)^/wp-content/uploads(/.*)?/$
	respond @uploads_dir 403

	@hidden {
		path_regexp (^|/)\.
		not path_regexp ^/\.well-known(/[^./][^/]*)+$
	}
	respond @hidden 403

	@private path_regexp (?i)^/(wp-config\.|xmlrpc\.php)|\.sql$
	respond @private 403

	php_server
}
```

Die Regeln brauchen `path_regexp`, weil `.*` im Unterschied zu `path` auch Schrägstriche überquert. `@uploads_php` hat bewusst keinen `$`-Anker, damit auch `/x.php/extra` erfasst ist. `@uploads_dir` ist nötig, weil `php_server` bei einer Verzeichnis-URL die `index.php` darin ausführt und die URL dabei gar kein `.php` enthält. Ohne diese Regel lief im Test eine hochgeladene `index.php` unter `/wp-content/uploads/evil/`. Geprüft blieben auch `//wp-content/…`, `x%2ephp`, Punktsegmente und `/XMLRPC.php` gesperrt, ACME-Pfade unter `/.well-known/` dagegen frei. Die Reihenfolge im Text ist außerhalb von `route` egal, weil Caddys feste Direktivenreihenfolge `respond` vor `php_server` setzt.

Der Block sperrt nur Pfade. PHP außerhalb von `uploads` läuft weiter, auch eine von einem Plugin irgendwo abgelegte Datei. `xmlrpc.php` zu sperren kann Apps und Plugins treffen. Andere Backups als `*.sql` und `wp-config.*` werden ausgeliefert. `.phtml` und `.phar` laufen nicht, kommen aber als Text. Getestet ist an Fake-Dateien, nicht an einer echten Installation.

Für einen Seiten-Cache brauchst du eine Lösung auf Anwendungsebene, denn ein Gegenstück zu nginx `fastcgi_cache` hat der [Standard-Build nicht](https://raw.githubusercontent.com/caddyserver/cache-handler/master/README.md) (englisch). Hinter einem Caddy, das HTTPS annimmt und unverschlüsselt weiterreicht, gehört die [X-Forwarded-Proto-Behandlung](https://developer.wordpress.org/advanced-administration/security/https/) (englisch) in die `wp-config.php`.

### Grav

Grav liefert [eine eigene Caddy-Konfiguration](https://raw.githubusercontent.com/getgrav/grav/develop/webserver-configs/Caddyfile) (englisch) mit. Geprüft an Grav 2.2.28 gilt: Die Matcher übernimmst du, das Ende mit `try_files`, `php_fastcgi` und `file_server` ersetzt `php_server`, und der `route`-Block entfällt. Dazu kommt eine Regel, denn unter `php_server` läuft auch `/datei.php/irgendwas`, und Gravs auf `$` endende Regeln ließen das in der wörtlichen Übersetzung durch:

```caddyfile
@path_info path_regexp (?i)\.php/
respond @path_info 403
```

Das Docker-Image bringt zudem nicht alles mit, was Grav verlangt. Ohne `gd` und `zip` meldet es 500:

```dockerfile
FROM dunglas/frankenphp:1.13.5
RUN install-php-extensions gd zip
```

Im Test kamen die Grav-Dateien noch per `COPY` dazu. Geprüft ist nur Grav-Core ohne Admin-Plugin, im klassischen Modus und sequenziell. `system/` und `vendor/` sind nach Dateiendung gesperrt, nicht pauschal.

### Container allgemein

Die Debian-Images sind laut [Doku](https://github.com/php/frankenphp/blob/v1.13.5/docs/docker.md) (englisch) die empfohlene Wahl. Eine eigene `php.ini` fehlt dort, es gelten die Built-in-Defaults samt `display_errors=1`, was GHSA-5359 mit ermöglichte. Kopiere also laut [Produktions-Doku](https://frankenphp.dev/docs/production/) (englisch) die `php.ini-production`. Standardmäßig läuft der Container als root, Non-Root ist Opt-in und schützt die Schlüssel nicht vor PHP. Unter Podman kann ein rootless Container, der ohne Root-Rechte läuft, laut [Doku](https://man.archlinux.org/man/extra/podman/podman-rootless.7.en) (englisch) nicht unter Port 1024 binden. `net.ipv4.ip_unprivileged_port_start` lockert das nur hostweit, die Grundlagen stehen im [Cheat-Sheet zu Podman](https://www.jpkc.com/db/cheatsheets/containers/podman/).

## Abstürze und Neustarts: der empfehlenswerte Weg

Server fallen manchmal aus. Bei FrankenPHP zieht ein einzelner Fehler den ganzen Prozess mit, und deshalb sollte jemand ihn automatisch neu starten. Meine Container nutzen Health Checks. Der folgende Weg ist die allgemeine Empfehlung, geprüft unter Docker, für Podman nur laut Doku.

Dabei gibt es zwei verschiedene Fehler, und sie brauchen verschiedene Gegenmittel:

- **Der Prozess stirbt**, etwa durch einen Segfault oder eine Panic (harte Programmabstürze in C beziehungsweise Go) oder durch ein hartes Speicherlimit. Der Container endet, eine Restart-Policy startet ihn neu. Geprüft: Absturz (Exit 2) und OOM-Kill (Exit 137) kommen mit `unless-stopped` zurück. Ein Health Check ist dafür nicht nötig.
- **Der Prozess lebt, antwortet aber nicht**, etwa weil alle PHP-Threads blockieren. Das erkennt nur ein Health Check, also ein regelmäßiger Selbsttest des Containers, und zwar einer, der wirklich PHP anspricht.

Ich würde dir raten, im Health Check PHP wirklich anzusprechen und nicht nur eine statische Datei. Geprüft blieben eine statische Datei und das im Image eingebaute `HEALTHCHECK` gegen `/metrics` auf Port 2019 grün, während alle PHP-Threads blockiert waren.

### Docker: `kill -QUIT 1` mit eigenem Zähler

Signale sind Nachrichten an einen Prozess: SIGTERM bittet ihn um ein geordnetes Ende, SIGKILL beendet ihn sofort, SIGQUIT bricht Caddy sofort mit Fehlercode ab. Unter Docker löst `unhealthy` allein keinen Neustart aus, geprüft, und die [Doku zu Restart-Policies](https://docs.docker.com/engine/containers/start-containers-automatically/) (englisch) erwähnt Health Checks gar nicht. Die naheliegende Form `curl … || kill 1` ist aus vier Gründen falsch. SIGTERM endet mit Exit 0, sodass `on-failure` nicht greift. Der Prozess wartet auf genau die Threads, die gerade hängen, geprüft auch mit `grace_period 3s`. Der erste Fehlschlag löst aus, `retries` wirkt also nicht. Und weil `kill` selbst 0 zurückgibt, meldet der Check Erfolg. `kill -9 1` von innen bleibt wirkungslos, weil PID 1, der Hauptprozess im Container, [im eigenen Namespace](https://man7.org/linux/man-pages/man7/pid_namespaces.7.html) (englisch) kein SIGKILL von innen bekommt.

Was funktioniert: `kill -QUIT 1` nach mehreren aufeinanderfolgenden Fehlschlägen. Das [beendet Caddy sofort](https://raw.githubusercontent.com/caddyserver/caddy/v2.11.9/sigtrap_posix.go) (englisch) mit Exit 2, die Restart-Policy greift. Geprüft mit Docker Compose. Speichere das folgende Skript als `healthcheck.sh` neben der `compose.yaml` und mach es mit `chmod +x healthcheck.sh` ausführbar, sonst scheitert der Check mit `permission denied`, und es wird nie neu gestartet:

```bash
#!/bin/sh
# Probe a real PHP script. After three consecutive failures, quit PID 1 so that
# the restart policy takes over. SIGQUIT, because SIGTERM waits for busy PHP
# threads and exits with 0.
state=/tmp/healthcheck.failures

if curl -fsS --max-time 5 -o /dev/null http://127.0.0.1:8081/health.php; then
	rm -f "$state"
	exit 0
fi

n=$(( $(cat "$state" 2>/dev/null || echo 0) + 1 ))
echo "$n" > "$state"

if [ "$n" -ge 3 ]; then
	rm -f "$state"
	kill -QUIT 1
fi
exit 1
```

Dazu ein interner Site-Block im `Caddyfile`, zusätzlich zu deiner eigentlichen Site, und ein `health.php`, das nur `ok` ausgibt:

```caddyfile
http://127.0.0.1:8081 {
	bind 127.0.0.1
	root * /srv/health
	php_server
}
```

```php
<?php
echo "ok\n";
```

Und die `compose.yaml`:

```yaml
services:
  app:
    image: dunglas/frankenphp:1.13.5
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - ./public:/app/public:ro
      - ./health:/srv/health:ro
      - ./Caddyfile:/etc/frankenphp/Caddyfile:ro
      - ./healthcheck.sh:/usr/local/bin/healthcheck.sh:ro
      - caddy_data:/data
      - caddy_config:/config
    stop_grace_period: 30s
    healthcheck:
      test: ["CMD", "/usr/local/bin/healthcheck.sh"]
      interval: 10s
      timeout: 8s
      retries: 3

volumes:
  caddy_data:
  caddy_config:
```

Port-Mapping, TLS und benannte Volumes waren im Test durch einen lokalen Port ersetzt. Das Wichtigste aus den Testläufen:

- **`start_period` schützt nicht.** Docker zählt die Fehlschläge dann nicht, der Befehl läuft aber und schickt das Signal. Die Startfrist ergibt sich aus Schwelle mal Intervall, hier also 30 Sekunden. Ein Worker mit 15 Sekunden Bootzeit lief mit Intervall 10 s durch. Mit Intervall 2 s geriet er in eine Neustartschleife, weil die drei Fehlschläge schon nach rund 6 Sekunden erreicht sind: im Test acht Neustarts in 70 Sekunden, nie `healthy`.
- **Docker-`timeout` muss größer sein als `curl --max-time`,** sonst beendet Docker den Check, bevor das Skript zählen kann.
- **Prüfe gegen einen unverschlüsselten internen Port.** Mit dem Standard-Caddyfile liefert `curl -fsS http://localhost/missing.php` einen Redirect mit Exit 0, PHP sieht die Anfrage nie.
- **Prüfe im Worker-Modus durch den Worker.** Ein klassisches `health.php` lieferte 200, während der Worker hing.
- **Halte den Check dumm.** Datenbank und APIs gehören nicht hinein, sonst startet ein Datenbankausfall deinen Webserver neu.
- **Plane den Preis ein.** SIGQUIT bricht alle laufenden Anfragen ab. Ein `sleep` löst sich laut Test ohnehin nach `max_execution_time` von selbst, ob das auch für Hänger in C-Code oder bei Datenbankanfragen gilt, ist nicht geprüft.

`stop_grace_period` steht hier auf 30 Sekunden, weil der Standard von 10 Sekunden geplante Stopps abschneidet. Nicht zu empfehlen ist ein Autoheal-Sidecar, also ein Hilfscontainer, der andere Container neu startet, mit eingebundenem Docker-Socket, denn der Socket bedeutet praktisch Root-Rechte auf dem Host. Die [Compose-Spezifikation](https://docs.docker.com/reference/compose-file/services/) (englisch) selbst kennt keine Aktion bei Fehlschlag. [Swarm](https://docs.docker.com/engine/swarm/how-swarm-mode-works/services/) (englisch) und andere Orchestratoren, die viele Container über mehrere Server steuern, ersetzen eine fehlgeschlagene Task selbst.

### Podman: laut Doku eingebaut

Podman löst das laut Doku direkt: `--health-on-failure` beziehungsweise in Quadlet `HealthOnFailure=`. Quadlet ist Podmans Weg, Container als Dienste von systemd, dem Dienste-Manager unter Linux, zu beschreiben. **Dieses Beispiel ist nicht getestet und folgt nur der [Doku](https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html) (englisch):**

```ini
[Unit]
Description=FrankenPHP app

[Container]
Image=docker.io/dunglas/frankenphp:1.13.5
PublishPort=8080:8080
Volume=%h/app/public:/app/public:ro
Volume=%h/app/health:/srv/health:ro
Volume=%h/app/Caddyfile:/etc/frankenphp/Caddyfile:ro
Volume=%h/app/data:/data
Volume=%h/app/config:/config
HealthCmd=curl -fsS --max-time 5 -o /dev/null http://127.0.0.1:8081/health.php
HealthInterval=10s
HealthTimeout=8s
HealthRetries=3
HealthStartPeriod=30s
HealthOnFailure=kill

[Service]
Restart=always
RestartSec=3s

[Install]
WantedBy=default.target
```

Die Site im `Caddyfile` muss dafür auf `:8080` lauschen, zusätzlich zum internen Block auf 8081. [Laut Doku](https://docs.podman.io/en/latest/markdown/podman-run.1.html) (englisch) passt `kill` zu systemd, weil systemd den Neustart übernimmt. Daraus lässt sich schließen, dass du hier weder Skript noch SIGQUIT brauchst, denn die Aktion kommt von außen, und `retries` und Startfrist wirken wie vorgesehen. Die Checks hängen an [systemd-Timern](https://raw.githubusercontent.com/containers/podman/main/libpod/healthcheck_linux.go) (englisch). Die Compose-Spezifikation kennt keinen Schlüssel für eine Aktion bei Fehlschlag, also bleib dafür bei Quadlet oder `podman run`.

### Den Neustart überbrücken

Während eines Neustarts ist der Dienst kurz weg. Ein vorgeschaltetes Caddy kann das für neue Anfragen überbrücken:

```caddyfile
example.com {
	reverse_proxy app:8080 {
		lb_try_duration 20s
		lb_try_interval 250ms
	}
}
```

Geprüft mit künstlicher Startverzögerung: Ohne Retry gab es von 30 Anfragen 24 mal 502, mit `lb_try_duration` 30 mal 200. Laufende Anfragen überleben den Neustart aber nicht. Ein laufender POST endete mit 502, ein laufender GET lief nach dem Neustart ein zweites Mal. Ein GET mit Nebenwirkung kann also doppelt laufen, und das schränkst du bei Bedarf mit `lb_retry_match` ein.

## Migrationsfallen

Wer von Apache oder nginx mit PHP-FPM umzieht, trifft meist auf dieselben Punkte. Beim Umzug von Apache solltest du aus meiner Sicht früh prüfen, was bisher `.htaccess` für dich gesperrt hat. Unter Caddy wirkt nichts davon, und der [Migrationsguide](https://raw.githubusercontent.com/php/frankenphp/v1.13.5/docs/migrate.md) (englisch) sagt es so: „check any request filtering that was done by the web server before PHP-FPM received the request".

- **`max_execution_time` zählt laut [PHP-Handbuch](https://www.php.net/manual/en/info.configuration.php) (englisch) auf Linux mit ZTS Wanduhrzeit.** Unter FPM zählt CPU-Zeit. `sleep` und I/O verbrauchen das Limit, Importe oder langsame API-Aufrufe stoßen also plötzlich daran.
- **`.user.ini` wirkt nicht,** das betrifft auch Sicherheits-Plugins mit `auto_prepend_file`.
- **Werte je Pool gibt es nicht mehr.** Der Guide bildet `php_admin_value` auf `php_ini` ab, erwähnt dabei aber nicht, dass das global gilt.
- **`request_terminate_timeout`, `slowlog` und FPM-Status:** Der Guide nennt dafür kein Gegenstück.
- **Inkompatible Extensions:** `imap`, `newrelic` und `pcov` werden laut [Known Issues](https://frankenphp.dev/docs/known-issues/) (englisch) nicht unterstützt, datadog, blackfire und imagick gelten als problematisch. Bei imagick nennt die Doku Instabilität und Abstürze durch die OpenMP-Threads von ImageMagick. Als Abhilfe begrenzt du ImageMagick auf einen Thread oder baust es ohne OpenMP. Betroffen sind laut Doku nur die Docker-Images und Homebrew-Installationen, in den statischen Binaries und den offiziellen Paketen ist OpenMP bereits abgeschaltet.

## Für wen es passt und für wen nicht

Gut passt FrankenPHP, wenn du ohnehin Caddy nutzt oder einsetzen willst, wenn dein Framework den Worker-Modus offiziell unterstützt, wenn Projekte in eigenen Containern laufen und wenn jemand wirklich auf Updates achtet. Auch für interne Apps kann es passen, weil `tls internal` das HTTPS vereinfacht, solange du die Verteilung der Root-CA einplanst.

Für klassisches Shared Hosting halte ich PHP-FPM mit getrennten Pools für dich meist für die bessere Wahl. Läuft dein Setup mit nginx und PHP-FPM sauber und deine Anwendung kann keinen Worker-Modus, würde ich allein für mehr Tempo nicht umziehen.

## Fazit

FrankenPHP löst für mich das Problem, mit dem dieser Text begann: Caddy kann nun auch PHP, in einem Programm, das leicht zu betreiben ist. Tempo bringt es vor allem im Worker-Modus, und dort nur mit einer Anwendung, die dafür gebaut ist. Die Sicherheitslage verlangt Aufmerksamkeit, weil ein Prozess alles teilt und die Update-Taktung hoch ist. Wer das einplant, also ein Projekt je Container, schnelle Updates, Health Checks gegen echtes PHP und eigene Regeln fürs Webroot, kann damit gut fahren. Für mich ist daraus eine sichere, performante und leicht zu verwaltende Lösung geworden.

## Weiterlesen

Die Direktiven im Überblick stehen in den Cheat-Sheets zu [FrankenPHP](https://www.jpkc.com/db/cheatsheets/web-servers/frankenphp/), [Caddy](https://www.jpkc.com/db/cheatsheets/web-servers/caddy/) und [Podman](https://www.jpkc.com/db/cheatsheets/containers/podman/). Was bei PHP2Shell zu tun ist, erklärt [der Artikel dazu](https://www.jpkc.com/db/blog/php2shell/). Warum Texte wie dieser getrennt vom Schreiben geprüft werden, zeigt [Wer prüft den Prüfer?](https://www.jpkc.com/db/blog/faktentreue-review/).

