Nginx handles static files and routes dynamic requests to PHP-FPM, which processes PHP scripts via FastCGI; 2. Optimize PHP-FPM by using Unix sockets, setting pm=dynamic with appropriate max_children, spare servers, and max_requests to balance performance and memory; 3. Configure Nginx with efficient location blocks, correct fastcgi_pass pointing to the socket, and proper SCRIPT_FILENAME to prevent errors; 4. Enable OpCache for PHP script caching, monitor FPM status via /fpm-status, and log slow requests exceeding 5 seconds to identify bottlenecks; 5. Secure the setup by running PHP-FPM as www-data, denying PHP execution in upload directories, and setting correct file permissions with 644 for files and 755 for directories—all essential for a fast, secure, and scalable PHP environment.

Setting up PHP-FPM with Nginx for high performance isn’t complicated, but it does require attention to configuration details that many tutorials skip. Done right, this combo delivers fast, scalable PHP applications with efficient resource use. Here’s how to get it right.

1. Understanding the Roles: Nginx PHP-FPM

Nginx is a lightweight, high-performance web server that handles static files and routes dynamic requests. PHP-FPM (FastCGI Process Manager) runs PHP scripts and communicates with Nginx via the FastCGI protocol.

• Nginx → Serves static assets (CSS, JS, images) directly
• PHP-FPM → Processes .php files and returns output to Nginx

This separation allows each service to do what it does best: Nginx handles concurrency efficiently, and PHP-FPM manages PHP execution with process control.

2. Optimizing PHP-FPM Configuration

The main configuration file is usually at /etc/php/{version}/fpm/pool.d/www.conf (path varies by OS and PHP version).

Key settings to tweak:

; Use Unix socket for speed (instead of TCP)
listen = /run/php/php8.1-fpm.sock

; Set proper permissions
listen.owner = www-data
listen.group = www-data
listen.mode = 0660

; Process management
pm = dynamic
pm.max_children = 50
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 35
pm.max_requests = 500

What these mean:

• pm = dynamic: Spawns child processes based on demand.
• max_children: Maximum number of PHP processes. Too high → memory exhaustion; too low → queued requests.
• max_requests: Restarts workers after 500 requests to prevent memory leaks.
• listen via socket: Faster than 127.0.0.1:9000 because it avoids network stack overhead.

? Rule of thumb: Estimate max_children based on available RAM. If each PHP process uses ~30MB, and you have 1.5GB reserved: 1500 / 30 = 50.

3. Nginx Configuration for Fast PHP Handling

In your Nginx server block (e.g., /etc/nginx/sites-available/example.com):

server {
    listen 80;
    server_name example.com;
    root /var/www/html;
    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.1-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ /\.ht {
        deny all;
    }
}

Critical optimizations:

• Use try_files to avoid unnecessary PHP execution for static files.
• Match the fastcgi_pass socket path to your PHP-FPM listen directive.
• Avoid @rewrite or complex rewrites—keep routing simple and fast.

? Pro tip: If you're using Laravel, WordPress, or similar, adjust SCRIPT_FILENAME carefully. A typo here causes blank pages or "File not found" errors.

4. Performance Tuning & Monitoring

Enable OpCache (in php.ini)

opcache.enable=1
opcache.memory_consumption=128
opcache.max_accelerated_files=4000
opcache.validate_timestamps=0  ; Disable in production
opcache.fast_shutdown=1

This caches compiled PHP scripts—massive performance gain.

Monitor PHP-FPM Status

Enable the status page in www.conf:

pm.status_path = /fpm-status

Then access it via Nginx:

location ~ ^/fpm-status$ {
    allow 127.0.0.1;
    deny all;
    fastcgi_pass unix:/run/php/php8.1-fpm.sock;
    include fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}

Visit http://yoursite.com/fpm-status to see active processes, requests, and idle time.

Log Slow Requests

Find bottlenecks by logging slow scripts:

slowlog = /var/log/php-fpm/slow.log
request_slowlog_timeout = 5

Any script taking over 5 seconds gets logged with a full backtrace.

5. Security & Permissions

• Run PHP-FPM under a dedicated user (e.g., www-data), not root.
• Restrict uploads and disable execution in upload directories:

  location /uploads/ {
      location ~ \.php$ {
          deny all;
      }
  }

• Set proper file ownership:

  chown -R www-data:www-data /var/www/html
  find /var/www/html -type f -exec chmod 644 {} \;
  find /var/www/html -type d -exec chmod 755 {} \;

  ---

  Basically, a high-performance PHP setup with Nginx and PHP-FPM comes down to smart process management, using Unix sockets, enabling OpCache, and writing clean Nginx configs. It’s not magic—just careful tuning.

  The above is the detailed content of Mastering PHP-FPM and Nginx: A High-Performance Setup Guide. For more information, please follow other related articles on the PHP Chinese website!