Laravel Octane

Overview: Why Long-Running PHP Matters Most developers view PHP through the lens of PHP-FPM. This traditional model follows a "shared-nothing" architecture: a request arrives, the entire framework boots from scratch, the request is served, and the process dies. While this ensures a clean state and prevents memory leaks from accumulating, it introduces significant overhead. As applications scale, the milliseconds spent booting service providers and loading configuration files add up. Laravel Octane flips this script. It serves your application using high-performance runtimes that boot the framework once and keep it in memory to handle subsequent requests. This transition from short-lived scripts to long-running processes allows for "supersonic" speeds by eliminating the boot cycle. Understanding Octane isn't just about knowing how to install the package; it requires a mental shift regarding concurrency, I/O blocking, and state management. Prerequisites: Fundamentals of PHP Execution Before exploring Octane, you should have a solid grasp of how PHP interacts with web servers like Nginx. You should understand the difference between synchronous execution (tasks happening one after another) and parallel execution (multiple tasks happening at once on different CPU cores). Familiarity with Laravel service providers and the request/response lifecycle is essential, as Octane fundamentally alters how these components persist in memory. Key Libraries & Tools * **Swoole**: A high-performance networking framework for PHP written in C and C++. It provides event loops and coroutines. * **FrankenPHP**: A modern PHP app server written in Go. It integrates with the Caddy web server and supports features like early hints. * **RoadRunner**: An open-source, high-performance PHP application server and load balancer written in Go. * **Laravel Octane**: The abstraction layer that allows Laravel applications to interface with the runtimes above without changing core application logic. Code Walkthrough: How Octane Manages State Octane serves as an adapter between the runtime and Laravel. When a request hits a worker, Octane must ensure the application feels "fresh" even though it is actually a long-lived instance. It achieves this by cloning the application instance into a sandbox for every request. ```php // Conceptual representation of Octane's request handling $app = $worker->getApplication(); // The warm, booted instance $worker->onRequest(function ($request) use ($app) { // Clone the app to prevent state pollution across requests $sandbox = clone $app; // Convert the runtime-specific request to a Laravel request $laravelRequest = Request::createFromBase($request); // Handle the request through the sandbox $response = $sandbox->handle($laravelRequest); // Send response back to the runtime client return $response; }); ``` In this walkthrough, notice that the `$app` instance is booted only once when the worker starts. The `clone` operation is significantly faster than a full framework boot. Octane also listens for worker start events to prepare this state. In Swoole, this looks like a typical event-driven registration: ```php $server->on('workerStart', function ($server, $workerId) { // Octane boots the framework here and stores it in worker state $this->bootWorker($workerId); }); ``` Leveraging Concurrency with Task Workers One of Octane's most powerful features is the ability to execute tasks concurrently. In standard PHP, if you need to fetch data from three different APIs, you wait for each one sequentially. With Octane's concurrency support—specifically through Swoole—you can resolve multiple callbacks simultaneously. ```php [$users, $orders, $stats] = Octane::concurrently([ fn () => ExternalApi::getUsers(), fn () => ExternalApi::getOrders(), fn () => ExternalApi::getStats(), ]); ``` Behind the scenes, Octane offloads these closures to "task workers." These are separate processes that execute the code and return the results to the main request worker. The total time for the operation becomes the duration of the slowest task rather than the sum of all tasks. This is a game-changer for dashboards or data-heavy endpoints. Syntax Notes & Architectural Patterns * **Closures**: Octane relies heavily on closures to wrap logic that should execute per-request versus logic that executes at boot time. * **Dependency Injection**: You must be careful with injecting the `$request` object into long-lived singleton constructors. Because the singleton persists, it might hold onto the first request it ever saw, leading to stale data. * **Super Globals**: Octane abstracts away `$_GET`, `$_POST`, and `$_SERVER`. You should always use Laravel's request objects to ensure compatibility across different runtimes. Practical Examples: High-Traffic Optimization Octane shines in scenarios where response latency is critical. Consider a route that only serves data from Redis. In a standard environment, the PHP boot process might take 20ms, while the Redis query takes 1ms. You spend 95% of your time just starting the engine. With Octane, that 20ms boot time disappears after the first request, allowing the endpoint to respond in nearly real-time. Infrastructure cost reduction is another practical application. Because each worker spends less time waiting for I/O and no time on redundant boot cycles, a single server can handle significantly higher throughput, allowing you to scale down your horizontal footprint. Tips & Gotchas: Avoiding Memory Leaks and Stale State The biggest pitfall in Octane is "polluted state." If you store data in a static variable or a singleton during a request, that data remains there for the next user. Octane attempts to flush core Laravel state (like the authenticated user and session) automatically, but it cannot know about your custom static caches. **Best Practices:** 1. **Restart Workers**: Configure Octane to restart workers after a set number of requests (e.g., 500) to clear any minor memory leaks. 2. **Avoid Static Properties**: Don't use static properties to cache request-specific data. 3. **Test in Octane**: Always run your test suite against an Octane-like environment if you plan to deploy it, as state issues won't appear in standard PHPUnit runs.

Overview Livewire provides a powerful way to build dynamic interfaces without leaving the Laravel ecosystem. However, as applications scale, developers often hit performance bottlenecks or security oversights. This tutorial breaks down advanced techniques to optimize your data handling, manage global latency, and secure your public properties using modern Livewire patterns. Prerequisites To follow this guide, you should have a firm grasp of PHP and the Laravel framework. Familiarity with Livewire basics—like components, properties, and actions—is essential. You should also understand basic database concepts like read/write replicas and caching. Key Libraries & Tools * Livewire: A full-stack framework for Laravel that makes building dynamic interfaces simple. * Wire Extender: A package allowing Livewire components to be embedded in static HTML or other frameworks. * Laravel Octane: Supercharges Laravel performance by keeping the application in memory. * Laravel Cached Database Stickiness: Ensures consistency when using read/write database replicas. * Livewire Strict: A security-focused package that locks all public properties by default. Optimizing Component Payloads One of the most common mistakes in Livewire development is assigning large datasets to public properties. Because Livewire stores public data on the client side in a snapshot, passing 600 users as a public array forces the browser to process massive JSON objects on every request. This leads to "UI freeze" during the morphing process. Instead of public properties, use the `#[Computed]` attribute. This keeps data on the server and caches it for the duration of the request. ```python use Livewire\Attributes\Computed; #[Computed] public function users() { return User::all(); } ``` To further boost speed for actions that don't change the UI, apply the `#[Renderless]` attribute. This skips the entire DOM morphing cycle, slashing response times. ```python use Livewire\Attributes\Renderless; #[Renderless] public function assignCountry($userId, $countryId) { User::find($userId)->update(['country_id' => $countryId]); } ``` Managing Global Latency and Read Replicas When your users are global but your database sits in Europe, latency kills the user experience. You can slash response times by deploying servers near your users and using read replicas. To handle the "replication lag" where a user creates a post but can't see it immediately because the read replica hasn't updated, use Laravel Cached Database Stickiness. This package ensures that once a user performs a "write" operation, their subsequent "read" requests stick to the primary database for a few seconds, preventing 404 errors during the sync window. Secure Your Properties with Locking Public properties in Livewire are open by design. An attacker can use the browser's console to call `Livewire.find(id).set('userId', 2)` and potentially view data they shouldn't. To prevent this, always use the `#[Locked]` attribute for sensitive data that should not be modified by the client. ```python use Livewire\Attributes\Locked; #[Locked] public $userId; ``` If you want to be safe by default, Livewire Strict reverses the framework's behavior by locking everything and requiring an `#[Unlocked]` attribute for properties intended for data binding. Syntax Notes and Best Practices * **Child Components**: For large tables, move row logic into child components. Livewire will only re-render the specific component that changed, keeping the rest of the page static. * **Optimistic UI**: Use `wire:loading.remove` combined with `wire:target` to hide elements instantly when an action starts. This makes the app feel faster than the network actually is. * **Component Hooks**: You can extend Livewire globally by using `Livewire::componentHook()`. This allows you to inject logic into every component's lifecycle without using traits. Practical Examples Imagine a high-traffic dashboard. By moving the data fetching to computed properties and splitting the rows into child components, you can reduce a 1.6MB payload to just a few kilobytes. Adding Cloudflare Argo and Laravel Octane on top of this architectural change can bring response times from seconds down to under 100 milliseconds.

Overview Laravel Octane boosts your application performance by serving requests using high-performance application servers. By keeping your application in memory, it eliminates the overhead of booting the framework on every request. The newest addition to the Octane ecosystem is FrankenPHP, a modern server written in Go that offers exceptional speed and features like automatic HTTPS. This integration represents a massive leap forward for developers seeking sub-millisecond response times. Prerequisites Before moving forward, ensure you have the following in your environment: * PHP 8.2 or higher * Composer for package management * Basic familiarity with the Laravel directory structure * A terminal environment capable of running binary files Key Libraries & Tools * **Laravel Octane**: The core package that integrates high-performance servers with Laravel. * **FrankenPHP**: A modern PHP app server built on top of the Caddy web server. * **Pest**: A testing framework focused on simplicity and speed. * **Pest Stressless**: A plugin for Pest used to perform stress testing and performance benchmarking. Code Walkthrough First, initialize a new project. We skip the starter kits to keep the setup lean and choose SQLite for rapid prototyping. ```bash laravel new my-octane-app ``` Next, install the Octane package via Composer. This provides the necessary scaffolding to bridge Laravel and FrankenPHP. ```bash composer require laravel/octane ``` Now, run the installation command. When prompted for the server type, select `frankenphp`. The installer automatically downloads the necessary FrankenPHP binary for your architecture. ```bash php artisan octane:install ``` Finally, fire up the server. You will receive a local URL where your application is now running in a persistent state. ```bash php artisan octane:start ``` Syntax Notes When using Pest Stressless to verify performance, the syntax is remarkably clean. Running `./vendor/bin/pest stress http://localhost:8000 --concurrency=5` tells the plugin to hit the endpoint with five simultaneous users. Note how the CLI output provides real-time feedback on request duration and successful hits. Practical Examples In a standard setup, a single request might take 30-50ms to boot the framework. With FrankenPHP and Octane, benchmark results show response times as low as 0.93ms. This is ideal for high-traffic APIs or real-time dashboards where latency must be kept to an absolute minimum. Tips & Gotchas Since Octane keeps your app in memory, global variables or static properties do not reset between requests. Always use dependency injection or the `Octane::forget` method to clear state. If you make code changes, remember that Octane needs to restart to pick them up, or you can use the `--watch` flag during development.