Setiap kali pengguna menekan tombol di aplikasi kita, sebuah HTTP request berangkat dari browser dan, sepersekian detik kemudian, sebuah response kembali sebagai halaman. Di antara dua momen itu terjadi rangkaian langkah yang panjang: entry point, bootstrap, middleware, routing, controller, hingga pengiriman response. Dokumentasi resmi menyebut perjalanan ini request lifecycle, dan memahaminya membuat perilaku Laravel terasa logis, bukan ajaib — mengapa session tersedia di controller, mengapa middleware dieksekusi dua arah, dan di mana konfigurasi error masuk ke dalam permainan. Chapter ini mengikuti perjalanan satu request dari public/index.php sampai response sampai ke browser.

Titik Masuk: public/index.php #

Semua request HTTP ke aplikasi Laravel diarahkan oleh web server (Apache atau Nginx) ke satu berkas yang sama: public/index.php. Berkas ini sengaja sangat pendek — bukan karena tidak ada yang terjadi, melainkan karena tugasnya hanya menyalakan mesin. Berikut isi aslinya pada Laravel 13:

php 
<?php

use Illuminate\Foundation\Application;
use Illuminate\Http\Request;

define('LARAVEL_START', microtime(true));

// Determine if the application is in maintenance mode...
if (file_exists($maintenance = __DIR__.'/../storage/framework/maintenance.php')) {
    require $maintenance;
}

// Register the Composer autoloader...
require __DIR__.'/../vendor/autoload.php';

// Bootstrap Laravel and handle the request...
/** @var Application $app */
$app = require_once __DIR__.'/../bootstrap/app.php';

$app->handleRequest(Request::capture());

Mari kita bedah baris-baris pentingnya:

  1. define('LARAVEL_START', ...): mencatat waktu mulai, dipakai untuk menghitung lama eksekusi request.
  2. Blok if maintenance: bila mode perbaikan aktif, berkas maintenance dimuat lebih dulu sehingga pengguna lain melihat halaman “sedang diperbaiki” tanpa memproses request.
  3. require .../vendor/autoload.php: memuat autoloader Composer — dari titik ini semua class framework dan aplikasi bisa di-load otomatis.
  4. require_once .../bootstrap/app.php: membuat instance aplikasi — sekaligus instance service container — beserta seluruh konfigurasinya.
  5. $app->handleRequest(Request::capture()): menangkap data request mentah dari superglobal PHP menjadi objek Request, lalu memasukkannya ke method yang menangani seluruh sisa lifecycle.

bootstrap/app.php dan Kernel #

Berkas bootstrap/app.php adalah tempat aplikasi dirakit. Pada Laravel 13, berkas ini memakai builder Application::configure() yang deklaratif:

php 
<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware): void {
        //
    })
    ->withExceptions(function (Exceptions $exceptions): void {
        $exceptions->shouldRenderJsonWhen(
            fn (Request $request) => $request->is('api/*') || $request->expectsJson(),
        );
    })->create();

Tiga method builder tersebut memetakan tugas besar aplikasi: withRouting() mendaftarkan berkas route web.php dan console.php serta endpoint health check /up; withMiddleware() adalah tempat kita mendaftarkan atau mengubah middleware; dan withExceptions() mengatur kebijakan penanganan error, termasuk kapan error harus dirender sebagai JSON. Sejak Laravel 11 tidak ada lagi app/Http/Kernel.php — konfigurasi lapisan HTTP terpusat di berkas ini.

Setelah aplikasi terbangun, request diserahkan ke HTTP kernel — satu-satunya gerbang yang dilewati seluruh request. Kernel menjalankan bootstrappers (menyiapkan error handling, logging, dan environment) lalu memuat seluruh service provider yang tugasnya meregistrasi dan menyalakan semua service framework — routing, database, session, queue, validasi. Setelah service siap, barulah request diantar ke router.

Middleware sebagai Lapisan Bawang #

Sebelum mencapai route, request melewati tumpukan middleware yang bekerja seperti lapisan-lapisan bawang: request masuk melewati tiap lapisan dari luar ke dalam, dan response keluar melewati lapisan yang sama dari dalam ke luar. Middleware yang menyertai route web membaca dan menulis session, memverifikasi token CSRF, sedangkan middleware lain bisa memblokir request saat mode maintenance. Karena arah dua arah ini, satu middleware punya dua kesempatan bertindak: menyaring request sebelum controller dan memodifikasi response setelahnya.

Alur Lengkap Satu Request #

Diagram berikut merangkum keseluruhan perjalanan request GET /status:

Ringkasnya: entry point memuat framework, kernel menyalakan service, middleware menyaring, router mencocokkan URL, route/controller menghasilkan response, dan response menempuh jalan yang sama keluar sampai dikirim ke browser.

Membuktikan Alur Secara Langsung #

Kita bisa meniru langkah-langkah public/index.php tanpa web server sungguhan, asalkan routes/web.php berisi route sederhana Route::get('/status', fn () => 'Aplikasi berjalan');. Skrip berikut membuat objek Request secara manual, menyerahkannya ke kernel HTTP, lalu membaca response yang kembali:

php 
<?php

// demo-lifecycle.php — jalankan dari root proyek Laravel
use Illuminate\Contracts\Http\Kernel;
use Illuminate\Http\Request;

require __DIR__.'/vendor/autoload.php';
$app = require __DIR__.'/bootstrap/app.php';

// Anggap browser membuka http://localhost:8000/status
$request = Request::create('/status', 'GET');

// Tahap inti public/index.php: kernel HTTP menangani request
$kernel = $app->make(Kernel::class);
$response = $kernel->handle($request);

echo 'Status : '.$response->getStatusCode().PHP_EOL;
echo 'Body   : '.$response->getContent().PHP_EOL;

// Terminable middleware berjalan setelah response dikirim
$kernel->terminate($request, $response);

Output yang Dihasilkan:

text 
Status : 200
Body   : Aplikasi berjalan

Skrip ini membuktikan bahwa kernel benar-benar adalah “kotak hitam” yang menerima Request dan mengembalikan Response: kita tidak menyentuh router maupun middleware secara langsung, namun seluruh lifecycle — termasuk pencocokan route /status — tetap terjadi. Panggilan terminate() pada baris terakhir meniru tahap akhir lifecycle, tempat terminable middleware (misalnya logger session) menyelesaikan pekerjaannya setelah response siap. Panduan lengkap tiap tahap tersedia di dokumentasi request lifecycle serta middleware .

Laravel ternyata bukan hanya framework tunggal, melainkan teras dari satu ekosistem paket lengkap. Chapter berikutnya memetakan ekosistem tersebut: dari Sanctum, Horizon, Telescope, hingga Reverb dan Pint.