PHP-FPM

PHP-FPM

- PHP-FPM** (FastCGI Process Manager) ist eine alternative PHP-Implementierung, die als eigenständiger FastCGI-Server fungiert. Es wurde entwickelt, um die Performance und Skalierbarkeit von PHP-Anwendungen zu verbessern, insbesondere bei Webservern wie nginx oder Apache.

1. Geschichte

PHP-FPM wurde ursprünglich 2004 von Andrei Nigmatulin als Patch für PHP entwickelt. Nach Jahren der separaten Entwicklung wurde es 2009 in den PHP-Core integriert und ist seit PHP 5.3.3 (2010) Teil der offiziellen PHP-Distribution.

1. Funktionsweise

1. 1. Architektur

PHP-FPM verwendet eine Master-Worker-Architektur:

Ein Master-Prozess verwaltet mehrere Worker-Pools
Worker-Prozesse führen die eigentlichen PHP-Scripts aus
Kommunikation erfolgt über das FastCGI-Protokoll

``` Webserver (nginx/Apache)

   ↓ FastCGI

PHP-FPM Master Process

   ├── Worker Pool 1
   ├── Worker Pool 2
   └── Worker Pool N

```

1. 1. Prozess-Management

PHP-FPM bietet drei verschiedene Prozess-Management-Modi:

static: Feste Anzahl von Worker-Prozessen
dynamic: Variable Anzahl basierend auf aktueller Last
ondemand: Prozesse werden nur bei Bedarf gestartet

1. Vorteile gegenüber traditionellen Ansätzen

Gegenüber Apache mod_php

Bessere Ressourcen-Kontrolle: Separate Prozesse ermöglichen präzise Speicher- und CPU-Verwaltung
Sicherheit: Verschiedene Anwendungen können mit unterschiedlichen Benutzern laufen
Stabilität: Ein Absturz eines PHP-Prozesses betrifft nicht den Webserver
Skalierbarkeit: Unabhängige Skalierung von Webserver und PHP-Backend

Gegenüber CGI

Performance: Wiederverwendung von Prozessen reduziert Overhead
Persistente Verbindungen: Datenbankverbindungen und andere Ressourcen bleiben erhalten
Speicher-Effizienz: Shared Memory für häufig verwendete Daten

1. Konfiguration

Pool-Konfiguration

Jeder Worker-Pool wird durch eine separate Konfigurationsdatei definiert:

```ini [pool-name] user = www-data group = www-data

Socket-Konfiguration

listen = /run/php/php-fpm.sock

oder TCP: listen = 127.0.0.1:9000

Prozess-Management

pm = dynamic pm.max_children = 50 pm.start_servers = 5 pm.min_spare_servers = 5 pm.max_spare_servers = 35 ```

Webserver-Integration

nginx

```nginx location ~ \.php$ {

   fastcgi_pass unix:/run/php/php-fpm.sock;
   fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
   include fastcgi_params;

} ```

Apache

```apache <FilesMatch \.php$>

   SetHandler "proxy:unix:/run/php/php-fpm.sock|fcgi://localhost/"

</FilesMatch> ```

1. Performance-Optimierung

Speicher-Management

Die optimale Anzahl von Worker-Prozessen berechnet sich aus:

``` Max Children = Verfügbarer RAM / Durchschnittlicher Prozess-Speicher ```

OPcache-Integration

PHP-FPM arbeitet optimal mit OPcache zusammen:

```ini opcache.enable = 1 opcache.memory_consumption = 128 opcache.max_accelerated_files = 4000 ```

1. Monitoring und Debugging

Status-Seite

PHP-FPM bietet eine integrierte Status-Seite mit wichtigen Metriken:

Aktive/Idle Prozesse
Request-Statistiken
Speicherverbrauch
Slow-Request-Logging

Log-Dateien

Error-Log: Fehler und Warnungen
Slow-Log: Langsame Requests
Access-Log: Alle verarbeiteten Requests

1. Sicherheitsaspekte

Prozess-Isolation

Verschiedene Pools können mit unterschiedlichen Benutzern laufen
chroot-Umgebungen für zusätzliche Isolation
Resource-Limits pro Pool

Konfigurationssicherheit

```ini

Sicherheitsbeschränkungen

php_admin_flag[allow_url_fopen] = off php_admin_value[disable_functions] = exec,shell_exec,system php_admin_value[open_basedir] = /var/www/website ```

1. Anwendungsfälle

Shared Hosting

Verschiedene Kunden mit eigenen PHP-Pools
Individuelle PHP-Konfigurationen
Bessere Ressourcen-Isolation

High-Performance Websites

Optimierte Ressourcen-Nutzung
Horizontale Skalierung
Load Balancing zwischen mehreren Servern

Microservices-Architektur

Separate PHP-FPM Instanzen für verschiedene Services
Unabhängige Skalierung und Updates
Service-spezifische Konfigurationen

1. Systemanforderungen

Betriebssystem: Linux, Unix-ähnliche Systeme
PHP-Version: 5.3.3 oder höher
Webserver: nginx, Apache (mit mod_proxy_fcgi), lighttpd
Speicher: Mindestens 512 MB RAM (abhängig von der Anwendung)

1. Alternativen

Apache mod_php: Eingebettete PHP-Ausführung
PHP-CGI: Traditioneller CGI-Ansatz
HHVM: Facebook's HipHop Virtual Machine
ReactPHP: Event-driven PHP-Server
Swoole: Asynchroner PHP-Server

1. Weblinks

Einzelnachweise