Costruire Applicazioni PHP ad Alte Prestazioni con Swoole su ServBay

ServBay è un ambiente locale per lo sviluppo web progettato specificamente per gli sviluppatori, già configurato con diversi ambienti linguistici, database e strumenti per semplificare il flusso di lavoro in locale. Questa guida si concentra su come sfruttare l’estensione Swoole in ServBay per potenziare le applicazioni PHP e creare servizi di rete ad alte performance.

Cos’è Swoole?

Swoole è un motore di comunicazione di rete parallela e ad alte prestazioni, basato su coroutine, pensato per PHP. Scritto interamente in C, offre funzionalità asincrone, parallele e coroutine per la comunicazione di rete su PHP. Con Swoole, gli sviluppatori possono superare i limiti del modello tradizionale di server web (come Apache/Nginx + PHP-FPM), gestendo compiti ad alta concorrenza in modo più efficiente—ideale per server web residenti in memoria, gestione di task asincroni, servizi di comunicazione in tempo reale come WebSocket e altro ancora.

Caratteristiche principali di Swoole:

• Alte prestazioni: Implementato in C, offre I/O asincrono e supporta multi-processo/multi-thread.
• Coroutine: Permette micro-coroutine leggere per l’esecuzione asincrona con una sintassi sincrona, semplificando la scrittura di codice asincrono.
• Ampio supporto protocolli: Nativamente compatibile con TCP, UDP, HTTP, WebSocket e altri protocolli.
• Facile da usare: API semplici che si adattano alle abitudini degli sviluppatori PHP.
• Processi residenti: Le applicazioni possono restare in memoria come processi persistenti, eliminando il costo della rinizializzazione tipico delle richieste PHP tradizionali.

Grazie a Swoole, PHP diventa adatto non solo allo sviluppo web tradizionale, ma anche per una vasta gamma di applicazioni di rete ad alte prestazioni.

Attivare Swoole in ServBay

Uno degli obiettivi di ServBay è facilitare la gestione e l’utilizzo delle estensioni PHP. Swoole è già presente in ServBay come componente fondamentale per lo sviluppo PHP moderno: per abilitarlo bastano pochi passi.

Prerequisiti:

• ServBay deve essere installato e in esecuzione.
• Un almeno una versione di PHP deve risultare installata in ServBay.

Procedura di attivazione:

1. Apri l'interfaccia di ServBay.
2. Vai a “Packages” o alla sezione per la gestione delle versioni PHP. (Nota: il nome preciso può variare a seconda della versione, generalmente si trova nella schermata principale o nelle impostazioni)
3. Seleziona la versione di PHP dove vuoi abilitare Swoole.
4. Trova l’opzione Swoole tra le estensioni e seleziona “Abilitato”. ServBay presenta le estensioni pronte in elenco o con un interruttore.
5. Salva e riavvia ServBay o solo il servizio PHP quando richiesto. ServBay configurerà automaticamente PHP per caricare l’estensione Swoole.

Dopo questi passaggi, puoi subito utilizzare Swoole nella versione PHP selezionata. Puoi verificarlo tramite il terminale con il comando php -m: cerca swoole tra le estensioni attive.

TIP

ServBay consiglia di salvare i siti e i file dei progetti nelle seguenti directory, facilitando la gestione e la configurazione:

• macOS: /Applications/ServBay/www
• Windows: C:\ServBay\www

Anche negli esempi seguenti useremo queste cartelle raccomandate.

Creare un Semplice Server HTTP con Swoole

Vediamo ora come creare un server HTTP di base con Swoole per gestire richieste web.

Passo 1: Crea la cartella di progetto

Apri il terminale, crea ed entra in una nuova cartella per il progetto, nella directory consigliata da ServBay:

macOS:

cd /Applications/ServBay/www
mkdir servbay-swoole-http
cd servbay-swoole-http

Windows:

cd C:\ServBay\www
mkdir servbay-swoole-http
cd servbay-swoole-http

Passo 2: Scrivi lo script del server

Nella cartella servbay-swoole-http crea il file server.php e inserisci:

<?php

use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;

// Crea un'istanza di Server HTTP Swoole
// Ascolta su tutti gli indirizzi di rete (0.0.0.0), porta 9501
$server = new Server("0.0.0.0", 9501);

// Registra la callback per l’evento 'start'
// Trigger quando il server parte con successo
$server->on("start", function (Server $server) {
    echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
    // Qui puoi loggare PID del master, PID del manager, ecc.
});

// Registra la callback per l’evento 'request'
// Trigger per ogni nuova richiesta HTTP ricevuta
$server->on("request", function (Request $request, Response $response) {
    // Imposta l’header della risposta
    $response->header("Content-Type", "text/plain");

    // Logica in base al path richiesto o ai parametri
    $path = $request->server['request_uri'] ?? '/';
    $content = "Hello ServBay!";

    if ($path === '/info') {
        $content = "Request path: " . $path . "\n";
        $content .= "Method: " . $request->server['request_method'] . "\n";
        $content .= "Client IP: " . $request->server['remote_addr'] . "\n";
        // Altre info dalla richiesta visibili sull’oggetto $request
    }

    // Invia la risposta, termina la richiesta
    $response->end($content);
});

// Avvia il server
$server->start();

Questo script crea un server HTTP Swoole che ascolta sulla porta 9501. Per ogni richiesta invia “Hello ServBay!” come risposta testuale; navigando su /info ottieni anche dettagli sulla richiesta.

Passo 3: Avvia il server Swoole

Assicurati di essere nella cartella servbay-swoole-http nel terminale. Lancia lo script con la versione PHP abilitata per Swoole:

php server.php

Se tutto funziona, vedrai sul terminale:

Swoole HTTP server is started at http://0.0.0.0:9501

Questo conferma che il server HTTP Swoole è attivo e in ascolto sulla porta 9501.

Passo 4: Accedi al server Swoole

Apri il browser e visita:

• http://localhost:9501
• http://localhost:9501/info

La pagina mostrerà rispettivamente Hello ServBay! e le informazioni sulla richiesta.

Per fermare il server, torna al terminale dove gira lo script e premi Ctrl + C.

Gestione di Connessioni WebSocket con Swoole

Swoole supporta nativamente il protocollo WebSocket, perfetto per app in tempo reale come chat, server di gioco e push di dati dal vivo.

Passo 1: Scrivi lo script del server WebSocket

Nel tuo progetto (ad esempio servbay-swoole-http, oppure crea una nuova cartella come servbay-swoole-websocket), crea il file websocket_server.php:

Percorso progetto:

• macOS: /Applications/ServBay/www/servbay-swoole-http
• Windows: C:\ServBay\www\servbay-swoole-http

<?php

use Swoole\WebSocket\Server;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;

// Crea un server WebSocket Swoole
// Il server WebSocket estende quello HTTP e può gestire anche richieste HTTP
$server = new Server("0.0.0.0", 9502); // Ascolta sulla porta 9502

// Registra evento 'start', attivato quando il server parte
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});

// Registra evento 'open' — nuova connessione WebSocket
// L'oggetto $request contiene dettagli come $request->fd (file descriptor client)
$server->on("open", function (Server $server, Request $request) {
    echo "connection open: {$request->fd}\n";
    // Invia messaggio di benvenuto al client
    $server->push($request->fd, "Welcome to ServBay WebSocket Demo!");
});

// Registra evento 'message' — ricezione messaggi WebSocket dal client
// L'oggetto $frame contiene dati del messaggio e fd del client
$server->on("message", function (Server $server, Frame $frame) {
    echo "received message from {$frame->fd}: {$frame->data}\n";
    // Esempio: rispondi solo al mittente
    $server->push($frame->fd, "Hello, you sent: {$frame->data}");

    // Esempio di broadcast (necessita lista connessioni o iterare)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // Escludi il mittente
    //         $server->push($fd, "User {$frame->fd} says: {$frame->data}");
    //     }
    // }
});

// Registra evento 'close', attivato quando la connessione viene chiusa
$server->on("close", function ($ser, $fd) {
    echo "connection close: {$fd}\n";
});

// Avvia il server
$server->start();

Questo script crea un server WebSocket su porta 9502 con callback per gli eventi principali: start (avvio server), open (nuova connessione), message (ricezione messaggio), close (disconnessione). Alla ricezione di un messaggio, il server risponde semplicemente al mittente.

Passo 2: Avvia il server WebSocket

Nel terminale, spostati dove si trova websocket_server.php. Avvialo con la versione PHP con Swoole attivo:

php websocket_server.php

Se funziona, viene mostrato:

Swoole WebSocket server is started at ws://0.0.0.0:9502

Il server WebSocket Swoole ora è operativo sulla porta 9502.

Passo 3: Collegati al server WebSocket

Ci sono diversi metodi per testare la connessione.

Metodo A: Usa gli strumenti per sviluppatori del browser

Quasi tutti i moderni browser hanno una Console accessibile con F12—utile per testare WebSocket.

1. Apri una pagina qualsiasi (es: about:blank).

2. Avvia la Console (F12) e incolla:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("WebSocket connection opened:", event);
     ws.send("Hello from Browser!"); // Manda un messaggio appena connesso
   };
   
   ws.onmessage = function(event) {
     console.log("Message from server:", event.data); // Ricevi messaggi
   };
   
   ws.onerror = function(event) {
     console.error("WebSocket error:", event); // Eventuali errori
   };
   
   ws.onclose = function(event) {
     console.log("WebSocket connection closed:", event); // Chiusura
   };
   
   // Puoi usare ws.send("tuo messaggio") e ws.close() quando vuoi

3. Esegui lo script nella console, osserva gli output; anche il terminale del server mostrerà log su connessioni e messaggi.

Metodo B: Usa il tool da terminale wscat

wscat è un noto client WebSocket su riga di comando, basato su Node.js.

1. Installa wscat: Se non hai Node.js/npm, installali. Poi:

   npm install -g wscat

2. Collegati al server: Esegui:

   wscat -c ws://localhost:9502

   Appena connesso vedrai il prompt >.

3. Invia un messaggio: Scrivi qualcosa e premi invio:

   > Hello ServBay via wscat

   Il server risponde e vedrai il messaggio preceduto da <:

   < Hello, you sent: Hello ServBay via wscat

   Nel terminale del server apparirà anche il relativo log.

Per chiudere wscat, premi Ctrl + C.

Avvertenze

• Conflitti di porta: Assicurati che la porta scelta (es. 9501, 9502) non sia già occupata. Un conflitto blocca l’avvio di Swoole.
• Versione di PHP: Quando esegui gli script, utilizza la stessa versione PHP configurata con Swoole in ServBay. Controlla la versione con php -v. ServBay offre tool comodi per il cambio versione.
• Stato dell’estensione: Se il server non parte, verifica che Swoole sia davvero attivo nella tua versione di PHP su ServBay, e che il servizio sia stato riavviato dopo la modifica.
• Gestione dei processi residenti: Il server Swoole resta in memoria. In produzione, usa strumenti come Supervisor, Systemd, pm2, ecc. per gestire i processi e i riavvii automatici. Per sviluppo locale con ServBay, eseguirlo manualmente dal terminale è in genere sufficiente.

Conclusione

Grazie a ServBay, abilitare e usare Swoole per sviluppare e testare applicazioni PHP ad alte prestazioni—sia http tradizionali che comunicazioni WebSocket moderne—è semplicissimo in locale. La potenza di Swoole combinata con la praticità di ServBay spalanca nuove opportunità agli sviluppatori PHP, consentendo la realizzazione di app più veloci e avanzate. Prova subito Swoole su ServBay!