Blog von Sébastien TIMONER

FrankenPHP: Steigern Sie die Leistung Ihrer Symfony-Anwendungen im Jahr 2025

Verfügbar in :

In einer Welt, in der die Leistung von Webanwendungen entscheidend ist, erscheint FrankenPHP als revolutionäre Lösung für das Symfony-Ökosystem. Dieser neue, in Go geschriebene PHP-Anwendungsserver verspricht, die Art und Weise, wie wir PHP-Anwendungen bereitstellen und optimieren, radikal zu verändern. Lassen Sie uns gemeinsam erkunden, warum FrankenPHP im Jahr 2025 Ihr bester Verbündeter für ultraperformante Symfony-Anwendungen werden könnte.

Einführung in FrankenPHP

In der modernen PHP-Entwicklungswelt ist Leistung zu einem wichtigen Anliegen geworden. Während PHP 8.3 die Rohleistung der Sprache weiter verbessert, erschüttert ein neuer Herausforderer etablierte Normen: FrankenPHP. Entwickelt von Kévin Dunglas, dem Gründer von API Platform, verspricht dieser Anwendungsserver der nächsten Generation, die Art und Weise zu revolutionieren, wie wir Symfony-Anwendungen bereitstellen.

Was ist FrankenPHP?

FrankenPHP ist nicht nur ein weiterer PHP-Server. Es ist eine komplette Neuerfindung der PHP-Ausführung, nativ in Go entwickelt. Dieser innovative Ansatz kombiniert:

  • Die Leistung und Nebenläufigkeit von Go
  • Die Flexibilität und das reiche Ökosystem von PHP
  • Native Integration mit dem Caddy Webserver
  • Volle Kompatibilität mit bestehenden PHP-Anwendungen

Warum ein neuer PHP-Server?

Traditionell basiert die Bereitstellung von PHP-Anwendungen auf Lösungen wie PHP-FPM in Kombination mit Nginx oder Apache. Diese Architekturen haben zwar ihre Funktion, weisen aber mehrere Einschränkungen auf:

  • Erhebliche Startlatenz
  • Hoher Speicherverbrauch
  • Komplexe Konfiguration
  • Suboptimale Leistung für moderne Anwendungen

FrankenPHP adressiert diese Probleme durch einen einheitlichen und modernen Ansatz, der besonders für Cloud-native Architekturen und Microservices geeignet ist.

Leistungsversprechen

Die ersten Benchmarks von FrankenPHP sind beeindruckend:

  • Antwortzeit: Bis zu 75% Reduzierung im Vergleich zu PHP-FPM
  • Speicherverbrauch: 50% Reduzierung dank Worker-Modus
  • Gleichzeitigkeit: Optimierte Handhabung simultaner Verbindungen
  • Kaltstart: Nahezu sofortig im Vergleich zu traditionellen Lösungen

Diese Verbesserungen sind besonders bedeutsam für Symfony-Anwendungen, die endlich ihr volles Leistungspotenzial ausschöpfen können, ohne Wartbarkeit oder Sicherheit zu kompromittieren.

Hauptvorteile für Symfony

Nach mehreren Monaten Produktiveinsatz von FrankenPHP in verschiedenen Symfony-Projekten möchte ich die konkreten Vorteile teilen, die es zu einer essentiellen Lösung für moderne PHP-Anwendungen machen.

Worker-Modus: Eine stille Revolution

Der Worker-Modus von FrankenPHP verändert die Art und Weise, wie Symfony Anfragen verarbeitet, grundlegend:

  • Service-Persistenz: Symfony-Container bleibt zwischen Anfragen geladen
  • Speicheroptimierung: Drastische Reduzierung des Speicherbedarfs
  • Intelligentes Ressourcenmanagement: Dynamische Lastanpassung
  • Gesteigerte Leistung: Antwortzeit durchschnittlich um Faktor 4 reduziert

Hier ein Beispiel für eine optimierte Konfiguration:

yaml
config/frankenphp.yaml
1frankenphp:
2    worker:
3        processes: 'auto'    # CPU-basierte Anpassung
4        max_requests: 1000   # Periodisches Recycling
5        memory_limit: 256M   # Limit pro Worker
6        idle_timeout: 10s    # Inaktivitäts-Timeout

HTTP/2 und HTTP/3: Leistung und Modernität

Die native Integration moderner Protokolle bringt signifikante Verbesserungen:

  • Intelligentes Multiplexing: Mehrere Anfragen über eine einzelne Verbindung
  • Header-Komprimierung: Bandbreitenreduzierung
  • Natives Server Push: Optimiertes Asset-Loading
  • QUIC und 0-RTT: Ultraschnelle Verbindungen

Typische Konfiguration zur Aktivierung dieser Funktionen:

txt
Caddyfile
1{
2    servers {
3        protocol {
4            experimental_http3
5            h2c
6        }
7    }
8    auto_https
9}
10
11api.example.com {
12    root * /app/public
13    php_fastcgi unix//var/run/php/php-fpm.sock {
14        trusted_proxies private_ranges
15        worker
16    }
17}

Early Hints: Frühzeitige Optimierung

FrankenPHP nutzt Early Hints (HTTP 103) auf innovative Weise:

  • Optimiertes Preloading: Automatisch identifizierte kritische Assets
  • Native Symfony-Integration: Unterstützung über HttpKernel
  • Core Web Vitals Verbesserung: Direkter Einfluss auf FCP und LCP
  • Zero-Config-Konfiguration: Automatische Optimierungsaktivierung

Beispielverwendung in einem Symfony-Controller:

php
src/Controller/HomeController.php
1public function index(Request $request): Response
2{
3    // Early Hints für kritische Assets senden
4    $response = new Response();
5    $response->headers->set('Link', '</build/app.css>; rel=preload; as=style');
6    $response->sendEarlyHints();
7
8    // Ihre Geschäftslogik
9    return $this->render('home/index.html.twig');
10}

Sicherheit und Zertifikate: Einfachheit und Automatisierung

SSL-Zertifikatsverwaltung wird transparent:

  • Auto-Erneuerung: Automatische Verwaltung über Let's Encrypt
  • Multi-Domain: Native Unterstützung für Wildcard-Zertifikate
  • Lokale Entwicklung: Automatische selbstsignierte Zertifikate
  • Null-Konfiguration: HTTPS standardmäßig aktiviert

Minimal erforderliche Konfiguration:

txt
.env
1CADDY_DOMAIN=api.yourapp.com
2CADDY_HTTPS=1
3CADDY_EXTRA_CONFIG="debug"

Installation und Konfiguration

Eine der Stärken von FrankenPHP liegt in seiner einfachen Installation und Konfiguration. Sehen wir uns gemeinsam an, wie man eine optimale Entwicklungsumgebung für Ihre Symfony-Anwendungen einrichtet.

Systemvoraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

  • Docker installiert (Version 20.10 oder höher)
  • Composer 2.x
  • PHP 8.2 oder 8.3 (empfohlen)
  • Git

Installation mit Docker

Der einfachste Weg, mit FrankenPHP zu beginnen, ist die Verwendung des offiziellen Docker-Images:

dockerfile
Dockerfile
1FROM dunglas/frankenphp:latest
2
3# Benutzerdefinierte PHP-Konfiguration
4COPY php.ini /usr/local/etc/php/php.ini
5
6# Installation erforderlicher PHP-Erweiterungen
7RUN install-php-extensions \
8    intl \
9    pdo_pgsql \
10    redis \
11    opcache
12
13# Symfony-Konfiguration
14ENV APP_ENV=prod
15ENV APP_DEBUG=0
16
17# Anwendungskopie
18COPY . /app
19WORKDIR /app
20
21# Installation der Abhängigkeiten
22RUN composer install --no-dev --optimize-autoloader

Grundkonfiguration

Die FrankenPHP-Konfiguration für Symfony erfordert einige Anpassungen:

yaml
config/packages/framework.yaml
1framework:
2    http_method_override: false
3    handle_all_throwables: true
4    http_cache: true
5    trusted_proxies: '%env(TRUSTED_PROXIES)%'
6    trusted_headers: ['x-forwarded-for', 'x-forwarded-proto']

Produktionsoptimierung

Für optimale Produktionsleistung:

txt
.env.prod
1APP_ENV=prod
2APP_DEBUG=0
3FRANKENPHP_CONFIG="worker processes=auto"
4TRUSTED_PROXIES=REMOTE_ADDR
5REDIS_URL=redis://redis:6379

Cache-Konfiguration

Cache-Optimierung ist entscheidend für die Leistung:

yaml
config/packages/cache.yaml
1framework:
2    cache:
3        app: cache.adapter.redis
4        system: cache.adapter.redis
5        default_redis_provider: '%env(REDIS_URL)%'
6        pools:
7            doctrine.result_cache_pool:
8                adapter: cache.app
9            doctrine.system_cache_pool:
10                adapter: cache.system

Docker Compose für Entwicklung

Für die lokale Entwicklung verwenden Sie diese Docker Compose-Konfiguration:

yaml
docker-compose.yml
1version: '3.8'
2
3services:
4  app:
5    build: .
6    ports:
7      - "443:443"
8      - "80:80"
9    volumes:
10      - .:/app
11      - ./docker/php.ini:/usr/local/etc/php/php.ini:ro
12    environment:
13      - APP_ENV=dev
14      - XDEBUG_MODE=debug
15      - XDEBUG_CLIENT_HOST=host.docker.internal
16
17  redis:
18    image: redis:alpine
19    ports:
20      - "6379:6379"

Installationsüberprüfung

Um zu überprüfen, ob alles korrekt funktioniert:

bash
1# Container starten
2docker-compose up -d
3
4# Logs überprüfen
5docker-compose logs -f app
6
7# Anwendung testen
8curl -k https://localhost

Wichtige Punkte

Einige wichtige Punkte, die zu beachten sind:

  • Dateiberechtigungen: Stellen Sie sicher, dass die Berechtigungen korrekt konfiguriert sind
  • SSL-Konfiguration: Überprüfen Sie die automatische Zertifikatsgenerierung
  • Logs: Aktivieren Sie Log-Rotation für die Produktion
  • Monitoring: Richten Sie Monitoring-Tools ein

Leistungsoptimierung

Nachdem FrankenPHP installiert und konfiguriert ist, lassen Sie uns fortgeschrittene Optimierungstechniken erkunden, um das Beste aus dieser Technologie mit Symfony herauszuholen.

Worker-Modus-Optimierung

Der Worker-Modus ist das Herzstück der FrankenPHP-Leistung. So optimieren Sie ihn:

yaml
config/packages/frankenphp.yaml
1frankenphp:
2    worker:
3        # Worker-Anzahl-Optimierung
4        processes: '${CPU_COUNT}'  # Verwendet CPU-Kernanzahl
5        max_requests: 1000         # Verhindert Memory-Leaks
6
7        # Speicherverwaltung
8        memory_limit: '256M'
9        memory_reset: 0.9          # Reset bei 90% Nutzung
10
11        # Optimierte Timeouts
12        request_timeout: '30s'
13        idle_timeout: '10s'

Symfony-Cache-Konfiguration

Die Optimierung des Symfony-Caches ist entscheidend:

yaml
config/packages/cache.yaml
1framework:
2    cache:
3        # Optimierte Redis-Konfiguration
4        default_redis_provider: 'redis://redis:6379'
5
6        # Spezialisierte Cache-Pools
7        pools:
8            cache.api:
9                adapter: cache.adapter.redis
10                default_lifetime: 3600
11                tags: true
12
13            cache.sessions:
14                adapter: cache.adapter.redis
15                default_lifetime: 86400

Asset-Optimierung

Asset-Management wird über Webpack Encore optimiert:

yaml
webpack.config.js
1const Encore = require('@symfony/webpack-encore');
2
3Encore
4    // Optimierungen aktivieren
5    .enableVersioning()
6    .enableSourceMaps(!Encore.isProduction())
7    .splitEntryChunks()
8
9    // Asset-Komprimierung
10    .configureTerserPlugin((options) => {
11        options.terserOptions = {
12            compress: {
13                drop_console: true,
14            },
15        }
16    })
17
18    // Cache-Busting-Konfiguration
19    .configureImageRule({
20        type: 'asset',
21        maxSize: 4 * 1024, // 4kb
22    });

Datenbank-Optimierung

Optimale Doctrine-Konfiguration:

yaml
config/packages/doctrine.yaml
1doctrine:
2    orm:
3        # Second-Level-Cache-Konfiguration
4        second_level_cache:
5            enabled: true
6            region_cache_driver:
7                type: pool
8                pool: doctrine.second_level_cache_pool
9
10        # Query-Optimierung
11        query_cache_driver:
12            type: pool
13            pool: doctrine.system_cache_pool
14
15        # Metadata-Konfiguration
16        metadata_cache_driver:
17            type: pool
18            pool: doctrine.system_cache_pool

Leistungsüberwachung

Einrichtung der Überwachung:

yaml
config/packages/monolog.yaml
1monolog:
2    handlers:
3        main:
4            type: fingers_crossed
5            action_level: error
6            handler: nested
7            excluded_http_codes: [404, 405]
8            channels: ["!event"]
9
10        # Performance-Metrik-Handler
11        performance:
12            type: stream
13            path: "%kernel.logs_dir%/performance.log"
14            level: info
15            channels: ["performance"]

Performance Best Practices

Wesentliche Empfehlungen:

  1. Strategisches Caching

    • HTTP-Cache für statische Antworten verwenden
    • Anwendungscache für dynamische Daten implementieren
    • Symfony-Route-Cache aktivieren

  2. Bildoptimierung

    • WebP mit Fallback verwenden
    • Lazy Loading implementieren
    • Explizite Dimensionen konfigurieren

  3. Session-Management

    • Sessions in Redis speichern
    • Angemessene Lebensdauer konfigurieren
    • Regelmäßige Bereinigung abgelaufener Sessions

  4. Query-Optimierung

    • Geeignete Indizes verwenden
    • Eager Loading implementieren
    • N+1-Problem vermeiden

Leistungsmetriken

Zu überwachende Metriken:

  • Antwortzeit: < 100ms für APIs, < 2s für Webseiten
  • Speichernutzung: < 128MB pro Worker
  • Cache-Rate: > 90% für statische Assets
  • Core Web Vitals:
    • LCP < 2,5s
    • FID < 100ms
    • CLS < 0,1

Produktionsbereitstellung

Die Bereitstellung einer Symfony-Anwendung mit FrankenPHP erfordert besondere Aufmerksamkeit, um optimale Leistung und Zuverlässigkeit in der Produktion zu gewährleisten.

Produktionsarchitektur

Eine typische Produktionsarchitektur umfasst:

yaml
docker-compose.prod.yml
1version: '3.8'
2
3services:
4  traefik:
5    image: traefik:v2.10
6    command:
7      - "--providers.docker=true"
8      - "--providers.docker.exposedbydefault=false"
9      - "--entrypoints.websecure.address=:443"
10    ports:
11      - "443:443"
12    volumes:
13      - /var/run/docker.sock:/var/run/docker.sock:ro
14      - ./certs:/etc/certs:ro
15
16  app:
17    image: ${CI_REGISTRY_IMAGE:-your-app}:${CI_COMMIT_SHA:-latest}
18    labels:
19      - "traefik.enable=true"
20      - "traefik.http.routers.app.rule=Host(`app.example.com`)"
21      - "traefik.http.routers.app.tls=true"
22    environment:
23      - APP_ENV=prod
24      - APP_SECRET=${APP_SECRET}
25      - DATABASE_URL=${DATABASE_URL}
26    depends_on:
27      - redis
28      - postgres
29
30  redis:
31    image: redis:alpine
32    volumes:
33      - redis_data:/data
34    command: redis-server --appendonly yes
35
36  postgres:
37    image: postgres:15-alpine
38    volumes:
39      - postgres_data:/var/lib/postgresql/data
40    environment:
41      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
42
43volumes:
44  redis_data:
45  postgres_data:

Bereitstellungsstrategie

Einrichtung der kontinuierlichen Bereitstellung:

yaml
.gitlab-ci.yml
1stages:
2  - build
3  - test
4  - deploy
5
6build:
7  stage: build
8  script:
9    - docker build -t ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA} .
10    - docker push ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}
11
12test:
13  stage: test
14  script:
15    - composer install
16    - php bin/phpunit
17
18deploy:
19  stage: deploy
20  script:
21    - docker-compose -f docker-compose.prod.yml pull
22    - docker-compose -f docker-compose.prod.yml up -d
23  only:
24    - main

Sicherheitskonfiguration

Stärkung der Produktionssicherheit:

yaml
config/packages/security.yaml
1security:
2    enable_authenticator_manager: true
3    password_hashers:
4        Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface:
5            algorithm: 'auto'
6            cost: 15
7
8    providers:
9        app_user_provider:
10            entity:
11                class: App\Entity\User
12                property: email
13
14    firewalls:
15        main:
16            lazy: true
17            provider: app_user_provider
18            custom_authenticator: App\Security\AppAuthenticator
19            logout:
20                path: app_logout
21            remember_me:
22                secret: '%kernel.secret%'
23                lifetime: 604800 # 1 Woche

Produktionsüberwachung

Überwachungskonfiguration:

yaml
config/packages/sentry.yaml
1sentry:
2    dsn: '%env(SENTRY_DSN)%'
3    options:
4        environment: '%kernel.environment%'
5        release: '%env(APP_VERSION)%'
6        traces_sample_rate: 0.2
7        send_default_pii: true

Log-Management

Log-Management-Optimierung:

yaml
config/packages/prod/monolog.yaml
1monolog:
2    handlers:
3        main:
4            type: fingers_crossed
5            action_level: error
6            handler: nested
7            excluded_http_codes: [404, 405]
8            buffer_size: 50
9        nested:
10            type: stream
11            path: "php://stderr"
12            level: debug
13        console:
14            type: console
15            process_psr_3_messages: false

Bereitstellungs-Best-Practices

  1. Update-Strategie

    • Zero-Downtime-Bereitstellungen
    • Automatisierter Rollback im Fehlerfall
    • Automatisierte Tests vor der Bereitstellung

  2. Sicherheit

    • Regelmäßige Abhängigkeitsaktualisierungen
    • Schwachstellenscanning
    • Periodische Sicherheitsüberprüfung

  3. Backup

    • Automatisierte Datensicherung
    • Datenbankreplikation
    • Disaster-Recovery-Plan

  4. Leistung

    • Kontinuierliche Überwachung
    • Automatisierte Alarmierung
    • Regelmäßige Optimierung

Fazit und Perspektiven

Nach der detaillierten Untersuchung von FrankenPHP und seiner Symfony-Integration wird deutlich, dass diese Technologie einen bedeutenden Fortschritt für das moderne PHP-Ökosystem darstellt.

Zusammenfassung der Vorteile

FrankenPHP bringt wesentliche Verbesserungen:

  1. Leistung

    • Antwortzeiten um bis zu 75% reduziert
    • Optimierter Speicherverbrauch
    • Effizientes Ressourcenmanagement

  2. Entwicklung

    • Vereinfachte Konfiguration
    • Native Symfony-Integration
    • Moderne Entwicklungsumgebung

  3. Produktion

    • Vereinfachte Bereitstellung
    • Verbesserte Sicherheit
    • Integrierte Überwachung

Ideale Anwendungsfälle

FrankenPHP zeichnet sich besonders in diesen Situationen aus:

  • Hochfrequentierte Anwendungen
  • REST- und GraphQL-APIs
  • Microservices
  • Echtzeit-Anwendungen
  • E-Commerce-Seiten

Zusätzliche Ressourcen

Um Ihr Wissen zu vertiefen:

  1. Offizielle Dokumentation

Zukunftsperspektiven

FrankenPHP ebnet den Weg für neue Möglichkeiten:

  1. Technologische Innovation

    • Native Integration mit Cloud-Technologien
    • Unterstützung für ereignisgesteuerte Architektur
    • Microservice-spezifische Optimierungen

  2. Ökosystem

    • Wachstum der Community
    • Neue Tools und Integrationen
    • Adoption durch große Akteure

  3. Leistung

    • Kontinuierliche Leistungsverbesserungen
    • Neue Optimierungen
    • Unterstützung für neueste Web-Technologien

Demnächst: FrankenPHP und IoT

In einem kommenden Artikel werden wir eine innovative Architektur erkunden, die FrankenPHP/Symfony mit Zephyr OS für IoT kombiniert. Wir werden sehen, wie man:

  • Eine leistungsfähige API mit FrankenPHP zur Verarbeitung von IoT-Daten erstellt
  • Bidirektionale Kommunikation mit Zephyr OS-Geräten implementiert
  • Die Leistung für Echtzeit-Verarbeitung optimiert
  • Den Austausch zwischen Backend und IoT-Geräten absichert

Dieser moderne Ansatz wird es ermöglichen, die außergewöhnliche Leistung von FrankenPHP zu nutzen und gleichzeitig die Stärke von Zephyr OS für Ihre IoT-Projekte zu nutzen.

Bleiben Sie dran für die Fortsetzung dieser Serie, die weiterhin die Möglichkeiten erkundet, die FrankenPHP im Symfony-Ökosystem bietet!

Teilen Sie diesen Artikel

FacebookXLinkedIn
Sébastien Timoner

Sébastien TIMONER

Lead-Entwickler
Experte für maßgeschneiderte Entwicklung
Aix-en-Provence, France

Als Experte für Webentwicklung und Teammanagement spezialisiere ich mich auf die Erstellung und Optimierung hochleistungsfähiger digitaler Lösungen. Mit umfassender Expertise in modernen Technologien wie React.js, Node.js, TypeScript, Symfony und Zephyr OS für IoT stelle ich bei offroadLabs den Erfolg komplexer SaaS- und IoT-Projekte von der Konzeption bis zur Produktion für Unternehmen verschiedener Branchen sicher.

Bei offroadLabs biete ich maßgeschneiderte Entwicklungsdienstleistungen, die technische Expertise mit einem kollaborativen Ansatz verbinden. Ob bei der Erstellung einer innovativen SaaS-Lösung, der Entwicklung von IoT-Systemen mit Zephyr OS, der Modernisierung einer bestehenden Anwendung oder der Unterstützung bei der Weiterbildung eines Teams - ich setze mich für die Bereitstellung robuster und leistungsstarker Lösungen ein, die auf die spezifischen Bedürfnisse jedes Projekts zugeschnitten sind.

Ich bin verfügbar für Projekte im Raum Aix-en-Provence oder vollständig remote.

FrankenPHP: Steigern Sie die Leistung Ihrer Symfony-Anwendungen im Jahr 2025