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.
von Jean Pierre Kolb ·
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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) einen einzigen Thread und warnt. Unterstützt wird PHP ab 8.2, die Docker-Images (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) im Mai 2025 ihre Unterstützung an, seit Juni 2025 liegt der Code in der PHP-Organisation (öffnet in neuem Tab) (englisch) auf GitHub, unter MIT-Lizenz. Die Führung blieb laut der Ankündigung vom Mai (öffnet in neuem Tab) (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.
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 (öffnet in neuem Tab) (englisch):
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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) komprimiert standardmäßig mit zstd, Brotli und gzip.
- Laufzeiten: Caddy erneuert laut Doku (öffnet in neuem Tab) (englisch) im letzten Drittel der Laufzeit. Die von Let's Encrypt angekündigte Verkürzung (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch). Im Container gehören
/dataund/configalso auf ein Volume, also einen Speicher, der den Container überlebt. - Die Zertifikatsstelle: Die Doku (öffnet in neuem Tab) (englisch) nennt zwei Stellen als Standard, laut Quelltext (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch), Stapling tut für solche Zertifikate also nichts mehr.
Bei der reinen Geschwindigkeit ist das Bild gemischt. In einem Test von 2026 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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.
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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch), dazu weiter unten mehr.
Worker-Modus: echter Gewinn mit Bedingungen
Im Worker-Modus zeigen Messungen einen echten Abstand. Bei Sylius (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch), Laravel über Octane (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) kennt das Wort „worker" gar nicht, und Dunglas sagte laut DevClass (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) meldet stark verlangsamte Sites mit 1.12.x, Stand auf 1.13.x unbekannt.
Stellschrauben
- Threads: Ohne Worker startet FrankenPHP laut Quelltext (öffnet in neuem Tab) (englisch) mit 2 Threads je CPU, und ohne gesetztes
max_threadsskaliert es nicht nach oben. Die Doku (öffnet in neuem Tab) (englisch) rät, die Standardwerte zu ändern („We strongly recommend changing these values.") und sie per Lasttest zu ermitteln, und nennt als Faustregelmax_threads x memory_limit < available_memory. Seit 1.13.0 (öffnet in neuem Tab) (englisch) zähltnum_threadsnur 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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) aktiv, die Abstimmung bleibt bei dir. Muss der Cache seinen Speicher neu aufbauen, kann das laut Metriken-Doku (öffnet in neuem Tab) (englisch) unter ZTS den Prozess abstürzen lassen: „The counter should stay at zero". Beobachte
frankenphp_opcache_restartsund vergrößere bei Bedarfopcache.memory_consumption. php_server-Komfort: Die Dateiprüfungen kosten etwas. Die Doku nennt verengtestry_filesoderfile_server offals Hebel, ohne Größenangabe.- Speicherlimit der Go-Laufzeit: Caddy setzt
GOMEMLIMITlaut Quelltext (öffnet in neuem Tab) (englisch) automatisch, mit dem Standardfaktor 0,9 (öffnet in neuem Tab) (englisch) der Bibliothek automemlimit also auf 90 % des verfügbaren Speichers, und das zählt C-Speicher nicht mit (öffnet in neuem Tab) (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
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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) schloss 17.
Zur Einordnung gehört mehr als die Summe:
- Das einzige kritische Advisory GHSA-x9p2 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 eigenephp.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. 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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 ausführlich. FrankenPHP gehört zu den gefährdeten SAPIs: Das PHP-Advisory (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) knapp: „Only the latest version is supported." Bei Caddy gilt dasselbe (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) nicht unter einem anderen Benutzer laufen als ihr Prozess. open_basedir, das PHP-Dateizugriffe auf bestimmte Verzeichnisse beschränkt, ist laut PHP-Handbuch (öffnet in neuem Tab) 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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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:
{
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. Mitmax_sizeund einempost_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. Bleibtpost_max_sizebeim 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,$_POSTblieb leer.post_max_sizebegrenztphp://inputaber nicht: Leer war es im Test nur, wenn der ClientExpect: 100-continueschickte, wie curl bei großen Bodys mit Content-Length. Ohne diesen Header kam der ganze Body an, ebenso bei Chunked. Setzepost_max_sizedeshalb nicht untermax_size, bei Uploads gilt das auch fürupload_max_filesize.- Timeouts:
read_headersteht 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 (öffnet in neuem Tab) (englisch).php_serversetzt 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 (öffnet in neuem Tab) (englisch) behebt das. Bodies, die PHP nicht beim Start der Anfrage liest, etwa beiPUT, 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 mussX-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 (öffnet in neuem Tab) (englisch). Der Matcherclient_iptraf im Test die gefälschte Adresse, sobald der Absender als Proxy vertraut war.- Nicht abgedeckt:
admin offnimmt das API-Risiko, nicht die Lesbarkeit der Schlüssel durch PHP.
Noch drei Punkte. Der Server-Header verrät in den offiziellen Docker-Builds (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch). Eingebaut wird über xcaddy, das Plugins in ein eigenes Binary kompiliert, mit dem builder-Image (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) und der CrowdSec-Bouncer (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) 2023 zehn Lücken, der heutige Stand ist nicht geprüft.
Caddy davor oder FrankenPHP allein
Der Doku-Standard (öffnet in neuem Tab) (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:
example.com {
reverse_proxy frankenphp:8080
}Innen, ohne eigenes HTTPS und mit dem äußeren Caddy als vertrauenswürdigem Proxy:
{
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:
{
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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch), das dem Standard-Build fehlt, du brauchst also xcaddy. Mit acme_server (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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:
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 (öffnet in neuem Tab) (englisch). Hinter einem Caddy, das HTTPS annimmt und unverschlüsselt weiterreicht, gehört die X-Forwarded-Proto-Behandlung (öffnet in neuem Tab) (englisch) in die wp-config.php.
Grav
Grav liefert eine eigene Caddy-Konfiguration (öffnet in neuem Tab) (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:
@path_info path_regexp (?i)\.php/
respond @path_info 403Das Docker-Image bringt zudem nicht alles mit, was Grav verlangt. Ohne gd und zip meldet es 500:
FROM dunglas/frankenphp:1.13.5
RUN install-php-extensions gd zipIm 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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) nicht unter Port 1024 binden. net.ipv4.ip_unprivileged_port_start lockert das nur hostweit, die Grundlagen stehen im Cheat-Sheet zu 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-stoppedzurü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 (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch) kein SIGKILL von innen bekommt.
Was funktioniert: kill -QUIT 1 nach mehreren aufeinanderfolgenden Fehlschlägen. Das beendet Caddy sofort (öffnet in neuem Tab) (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:
#!/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 1Dazu ein interner Site-Block im Caddyfile, zusätzlich zu deiner eigentlichen Site, und ein health.php, das nur ok ausgibt:
http://127.0.0.1:8081 {
bind 127.0.0.1
root * /srv/health
php_server
}<?php
echo "ok\n";Und die compose.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_periodschü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, niehealthy.- Docker-
timeoutmuss größer sein alscurl --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.phpeinen Redirect mit Exit 0, PHP sieht die Anfrage nie. - Prüfe im Worker-Modus durch den Worker. Ein klassisches
health.phplieferte 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
sleeplöst sich laut Test ohnehin nachmax_execution_timevon 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 (öffnet in neuem Tab) (englisch) selbst kennt keine Aktion bei Fehlschlag. Swarm (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (englisch):
[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.targetDie Site im Caddyfile muss dafür auf :8080 lauschen, zusätzlich zum internen Block auf 8081. Laut Doku (öffnet in neuem Tab) (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 (öffnet in neuem Tab) (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:
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 (öffnet in neuem Tab) (englisch) sagt es so: „check any request filtering that was done by the web server before PHP-FPM received the request".
max_execution_timezählt laut PHP-Handbuch (öffnet in neuem Tab) (englisch) auf Linux mit ZTS Wanduhrzeit. Unter FPM zählt CPU-Zeit.sleepund I/O verbrauchen das Limit, Importe oder langsame API-Aufrufe stoßen also plötzlich daran..user.iniwirkt nicht, das betrifft auch Sicherheits-Plugins mitauto_prepend_file.- Werte je Pool gibt es nicht mehr. Der Guide bildet
php_admin_valueaufphp_iniab, erwähnt dabei aber nicht, dass das global gilt. request_terminate_timeout,slowlogund FPM-Status: Der Guide nennt dafür kein Gegenstück.- Inkompatible Extensions:
imap,newrelicundpcovwerden laut Known Issues (öffnet in neuem Tab) (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, Caddy und Podman. Was bei PHP2Shell zu tun ist, erklärt der Artikel dazu. Warum Texte wie dieser getrennt vom Schreiben geprüft werden, zeigt Wer prüft den Prüfer?.