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

Blog / Performance, Caching & Scalability / Laravel Octane vs PHP-FPM: Per...
Performance, Caching & Scalability

Laravel Octane vs PHP-FPM: Perbedaan, Kelebihan, Risiko, dan Skenario Penggunaan

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
11 min read
40 views

Bagaimana Octane membuat Laravel lebih cepat dengan mem-boot aplikasi sekali dan menyimpannya di memori, apa yang sebenarnya dipercepat (dan yang tidak), risiko kebocoran state antar-request yang wajib dipahami, cara memeriksa kode agar aman untuk Octane, pemasangan dengan FrankenPHP di production, serta matriks keputusan kapan Octane layak dipakai.

Overview

Di PHP-FPM, setiap request memulai Laravel dari nol: memuat autoloader, membuat container, mendaftarkan dan mem-boot puluhan service provider, membaca konfigurasi, menyusun route, lalu menjalankan controller. Setelah respons terkirim, semuanya dibuang. Untuk aplikasi Laravel pada umumnya, proses bootstrap ini memakan beberapa hingga belasan milidetik per request, bahkan dengan OPcache dan php artisan optimize.

Laravel Octane menjalankan aplikasi di atas server aplikasi yang berumur panjang (FrankenPHP, Swoole/OpenSwoole, atau RoadRunner). Aplikasi di-boot sekali per worker, lalu worker yang sama melayani ribuan request berikutnya. Overhead bootstrap hilang.

Kedengarannya seperti peningkatan gratis. Kenyataannya ada harga yang harus dibayar: state yang tersimpan di memori ikut terbawa ke request berikutnya. Kode yang aman di PHP-FPM bisa membocorkan data pengguna A ke pengguna B di Octane.

Hasil akhir:

  • pemahaman perbedaan model eksekusi PHP-FPM dan Octane,
  • gambaran realistis tentang apa yang dipercepat,
  • daftar pola kode yang tidak aman untuk Octane dan perbaikannya,
  • pemasangan Octane dengan FrankenPHP di belakang Nginx, plus Supervisor,
  • strategi deploy dan pengendalian memori,
  • matriks keputusan: kapan Octane, kapan tetap PHP-FPM.

Prerequisites

Komponen Versi
PHP 8.3+ (disarankan 8.4)
Laravel 13.x
Laravel Octane 2.x (rilis terbaru 2.22, mendukung Laravel 10–13)
Server aplikasi FrankenPHP 1.x, Swoole/OpenSwoole 5.x+, atau RoadRunner 2025.x
Nginx 1.24+ (sebagai reverse proxy, opsional dengan FrankenPHP)

Step-by-step Tutorial

Langkah 1: Perbedaan Model Eksekusi

PHP-FPM (shared-nothing)
  request 1: [boot framework][handle][respons][buang semua]
  request 2: [boot framework][handle][respons][buang semua]
  request 3: [boot framework][handle][respons][buang semua]

Octane (worker berumur panjang)
  worker:    [boot framework sekali]
  request 1:                         [handle][respons][reset sebagian]
  request 2:                                                         [handle][respons][reset sebagian]
  request 3:                                                                                             [handle]...
Aspek PHP-FPM Octane
Bootstrap Setiap request Sekali per worker
State antar-request Selalu bersih Bertahan kecuali di-reset
Kebocoran memori kecil Tidak terasa (proses berakhir) Menumpuk; worker perlu didaur ulang
Deploy Reload PHP-FPM octane:reload (worker di-boot ulang)
Kompatibilitas paket Hampir semua Sebagian paket perlu penyesuaian
Fitur tambahan — Tugas konkuren, tick/interval, cache & table in-memory (Swoole)
Kerumitan debugging Rendah Lebih tinggi (bug state)

Langkah 2: Apa yang Sebenarnya Dipercepat

Octane menghilangkan waktu bootstrap. Ia tidak mempercepat query database, panggilan API eksternal, atau rendering Blade yang berat.

Ilustrasi pola yang umum (bukan hasil benchmark aplikasi Anda):

Endpoint Waktu di PHP-FPM Bootstrap Waktu di Octane Perubahan
GET /api/v1/ping (tanpa query) 12 ms ≈ 10 ms 2 ms Sangat besar
GET /api/v1/pengumuman (2 query cepat) 25 ms ≈ 10 ms 15 ms Besar
GET /iuran (halaman admin, 8 query, Blade) 180 ms ≈ 10 ms 170 ms Kecil
GET /laporan/kas (query agregat berat) 1.400 ms ≈ 10 ms 1.390 ms Hampir tidak ada

Kesimpulannya: Octane memberi dampak terbesar pada endpoint yang cepat dan sering dipanggil (API mobile, endpoint polling, health check dengan volume tinggi). Untuk halaman yang lambat karena database, perbaiki query dan index dulu.

Throughput bisa meningkat lebih besar dari angka latensi karena CPU tidak lagi dihabiskan untuk bootstrap. Ukur sendiri dengan load test.

Langkah 3: Pola Kode yang Tidak Aman di Octane

1. Menyuntikkan request, config repository, atau container ke singleton

// ❌ Singleton menyimpan Request dari request PERTAMA selamanya
$this->app->singleton(LayananTenant::class, function ($app) {
    return new LayananTenant($app['request']);
});

// ✅ Resolve request saat dibutuhkan
$this->app->singleton(LayananTenant::class, fn ($app) => new LayananTenant(fn () => $app['request']));

// ✅ Atau gunakan scoped(): dibuat ulang setiap request di Octane
$this->app->scoped(LayananTenant::class, fn ($app) => new LayananTenant($app['request']));

scoped() berperilaku seperti singleton di dalam satu request (atau satu job), lalu dibuang saat request berikutnya dimulai. Ini pilihan paling sederhana untuk layanan yang bergantung pada konteks request atau pengguna.

2. Properti statis sebagai cache

// ❌ Bertahan selama worker hidup; nilai RW pertama terus dipakai
class KonteksRw
{
    private static ?RukunWarga $aktif = null;

    public static function aktif(): RukunWarga
    {
        return self::$aktif ??= RukunWarga::find(auth()->user()->rw_id);
    }
}

Perbaikan: simpan di layanan scoped, atau gunakan Context/atribut request, atau reset di listener RequestReceived.

3. Array yang terus ditambah

// ❌ Memori bocor: setiap request menambah entri, tidak pernah dikosongkan
class PencatatAudit
{
    public array $entri = [];   // singleton
}

4. Mengubah konfigurasi saat runtime

// ❌ Berlaku untuk semua request berikutnya di worker ini
config(['app.locale' => $user->bahasa]);

Octane mengembalikan konfigurasi ke nilai awal di awal setiap request, sehingga contoh ini tidak bocor ke request lain, tetapi pola yang lebih jelas adalah App::setLocale() yang memang di-reset per request.

5. Koneksi atau klien yang dibuat sekali dan menyimpan state pengguna

Klien HTTP pihak ketiga yang menyimpan token pengguna di properti objek singleton akan memakai token yang sama untuk semua pengguna.

6. auth() dan request() di constructor kelas yang di-cache

Constructor singleton hanya dipanggil sekali; nilai auth()->user() di sana adalah pengguna pada request pertama.

Langkah 4: Audit Kode Sebelum Memakai Octane

Cari pola berisiko di kode aplikasi:

# Singleton yang menerima request/auth/session
grep -rn "singleton(" app/ | grep -E "request|auth|session|Request" 

# Properti statis yang bisa diubah
grep -rnE "(private|protected|public) static (\??[A-Za-z\\\\]+ )?\\\$[a-zA-Z_]+ *(=|;)" app/

# auth()/request() di constructor
grep -rn -A5 "function __construct" app/ | grep -E "auth\(\)|request\(\)|Auth::|Request::"

Hasil grep perlu ditinjau satu per satu; tidak semua properti statis berbahaya (konstanta atau cache yang memang global dan tidak bergantung pengguna boleh saja).

Periksa juga paket pihak ketiga. Paket populer yang aktif dirawat umumnya sudah kompatibel, tetapi cari di dokumentasinya kata kunci "Octane". Untuk paket yang menyimpan state, tambahkan ke daftar flush di config/octane.php:

// config/octane.php
'flush' => [
    \App\Support\KonteksRw::class,
],

flush membuang instance binding tersebut dari container di antara request.

Langkah 5: Reset State dengan Listener Octane

// app/Listeners/ResetStateRequest.php
namespace App\Listeners;

use App\Support\KonteksRw;

class ResetStateRequest
{
    public function handle($event): void
    {
        KonteksRw::reset();      // mengosongkan properti statis
    }
}
// config/octane.php
use Laravel\Octane\Events\RequestReceived;

'listeners' => [
    RequestReceived::class => [
        ...Octane::prepareApplicationForNextOperation(),
        ...Octane::prepareApplicationForNextRequest(),
        \App\Listeners\ResetStateRequest::class,
    ],
    // ...
],

Listener bawaan Octane sudah mereset banyak hal: auth guard, session, cookie queue, locale, URL generator, config, dan lainnya. Listener tambahan hanya untuk state milik aplikasi Anda sendiri.

Langkah 6: Test Kebocoran State

Test biasa membuat aplikasi baru untuk setiap test, sehingga tidak menangkap bug Octane. Simulasikan dua request berurutan dengan pengguna berbeda di satu instance aplikasi:

// tests/Feature/Octane/StateTest.php
it('konteks RW tidak bocor antar-request pengguna berbeda', function () {
    $rwA = RukunWarga::factory()->create();
    $rwB = RukunWarga::factory()->create();
    $userA = User::factory()->for($rwA, 'rukunWarga')->create()->assignRole('pengurus');
    $userB = User::factory()->for($rwB, 'rukunWarga')->create()->assignRole('pengurus');

    $this->actingAs($userA)->getJson('/api/v1/rw/aktif')->assertJsonPath('data.id', $rwA->id);

    // Simulasikan reset antar-request ala Octane: binding scoped dibuang,
    // dan listener reset milik aplikasi dijalankan. Singleton & properti statis TIDAK dibuang.
    app()->forgetScopedInstances();
    (new \App\Listeners\ResetStateRequest)->handle(null);

    $this->actingAs($userB)->getJson('/api/v1/rw/aktif')->assertJsonPath('data.id', $rwB->id);
});

Simulasi ini tidak identik dengan Octane sungguhan. Lengkapi dengan uji di staging yang menjalankan Octane: login sebagai dua pengguna di dua browser, lalu bergantian membuka halaman yang bergantung pada pengguna, sambil worker dibatasi 1 (--workers=1) agar keduanya pasti dilayani worker yang sama.

Langkah 7: Pasang Octane dengan FrankenPHP

composer require laravel/octane
php artisan octane:install --server=frankenphp

Installer mengunduh biner FrankenPHP bila belum tersedia dan menambahkan konfigurasi. Jalankan di lokal:

php artisan octane:start --watch

Di production, jalankan di port lokal di belakang Nginx (yang menangani TLS, aset statis, dan header), atau biarkan FrankenPHP langsung menangani HTTPS (FrankenPHP dibangun di atas Caddy dan bisa mengurus sertifikat otomatis).

# .env
OCTANE_SERVER=frankenphp
OCTANE_HTTPS=true          # bila TLS diterminasi di proxy, agar URL dibuat https
; /etc/supervisor/conf.d/octane.conf
[program:rw-octane]
command=php /var/www/rw/current/artisan octane:start --server=frankenphp --host=127.0.0.1 --port=8000 --workers=8 --max-requests=500
directory=/var/www/rw/current
user=deploy
autostart=true
autorestart=true
stopwaitsecs=60
redirect_stderr=true
stdout_logfile=/var/www/rw/shared/storage/logs/octane.log
# /etc/nginx/sites-available/rw-octane
server {
    listen 443 ssl;
    http2 on;
    server_name rw.example.id;
    root /var/www/rw/current/public;

    # Aset statis langsung dari Nginx
    location /build/ {
        expires 1y;
        add_header Cache-Control "public, immutable";
        try_files $uri =404;
    }

    location / {
        try_files $uri @octane;
    }

    location @octane {
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Connection "";
        proxy_pass http://127.0.0.1:8000;
        proxy_read_timeout 70s;
    }
}

Karena Laravel sekarang berada di balik proxy lokal, konfigurasikan trustProxies (lihat artikel load balancer).

Langkah 8: Jumlah Worker dan Memori

  • Worker: titik awal yang umum adalah jumlah core CPU (Octane memakai jumlah core sebagai default). Untuk aplikasi yang banyak menunggu I/O, worker bisa dinaikkan; ukur dengan load test.
  • --max-requests: worker di-restart setelah sekian request untuk membersihkan kebocoran memori kecil. Mulai dari 500–1.000.
  • Memori: satu worker Octane biasanya memakai memori lebih besar dari worker PHP-FPM yang baru di-boot (karena tetap memegang aplikasi), tetapi jumlah worker yang dibutuhkan lebih sedikit. Pantau RSS per worker dari waktu ke waktu; kenaikan yang terus-menerus adalah tanda kebocoran.
  • max_execution_time di config/octane.php membatasi lama satu request (default 30 detik).

Langkah 9: Deploy

Worker memegang kode di memori, jadi kode baru tidak terpakai sampai worker di-boot ulang:

# skrip deploy
php artisan optimize
php artisan octane:reload        # worker di-restart dengan anggun
php artisan queue:restart        # worker queue juga

Bila struktur direktori rilis berganti (symlink current diarahkan ke folder rilis baru), pastikan proses Octane dijalankan dari path symlink dan di-restart penuh oleh Supervisor bila octane:reload tidak cukup (misalnya setelah memperbarui biner FrankenPHP atau ekstensi PHP).

Langkah 10: Fitur Tambahan Octane

Tugas konkuren (Swoole menjalankan secara paralel di task worker; driver lain menjalankannya berurutan):

use Laravel\Octane\Facades\Octane;

[$kas, $iuran, $warga] = Octane::concurrently([
    fn () => app(RingkasanKas::class)->untuk($rwId, $periode),
    fn () => Iuran::where('periode', $periode)->count(),
    fn () => Keluarga::where('rw_id', $rwId)->count(),
]);

Untuk kode yang juga harus berjalan di PHP-FPM, facade Concurrency bawaan Laravel (driver process, fork, atau sync) adalah alternatif yang tidak bergantung pada Octane.

Cache dan table in-memory (Cache::store('octane'), Octane::table()) hanya tersedia di Swoole, dan datanya hilang saat server restart serta tidak dibagi antar-server. Cocok untuk cache yang sangat panas di satu server, bukan pengganti Redis.

Langkah 11: Matriks Keputusan

Situasi Rekomendasi
Aplikasi admin/CRUD, bottleneck di database PHP-FPM; optimasi query, index, cache dulu
API dengan volume tinggi dan endpoint cepat (mobile, polling) Octane layak dipertimbangkan
Tim kecil, belum ada pengalaman bug state PHP-FPM; mulai Octane di layanan kecil terpisah
Banyak paket lama yang tidak dirawat PHP-FPM, atau audit paket terlebih dahulu
Biaya server menjadi masalah utama dan throughput tinggi Octane bisa mengurangi jumlah server
Latensi p50 harus sangat rendah (< 20 ms) Octane
Butuh HTTP/3, Early Hints, atau satu biner mandiri Octane dengan FrankenPHP

Strategi bertahap yang aman: jalankan Octane hanya untuk prefix /api/ (Nginx mengarahkan /api/ ke Octane dan sisanya ke PHP-FPM) dengan kode yang sama. Bila stabil beberapa minggu, perluas.

location /api/ {
    try_files $uri @octane;
}

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

location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/run/php/php8.4-fpm.sock;
}

Troubleshooting

Error / Gejala Penyebab Solusi
Pengguna melihat data pengguna lain State bocor lewat singleton/statis scoped(), flush, listener reset; audit Langkah 4
Perubahan kode tidak berlaku Worker memegang kode lama php artisan octane:reload saat deploy
Memori worker naik terus Kebocoran (array statis, listener terdaftar berulang) Perbaiki sumbernya; --max-requests
Event::listen di controller terpanggil berlipat Listener didaftarkan ulang setiap request Daftarkan listener di service provider
URL dibuat http:// Di balik proxy OCTANE_HTTPS=true, trustProxies
Octane::concurrently tidak paralel Bukan driver Swoole Gunakan Swoole, atau facade Concurrency
Cache octane tidak tersedia Bukan Swoole Gunakan Redis
Request panjang terputus max_execution_time Octane Sesuaikan di config/octane.php atau pindah ke queue
Paket pihak ketiga error setelah beberapa request Paket menyimpan state Tambahkan ke flush atau ganti paket
Error koneksi database setelah idle lama Koneksi persisten terputus Laravel menyambung ulang otomatis; periksa wait_timeout

Best Practices

Keamanan

  • Audit singleton, properti statis, dan constructor sebelum mengaktifkan Octane.
  • Uji kebocoran state dengan dua pengguna pada satu worker di staging.
  • Layanan yang bergantung pengguna/tenant memakai scoped().

Performa

  • Ukur dulu: Octane membantu endpoint cepat bervolume tinggi, bukan query lambat.
  • --max-requests dan pemantauan memori per worker.
  • Nginx menyajikan aset statis; Octane hanya melayani request aplikasi.

Maintainability

  • octane:reload bagian wajib dari skrip deploy.
  • Kode tetap kompatibel dengan PHP-FPM agar bisa kembali kapan saja.
  • Migrasi bertahap (mulai dari /api/), dengan rencana kembali ke PHP-FPM bila muncul masalah.

Related Articles

Last Tested

Komponen Versi
Laravel 13.x
PHP 8.4
Laravel Octane 2.22
FrankenPHP 1.x
Nginx 1.24
Tanggal 19 Oktober 2026

Bagikan artikel:

Artikel lainnya