Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk

Blog / Performance, Caching & Scalability / PHP-FPM Tuning untuk Laravel:...
Performance, Caching & Scalability

PHP-FPM Tuning untuk Laravel: Memahami Worker, Memory Limit, dan Kapasitas Request

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
11 min read
25 views

Memahami cara PHP-FPM melayani request, menghitung pm.max_children dari memori yang benar-benar dipakai worker, memilih mode static, dynamic, atau ondemand, mengatur timeout dan memory_limit, membaca status page dan slow log, serta memperkirakan kapasitas request per detik dengan Little's Law.

Overview

Pada tanggal 1–10 setiap bulan, aplikasi RW sering menampilkan 502 Bad Gateway. Log PHP-FPM penuh dengan:

WARNING: [pool www] server reached pm.max_children setting (5), consider raising it

Nilai pm.max_children = 5 adalah default paket di banyak distribusi Linux. Artinya hanya 5 request PHP yang bisa diproses bersamaan; request ke-6 menunggu di antrean, dan bila antrean penuh atau terlalu lama, Nginx menyerah.

Reaksi spontan adalah menaikkan ke 100. Hasilnya bisa lebih buruk: setiap worker Laravel memakai 40–80 MB, sehingga 100 worker butuh 4–8 GB. Server 4 GB mulai memakai swap, semuanya melambat, lalu kernel mematikan proses (OOM killer), dan yang pertama dimatikan bisa jadi MySQL.

Tuning PHP-FPM adalah soal menghitung, bukan menebak.

Hasil akhir:

  • pemahaman alur request Nginx → PHP-FPM → Laravel,
  • cara mengukur memori per worker dan menghitung pm.max_children,
  • konfigurasi pool untuk server 4 GB dan 8 GB,
  • timeout yang konsisten dari Nginx sampai PHP,
  • status page dan slow log untuk pemantauan dan investigasi,
  • perkiraan kapasitas request per detik.

Prerequisites

Komponen Versi
PHP-FPM 8.3+ (disarankan 8.4)
Laravel 13.x
Nginx 1.24+
OS Ubuntu 24.04 LTS
Akses root/sudo ke server

Path di artikel ini memakai PHP 8.4 dari paket Ubuntu/ondrej (/etc/php/8.4/fpm/). Sesuaikan dengan versi Anda.

Step-by-step Tutorial

Langkah 1: Pahami Alurnya

Browser ──▶ Nginx ──(FastCGI, socket)──▶ PHP-FPM master
                                            │ membagikan ke worker yang menganggur
                                            ▼
                                   ┌─ worker 1: request A (sibuk 180 ms)
                                   ├─ worker 2: request B (sibuk 2.400 ms, menunggu API luar)
                                   ├─ worker 3: menganggur
                                   └─ ...
  • Satu worker melayani satu request pada satu waktu. Selama request berjalan, termasuk saat menunggu query MySQL atau API eksternal, worker itu tidak bisa melayani request lain.
  • Bila semua worker sibuk, request baru menunggu di antrean socket (listen.backlog).
  • Nginx menunggu sampai fastcgi_read_timeout; bila habis, pengguna melihat 504 Gateway Timeout. Bila koneksi ke PHP-FPM gagal atau ditolak, pengguna melihat 502 Bad Gateway.

Konsekuensinya: request lambat menghabiskan worker. Satu API eksternal yang lambat bisa membuat seluruh aplikasi terlihat mati walau CPU hanya terpakai 10%.

Langkah 2: Ukur Memori per Worker

Jalankan aplikasi dengan traffic normal (atau load test), lalu ukur:

# Rata-rata RSS (MB) worker php-fpm, tanpa proses master
ps --no-headers -o rss,cmd -C php-fpm8.4 | grep 'pool' \
  | awk '{ total += $1; n++ } END { printf "worker=%d rata2=%.1f MB\n", n, total/n/1024 }'

# Rincian per proses
ps -ylC php-fpm8.4 --sort:rss

RSS menghitung juga memori bersama (OPcache, library), sehingga angka ini sedikit melebih-lebihkan. Untuk angka yang lebih tepat, gunakan PSS:

sudo apt install smem
sudo smem -k -P 'php-fpm: pool' -c 'pid pss rss'

Lihat juga dari sisi Laravel: memori puncak request terberat.

// sementara, di middleware terminate()
Log::info('memori', ['route' => $request->path(), 'mb' => round(memory_get_peak_usage(true) / 1048576, 1)]);

Contoh hasil untuk aplikasi RW: rata-rata 55 MB per worker, request terberat (ekspor) 180 MB.

Langkah 3: Hitung pm.max_children

pm.max_children = (RAM total − RAM untuk layanan lain − cadangan) ÷ memori rata-rata per worker

Contoh server 4 GB, semuanya dalam satu mesin:

Pemakai Perkiraan
OS + Nginx + layanan lain 400 MB
MySQL (innodb_buffer_pool_size 1 GB + overhead) 1.300 MB
Redis 300 MB
Queue worker (2 × 80 MB) 160 MB
Cadangan (lonjakan, page cache) 400 MB
Sisa untuk PHP-FPM ≈ 1.500 MB
1.500 MB ÷ 55 MB ≈ 27  →  pm.max_children = 25

Contoh server 8 GB khusus web (database dan Redis di server lain):

(8.192 − 600 OS/Nginx − 800 cadangan) ÷ 55 ≈ 123  →  pm.max_children = 100–120

Lalu periksa batas CPU. Untuk request yang sebagian besar menunggu I/O (query, Redis, HTTP), jumlah worker bisa beberapa kali jumlah core. Untuk request yang berat CPU (membuat PDF, mengolah gambar), worker yang jauh melebihi jumlah core hanya membuat semuanya antre di CPU. Itulah alasan pekerjaan berat CPU dipindah ke queue.

Langkah 4: Pilih Mode Process Manager

Mode Perilaku Cocok untuk
static Selalu max_children worker Server khusus web dengan traffic stabil; latensi paling konsisten
dynamic Antara min_spare dan max_children, dimulai dari start_servers Server campuran; pilihan umum
ondemand Worker dibuat saat ada request, dimatikan setelah menganggur Server kecil dengan banyak situs bertraffic rendah

Konfigurasi untuk server 4 GB campuran:

; /etc/php/8.4/fpm/pool.d/www.conf
[www]
user = www-data
group = www-data

listen = /run/php/php8.4-fpm.sock
listen.owner = www-data
listen.group = www-data
listen.mode = 0660
listen.backlog = 511

pm = dynamic
pm.max_children = 25
pm.start_servers = 8
pm.min_spare_servers = 5
pm.max_spare_servers = 12
pm.max_requests = 1000
pm.process_idle_timeout = 10s

pm.status_path = /fpm-status
ping.path = /fpm-ping

request_terminate_timeout = 65s
request_slowlog_timeout = 3s
slowlog = /var/log/php8.4-fpm/www-slow.log

catch_workers_output = yes
decorate_workers_output = no

Konfigurasi untuk server web 8 GB khusus:

pm = static
pm.max_children = 100
pm.max_requests = 1000

pm.max_requests: worker dimatikan dan diganti setelah melayani sekian request. Ini mencegah kebocoran memori dari ekstensi atau kode yang menumpuk data statis. Nilai 500–2.000 umum dipakai.

Langkah 5: memory_limit Bukan Kapasitas

memory_limit adalah batas atas per request, bukan memori yang dipakai. Dengan memory_limit = 512M dan 25 worker, PHP tidak memesan 12,5 GB. Namun bila beberapa request berat terjadi bersamaan, total pemakaian bisa melampaui RAM.

; /etc/php/8.4/fpm/php.ini
memory_limit = 256M
max_execution_time = 60
post_max_size = 25M
upload_max_filesize = 20M

Panduan:

  • Set memory_limit sedikit di atas request terberat yang sah (di contoh: 180 MB → 256M).
  • Request yang butuh lebih dari itu (ekspor besar, impor) sebaiknya dijalankan di queue worker, yang bisa memakai batas lebih besar lewat --memory dan php -d memory_limit=1G.
  • Bila Anda menaikkan memory_limit hanya untuk satu route, gunakan ini_set('memory_limit', '512M') di route itu, bukan menaikkan untuk semua.

Langkah 6: Samakan Timeout dari Luar ke Dalam

Timeout yang tidak selaras menghasilkan perilaku membingungkan: PHP masih bekerja padahal Nginx sudah mengembalikan 504, atau worker terkunci lebih lama dari yang perlu.

Urutan yang disarankan (dari dalam ke luar, makin ke luar makin panjang):

Lapisan Setelan Nilai
HTTP client di kode Http::timeout() 5–10 detik
Query database wait_timeout, timeout per query sesuai kebutuhan
PHP max_execution_time 60 detik
PHP-FPM request_terminate_timeout 65 detik
Nginx → FPM fastcgi_read_timeout 70 detik
Load balancer timeout upstream 75 detik
# /etc/nginx/sites-available/rw
location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/run/php/php8.4-fpm.sock;
    fastcgi_read_timeout 70s;
    fastcgi_buffers 16 16k;
    fastcgi_buffer_size 32k;
}

max_execution_time di Linux hanya menghitung waktu CPU skrip, bukan waktu menunggu I/O (query, HTTP). Karena itu request_terminate_timeout di PHP-FPM tetap diperlukan sebagai batas waktu nyata.

Langkah 7: Status Page untuk Pemantauan

Buka status page hanya untuk localhost atau jaringan pemantauan:

location ~ ^/(fpm-status|fpm-ping)$ {
    allow 127.0.0.1;
    allow 10.0.0.0/24;      # server monitoring
    deny all;
    include fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $fastcgi_script_name;
    fastcgi_pass unix:/run/php/php8.4-fpm.sock;
}
curl -s http://127.0.0.1/fpm-status
curl -s 'http://127.0.0.1/fpm-status?full' | head -40
pool:                 www
process manager:      dynamic
accepted conn:        184522
listen queue:         0
max listen queue:     37
listen queue len:     511
idle processes:       9
active processes:     16
total processes:      25
max active processes: 25
max children reached: 14
slow requests:        212
Metrik Arti Tindakan
listen queue Request yang sedang menunggu worker > 0 terus-menerus = kekurangan worker atau request lambat
max children reached Berapa kali batas worker tercapai sejak start Naik terus = kapasitas kurang
active processes Worker yang sedang bekerja Mendekati total di jam sibuk
slow requests Request melebihi request_slowlog_timeout Periksa slow log

Ekspor metrik ini ke sistem pemantauan (misalnya php-fpm_exporter untuk Prometheus) agar terlihat polanya per jam.

Langkah 8: Slow Log untuk Menemukan Kode yang Lambat

Dengan request_slowlog_timeout = 3s, PHP-FPM mencatat stack trace request yang berjalan lebih dari 3 detik:

[19-Oct-2026 09:14:02]  [pool www] pid 21877
script_filename = /var/www/rw/current/public/index.php
[0x00007f...] curl_exec() /var/www/rw/current/vendor/guzzlehttp/guzzle/src/Handler/CurlHandler.php:44
[0x00007f...] __invoke() .../Illuminate/Http/Client/PendingRequest.php:...
[0x00007f...] ambilDataKelurahan() /var/www/rw/current/app/Services/WilayahClient.php:58
...

Contoh di atas langsung menunjukkan penyebabnya: worker menunggu curl_exec ke API wilayah. Solusinya timeout yang ketat, cache hasilnya, atau pindahkan ke job.

Langkah 9: Perkirakan Kapasitas dengan Little's Law

Request bersamaan (concurrency) = throughput (rps) × waktu respons rata-rata (detik)

Dibalik untuk kapasitas maksimum:

Throughput maksimum ≈ jumlah worker ÷ waktu respons rata-rata
Worker Waktu respons rata-rata Kapasitas maksimum
25 200 ms ≈ 125 rps
25 800 ms ≈ 31 rps
25 2.000 ms (karena API eksternal lambat) ≈ 12 rps
100 200 ms ≈ 500 rps (bila CPU dan database sanggup)

Tabel ini menunjukkan mengapa mempercepat request sering kali lebih efektif daripada menambah worker: menurunkan waktu respons dari 800 ms ke 200 ms melipatgandakan kapasitas empat kali tanpa tambahan memori.

Validasi perkiraan dengan load test (ApacheBench/k6), sambil memantau status page dan memori.

Langkah 10: Pool Terpisah untuk Beban Berbeda

Bila ada endpoint berat yang tidak bisa dipindah ke queue (misalnya ekspor sinkron untuk admin), pisahkan ke pool sendiri agar tidak menghabiskan worker halaman warga:

; /etc/php/8.4/fpm/pool.d/admin-berat.conf
[admin-berat]
user = www-data
group = www-data
listen = /run/php/php8.4-fpm-berat.sock
listen.owner = www-data
listen.group = www-data
pm = ondemand
pm.max_children = 4
pm.process_idle_timeout = 30s
request_terminate_timeout = 300s
php_admin_value[memory_limit] = 768M
php_admin_value[max_execution_time] = 280

Arahkan URL tertentu ke pool tersebut dengan map. Semua route Laravel tetap lewat index.php, dan $request_uri masih berisi URL asli:

# /etc/nginx/conf.d/fpm-pool-map.conf  (konteks http)
map $request_uri $fpm_pool {
    default            unix:/run/php/php8.4-fpm.sock;
    ~^/admin/ekspor/   unix:/run/php/php8.4-fpm-berat.sock;
}
# /etc/nginx/sites-available/rw
location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass $fpm_pool;
    fastcgi_read_timeout 310s;    # cukup untuk pool berat; pool utama dibatasi request_terminate_timeout-nya sendiri
}

Uji konfigurasi dengan sudo nginx -t sebelum reload.

Langkah 11: Batas Sistem Operasi

Saat traffic tinggi, batas kernel bisa tercapai sebelum batas PHP-FPM:

# Antrean koneksi socket
sudo sysctl -w net.core.somaxconn=1024
echo 'net.core.somaxconn=1024' | sudo tee /etc/sysctl.d/60-somaxconn.conf

# Batas file terbuka untuk PHP-FPM (systemd override)
sudo systemctl edit php8.4-fpm
#   [Service]
#   LimitNOFILE=65535

listen.backlog PHP-FPM dibatasi oleh net.core.somaxconn; menaikkan satu tanpa yang lain tidak berpengaruh.

Langkah 12: Terapkan dan Verifikasi

sudo php-fpm8.4 -t                 # uji konfigurasi
sudo systemctl reload php8.4-fpm   # reload tanpa memutus request berjalan
sudo nginx -t && sudo systemctl reload nginx

Setelah perubahan:

  1. Jalankan load test dengan pola traffic jam sibuk.
  2. Pantau listen queue, max children reached, pemakaian memori (free -m), dan swap.
  3. Pastikan tidak ada swap aktif yang terus naik dan tidak ada pesan OOM di dmesg.
  4. Bandingkan p95 waktu respons sebelum dan sesudah.
free -m
vmstat 1 10                       # kolom si/so harus mendekati 0
sudo dmesg -T | grep -i 'killed process'

Troubleshooting

Error / Gejala Penyebab Solusi
server reached pm.max_children Worker habis Cari request lambat (slow log), lalu hitung ulang max_children dari memori
502 Bad Gateway PHP-FPM mati/menolak, socket permission salah, antrean penuh systemctl status php8.4-fpm; cek listen.owner; listen.backlog/somaxconn
504 Gateway Timeout Request melebihi fastcgi_read_timeout Selidiki request lambat; selaraskan timeout
Server memakai swap, semuanya lambat max_children terlalu besar Turunkan sesuai perhitungan memori
MySQL/Redis mati tiba-tiba OOM killer dmesg; kurangi worker; pisahkan server database
Memori worker naik terus Kebocoran memori pm.max_requests
Allowed memory size exhausted Request melampaui memory_limit Optimasi (chunk, stream) atau pindah ke queue
Status page 404 Path tidak diteruskan ke FPM Konfigurasi location khusus status
Kode baru tidak terpakai OPcache dengan validate_timestamps=0 systemctl reload php8.4-fpm saat deploy
CPU 100% dengan worker banyak Pekerjaan berat CPU di request Pindah ke queue; kurangi worker

Best Practices

Keamanan

  • Status page dan ping hanya bisa diakses dari localhost/jaringan pemantauan.
  • Pool berjalan sebagai pengguna non-root dengan socket permission ketat.
  • expose_php = Off dan display_errors = Off di production.

Performa

  • Hitung max_children dari memori yang diukur, bukan menebak.
  • Timeout berlapis: makin ke luar makin panjang, dan timeout HTTP di kode paling pendek.
  • Pekerjaan berat CPU dan lambat pindah ke queue; kapasitas web naik tanpa menambah worker.
  • pm.max_requests untuk mencegah kebocoran memori.

Maintainability

  • Simpan konfigurasi pool di repository infrastruktur (Ansible, dsb.), bukan diedit langsung di server.
  • Catat dasar perhitungan (memori per worker, RAM tersedia) di komentar konfigurasi.
  • Pantau status page dan slow log secara rutin; tinjau ulang setelah fitur besar dirilis.

Related Articles

Last Tested

Komponen Versi
Laravel 13.x
PHP-FPM 8.4
Nginx 1.24
Ubuntu 24.04 LTS
Tanggal 19 Oktober 2026

Bagikan artikel:

Artikel lainnya