Laravel Octane

Taylor Otwell nous avait déjà montré un aperçu de son dernier package de laravel: Octane lors de la dernière Laracon Online.

Le nouveau package est disponible sur GitHub

Attention cependant, si vous souhaitez utiliser ce package, il n’est encore disponible que dans sa version bêta.

Qu’est ce que c’est Laravel Octane ?

Laravel Octane est un projet open source qui augmentera les performances de votre application. Si vous êtes toujours sur une version antérieur à PHP8, vous allez devoir mettre à jour votre version de php. Laravel Octane nécessite PHP8.

Ce package utilise Swoole et RoadRunner deux serveur d’applications qui vont se charger de démarrer votre application Laravel

Qu’est ce que ca change réellement ?

Une application standard qui utilise Apache ou Nginx, va générer un worker PHP-FPM (FastCGI Process Manager) pour chaque requête entrante. Ce qui signifie que chaque requête nécessite un nouveau processus individuel.

Dans le cas de Laravel , cela signifie qu’il doit démarrer tous les services providers, enregistrer les services dans les containers, la requête va passer par tous les middlewares avant d’arriver à votre controller avant d’être rendu à l’utilisateur.

Avec Swoole et RoadRunner, nous avons toujours un worker pour chaque requête HTTP, cependant ses worker partagerons tous un l’instance de Laravel démarré. Cela signifie, que la première requête se chargera de démarré l’application et que les autres utiliserons la même instance.

Installation

Laravel Octane étant un package on peut l’installé via la commande suivante :

composer require laravel/octane

Après l’avoir téléchargé au sein de votre projet, n’oubliez pas de l’installer

php artisan octane:install

Il va générer un fichier de configuration config/octane.php

Le fichier de configuration publié est le suivant :

return [
    /*
    |--------------------------------------------------------------------------
    | Octane Server
    |--------------------------------------------------------------------------
    |
    | This value determines the default "server" that will be used by Octane
    | when starting, restarting, or stopping your server via the CLI. You
    | are free to change this to the supported server of your choosing.
    |
    | Supported: "roadrunner", "swoole"
    |
    */

    'server' => env('OCTANE_SERVER', 'roadrunner'),

    /*
    |--------------------------------------------------------------------------
    | Force HTTPS
    |--------------------------------------------------------------------------
    |
    | When this configuration value is set to "true", Octane will inform the
    | framework that all absolute links must be generated using the HTTPS
    | protocol. Otherwise your links may be generated using plain HTTP.
    |
    */
    
    'https' => env('OCTANE_HTTPS', false),
    
    /*
    |--------------------------------------------------------------------------
    | Octane Listeners
    |--------------------------------------------------------------------------
    |
    | All of the event listeners for Octane's events are defined below. These
    | listeners are responsible for resetting your application's state for
    | the next request. You may even add your own listeners to the list.
    |
    */
    'listeners' => [
        WorkerStarting::class => [
            EnsureUploadedFilesAreValid::class,
        ],
        RequestReceived::class => [
            ...Octane::prepareApplicationForNextOperation(),
            ...Octane::prepareApplicationForNextRequest(),
        ],
        RequestHandled::class => [
            //
        ],
        RequestTerminated::class => [
            //
        ],

        TaskReceived::class => [
            ...Octane::prepareApplicationForNextOperation(),
            //
        ],

        TickReceived::class => [
            ...Octane::prepareApplicationForNextOperation(),
            //
        ],

        OperationTerminated::class => [
            FlushTemporaryContainerInstances::class,
            // DisconnectFromDatabases::class,
            // CollectGarbage::class,
        ],

        WorkerErrorOccurred::class => [
            ReportException::class,
            StopWorkerIfNecessary::class,
        ],

        WorkerStopping::class => [
            //
        ],
    ],

    /*
    |--------------------------------------------------------------------------
    | Warm / Flush Bindings
    |--------------------------------------------------------------------------
    |
    | The bindings listed below will either be pre-warmed when a worker boots
    | or they will be flushed before every new request. Flushing a binding
    | will force the container to resolve that binding again when asked.
    |
    */

    'warm' => [
        ...Octane::defaultServicesToWarm(),
    ],

    'flush' => [
        //
    ],
    /*
    |--------------------------------------------------------------------------
    | Garbage Collection Threshold
    |--------------------------------------------------------------------------
    |
    | When executing long-lived PHP scripts such as Octane, memory can build
    | up before being cleared by PHP. You can force Octane to run garbage
    | collection if your application consumes this amount of megabytes.
    |
    */

    'garbage' => 50,

    /*
    |--------------------------------------------------------------------------
    | Maximum Execution Time
    |--------------------------------------------------------------------------
    |
    | (info) 0 means no maximum limit
    |
    */

    ‘max_execution_time’ => 30,

    /*
    |—————————————————————————————————————
    | Octane Cache Table
    |—————————————————————————————————————
    |
    | While using Swoole, you may leverage the Octane cache, which is powered
    | by a Swoole table. You may set the maximum number of rows as well as
    | the number of bytes per row using the configuration options below.
    |
    */

    ‘cache’ => [
        ‘rows’ => 1000,
        ‘bytes’ => 10000,
    ],

    /*
    |—————————————————————————————————————
    | Octane Swoole Tables
    |—————————————————————————————————————
    |
    | While using Swoole, you may define additional tables as required by the
    | application. These tables can be used to store data that needs to be
    | quickly accessed by other workers on the particular Swoole server.
    |
    */

    ‘tables’ => [
        ‘example:1000’ => [
            ‘name’ => ‘string:1000’,
            ‘votes’ => ‘int’,
        ],
    ],
];

Vous devez maintenant décider si vous allez utilisé RoadRunner ou bien Swoole.

RoadRunner

RoadRunner est un serveur d’application écrit en Go qui n’a aucune autre dépendance. Choisissez d’utiliser RoadRunner si vous ne souhaitez pas installer d’autre package.

Swoole

Swoole quant a lui nous livre quelques avantages. En effet si vous souhaitez utiliser les «ticks» ou les «coroutines».

Démarrage

Une fois que vous avez choisis votre serveur d’application, vous pouvez lancer Octane avec la commande suivante :

php artisan octane:start

Par défaut Octane va démarrer sur le port 8000. Rendez vous ensuite sur la page http://localhost:8000 et faite plusieurs requêtes.

Vous devriez apercevoir les différents temps de réponse pour chacune de vos requête. Comme vous pouvez le constater la première est plus longue puisqu’elle permet de démarrer l’application. Les autres utilisant la même instance du framework sont donc beaucoup plus rapides.

200 GET / ………….. 13.23 ms
200 GET / …………..  1.83 ms
200 GET / …………..  2.16 ms

Pour toutes informations complémentaires vous trouverez la documentation sur le GitHub du package : Laravel Octane