# 2026'da Laravel Octane: Swoole, RoadRunner ve Performans Optimizasyonu

> Laravel Octane hakkında kapsamlı rehber. Swoole ve RoadRunner karşılaştırması, performans optimizasyon teknikleri, production yapılandırması ve mülakat soruları.

- Published: 2026-09-11
- Updated: 2026-09-11
- Author: Anthony Fillion-Maillet
- Tags: laravel, octane, swoole, roadrunner, php, performans
- Reading time: 12 min

---

Laravel Octane, yüksek performanslı uygulama sunucuları olan Swoole ve RoadRunner desteğiyle PHP uygulamalarının performansına devrim getirdi. 2026 yılında Octane, saniyede binlerce istek işlemesi gereken Laravel uygulamaları için standart çözüm haline geldi. Bu makale Octane mimarisini analiz ediyor, mevcut motorları karşılaştırıyor, optimizasyon tekniklerini tartışıyor ve teknik mülakatlarda sıkça sorulan soruları sunuyor.

> **Laravel Octane Nedir?**
>
> Laravel Octane, Laravel uygulamalarını yüksek performanslı uygulama sunucularında çalıştırarak süper hızlandıran birinci taraf resmi pakettir. Her isteğin yeni bir PHP süreci başlattığı geleneksel PHP-FPM modelinin aksine, Octane uygulamayı bellekte tutar ve istekleri kalıcı worker süreçleri içinde işler. Sonuç olarak gecikme dramatik şekilde azalır ve throughput önemli ölçüde artar.

## Laravel Octane Mimarisi: Nasıl Çalışır

Geleneksel PHP yığını Nginx ve PHP-FPM ile her isteği yeni bir PHP süreci başlatarak, framework'ü yükleyerek, isteği işleyerek ve süreci sonlandırarak işler. Bu yaşam döngüsü, özellikle çok sayıda servis sağlayıcısı olan karmaşık Laravel uygulamalarında önemli bir ek yük oluşturur.

Octane bu modeli temelden değiştirir. Uygulama bir kez başlatılır ve ardından bellekte kalarak, yeniden başlatılmadan ardışık istekleri işler. Laravel framework'ü, servis container'ı, route'lar ve yapılandırma yalnızca sunucu başlangıcında yüklenir.

```php
// Geleneksel PHP-FPM döngüsü (basitleştirilmiş)
// İstek 1: PHP Yükle → Composer Yükle → Laravel Başlat → İşle → Sonlandır
// İstek 2: PHP Yükle → Composer Yükle → Laravel Başlat → İşle → Sonlandır
// İstek 3: PHP Yükle → Composer Yükle → Laravel Başlat → İşle → Sonlandır

// Octane Modeli
// Başlangıç: PHP Yükle → Composer Yükle → Laravel Başlat
// İstek 1: İşle
// İstek 2: İşle
// İstek 3: İşle
```

Bu mimari değişikliği bazı zorluklar getirir. Geliştiriciler static özellikleri ve singleton'ları dikkatli yönetmezse uygulama durumu istekler arasında sızabilir. Octane durum sıfırlama mekanizmaları sağlar, ancak geliştiricilerin bu sınırlamaları anlaması gerekir.

## Swoole vs RoadRunner: Motor Karşılaştırması

Laravel Octane iki ana motoru destekler: Swoole ve RoadRunner. Her birinin avantajları ve kullanım senaryoları vardır.

### Swoole

Swoole, asenkron I/O ve coroutine tabanlı eşzamanlılık sağlayan C dilinde yazılmış bir PHP uzantısıdır. En yüksek ham performansı sunar, ancak PHP uzantısının kurulmasını gerektirir.

```bash
# Ubuntu/Debian'da Swoole kurulumu
pecl install swoole

# php.ini'ye ekle
extension=swoole.so
```

```php
// config/octane.php
return [
    'server' => 'swoole',
    
    'swoole' => [
        'options' => [
            'worker_num' => env('OCTANE_WORKERS', 8),
            'task_worker_num' => env('OCTANE_TASK_WORKERS', 4),
            'max_request' => env('OCTANE_MAX_REQUESTS', 10000),
            'enable_static_handler' => true,
            'document_root' => public_path(),
        ],
    ],
];
```

Swoole, RoadRunner'da bulunmayan benzersiz özellikler sunar:
- **Swoole Tabloları**: Worker süreçleri arasında paylaşılan bellek
- **Eşzamanlı Görevler**: Native asenkron yürütme
- **WebSocket Sunucusu**: Yerleşik WebSocket bağlantı desteği
- **Coroutine'ler**: Callback olmadan eşzamanlılık

### RoadRunner

RoadRunner, standart giriş/çıkış üzerinden PHP worker süreçleriyle iletişim kuran Go dilinde yazılmış bir uygulama sunucusudur. PHP uzantısı gerektirmediği için kurulumu daha kolaydır.

```bash
# RoadRunner kurulumu
composer require spiral/roadrunner-cli
./vendor/bin/rr get-binary
```

```yaml
# .rr.yaml
version: '3'

server:
  command: "php artisan octane:start --server=roadrunner --host=0.0.0.0 --port=8000"
  relay: pipes

http:
  address: 0.0.0.0:8000
  pool:
    num_workers: 8
    max_jobs: 10000
    supervisor:
      max_worker_memory: 128
```

| Özellik | Swoole | RoadRunner |
|---------|--------|------------|
| Ham Performans | Daha Yüksek | Biraz Düşük |
| Kurulum | PECL Uzantısı | Go Binary |
| Docker Desteği | Karmaşık | Basit |
| Paylaşılan Tablolar | Native | Yok |
| WebSocket'ler | Native | Centrifugo ile |
| Kararlılık | İyi | Çok İyi |
| Eklenti Ekosistemi | Sınırlı | Kapsamlı |

## Octane Kurulumu ve Yapılandırması

Laravel Octane yapılandırması, seçilen motordan bağımsız olarak birkaç adım gerektirir.

```bash
# Octane paketini kur
composer require laravel/octane

# Yapılandırma dosyasını yayınla
php artisan octane:install

# Kurulum sırasında motor seç
# [0] roadrunner
# [1] swoole
```

Kurulumdan sonra geliştirme sunucusunu başlatma:

```bash
# Hot-reload ile başlat
php artisan octane:start --watch

# Production başlatma
php artisan octane:start --host=0.0.0.0 --port=8000 --workers=8
```

Production yapılandırması ortam değişkenleri üzerinden yönetilir:

```env
OCTANE_SERVER=swoole
OCTANE_WORKERS=8
OCTANE_TASK_WORKERS=4
OCTANE_MAX_REQUESTS=10000
OCTANE_HTTPS=false
```

## Durum Yönetimi ve Bellek Sızıntıları

Octane ile çalışırken en ciddi zorluk uygulama durumunu yönetmektir. Uygulama bellekte kaldığı için, static değişkenler ve singleton'lar istekler arasında değerlerini korur.

```php
// SORUN: Durum sızıntısı
class CartService
{
    private static array $items = [];
    
    public function addItem(string $item): void
    {
        self::$items[] = $item; // İstekler arasında birikir!
    }
}

// ÇÖZÜM 1: Instance özelliklerini kullan
class CartService
{
    private array $items = [];
    
    public function addItem(string $item): void
    {
        $this->items[] = $item; // Her instance ile sıfırlanır
    }
}

// ÇÖZÜM 2: Flushable olarak kaydet
Octane::flush(CartService::class);
```

Octane birçok Laravel bileşenini otomatik olarak sıfırlar, ancak özel servisler manuel yapılandırma gerektirir:

```php
// app/Providers/AppServiceProvider.php
use Laravel\Octane\Facades\Octane;

public function boot(): void
{
    Octane::flush(function () {
        // Özel durumu sıfırla
        MyStatefulService::reset();
    });
}
```

Octane listener'ları yaşam döngüsünün belirli noktalarında kod yürütmeye izin verir:

```php
// app/Providers/OctaneServiceProvider.php
protected $listen = [
    RequestReceived::class => [
        EnsureAuthenticationDataIsCleared::class,
    ],
    RequestTerminated::class => [
        FlushTemporaryData::class,
    ],
    TaskReceived::class => [
        SetupTaskEnvironment::class,
    ],
    WorkerStarting::class => [
        WarmUpCaches::class,
    ],
];
```

## Swoole Tabloları: Paylaşılan Bellek

Swoole Tabloları, worker süreçleri arasında ultra hızlı paylaşılan bellek erişimi sağlar. Sık okunan ancak nadiren değiştirilen veriler için idealdir.

```php
// config/octane.php
'tables' => [
    'rates' => [
        'columns' => [
            ['name' => 'currency', 'type' => Table::TYPE_STRING, 'size' => 3],
            ['name' => 'rate', 'type' => Table::TYPE_FLOAT],
            ['name' => 'updated_at', 'type' => Table::TYPE_INT],
        ],
        'rows' => 100,
    ],
],
```

```php
// Tabloya yazma
use Laravel\Octane\Facades\Octane;

Octane::table('rates')->set('USD', [
    'currency' => 'USD',
    'rate' => 1.0,
    'updated_at' => time(),
]);

Octane::table('rates')->set('EUR', [
    'currency' => 'EUR',
    'rate' => 0.85,
    'updated_at' => time(),
]);

// Tablodan okuma
$usdRate = Octane::table('rates')->get('USD');
$allRates = Octane::table('rates')->toArray();
```

Tablolar, veriler süreç belleğinde bulunduğu için basit key-value işlemleri için Redis'ten çok daha hızlıdır.

## Eşzamanlı Görevler

Octane, eşzamanlı görevler aracılığıyla birden fazla işlemi paralel olarak yürütmeyi sağlar:

```php
use Laravel\Octane\Facades\Octane;

// Birden fazla görevi paralel yürüt
[$users, $orders, $stats] = Octane::concurrently([
    fn () => User::where('active', true)->get(),
    fn () => Order::where('status', 'pending')->get(),
    fn () => DB::table('metrics')->selectRaw('SUM(value) as total')->first(),
]);
```

Eşzamanlı görevler, bağımsız veritabanı sorguları veya harici API çağrıları için özellikle kullanışlıdır:

```php
// Birden fazla kaynaktan veri toplama
public function getDashboardData(int $userId): array
{
    [$profile, $notifications, $recommendations] = Octane::concurrently([
        fn () => $this->userService->getProfile($userId),
        fn () => $this->notificationService->getUnread($userId),
        fn () => $this->mlService->getRecommendations($userId),
    ], 5000); // 5 saniye timeout
    
    return compact('profile', 'notifications', 'recommendations');
}
```

## Performans Optimizasyonu: En İyi Uygulamalar

Octane ile maksimum performans elde etmek çoklu düzeylerde optimizasyon gerektirir.

### Cache Isıtma

Worker başlangıcında sık kullanılan verilerin yüklenmesi ilk istek gecikmelerini ortadan kaldırır:

```php
// app/Providers/OctaneServiceProvider.php
use Laravel\Octane\Events\WorkerStarting;

protected $listen = [
    WorkerStarting::class => [
        WarmUpApplication::class,
    ],
];

// app/Listeners/WarmUpApplication.php
class WarmUpApplication
{
    public function handle(WorkerStarting $event): void
    {
        // Yapılandırmayı belleğe yükle
        config()->all();
        
        // Route cache'ini ısıt
        app('router')->getRoutes()->compile();
        
        // Eloquent ilişkilerini yükle
        User::query()->with(['profile', 'settings'])->first();
        
        // Cache bağlantılarını başlat
        Cache::get('warmup');
    }
}
```

### OPcache Optimizasyonu

OPcache, Octane performansı için kritiktir. Önerilen yapılandırma:

```ini
; php.ini
opcache.enable=1
opcache.enable_cli=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=32
opcache.max_accelerated_files=30000
opcache.validate_timestamps=0
opcache.save_comments=1
opcache.jit_buffer_size=256M
opcache.jit=1255
```

### Worker Sayısı Yapılandırması

Optimal worker sayısı şu formülle belirlenir:

```php
// CPU-bound görevler için
$workers = CPU_CORES;

// I/O-bound görevler için (çoğu web uygulaması)
$workers = CPU_CORES * 2;

// Kullanımı kontrol et
php artisan octane:status
```

### Bellek Sızıntısı İzleme

```php
// Bellek limiti aşıldığında worker'ları otomatik yeniden başlat
'max_requests' => 10000, // 10k istekten sonra yeniden başlat

// Bellek izleme
Octane::tick('memory-monitor', function () {
    $usage = memory_get_usage(true) / 1024 / 1024;
    if ($usage > 100) {
        Log::warning("Yüksek bellek kullanımı: {$usage}MB");
    }
})->seconds(30);
```

## Supervisor ile Production Yapılandırması

Production ortamında Octane bir süreç denetleyicisi gerektirir:

```ini
; /etc/supervisor/conf.d/octane.conf
[program:octane]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/html/artisan octane:start --server=swoole --host=0.0.0.0 --port=800%(process_num)d
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=1
redirect_stderr=true
stdout_logfile=/var/log/octane.log
stopwaitsecs=60
```

Reverse proxy olarak Nginx yapılandırması:

```nginx
upstream octane {
    server 127.0.0.1:8000 weight=5;
    server 127.0.0.1:8001 weight=5;
    keepalive 32;
}

server {
    listen 80;
    server_name example.com;
    
    location / {
        proxy_pass http://octane;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Connection "";
        proxy_buffering off;
    }
}
```

## Mülakat Soruları: Laravel Octane

**S1: Octane'in yürütme modeli geleneksel PHP-FPM'den nasıl farklıdır?**

PHP-FPM'de her istek yeni bir PHP süreci başlatır, Composer autoloader'ı yükler, Laravel framework'ünü başlatır, isteği işler ve sonlanır. Octane uygulamayı bellekte tutar - framework yalnızca sunucu başlangıcında yüklenir ve ardışık istekler yeniden başlatma olmadan worker süreçleri tarafından işlenir. Bu, framework bootstrap overhead'ini ortadan kaldırır ve tipik Laravel uygulamaları için 2-3 kat performans artışı sağlar.

**S2: Swoole ve RoadRunner arasındaki temel farklar nelerdir?**

Swoole, native asenkronluk, coroutine'ler ve paylaşılan tablolar gibi özellikler sunan C dilinde yazılmış bir PHP uzantısıdır. RoadRunner, standart I/O üzerinden PHP ile iletişim kuran bir Go sunucusudur. Swoole daha yüksek ham performans ve daha fazla özellik sunar, ancak kurulumu daha zordur (uzantı derleme gerektirir). RoadRunner yapılandırması daha basittir, container'larla daha iyi entegre olur ve daha kararlı bir eklenti ekosistemine sahiptir.

**S3: Octane uygulamasında bellek sızıntılarını nasıl önlersiniz?**

Üç ana strateji: veri biriktiren static özelliklerden kaçınma, durum tutan servisleri istekler arasında otomatik sıfırlama için `Octane::flush()` ile kaydetme ve worker'ları periyodik olarak yeniden başlatmak için `max_requests` yapılandırması. Ayrıca istek özelinde veri depolayan singleton'lardan kaçınılmalı ve servis container'ında scoped binding'ler kullanılmalıdır.

**S4: Swoole tabloları Redis yerine ne zaman kullanılmalı?**

Swoole tabloları, döviz kurları, yapılandırma veya session cache gibi sık okunan ancak nadiren değiştirilen veriler için idealdir. Veriler ağ overhead'i olmadan süreç belleğinde bulunduğu için Redis'ten daha hızlıdır. Redis, birden fazla sunucu arasında paylaşılan veriler, karmaşık veri yapıları (sorted sets, streams) veya veri kalıcılığı gerektiğinde daha iyi bir seçim olmaya devam eder.

**S5: Octane WebSocket desteği için nasıl yapılandırılır?**

Swoole ile Octane native WebSocket desteği sunar. Bu, `onOpen`, `onMessage` ve `onClose` olayları için listener'ların yapılandırılmasını gerektirir. Alternatif olarak Laravel Reverb veya Pusher kullanılabilir. RoadRunner ile WebSocket, ek bir centrifugo sunucusu veya benzer bir çözüm gerektirir, çünkü RoadRunner native olarak WebSocket'i desteklemez.

## Performans Kıyaslamaları

Tipik bir Laravel uygulaması performans karşılaştırması:

| Yapılandırma | İstek/sn | p99 Gecikme | Bellek/worker |
|--------------|----------|-------------|---------------|
| PHP-FPM | 850 | 45ms | 35MB |
| Octane + RoadRunner | 2,400 | 12ms | 45MB |
| Octane + Swoole | 3,100 | 8ms | 55MB |

Sonuçlar uygulamanın özelliklerine göre değişebilir. I/O ağırlıklı uygulamalar (veritabanı, API) CPU-bound uygulamalardan daha fazla fayda görür.

## Sonuç

2026 yılında Laravel Octane, yüksek performanslı PHP uygulamaları çalıştırmak için olgun bir çözüm teşkil etmektedir. Swoole ve RoadRunner arasındaki seçim proje gereksinimlerine bağlıdır - Swoole maksimum performans ve paylaşılan tablolar gibi özellikler sunarken, RoadRunner daha basit yapılandırma ve daha iyi container uyumluluğu sağlar.

Anahtar çıkarımlar:

- Octane, uygulamayı bellekte tutarak framework bootstrap overhead'ini ortadan kaldırır
- Durum yönetimi kritiktir - static özelliklerden kaçının ve servisleri sıfırlama için kaydedin
- Swoole tabloları worker'lar arasında paylaşılan verilere ultra hızlı erişim sunar
- Eşzamanlı görevler paralel yürütme ile I/O-bound işlemleri hızlandırır
- Production yapılandırması Supervisor, reverse proxy olarak Nginx ve bellek izleme gerektirir

Laravel Octane bilgisi, yüksek performans gereksinimleri olan uygulamalar üzerinde çalışan PHP geliştiricileri için giderek daha önemli hale gelmektedir. Durum yönetimi, production yapılandırması ve performans optimizasyonuna hakim olmak, saniyede binlerce istek işleyen uygulamalar oluşturmayı mümkün kılar.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/tr/blog/laravel/laravel-octane-swoole-roadrunner-performance-optimization