FrankenPHP: Boost Your Symfony Applications Performance in 2025

In a world where web application performance is crucial, FrankenPHP emerges as a revolutionary solution for the Symfony ecosystem. This new PHP application server, written in Go, promises to radically transform how we deploy and optimize our PHP applications. Let's explore together why FrankenPHP could become your best ally for ultra-performant Symfony applications in 2025.

Introduction to FrankenPHP

In the modern PHP development universe, performance has become a major concern. While PHP 8.3 continues to improve the language's raw performance, a new challenger is disrupting established norms: FrankenPHP. Created by Kévin Dunglas, the founder of API Platform, this next-generation application server promises to revolutionize how we deploy our Symfony applications.

What is FrankenPHP?

FrankenPHP isn't just another PHP server. It's a complete reinvention of PHP execution, natively built in Go. This innovative approach combines:

• Go's power and concurrency
• PHP's flexibility and rich ecosystem
• Native integration with Caddy web server
• Full compatibility with existing PHP applications

Why a new PHP server?

Traditionally, PHP application deployment relies on solutions like PHP-FPM coupled with Nginx or Apache. While functional, these architectures have several limitations:

• Significant startup latency
• High memory consumption
• Complex configuration
• Suboptimal performance for modern applications

FrankenPHP addresses these issues by offering a unified and modern approach, particularly suited for cloud-native architectures and microservices.

Performance Promises

FrankenPHP's initial benchmarks are impressive:

• Response time: Up to 75% reduction compared to PHP-FPM
• Memory consumption: 50% decrease thanks to worker mode
• Concurrency: Optimized handling of simultaneous connections
• Cold start: Near-instant compared to traditional solutions

These improvements are particularly significant for Symfony applications, which can finally fully exploit their performance potential without compromising maintainability or security.

Key Benefits for Symfony

After several months of using FrankenPHP in production on various Symfony projects, I want to share the concrete benefits that make it an essential solution for modern PHP applications.

Worker Mode: A Silent Revolution

FrankenPHP's worker mode radically transforms how Symfony handles requests:

• Service persistence: Symfony container remains loaded between requests
• Memory optimization: Drastic reduction in memory footprint
• Intelligent resource management: Dynamic load adaptation
• Increased performance: Response time reduced by 4 on average

Here's an example of optimized configuration:

yaml
config/frankenphp.yaml
1frankenphp:
2    worker:
3        processes: 'auto'    # CPU-based adaptation
4        max_requests: 1000   # Periodic recycling
5        memory_limit: 256M   # Per worker limit
6        idle_timeout: 10s    # Inactivity timeout

HTTP/2 and HTTP/3: Performance and Modernity

Native integration of modern protocols brings significant improvements:

• Smart multiplexing: Multiple requests over a single connection
• Header compression: Bandwidth reduction
• Native Server Push: Optimized asset loading
• QUIC and 0-RTT: Ultra-fast connections

Typical configuration to enable these features:

text
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: Early Optimization

FrankenPHP leverages Early Hints (HTTP 103) in an innovative way:

• Optimized preloading: Automatically identified critical assets
• Native Symfony integration: Support via HttpKernel
• Core Web Vitals improvement: Direct impact on FCP and LCP
• Zero-config configuration: Automatic optimization activation

Example usage in a Symfony controller:

php
src/Controller/HomeController.php
1public function index(Request $request): Response
2{
3    // Sending Early Hints for critical assets
4    $response = new Response();
5    $response->headers->set('Link', '</build/app.css>; rel=preload; as=style');
6    $response->sendEarlyHints();
7
8    // Your business logic
9    return $this->render('home/index.html.twig');
10}

Security and Certificates: Simplicity and Automation

SSL certificate management becomes transparent:

• Auto-renewal: Automatic management via Let's Encrypt
• Multi-domain: Native support for wildcard certificates
• Local development: Automatic self-signed certificates
• Zero-configuration: HTTPS enabled by default

Minimal required configuration:

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

Installation and Configuration

One of FrankenPHP's strengths lies in its simple installation and configuration. Let's see together how to set up an optimal development environment for your Symfony applications.

System Prerequisites

Before starting, make sure you have:

• Docker installed (version 20.10 or higher)
• Composer 2.x
• PHP 8.2 or 8.3 (recommended)
• Git

Installation with Docker

The simplest way to start with FrankenPHP is to use the official Docker image:

dockerfile
Dockerfile
1FROM dunglas/frankenphp:latest
2
3# Custom PHP configuration
4COPY php.ini /usr/local/etc/php/php.ini
5
6# Installing required PHP extensions
7RUN install-php-extensions \
8    intl \
9    pdo_pgsql \
10    redis \
11    opcache
12
13# Symfony configuration
14ENV APP_ENV=prod
15ENV APP_DEBUG=0
16
17# Application copy
18COPY . /app
19WORKDIR /app
20
21# Dependencies installation
22RUN composer install --no-dev --optimize-autoloader

Basic Configuration

FrankenPHP configuration for Symfony requires some adjustments:

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']

Production Optimization

For optimal production performance:

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

Cache Configuration

Cache optimization is crucial for performance:

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 for Development

For local development, use this Docker Compose configuration:

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"

Installation Verification

To verify that everything works correctly:

bash
1# Starting containers
2docker-compose up -d
3
4# Checking logs
5docker-compose logs -f app
6
7# Testing the application
8curl -k https://localhost

Important Points

Some important points to watch:

• File permissions: Ensure permissions are correctly configured
• SSL configuration: Check automatic certificate generation
• Logs: Enable log rotation for production
• Monitoring: Set up monitoring tools

Performance Optimization

Now that FrankenPHP is installed and configured, let's explore advanced optimization techniques to get the most out of this technology with Symfony.

Worker Mode Optimization

Worker mode is the heart of FrankenPHP's performance. Here's how to optimize it:

yaml
config/packages/frankenphp.yaml
1frankenphp:
2    worker:
3        # Worker number optimization
4        processes: '${CPU_COUNT}'  # Uses CPU core count
5        max_requests: 1000         # Prevents memory leaks
6
7        # Memory management
8        memory_limit: '256M'
9        memory_reset: 0.9          # Reset at 90% usage
10
11        # Optimized timeouts
12        request_timeout: '30s'
13        idle_timeout: '10s'

Symfony Cache Configuration

Symfony cache optimization is crucial:

yaml
config/packages/cache.yaml
1framework:
2    cache:
3        # Optimized Redis configuration
4        default_redis_provider: 'redis://redis:6379'
5
6        # Specialized 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 Optimization

Asset management is optimized via Webpack Encore:

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

Database Optimization

Optimal Doctrine configuration:

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

Performance Monitoring

Setting up monitoring:

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 metrics handler
11        performance:
12            type: stream
13            path: "%kernel.logs_dir%/performance.log"
14            level: info
15            channels: ["performance"]

Performance Best Practices

Essential recommendations:

1. Strategic Caching

   • Use HTTP Cache for static responses
   • Implement application cache for dynamic data
   • Enable Symfony route cache

2. Image Optimization

   • Use WebP with fallback
   • Implement lazy loading
   • Configure explicit dimensions

3. Session Management

   • Store sessions in Redis
   • Configure appropriate lifetime
   • Regularly clean expired sessions

4. Query Optimization

   • Use appropriate indexes
   • Implement eager loading
   • Avoid N+1 problem

Performance Metrics

Metrics to monitor:

• Response time: < 100ms for APIs, < 2s for web pages
• Memory usage: < 128MB per worker
• Cache rate: > 90% for static assets
• Core Web Vitals:
  • LCP < 2.5s
  • FID < 100ms
  • CLS < 0.1

Production Deployment

Deploying a Symfony application with FrankenPHP requires special attention to ensure optimal performance and reliability in production.

Production Architecture

A typical production architecture includes:

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:

Deployment Strategy

Setting up continuous deployment:

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

Security Configuration

Strengthening production security:

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 week

Production Monitoring

Monitoring configuration:

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 optimization:

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

Deployment Best Practices

1. Update Strategy

   • Zero-downtime deployments
   • Automated rollback in case of error
   • Automated testing before deployment

2. Security

   • Regular dependency updates
   • Vulnerability scanning
   • Periodic security audit

3. Backup

   • Automated data backup
   • Database replication
   • Disaster recovery plan

4. Performance

   • Continuous monitoring
   • Automated alerting
   • Regular optimization

Conclusion and Perspectives

After exploring FrankenPHP and its Symfony integration in detail, it's clear that this technology represents a major advancement for the modern PHP ecosystem.

Benefits Summary

FrankenPHP brings significant improvements:

1. Performance

   • Response times reduced by up to 75%
   • Optimized memory consumption
   • Efficient resource management

2. Development

   • Simplified configuration
   • Native Symfony integration
   • Modern development environment

3. Production

   • Simplified deployment
   • Enhanced security
   • Integrated monitoring

Ideal Use Cases

FrankenPHP particularly excels in these situations:

• High-traffic applications
• REST and GraphQL APIs
• Microservices
• Real-time applications
• E-commerce sites

Additional Resources

To deepen your knowledge:

1. Official Documentation

   • FrankenPHP Documentation
   • Symfony Integration Guide

Future Perspectives

FrankenPHP paves the way for new possibilities:

1. Technological Innovation

   • Native integration with cloud technologies
   • Event-driven architecture support
   • Microservice-specific optimizations

2. Ecosystem

   • Community growth
   • New tools and integrations
   • Adoption by major players

3. Performance

   • Continuous performance improvements
   • New optimizations
   • Support for latest web technologies

Coming Soon: FrankenPHP and IoT

In an upcoming article, we'll explore an innovative architecture combining FrankenPHP/Symfony with Zephyr OS for IoT. We'll see how to:

• Create a performant API with FrankenPHP to handle IoT data
• Implement bidirectional communication with Zephyr OS devices
• Optimize performance for real-time processing
• Secure exchanges between backend and IoT devices

This modern approach will allow leveraging FrankenPHP's exceptional performance while harnessing Zephyr OS's power for your IoT projects.

Stay tuned for the continuation of this series that will keep exploring the possibilities offered by FrankenPHP in the Symfony ecosystem!