Laravel Octane

Laravel Octane - Co, jak i dlaczego

Taylor Otwell pokazał już najnowszy pakiet open source Laravela, Octane, podczas swojej rozmowy Laracon Online - ale dziś nowy pakiet jest dostępny na GitHub dla wszystkich do testów beta.

W tym poście na blogu zamierzam zbadać Laravel Octane i powiedzieć, co to jest, jak możesz go zainstalować i używać oraz dlaczego możesz go potrzebować.

Zrzeczenie się: Laravel Octane jest nadal oprogramowaniem beta i nie powinno być jeszcze używane w produkcji!

Co to jest Laravel Octane?

Laravel Octane to pakiet typu open source, który zwiększy wydajność aplikacji Laravel. Laravel Octane wymaga PHP 8, więc jeśli nadal korzystasz z 7.x, musisz zaktualizować swoją wersję PHP. Pod maską Octane korzysta z Swoole Swoole i RoadRunner RoadRunner - dwóch serwerów aplikacji, które zajmują się obsługą i uruchamianiem aplikacji Laravel. Dlaczego jest szybszy, możesz zapytać. Pozwólcie, że wyjaśnię.

W przypadku tradycyjnej aplikacji PHP, która jest obsługiwana przez serwer internetowy, taki jak nginx, każde przychodzące żądanie spowoduje powstanie procesu roboczego PHP-FPM. Oznacza to, że każde żądanie uruchamia jeden indywidualny proces PHP, który wykona wszystkie niezbędne zadania, aby obsłużyć to jedno żądanie.

W przypadku Laravela oznacza to, że Framework musi zostać uruchomiony, wszyscy dostawcy usług rejestrują swoje usługi w kontenerze, wszyscy dostawcy sami zostają uruchomieni, żądanie przechodzi przez listę klas oprogramowania pośredniczącego, trafia na kontroler, renderowany jest widok itp., Aż w końcu otrzymamy odpowiedź z naszego serwera.

Z Swoole Swoole lub RoadRunner RoadRunner na miejscu, nadal mamy proces roboczy dla każdego przychodzącego żądania HTTP, ale wszystkie one współużytkują tę samą rozruchową strukturę. Oznacza to, że tylko pierwsze przychodzące żądanie uruchomi framework (w tym wszystkich dostawców usług itp.), podczas gdy każde inne żądanie może następnie korzystać z gotowej do użycia struktury. I to właśnie sprawia, że Octane jest tak niesamowicie szybki.

Wprowadzenie do Laravel Octane Ponieważ Laravel Octane

jest pakietem, musisz go zainstalować jako zależność od konkretnej aplikacji. Możesz to zrobić za pomocą kompozytora:

composer require laravel/octane\

Po zainstalowaniu Octane w aplikacji upewnij się, że uruchomiłeś php artisan octane:install. Spowoduje to opublikowanie pliku konfiguracyjnego Octane, a także dodanie rr do pliku binarnego .gitignore RoadRunner RoadRunner.

Jak już powiedziałem, Octane opublikuje swój plik konfiguracyjny, który wygląda tak:

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.
    |
    */
    '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 Słuchacze
    |--------------------------------------------------------------------------
    |
    | 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 Swoole, you may leverage the Octane cache, which is powered
    | by a Swoole 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 Swoole Tables
    |--------------------------------------------------------------------------
    |
    | While using Swoole 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 Swoole server.
    |
    */
    'tables' => [
        'example:1000' => [
            'name' => 'string:1000',
            'votes' => 'int',
        ],
    ],
];

Następnie musisz sam zdecydować, czy chcesz użyć RoadRunner RoadRunnera, czy Swoole Swoole. Następnie można skonfigurować serwer aplikacji, który ma być używany, dostosowując server klucz w pliku konfiguracji. Może to być swoole, lub roadrunner.

RoadRunner RoadRunner

RoadRunner RoadRunner is an application server that is written in Go, that does not have any other dependencies within PHP itself. Choose RoadRunner RoadRunner, if you do not want to install additional PHP extensions. You can install RoadRunner RoadRunner through composer, like this:

composer require spiral/roadrunner

Swoole Swoole

Swoole Swoole comes with a couple of nice benefits, that RoadRunner RoadRunner can not provide. As Swoole Swoole is an extension on top of PHP, PHP itself gains some cool new features, such as "ticks" and "coroutines", which I'm going to cover in a bit. These features are not available with RoadRunner RoadRunner, so if you want to make use of them, you should go with Swoole Swoole.

You can install the Swoole Swoole extension using:

pecl install swoole

During the installation, you will be asked if you want to have support for HTTP2, curl, JSON, and open_ssl within Swoole Swoole. You can safely stick to the default values here (which are off) as those settings only affect things like coroutines. You will still be able to use curl, JSON, and everything else.

Uruchamianie Octane Po zainstalowaniu RoadRunner lub Swoole i zdefiniowaniu go w octane.php pliku konfiguracyjnym, możesz uruchomić Octane

Once you have installed RoadRunner RoadRunner or Swoole Swoole, and defined it in your octane.php configuration file, you can start Octane and let it serve your Laravel application. The Octane server can be started with:

php artisan octane:start

Domyślnie Octane uruchomi serwer na porcie 8000, więc możesz uzyskać dostęp do swojej aplikacji w przeglądarce za pośrednictwem http://localhost:8000.

Więc śmiało, odwiedź tę trasę i zobacz, jak Twoja aplikacja Laravel lata! Jeśli wysyłasz wiele żądań do aplikacji, możesz zobaczyć, że pierwszy z nich jest nieco wolniejszy - tam framework jest uruchamiany, podczas gdy pozostałe są zauważalnie szybsze, ponieważ mogą korzystać z uruchomionego frameworka z pamięci.

200 GET / .............. 14.23 ms
200 GET / ..............  1.93 ms
200 GET / ..............  2.06 ms

Wprowadzanie zmian w

kodzie Jeśli teraz wprowadzisz zmianę kodu - na przykład dodasz nową /test trasę - i spróbujesz trafić na ten adres URL, otrzymasz 404! A to dlatego, że żądanie nadal używa frameworka (i wszystkich jego tras / kodu), który został uruchomiony po uruchomieniu serwera Octane. Aby zobaczyć zmianę kodu, musisz ponownie uruchomić serwer Octane. Ponieważ jest to bardzo uciążliwe podczas programowania, Octane ma przyjemny sposób na automatyczne obserwowanie bazy kodu pod kątem zmian i automatyczne ponowne uruchomienie serwera Octane.

Aby to zadziałało, zainstaluj Chokidar - bibliotekę do obserwacji plików opartą na NodeJS: Następnie możesz uruchomić serwer Octane w trybie "watch", w ten sposób:

npm install --save-dev chokidar

php artisan octane:start --watch

Teraz następnym razem, gdy wprowadzisz zmianę w bazie kodu, zostanie to wykryte, a Octane zrestartuje procesy robocze dla żądań i natychmiast zobaczysz swoje zmiany.

Dostosowywanie pracowników

Mówiąc o pracownikach - domyślnie Octane uruchomi jednego pracownika dla każdego rdzenia procesora, który posiadasz. Ale możesz to również zmienić, przekazując --workers opcję do octane:start polecenia:

php artisan octane:start --workers=2

Swoole Specyficzne funkcje

As I mentioned, Octane comes with a couple of Swoole Specyficzne funkcje, so lets take a look at those, as I think they are very interesting.

Zadania

współbieżne Octane umożliwia jednoczesne wykonywanie wielu zadań. Oznacza to, że zostaną one wykonane w tym samym czasie i zostaną zwrócone, gdy tylko wszystkie zadania zostaną zakończone.

Oto przykład zaczerpnięty z dokumentacji Octane na GitHub:Here's an example taken from the Octane documentation on GitHub:Here's an example taken from the Octane documentation on GitHub:Here's an example taken from the Octane documentation on GitHub:Here's an example taken from the Octane documentation on GitHub:Here's an example taken from the Octane documentation on GitHub:

use App\User;
use App\Server;
use Laravel\Octane\Facades\Octane;
[$users, $servers] = Octane::concurrently([
    fn () => User::all(),
    fn () => Server::all(),
]);

Here's Aby to wyjaśnić, oto kolejny przykład: Wykonujemy dwa "zadania" jednocześnie, a PHP będzie kontynuować ocenę kodu,

Octane::concurrently([
	    function () {
		    	sleep(0.5);
		    	return 1;
	    },
	    function () {
		    	sleep(1);
		    	return 2;
	    },
	]);

gdy tylko oba zadania zostaną zakończone. Jedno zadanie czeka 0,5 sekundy, drugie 1 sekundę. Ponieważ są one oceniane równocześnie, w dwóch indywidualnych zadaniach, PHP będzie czekać dokładnie 1 sekundę (nie 1,5), aż oba wyniki będą dostępne. Ta funkcja to świetny sposób na jednoczesne wykonywanie wielu mniejszych zadań.

Podobnie jak opcja--workers, możesz również dostosować ilość--task-workers, którą Octane powinien udostępnić.

Ticki / Interwały

Octane in combination with Swoole Swoole, allows you to register ticks - which are operations that will automatically be executed at a given interval. Similar to the setInterval method in JavaScript. Unfortunately, there's no way to stop those ticks at the moment, but you can register them within your application like this:

Octane::tick('simple-ticker', fn () => ray('Ticking...'))
        ->seconds(10);

The Octane Cache

Another new feature within Octane and Swoole Swoole is a new cache driver. This cache driver, according to the official documentation, provides read and write speeds of up to 2 million operations per second. Behind the scenes, Swoole Swoole is caching the data in a shared memory using Swoole Swoole Tables, which can be accessed across all workers. When the server restarts, the cached data will be flushed though, as the cache is only persisted in memory.

Aby skorzystać z tej pamięci podręcznej, możesz uzyskać do niej dostęp za pośrednictwem octane magazynu pamięci podręcznej na fasadzie pamięci podręcznej, w następujący sposób:

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

Another cool new addition, that is Swoole Swoole and Octane specific is the ability of a "cache interval". This allows you to store information in the Octane cache and refresh the data in a given interval:

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

Tabele oktanowe Opierając się na funkcji tabel Swoole, możesz tworzyć własne tabele

Built upon the feature of Swoole Swoole Tables, you can create your own tables that you want to access within your Octane applications. These tables have the same performance benefit as a Cache would have, by allowing you to save data in a structured way. Keep in mind that all data that you store within such a table will be lost when the server restarts though.

Aby skonfigurować tabelę, możesz utworzyć wpis w tables sekcji octane.php pliku konfiguracyjnego:

'tables' => [
    'example:1000' => [
        'name' => 'string:1000',
        'votes' => 'int',
    ],
],

W tym przykładzie definiujemy tabelę o nazwie example, która może pomieścić maksymalnie 1.000 wpisów/wierszy. Struktura tej tabeli to name, który jest ciągiem o maksymalnej długości 1000, oraz votes, który jest liczbą całkowitą.

Aby zapisać dane do tej tabeli, możemy skorzystać z Octane::table metody:

use Laravel\Octane\Facades\Octane;
Octane::table('example')->set('a-unique-identifier', [
    'name' => 'Marcel Pociot',
    'votes' => 1000,
]);

Aby wyciągnąć dane, możemy użyć get metody na stole, takiej jak:

return Octane::table('example')->get('a-unique-identifier');

Ostrzeżenia z Octane Jest kilka rzeczy, na które musisz uważać, gdy chcesz przygotować istniejącą aplikację do Octane

lub zacząć budować nową aplikację od zera.

Ponieważ Octane przechowuje framework w pamięci wszystkich pracowników, rzeczy takie jak wszyscy dostawcy usług aplikacji zostaną zarejestrowani i uruchomieni tylko raz. Podczas gdy Octane zajmuje się resetowaniem stanu pakietów własnych (co obejmuje inercję), nie jest możliwe, aby Octane zresetował stan globalny, który możesz mieć we własnym kodzie aplikacji.

Oficjalna dokumentacja, którą obecnie można znaleźć na GitHubie , zawiera jedne z najczęstszych scenariuszy, na które należy uważać.

Słuchacze

Jedną z cech Octane, która nie została jeszcze udokumentowana, jest możliwość rejestrowania niestandardowych słuchaczy, gdy coś dzieje się na serwerze aplikacji w Octane. Możesz dołączyć do następujących zdarzeń:

• PracownikRozpoczęcie pracy
• RequestReceived
• RequestHandled
• RequestTerminated
• ZadanieOdebrane
• TickReceived
• OperationTerminated
• WorkerErrorOccurred
• WorkerStop

Aby dołączyć detektory do tych zdarzeń, możesz dodać je do octane.php pliku konfiguracyjnego.

Ocieplanie i płukanie

usług Gdy nowy proces roboczy Octane zostanie uruchomiony, możesz określić listę powiązań / usług kontenera, które chcesz "rozgrzać" podczas procesu rozruchu. Oznacza to, że po uruchomieniu procesu roboczego kontener usług będzie już udostępniał określone usługi, dzięki czemu następujące żądania będą mogły natychmiast uzyskać do nich dostęp.

Octane ma już listę usług wewnętrznych, które utrzymuje ciepło podczas każdego procesu uruchamiania roboczego, ale możesz dodać własne usługi do warm sekcji pliku konfiguracyjnego octane.php .

Podobnie jak w ten sposób, można również zdefiniować listę usług, które mają zostać opróżnione, zanim nadejdzie nowe żądanie. Może to być przydatne w przypadku usług, które są manipulowane w trakcie żądania, które chcesz zresetować do stanu pierwotnego/niezaładowanego, gdy nadejdzie nowe żądanie.

Trasy

oktanowe Jeśli Octane nie zapewnia jeszcze wystarczającego zwiększenia prędkości, możesz nawet wycisnąć z niego trochę więcej, korzystając z routingu wbudowanego w Octane. Możesz zdefiniować niestandardową trasę Octane przez fasadę Octane w następujący sposób:Te trasy są bardzo szybkie, ponieważ całkowicie pomijają system routingu Laravels (więc te trasy nie zapewniają żadnego oprogramowania pośredniczącego) - co może być pomocne w przypadku punktów końcowych,

Octane::route('GET', '/fast', function() {
    
});

które muszą tylko szybko dostarczać dane.

Ponieważ jądro HTTP w Laravel nie jest używane do tych żądań, musisz sam zwrócić obiekt odpowiedzi Symfony, w ten sposób:

use Symfony\Component\HttpFoundation\Response;
Octane::route('GET', '/faster', function() {
    return new Response('Hello from Octane.');
});

Wszyscy dostawcy usług są oczywiście uruchomieni i dostępni, abyś mógł nadal korzystać z tych usług, wykonywać zapytania Eloquent, itp.

Porządku... więc dlaczego Octane?

Laravel Octane zdecydowanie zwiększy wydajność Twojej aplikacji Laravel - a wszyscy kochamy wzrost wydajności, prawda? Czy rzeczywiście potrzebujemy tego zwiększenia wydajności? Cóż, może - myślę, że to zależy od aplikacji, którą uruchamiasz. Ale ważniejsze dla mnie jest to, że Laravel (po raz kolejny) forsuje obecny stan PHP. Octane jest nie tylko pakietem, który wymaga co najmniej PHP 8, ale także wprowadza ekscytujące nowe funkcje w świecie PHP, takie jak coroutines, ticks i ogólnie sposób myślenia o obsłudze własnej aplikacji za pomocą polecenia rzemieślniczego.

Jestem podekscytowany przyszłością Octane!