> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Laravel Octane

> Versnel je Laravel-applicatie met FrankenPHP, Swoole en RoadRunner

## Wat is Octane

[Laravel Octane](https://github.com/laravel/octane) is een package die de prestaties van je Laravel-applicatie drastisch verbetert door gebruik te maken van hoogperformante applicatieservers.

Bij regulier PHP-FPM start en stopt de applicatie bij elke request. Met Octane wordt de applicatie één keer opgestart en in het geheugen gehouden, waarna volgende requests razendsnel worden afgehandeld.

```mermaid theme={null}
sequenceDiagram
    participant Client
    participant Nginx
    participant Octane as Octane<br>(resident proces)
    participant App as Laravel<br>app
    Client->>Nginx: Request
    Nginx->>Octane: Proxy
    Octane->>App: Requestverwerking (in geheugen)
    App->>Nginx: Response
    Nginx->>Client: Response
```

Het grootste verschil met PHP-FPM is dat het bootproces van de applicatie (zoals het registreren van service providers) niet bij elke request wordt herhaald. Na één keer opstarten worden requests supersnel verwerkt.

## Ondersteunde servers

Octane ondersteunt de volgende drie servers.

```mermaid theme={null}
flowchart LR
    A["Serverkeuze"] --> B{"Gelijktijdige taken of<br>Swoole-functies nodig?"}
    B -->|"Yes"| C["Swoole<br>(PECL-extensie)"]
    B -->|"No"| D{"HTTP/3 of Brotli-<br>compressie nodig?"}
    D -->|"Yes"| E["FrankenPHP<br>(aanbevolen)"]
    D -->|"No"| F["RoadRunner<br>(Go-binary)"]
```

| Server     | Taal         | Installatie          | Gelijktijdige taken | Opmerkingen                                     |
| ---------- | ------------ | -------------------- | ------------------- | ----------------------------------------------- |
| FrankenPHP | Go           | Automatisch (binary) | —                   | Aanbevolen. Ondersteunt HTTP/3 en Brotli        |
| RoadRunner | Go           | Automatisch (binary) | —                   | Eenvoudig en makkelijk te configureren          |
| Swoole     | PHP-extensie | Handmatig via PECL   | ✅                   | Gelijktijdige taken en Octane-cache beschikbaar |

<Info>
  Op Laravel Cloud wordt het draaien van Octane met FrankenPHP aanbevolen en volledig managed ondersteund.
</Info>

## Installatie en configuratie

### De package installeren

```bash theme={null}
composer require laravel/octane
```

### Octane initialiseren

```bash theme={null}
php artisan octane:install
```

Bij het uitvoeren verschijnt een prompt waarin je een server kiest. Na de keuze wordt `config/octane.php` gegenereerd.

### FrankenPHP

Kies je FrankenPHP, dan downloadt Octane automatisch de binary. Er zijn geen extra stappen nodig.

### RoadRunner

Kies je RoadRunner, dan downloadt Octane automatisch de binary.

### Swoole

Swoole installeer je als PHP-extensie via PECL.

```bash theme={null}
pecl install swoole
```

Gebruik je Open Swoole, dan installeer je die met het volgende commando.

```bash theme={null}
pecl install openswoole
```

## Starten

### De server starten

```bash theme={null}
php artisan octane:start
```

Standaard start de server op poort `8000`. Je kunt de applicatie bereiken via `http://localhost:8000`.

### Een server opgeven

```bash theme={null}
php artisan octane:start --server=frankenphp
php artisan octane:start --server=roadrunner
php artisan octane:start --server=swoole
```

### Het aantal workers opgeven

```bash theme={null}
php artisan octane:start --workers=4
```

Wil je bij Swoole ook taskworkers opgeven, dan doe je dat zo.

```bash theme={null}
php artisan octane:start --workers=4 --task-workers=6
```

### Bestandswijzigingen volgen

Tijdens de ontwikkeling worden bestandswijzigingen pas zichtbaar na een herstart van de server. Met de flag `--watch` herstart de server automatisch.

```bash theme={null}
php artisan octane:start --watch
```

<Warning>
  Voor `--watch` heb je [Node.js](https://nodejs.org) en Chokidar nodig.

  ```bash theme={null}
  npm install --save-dev chokidar
  ```
</Warning>

### Overige beheercommando's

```bash theme={null}
# Workers herladen (uitvoeren na een deploy)
php artisan octane:reload

# De server stoppen
php artisan octane:stop

# De status van de server controleren
php artisan octane:status
```

## Aandachtspunten bij dependency injection

Omdat Octane de applicatie in het geheugen houdt, worden **de `register`- en `boot`-methoden van service providers slechts één keer uitgevoerd, bij het opstarten van de server**. Dezelfde applicatie-instantie wordt hergebruikt tussen requests, dus wees voorzichtig wanneer je de container of de request in de constructor van een object injecteert.

```mermaid theme={null}
flowchart LR
    A["Server start<br>(één keer)"] --> B["ServiceProvider<br>register / boot"]
    B --> C["Applicatie-<br>instantie (geheugen)"]
    C --> D["Request 1"]
    C --> E["Request 2"]
    C --> F["Request 3..."]
```

### Injectie van de container

Injecteer je de container rechtstreeks in de constructor van een singleton, dan wordt een verouderde container hergebruikt.

```php theme={null}
// ❌ Problematisch voorbeeld — een verouderde container wordt hergebruikt
$this->app->singleton(Service::class, function (Application $app) {
    return new Service($app);
});

// ✅ Veilig voorbeeld — haal via een closure telkens de nieuwste container op
$this->app->singleton(Service::class, function () {
    return new Service(fn () => Container::getInstance());
});
```

De globale helper `app()` en `Container::getInstance()` geven altijd de meest recente container terug en zijn dus veilig.

### Injectie van de request

```php theme={null}
// ❌ Problematisch voorbeeld — een verouderde request wordt hergebruikt
$this->app->singleton(Service::class, function (Application $app) {
    return new Service($app['request']);
});

// ✅ Veilig voorbeeld — haal via een closure telkens de nieuwste request op
$this->app->singleton(Service::class, function (Application $app) {
    return new Service(fn () => $app['request']);
});

// ✅ Meest aanbevolen — geef alleen de benodigde waarden door aan de methode
$service->method($request->input('name'));
```

<Info>
  Het typehinten van `Illuminate\Http\Request` in controllermethoden of routeclosures is veilig. Ook de globale helper `request()` geeft altijd de huidige request terug.
</Info>

### Injectie van de configuration repository

```php theme={null}
// ❌ Problematisch voorbeeld — ook als configuratiewaarden wijzigen wordt de oude repository gebruikt
$this->app->singleton(Service::class, function (Application $app) {
    return new Service($app->make('config'));
});

// ✅ Veilig voorbeeld
$this->app->singleton(Service::class, function () {
    return new Service(fn () => Container::getInstance()->make('config'));
});
```

De globale helper `config()` geeft altijd de meest recente configuration repository terug en is dus veilig.

## Geheugenlekken voorkomen

Omdat Octane de applicatie in het geheugen houdt, ontstaan er geheugenlekken als je data ophoopt in bijvoorbeeld statische properties.

```php theme={null}
// ❌ Voorbeeld van een geheugenlek — $data blijft groeien bij elke request
class Service
{
    public static array $data = [];
}

public function index(Request $request): array
{
    Service::$data[] = Str::random(10);
    return [];
}
```

### Workers recyclen met max-requests

Je kunt geheugenlekken beperken door workers automatisch te laten herstarten nadat ze een bepaald aantal requests hebben verwerkt. De standaardwaarde is 500 requests.

```bash theme={null}
php artisan octane:start --max-requests=250
```

### De maximale uitvoeringstijd instellen

In `config/octane.php` kun je de maximale uitvoeringstijd van een request instellen. De standaardwaarde is 30 seconden.

```php theme={null}
'max_execution_time' => 30,
```

<Warning>
  Herstart de Octane-server nadat je `max_execution_time` hebt gewijzigd.
</Warning>

## Gelijktijdige taken (alleen Swoole)

Als je Swoole gebruikt, kun je met `Octane::concurrently()` meerdere bewerkingen gelijktijdig uitvoeren.

```php theme={null}
use App\Models\User;
use App\Models\Server;
use Laravel\Octane\Facades\Octane;

[$users, $servers] = Octane::concurrently([
    fn () => User::all(),
    fn () => Server::all(),
]);
```

Gelijktijdige taken worden uitgevoerd in aparte processen als "taskworkers" van Swoole. Het aantal taskworkers geef je op met `--task-workers`.

```bash theme={null}
php artisan octane:start --workers=4 --task-workers=6
```

<Warning>
  Je kunt maximaal 1024 taken doorgeven aan `concurrently` (een beperking van Swoole).
</Warning>

## Ticks en intervals (alleen Swoole)

Met Swoole kun je bewerkingen registreren die periodiek op een opgegeven interval worden uitgevoerd. Je registreert ze in de `boot`-methode van een service provider.

```php theme={null}
use Laravel\Octane\Facades\Octane;

// Elke 10 seconden uitvoeren
Octane::tick('delayed-ticker', fn () => ray('Ticking...'))
    ->seconds(10);

// Ook direct na het opstarten van de server meteen uitvoeren
Octane::tick('immediate-ticker', fn () => ray('Ticking...'))
    ->seconds(10)
    ->immediate();
```

## Octane-cache (alleen Swoole)

Een supersnelle in-memory cache op basis van [Swoole-tabellen](https://www.swoole.co.uk/docs/modules/swoole-table). Er zijn tot 2 miljoen lees- en schrijfbewerkingen per seconde mogelijk.

```php theme={null}
use Illuminate\Support\Facades\Cache;

Cache::store('octane')->put('framework', 'Laravel', 30);
```

### Intervalcache

Een cache die automatisch op een opgegeven interval wordt ververst.

```php theme={null}
use Illuminate\Support\Str;

Cache::store('octane')->interval('random', function () {
    return Str::random(10);
}, seconds: 5);
```

<Warning>
  Alle data in de Octane-cache wordt gewist wanneer je de server herstart.
</Warning>

## Swoole-tabellen (alleen Swoole)

Je kunt willekeurige in-memory tabellen definiëren die toegankelijk zijn vanuit alle workers. Je configureert ze via `tables` in `config/octane.php`.

```php theme={null}
'tables' => [
    'example:1000' => [
        'name' => 'string:1000',
        'votes' => 'int',
    ],
],
```

Voor toegang tot een tabel gebruik je de methode `Octane::table()`.

```php theme={null}
use Laravel\Octane\Facades\Octane;

Octane::table('example')->set('uuid', [
    'name' => 'Nuno Maduro',
    'votes' => 1000,
]);

$row = Octane::table('example')->get('uuid');
```

<Warning>
  In Swoole-tabellen kun je alleen de kolomtypen `string`, `int` en `float` gebruiken. De data verdwijnt bij een herstart van de server.
</Warning>

## Draaien in productie

### Configuratie met Nginx + Octane

In productie draai je Octane doorgaans achter Nginx. Nginx serveert de statische bestanden en handelt de SSL-terminatie af, en proxyt dynamische requests naar Octane.

```nginx theme={null}
map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

server {
    listen 80;
    server_name example.com;
    root /home/forge/example.com/public;

    location /index.php {
        try_files /not_exists @octane;
    }

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

    location @octane {
        set $suffix "";

        if ($uri = /index.php) {
            set $suffix ?$query_string;
        }

        proxy_http_version 1.1;
        proxy_set_header Host $http_host;
        proxy_set_header Scheme $scheme;
        proxy_set_header SERVER_PORT $server_port;
        proxy_set_header REMOTE_ADDR $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;

        proxy_pass http://127.0.0.1:8000$suffix;
    }
}
```

### Als daemon draaien met Supervisor

In productie houd je Octane continu actief met Supervisor.

```ini theme={null}
[program:octane]
process_name=%(program_name)s_%(process_num)02d
command=php /home/forge/example.com/artisan octane:start --server=frankenphp --host=127.0.0.1 --port=8000
autostart=true
autorestart=true
user=forge
redirect_stderr=true
stdout_logfile=/home/forge/example.com/storage/logs/octane.log
stopwaitsecs=3600
```

### HTTPS inschakelen

Om via Octane HTTPS-links te genereren, stel je het volgende in in `.env`.

```ini theme={null}
OCTANE_HTTPS=true
```

### Integratie met Laravel Cloud

[Laravel Cloud](https://cloud.laravel.com) ondersteunt Octane met FrankenPHP volledig managed. Je hebt geen Nginx- of Supervisor-configuratie nodig en kunt Octane in slechts twee stappen inschakelen.

<Steps>
  <Step title="De package installeren">
    Installeer Octane. Je mag het commando `octane:install` uitvoeren, maar dat is niet verplicht.

    ```bash theme={null}
    composer require laravel/octane
    ```
  </Step>

  <Step title="Octane inschakelen in Laravel Cloud">
    Open de instellingen van het App-computecluster van je omgeving, zet **"Use Octane as runtime"** aan en sla op en deploy. Laravel Cloud bouwt en start je applicatie automatisch met FrankenPHP + Octane.
  </Step>
</Steps>

Zie de [documentatie van Laravel Cloud](https://cloud.laravel.com/docs/compute#laravel-octane) voor meer details.

### Workers herladen na een deploy

Na een deploy herlaad je de workers om de nieuwe code in het geheugen te laden.

```bash theme={null}
php artisan octane:reload
```

## De lokale server opgeven voor `php artisan dev`

Na het installeren van Octane kan het gebeuren dat het `server`-proces van `php artisan dev` ook Octane gaat gebruiken. Wil je in productie op Laravel Cloud Octane gebruiken maar lokaal de reguliere `php artisan serve`, registreer dan het `server`-commando opnieuw in de `register`-methode van je `AppServiceProvider`.

```php theme={null}
use Illuminate\Foundation\DevCommands;

class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        DevCommands::artisan('serve', 'server');
    }
}
```

Wanneer je nu `php artisan dev` uitvoert, start het lokale `server`-proces met `php artisan serve`. Aan de kant van Laravel Cloud kun je Octane als runtime ingeschakeld laten.


## Related topics

- [Laravel Cloud — het complete beeld van de PaaS speciaal voor Laravel](/nl/blog/laravel-cloud.md)
- [Deployment](/nl/deployment.md)
- [Service container](/nl/service-container.md)
- [Laravel-updates van augustus 2026](/nl/blog/changelog/202608.md)
- [Laravel Telescope](/nl/telescope.md)