FrankenPHP Worker-Modus mit Symfony: Memory Leaks, Service-Resets und wann du ihn abschaltest

Sandor Farkas
Gründer & Lead Developer
Experte für Softwareentwicklung und Legacy-Code-Optimierung
LinkedInEin Symfony-Setup mit FrankenPHP im Worker-Modus verspricht vor allem eines: Du sparst dir die Kosten, bei jedem Request einen frischen Kernel zu booten, und hältst deine Anwendung zwischen den Requests im Speicher. Genau dort beginnt aber auch der Ärger. Klassisches PHP war zwei Jahrzehnte lang nachsichtig mit schlampigem State-Management, weil jeder Request einen sauberen Prozess und frischen Speicher bekam, sobald er beendet war. Der Worker-Modus nimmt dieses Sicherheitsnetz weg. Der Kernel bootet einmal und verarbeitet dann Tausende Requests, bevor er neu startet, und alles, was leckt oder State aus einem Request festhält, kann still in den nächsten durchsickern.
Dieser Beitrag knüpft direkt an unseren früheren Artikel zum Betrieb von FrankenPHP in Produktion an, der den Migrationspfad weg von Nginx und PHP-FPM beschreibt. Hier gehen wir eine Ebene tiefer: was tatsächlich kaputtgeht, wenn eine Symfony-Anwendung im Worker-Modus läuft, wie du die Leaks findest, bevor sie in Produktion als Out-of-Memory-Neustart auftauchen, und in welchen Fällen das Abschalten des Worker-Modus die ehrlichere Antwort für deine tatsächliche Codebasis ist.
Was der FrankenPHP Worker-Modus an einem Symfony-Request ändert
Im klassischen PHP kommt ein Request rein, PHP-FPM startet einen Worker-Prozess (oder verwendet einen wieder), Symfony bootet seinen Kernel, baut den Service-Container, verarbeitet den Request, und der Prozess stirbt entweder oder wird mit sauberem Zustand recycelt. Jedes Objekt, das du während dieses Requests erzeugst, jede statische Property, die du setzt, jeder Wert, den du in ein Cache-Array schiebst, verschwindet, wenn der Request endet.
Der Worker-Modus ändert diesen Vertrag. FrankenPHP bootet den Symfony-Kernel einmal pro Worker-Prozess und läuft dann in einer Schleife: Request verarbeiten, zurücksetzen, was zurückgesetzt werden muss, nächsten Request verarbeiten, solange dieser Worker lebt. Der Performance-Gewinn ist real, denn du zahlst nicht mehr bei jedem einzelnen Request die Kosten für Autoloading und Container-Kompilierung. Aber jeder Service in deinem Container muss jetzt eine Frage beantworten, die ihm vorher nie gestellt wurde: Was passiert mit meinem internen State, wenn der nächste Request kommt und ich immer noch dasselbe PHP-Objekt bin wie vor einer Sekunde?
Die meisten Services beantworten diese Frage ohne zusätzliche Arbeit richtig, weil sie von vornherein zustandslos sind: Sie nehmen Input, tun etwas, geben Output zurück und halten zwischen den Aufrufen nichts fest. Die Services, die sie schlecht beantworten, sind die, die du prüfen solltest, bevor du den Worker-Modus in Produktion einschaltest.
Wo State tatsächlich durchsickert
Drei Kategorien verursachen die überwältigende Mehrheit der Worker-Modus-Vorfälle in Symfony-Anwendungen.
Services, die Symfonys ResetInterface implementieren, bekommen zwischen Requests automatisch einen reset()-Aufruf, und das Framework liefert das aus gutem Grund mit: Viele Core-Services (der Request-Stack, der Security-Token-Storage, Teile des HTTP-Clients) brauchen es bereits. Wenn du eigene Services mit internen Arrays, Zählern oder gesammelten Daten hast, die den Request nicht überleben sollen, und du ResetInterface darauf nicht implementiert hast, liegen diese Daten noch da, wenn Request zwei startet. Ein Collector-Service, der Log-Einträge für einen Batch-Job sammelt und nie leert, ist das Lehrbuchbeispiel: Im klassischen Modus würde er mit dem Prozess sterben und niemand würde es merken; im Worker-Modus wächst er, bis der Worker neu startet oder ihm der Speicher ausgeht.
Doctrines EntityManager ist die zweite Kategorie, und sie verursacht die seltsamsten Bugs. Nach einer Exception kann Doctrine den EntityManager in einen geschlossenen Zustand versetzen, und im klassischen PHP starb dieser geschlossene EntityManager mit dem Prozess, sodass der nächste Request automatisch einen frischen bekam. Im Worker-Modus kann ein geschlossener EntityManager beim nächsten Request immer noch im Container liegen, wenn ihn nichts zurücksetzt, und das Symptom ist kein sauberer Absturz, sondern ein verwirrender „entity manager is closed“-Fehler bei einem Request, der ansonsten nichts mit dem zu tun hat, was vorher fehlgeschlagen ist.
Statische Properties und Singletons sind die dritte Kategorie, und sie sind am schwersten zu finden, weil sie oft aus einer Abhängigkeit stammen statt aus deinem eigenen Code. Ein statisches Cache-Array, das aus Performance-Gründen einen berechneten Wert innerhalb einer Schleife memoisiert, ein Singleton-Pattern, das geschrieben wurde, bevor es den Service-Container gab, ein Zähler auf Klassenebene für Paginierung oder Batching: All das überlebt im Worker-Modus zwischen Requests, weil die Klasse selbst im Speicher des Workers geladen bleibt, nicht nur die Objektinstanz.
Leaks finden, bevor die Produktion sie für dich findet
Der ehrliche Weg, diese Probleme zu erkennen, ist, die Anwendung im Worker-Modus in einer Staging-Umgebung mit realistischem Traffic laufen zu lassen und den Speicher über die Zeit zu beobachten, nicht nur einmal beim Start. Ein Worker-Prozess, der Request für Request stetig nach oben klettert und nie ein Plateau erreicht, hat irgendwo ein Leak, auch wenn keine Exception fliegt. Unser Beitrag zum Symfony Performance-Monitoring beschreibt die Metriken, die sich zu visualisieren lohnen, und der Speicher pro Worker im Verhältnis zur Request-Anzahl ist genau die Metrik, die Worker-Modus-Leaks erwischt, lange bevor für Nutzer etwas sichtbar kaputtgeht.
Ein zweiter, günstigerer Check: Durchsuch deine Codebasis nach static-Properties auf Services und nach Klassen, die ein Singleton-Pattern von Hand implementieren statt über den Container. Beides ist nicht automatisch ein Problem, aber jeder Treffer ist ein Kandidat, den du dir einzeln ansehen und bei dem du entscheiden musst, ob der gehaltene State einen Request überleben soll oder nicht.
Drittens: Lass deine bestehende Testsuite gegen einen persistenten Worker-Prozess laufen, statt pro Test einen frischen Kernel zu booten. Erstaunlich viele State-Leaks, die in normalen Unit-Tests nie auftauchen (weil jeder Test einen frischen Kernel bekommt), zeigen sich sofort, sobald dieselbe Kernel-Instanz die ganze Suite nacheinander abarbeitet.
Max Requests und Neustarts als Sicherheitsnetz, nicht als Lösung
FrankenPHP unterstützt eine max_requests-Einstellung, die einen Worker neu startet, nachdem er eine konfigurierte Anzahl von Requests verarbeitet hat, und es ist verlockend, das als Workaround für Memory Leaks zu behandeln. Als Sicherheitsnetz ist es vernünftig: Worker regelmäßig neu zu starten begrenzt den Schaden durch ein langsames Leak, das du noch nicht gefunden hast, so wie regelmäßige Neustarts eines klassischen PHP-FPM-Pools schon immer eine günstige Versicherung waren. Ein Ersatz für die Suche nach dem Leak ist es aber nicht. Ein Worker, der alle 200 Requests neu gestartet werden muss, um unter seinem Speicherlimit zu bleiben, startet unter echtem Traffic ständig neu, und jeder Neustart zahlt die vollen Kernel-Boot-Kosten, die der Worker-Modus eigentlich vermeiden soll. Wenn du max_requests nach unten drehst, um ein Leak auszugleichen, statt es als routinemäßige Hygiene nach oben zu setzen, ist das ein Zeichen, zurückzugehen und die eigentliche Ursache zu finden.
Wann der klassische Modus die richtige Wahl ist
Nicht jede Symfony-Anwendung ist bereit für den Worker-Modus, und das ist in Ordnung. Wenn du eine Legacy-Codebasis betreibst, deren Services geschrieben wurden, bevor Dependency-Injection-Disziplin konsequent war, vor allem mit selbstgebauten Singletons, globalem State oder statischen Caches, die sich über Jahre und viele Entwickler angesammelt haben, kann es mehr kosten, all das vor einer Umstellung in Produktion zu prüfen, als der Performance-Gewinn gerade wert ist. Der klassische Modus unter FrankenPHP bringt dir trotzdem das Single-Binary-Deployment und die HTTP/3-Unterstützung, du verzichtest nur auf die Wiederverwendung des Kernels im Speicher, und für viele Anwendungen ist das ein akzeptabler Kompromiss, bis die Prüfung auf State-Leaks ordentlich erledigt ist.
Ein einfacher Bereitschafts-Check, bevor du den Worker-Modus aktivierst: Kannst du jeden Service in deinem Container benennen, der über Aufrufe hinweg internen State hält, und kannst du sicher sagen, was mit diesem State beim nächsten Request passiert? Wenn die Antwort Nachsehen statt Wissen erfordert, lohnt sich zuerst ein gezieltes Code-Review. Falls die Anwendung erst kürzlich containerisiert wurde, behandelt unser Leitfaden zur Containerisierung einer Symfony-Anwendung auch die Konfigurationsentscheidungen für Produktion, die meist zur gleichen Zeit wie Fragen zum Worker-Modus aufkommen, weil beides normalerweise beim selben Deployment-Umbau auf den Tisch kommt.
Den Worker-Modus abzuschalten, wenn du ihn schon aktiviert hast und unerklärliche Fehler oder steigenden Speicherverbrauch siehst, ist eine einzeilige Konfigurationsänderung und ein sicherer Standard, auf den du zurückfallen kannst, während du die Ursache untersuchst. Es gibt keinen Nachteil, FrankenPHP dauerhaft im klassischen Modus zu betreiben. Die Performance-Obergrenze ist niedriger, aber eine korrekte Anwendung im klassischen Modus schlägt eine schnelle Anwendung, die gelegentlich die Daten eines Kunden einem anderen ausliefert, weil ein statischer Cache nie zurückgesetzt wurde.
Wenn dein Team den Worker-Modus für eine Symfony-Anwendung mit ein paar Jahren Geschichte abwägt, kann ein kurzes externes Code-Review meist in ein bis zwei Tagen sagen, ob das Risiko für State-Leaks klein und klar umrissen ist oder sich über die ganze Codebasis verteilt. Unsere Arbeit im Bereich Code-Qualitätsberatung deckt genau diese Art von Prüfung ab, und für Anwendungen, die durchgehend ältere Muster mitschleppen, ist die Legacy-Code-Optimierung der bessere Einstieg. Schreib uns an hello@wolf-tech.io oder über wolf-tech.io, wenn du eine zweite Meinung willst, bevor du in Produktion den Schalter umlegst.
