Laravel Swoole Entegrasyonunu

Laravel Swoole entegrasyonunu detaylıca inceleyelim:

1. Swoole Nedir?

• PHP için geliştirilmiş asenkron, event-driven programlama framework’üdür
• C/C++ ile yazılmış yüksek performanslı PHP eklentisidir
• Web sunucusu, WebSocket sunucusu ve Task worker özellikleri sunar
• Geleneksel PHP-FPM’e göre çok daha yüksek performans sağlar

2. Ne Zaman Kullanılır?

Örnek senaryolar:

- Yüksek performans gerektiren uygulamalar
- Real-time uygulamalar (chat, bildirimler)
- WebSocket gerektiren uygulamalar
- Mikroservisler
- Uzun süren işlemler
- Yüksek concurrency gerektiren durumlar

3. Laravel Octane ile Swoole Entegrasyonu:

a) Kurulum:

# Swoole PHP eklentisi kurulumu
pecl install swoole

# Laravel Octane kurulumu
composer require laravel/octane

# Octane yapılandırması
php artisan octane:install

b) Konfigürasyon:

// config/octane.php
return [
    'server' => 'swoole',
    
    'swoole' => [
        'options' => [
            'worker_num' => 8,
            'task_worker_num' => 4,
            'max_request' => 1000,
            'buffer_output_size' => 2 * 1024 * 1024
        ]
    ]
];

4. Swoole Server Yönetimi:

a) Server Başlatma:

# Temel başlatma
php artisan octane:start

# Port belirterek başlatma
php artisan octane:start --port=8000

# Worker sayısı belirterek başlatma
php artisan octane:start --workers=4

# Task worker sayısı belirterek başlatma
php artisan octane:start --task-workers=2

# Watch mode (development)
php artisan octane:start --watch

b) Server Yönetim Komutları:

# Server'ı durdurma
php artisan octane:stop

# Server'ı yeniden başlatma
php artisan octane:reload

# Server durumunu kontrol etme
php artisan octane:status

5. Swoole WebSocket Desteği:

a) WebSocket Handler:

use Swoole\WebSocket\Server;

class WebSocketHandler
{
    public function onOpen($server, $request)
    {
        echo "Connection open: {$request->fd}\n";
    }

    public function onMessage($server, $frame)
    {
        $server->push($frame->fd, "Server: {$frame->data}");
    }

    public function onClose($server, $fd)
    {
        echo "Connection close: {$fd}\n";
    }
}

b) WebSocket Kullanımı:

// routes/websocket.php
use SwooleTW\Http\Websocket\Facades\Websocket;

Websocket::on('connect', function ($websocket, $request) {
    // Bağlantı kurulduğunda
});

Websocket::on('message', function ($websocket, $data) {
    $websocket->emit('message', $data);
});

Websocket::on('close', function ($websocket) {
    // Bağlantı kapandığında
});

6. Swoole Task Workers:

class HandleLongRunningTask
{
    public function handle()
    {
        Octane::task(function () {
            // Uzun süren işlem
            return 'Task completed';
        });
    }
}

7. Swoole Tables (Shared Memory):

use Swoole\Table;

class UserOnlineStatus
{
    protected $table;

    public function __construct()
    {
        $this->table = new Table(1024);
        $this->table->column('user_id', Table::TYPE_INT);
        $this->table->column('status', Table::TYPE_STRING, 32);
        $this->table->create();
    }

    public function setUserStatus($userId, $status)
    {
        $this->table->set($userId, [
            'user_id' => $userId,
            'status' => $status
        ]);
    }

    public function getUserStatus($userId)
    {
        return $this->table->get($userId);
    }
}

8. Performance Optimizasyonları:

a) Coroutine Kullanımı:

use Swoole\Coroutine;

public function handleRequest()
{
    go(function () {
        // Asenkron işlem
        $result = Coroutine::http_get('http://api.example.com');
        
        // Sonucu işle
        $this->processResult($result);
    });
}

b) Connection Pooling:

use Swoole\Database\PDOPool;

class DatabasePool
{
    protected $pool;

    public function __construct()
    {
        $this->pool = new PDOPool(
            getenv('DB_CONNECTION'),
            getenv('DB_USERNAME'),
            getenv('DB_PASSWORD'),
            10 // pool size
        );
    }

    public function query($sql)
    {
        $pdo = $this->pool->get();
        try {
            $result = $pdo->query($sql);
            return $result->fetchAll();
        } finally {
            $this->pool->put($pdo);
        }
    }
}

9. Memory Management:

// config/octane.php
return [
    'swoole' => [
        'options' => [
            'max_request' => 1000,        // Worker yeniden başlatma
            'max_conn' => 10000,          // Maximum bağlantı
            'heartbeat_check_interval' => 60,  // Heartbeat kontrolü
            'heartbeat_idle_time' => 120,      // Idle bağlantı timeout
        ]
    ]
];

10. Error Handling:

use Swoole\Server;

$server = new Server('127.0.0.1', 9501);

$server->on('WorkerError', function ($server, $workerId, $workerPid, $exitCode, $signal) {
    // Worker hata yönetimi
    logger()->error('Worker error', [
        'worker_id' => $workerId,
        'pid' => $workerPid,
        'exit_code' => $exitCode
    ]);
});

11. Monitoring ve Debugging:

// Server metrics
$server->on('Start', function ($server) {
    $metrics = [
        'worker_num' => $server->setting['worker_num'],
        'task_worker_num' => $server->setting['task_worker_num'],
        'max_request' => $server->setting['max_request'],
        'start_time' => time()
    ];
    
    // Metrics kaydet
});

12. Best Practices:

Resource Management:

// Worker başlatıldığında
$server->on('WorkerStart', function ($server, $workerId) {
    // Bağlantıları initialize et
    $this->initializeConnections();
});

// Worker sonlandığında
$server->on('WorkerStop', function ($server, $workerId) {
    // Bağlantıları kapat
    $this->closeConnections();
});

Stateless Application Design:

// Shared state kullanımından kaçının
class UserService
{
    private $cache;

    public function __construct()
    {
        // Her worker için ayrı cache instance
        $this->cache = new SwooleTable(1024);
    }
}