Shulou(Shulou.com)06/03 Report--

This article mainly introduces "what is Laravel Octane". In daily operation, I believe many people have doubts about what is Laravel Octane. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful for you to answer the doubts about "what is Laravel Octane?" Next, please follow the editor to study!

What is Laravel Octane?

Laravel Octane is an open source package that can improve the performance of your Laravel applications. Laravel Octane requires PHP 8, and if you are still using 7.x, you need to upgrade your version of PHP. At the bottom, Octane uses two application servers, Swoole and RoadRunner, to serve and start your Laravel program.

For traditional PHP applications that are serviced through a network server such as nginx, each incoming request generates a PHP-FPM worker. This means that each request starts a separate PHP process that runs all the necessary tasks to service the request.

In the case of Laravel, this means that you need to start the framework, all service providers register their services in the container, all providers start themselves, request through the middleware class list, hit your controller, render the view, and so on. Until we finally get a response from our server.

With Swoole or RoadRunner, we still provide a worker thread for each incoming HTTP request, but they all share the same boot framework. This means that only the first incoming request will guide the framework (including all service providers, etc.). All other requests can use a ready-made framework. That's why Octane is so fast.

Start using Laravel Octane

Because Laravel Octane is a package, you need to install it as a dependency for a particular application. You can install it through composer:

Composer require laravel/octane

After installing Octane in your application, be sure to run php artisan octane:install. This publishes the configuration file for Octane and adds the rr-RoadRunner binary to the .gitignore file.

As I said, Octane will publish its configuration file, as follows:

Return [/ * |-| Octane server |-- -| | this value determines whether Octane is started through CLI, | the default "server" that will be used when restarting or stopping the server. | you can change it to a supported server of your choice at will. | | * / 'server' = > env (' OCTANE_SERVER', 'roadrunner') | / * |-| mandatory HTTPS |-- -- | | when the configuration value is set to "true" | Octane will notify the framework that the link must be generated using HTTPS protocol. | otherwise, your links may be generated using normal HTTP. | | * / 'https' = > env (' OCTANE_HTTPS', false) | / * |-- | Octane listener | -| | all event listeners for Octane events are defined as follows | these listeners are responsible for resetting the state of the application for the next request. | you can 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 = > [/ /] / * |-| preheat / refresh binding | -| | the bindings listed below either warm up when the worker process starts | either refresh before each new request. | Refresh the binding will force the container to parse the binding again when requested. | | * / 'warm' = > [... Octane::defaultServicesToWarm (),],' flush' = > [/ /] | / * |-| garbage collection threshold |-- -| | when executing long-standing PHP scripts such as Octane | memory may accumulate before being cleared by PHP. | if your application consumes this number of megabytes, | you can force Octane to run garbage collection. | | * / 'garbage' = > 50 | / * |-| maximum execution time | -- | | (prompt) 0 means there is no maximum time limit | * / 'max_execution_time' = > 30 / * |-| Octane cache table |-- -| | when using Swoole | you can take advantage of Octane cache supported by Swoole table. | you can use the following configuration options to set the maximum number of rows and the number of bytes per row. | | * / 'cache' = > [' rows' = > 1000, 'bytes' = > 10000,] | / * |-| Octane Swoole table |-- -| | when using Swoole | you can define additional tables according to the needs of your application. | these tables can be used to store data that other staff on a specific Swoole server need to access quickly. | | * / 'tables' = > [' example:1000' = > ['name' = >' string:1000', 'votes' = >' int',],]] |

Next, you need to decide whether to use RoadRunner or Swoole, and then you can configure the application server to use by customizing the server key in the configuration file. This can be swoole or roadrunner.

RoadRunner

RoadRunner is an application server written in Go that does not have any other dependencies on PHP itself. If you do not want to install additional PHP extensions, select RoadRunner. You can install RoadRunner through composer, as follows:

Composer require spiral/roadrunnerSwoole

Swoole brings some benefits that RoadRunner cannot provide. Because Swoole is an extension on top of PHP, PHP itself has some cool new features, such as "ticks" and "co-programming", which I will introduce later. RoadRunner doesn't have these features, so if you want to use them, you should use Swoole.

You can install the Swoole extension using the following methods:

Pecl install swoole

During installation, you will be asked if you want to support HTTP2, curl, JSON and open_ssl in Swoole. You can safely use the default values here (that is, off) because these settings only affect things like collaborators.

Start Octane

Once you have installed RoadRunner or Swoole and defined it in your octane.php configuration file, you can start Octane and have it serve your Laravel application.

Php artisan octane:start

By default, Octane starts the server on port 8000 because you can access your application in the browser through http://localhost:8000.

Go ahead, visit the route and view the Laravel application! If you make multiple requests, you will see that the first request is slightly slower because this is where the framework starts, while the other requests are significantly faster because they can use the booted framework from memory.

200 GET /. 14.23 ms200 GET /. 1.93 ms200 GET /. 2.06 ms change Code

If you add a new / test route now-and try to access it, you will receive a 404 response! This is because the request is to access the framework (and all its routes / code) in the memory of the Octane service. Therefore, in order to see the code changes, you need to restart the Octane service. This leads to a lot of hassle in the development process, so Octane provides a good way to automatically monitor changes to the code base and restart Octane services automatically.

To do this, be sure to install Chokidar, the NodeJS-based file monitoring library:

Npm install-save-dev chokidar

You can then start the Octane server in "watch" mode, as follows:

Php artisan octane:start-watch

Now, the next time you make changes to the code base, the system will detect this, Octane will restart the working program for the request, and you can see your changes immediately.

Custom Workers

Speaking of Workers, by default, Octane will launch a worker for each CPU kernel you own, but you can also change this by passing the octane:start command with the-- workers option:

Php artisan octane:start-workers=2Swoole specific function

As mentioned in the article, Octane has some Swoole-specific features, which I think are very interesting, so let's take a look at them.

Concurrent task

Octane can perform multiple tasks at the same time. They are executed at the same time and return immediately after all tasks are completed.

The following is an example from the Octane document on GitHub:

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

In this example, we get all users and all services at the same time. To prove that they are executed at the same time, this is another example:

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

We perform two "tasks" at the same time, and once they are complete, PHP will continue to execute the code. One task waits for 0.5 seconds and the other waits for 1 second. Because they are executed at the same time, in two separate tasks, PHP waits for 1 second (not 1.5 seconds) until both results are available. This feature is an excellent way to perform multiple smaller tasks at the same time.

Just like the-- workers option, you can also customize the number of-- task-workers provided by Octane.

Ticks / interval

Octane, in conjunction with Swoole, allows you to register for ticks-these operations are performed automatically at a given interval. Similar to the setInterval method in JavasScript. Unfortunately, you cannot stop these ticks at this time, but you can register them in your application like this:

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

Another new feature in Octane and Swoole is the new cache driver. According to official documentation, this cache driver provides read and write speeds of up to 2 million operations per second. Behind the scenes, Swoole uses the Swoole table to cache data in shared memory, which is accessible to all workers. When the server restarts, the cached data is flushed because the cache remains only in memory.

To use this cache, you can access it through the otance cache store of the Cache facade, as follows:

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

Another cool addition, Swoole and Octane, is the "cache interval" capability. This allows you to store the information in the Octane cache and refresh the data at a given interval:

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

Based on the functionality of Swoole tables, you can create tables that you want to access in your Octane application. These tables have the same performance advantages as caching, allowing you to save data in a structured manner. Keep in mind that when the server restarts, all data you store in this table is lost.

To configure the table, you can create an entry in the tables section of the octane.php configuration file:

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

In the example, we define a table named example that can hold up to 1.000 entries / rows. The structure of the table is a name, which has a maximum length of 1000 strings, whereas votes, which is an integer.

To write the data to a table, we can use the Octane::table method:

Use Laravel\ Octane\ Facades\ Octane;Octane::table ('example')-> set (' a murmur Unique identifiers, ['name' = >' Marcel Pociot', 'votes' = > 1000,])

To fetch the data, we can use the get method on the table, as follows:

Return Octane::table ('example')-> get (' a murmurUniqueMutual identifier'); matters needing attention of Octane

There are a few things you need to be aware of when you want to prepare an existing application for Octane or build a new application from the beginning.

Because Octane keeps the framework in memory for all workers, all things like application service providers are registered and started only once. However, it is not possible for Octane to reset the global state that you might have in your application code.

The official documentation currently available on GitHub contains some of the most common scenarios you should pay attention to.

Listener

One of the undocumented features of Octane is that custom listeners can be registered whenever something happens in the application server within Octane. You can monitor the following events:

WorkerStarting

RequestReceived

RequestHandled

RequestTerminated

TaskReceived

TickReceived

OperationTerminated

WorkerErrorOccurred

WorkerStopping

To attach listeners to these events, you can add them to your octane.php configuration file.

Service warm-up and refresh

When a new Octane worker starts, you can specify a list of container bindings / services to "warm up" during startup. This means that when Worker starts, the service container will have made the specified services available so that subsequent requests can access them immediately.

Octane already has an internal list of services that remains hot loaded as each worker program starts, or you can add your own services to the warm section of the octane.php configuration file.

Similarly, you can also define a list of services to refresh before a new request enters. This is useful for services that are manipulated during the request, and when a new request comes in, you want to reset it to the original / unloaded state.

Octane routing

If Octane doesn't give you enough speed, you can use Octane's built-in routing to further speed up. You can customize the route through Octane, as follows:

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

These routes are very fast because they completely skip Laravel's routing system (so these routes do not provide any type of middleware)-this is helpful for endpoints that only need to provide data quickly.

Since the HTTP kernel in Laravel is not used for these requests, you need to return a Symfony Response object yourself, as shown below:

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

Of course, all service providers are started and available, so you can still use these services to perform Eloquent queries, and so on.

Well. Then why Octane?

Laravel Octane is sure to bring huge performance improvements to your Laravel applications-we all like performance improvements, don't we? Do we really need this performance improvement? Well, maybe-I think it depends on the application you're running. But what is more important to me is that Laravel is (again) driving the current state of PHP. Octane is not only a package that requires at least PHP 8, but it also introduces exciting new features in the PHP world, such as collaboration, ticks, and the mindset of using artisan commands to serve your application.

At this point, the study of "what is Laravel Octane" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.