Creare Applicazioni PHP ad Alte Prestazioni con Swoole in ServBay

ServBay è un ambiente locale di sviluppo web progettato appositamente per gli sviluppatori e integrato con diversi ambienti linguistici, database e strumenti, con l'obiettivo di semplificare il flusso di lavoro locale. In questo articolo ci concentreremo su come sfruttare l'estensione Swoole in ServBay per potenziare le tue applicazioni PHP realizzando servizi di rete ad alte prestazioni.

Cos'è Swoole?

Swoole è un motore di comunicazione di rete parallelo e ad alte prestazioni basato su coroutine, progettato specificamente per PHP. Scritto interamente in C, conferisce a PHP la capacità di gestire in modo asincrono, parallelo e tramite coroutine le comunicazioni di rete. Grazie a Swoole, gli sviluppatori PHP possono superare i limiti del tradizionale modello "request-response" di server come Apache o Nginx con PHP-FPM, e gestire con efficienza compiti ad alta concorrenza come server web residenti in memoria, elaborazione asincrona di task, servizi di comunicazione in tempo reale come WebSocket, e molto altro.

Caratteristiche principali di Swoole:

• Alte prestazioni: Sviluppato in C a basso livello, offre IO asincrono e supporto multi-processo/multi-thread.
• Coroutine: Supporto avanzato alle coroutine per l'esecuzione asincrona usando codice sincrono, semplificando la programmazione asincrona.
• Ampio supporto ai protocolli: Supporta nativamente numerosi protocolli di rete tra cui TCP, UDP, HTTP, WebSocket.
• Facile da usare: API semplici e in linea con la sintassi familiare di PHP.
• Residente in memoria: Le applicazioni girano come processi persistenti, evitando il costo di inizializzare l'ambiente ad ogni richiesta come nei comuni script PHP.

Con Swoole, PHP non è più solo una lingua da scripting per il web, ma è perfettamente in grado di affrontare scenari di applicazioni di rete ad alte prestazioni più ampi e complessi.

Come Abilitare Swoole in ServBay

Uno degli obiettivi di ServBay è consentire la gestione e l'uso facile delle varie estensioni PHP. Swoole, considerata estensione fondamentale per lo sviluppo PHP moderno e performante, è inclusa di default in ServBay. Attivarla richiede solo pochi passaggi.

Prerequisiti:

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

Procedura per l'abilitazione:

1. Apri l'interfaccia grafica di ServBay.
2. Vai alla sezione "Pacchetti (Packages)" oppure "Gestione versioni PHP". (Nota: il nome potrebbe variare a seconda della versione di ServBay, ma di solito si trova nella schermata principale o nelle impostazioni)
3. Seleziona la versione di PHP su cui vuoi abilitare Swoole.
4. Trova l'opzione dell'estensione Swoole e attivala. ServBay mostra generalmente le estensioni compilate come elenco o tramite uno switch.
5. Salva le modifiche e, se richiesto, riavvia ServBay o il servizio PHP selezionato. ServBay configurerà automaticamente l'ambiente PHP per caricare l'estensione Swoole.

Con questi semplici passaggi, Swoole sarà attivo sulla versione di PHP scelta. Puoi verificarne il caricamento eseguendo da terminale il comando php -m e controllando che swoole compaia tra le estensioni abilitate.

TIP

Per una corretta gestione di siti e progetti, ServBay consiglia di salvare i file nella cartella /Applications/ServBay/www. In tutti gli esempi di questa guida, faremo riferimento a questo percorso consigliato.

Costruire un Semplice Server HTTP con Swoole

Vediamo come creare un server HTTP basilare con Swoole che risponda alle richieste web.

Passo 1: Crea la cartella del progetto

Apri il terminale, crea e accedi a una nuova cartella per il progetto. Seguendo il consiglio di ServBay, useremo /Applications/ServBay/www:

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

Passo 2: Scrivi lo script del server

Nella cartella servbay-swoole-http crea un nuovo file server.php con il seguente contenuto:

<?php

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

// Crea un'istanza di server HTTP Swoole
// Ascolta sulla porta 9501 su tutte le interfacce (0.0.0.0)
$server = new Server("0.0.0.0", 9501);

// Registra il callback per l'evento 'start'
// Viene eseguito quando il server viene avviato con successo
$server->on("start", function (Server $server) {
    echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
    // Qui puoi registrare l'ID processo principale, l'ID processo di gestione, ecc.
});

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

    // Gestisci la logica in base al percorso della richiesta 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 informazioni sulla richiesta sono disponibili nell'oggetto $request
    }

    // Invia il corpo della risposta e termina la richiesta
    $response->end($content);
});

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

Questo script realizza un server HTTP Swoole in ascolto sulla porta 9501. Alla ricezione di una richiesta, risponde con "Hello ServBay!". Visitando invece il percorso /info riceverai dettagli sulle informazioni della richiesta.

Passo 3: Avvia il server Swoole

Assicurati che il terminale sia posizionato nella cartella servbay-swoole-http. Avvia lo script usando la versione PHP di ServBay con Swoole abilitato:

php server.php

Se tutto va bene, vedrai nel terminale il seguente messaggio:

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

Ciò significa che il server HTTP Swoole è attivo in background sulla porta 9501.

Passo 4: Accedi al server Swoole

Apri il browser e visita:

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

Vedrai rispettivamente la risposta "Hello ServBay!" e, per /info, un testo con le informazioni della richiesta.

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

Gestire le Connessioni WebSocket con Swoole

Swoole offre supporto nativo al protocollo WebSocket, ideale per app di comunicazione real-time come chat, giochi online, o notifiche push.

Passo 1: Scrivi lo script del server WebSocket

Nella cartella /Applications/ServBay/www/servbay-swoole-http (oppure creane una nuova come servbay-swoole-websocket) crea il file websocket_server.php con il seguente contenuto:

<?php

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

// Crea un'istanza di server WebSocket Swoole
// Il server WebSocket estende il server HTTP, quindi può gestire anche richieste HTTP
$server = new Server("0.0.0.0", 9502); // In ascolto sulla porta 9502

// Registra l'evento 'start', scatenato all'avvio del server
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});

// Registra l'evento 'open'
// Eseguito all'instaurarsi di una nuova connessione WebSocket
// L'oggetto $request contiene info sulla connessione, ad esempio $request->fd che è il file descriptor del client
$server->on("open", function (Server $server, Request $request) {
    echo "connection open: {$request->fd}\n";
    // Puoi inviare un messaggio di benvenuto al client
    $server->push($request->fd, "Welcome to ServBay WebSocket Demo!");
});

// Registra l'evento 'message'
// Scatenato quando arriva un messaggio WebSocket da un client
// L'oggetto $frame contiene info sul messaggio, come $frame->data (testo) e $frame->fd (client mittente)
$server->on("message", function (Server $server, Frame $frame) {
    echo "received message from {$frame->fd}: {$frame->data}\n";
    // Invia un messaggio di risposta al mittente, oppure broadcast a tutti
    // Ad esempio, rispondi solo al mittente
    $server->push($frame->fd, "Hello, you sent: {$frame->data}");

    // Esempio di broadcast (richiede la gestione della lista connessioni o iterazione)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // Non inviare al mittente
    //         $server->push($fd, "User {$frame->fd} says: {$frame->data}");
    //     }
    // }
});

// Registra l'evento 'close'
// Scatenato alla chiusura di una connessione client
$server->on("close", function ($ser, $fd) {
    echo "connection close: {$fd}\n";
});

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

Questo script avvia un server WebSocket Swoole in ascolto sulla porta 9502, definendo i callback per gli eventi chiave: start (server avviato), open (nuova connessione), message (ricezione messaggio), close (connessione chiusa). Nell'evento message risponde semplicemente al mittente con il contenuto del messaggio ricevuto.

Passo 2: Avvia il server WebSocket

Posizionati nel terminale dove si trova websocket_server.php e lancia lo script con la versione PHP di ServBay con Swoole:

php websocket_server.php

Se tutto è corretto, vedrai il messaggio:

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

Ora il server WebSocket è attivo e in ascolto sulla porta 9502.

Passo 3: Connettersi al server WebSocket

Puoi testare la connessione al server WebSocket in vari modi.

Metodo A: Tramite strumenti di sviluppo del browser

La maggior parte dei browser moderni consente di testare le WebSocket tramite il pannello "Console" degli strumenti di sviluppo (F12).

1. Apri una pagina web (ad esempio about:blank).

2. Apri gli strumenti di sviluppo e vai sulla scheda "Console".

3. Inserisci questo codice JavaScript per connetterti:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("WebSocket connection opened:", event);
     ws.send("Hello from Browser!"); // Invia un messaggio al momento della connessione
   };
   
   ws.onmessage = function(event) {
     console.log("Message from server:", event.data); // Ricevi messaggio dal server
   };
   
   ws.onerror = function(event) {
     console.error("WebSocket error:", event); // Gestisci errori
   };
   
   ws.onclose = function(event) {
     console.log("WebSocket connection closed:", event); // Connessione chiusa
   };
   
   // Puoi inviare messaggi con ws.send("Il tuo messaggio")
   // Chiudere con ws.close()

4. Esegui il codice in console e guarda i log. Allo stesso tempo, il terminale con websocket_server.php mostrerà log delle connessioni e messaggi ricevuti.

Metodo B: Usando il tool da terminale wscat

wscat è un client WebSocket da terminale basato su Node.js.

1. Installa wscat: Se non hai già Node.js e npm, installali. Quindi esegui:

   npm install -g wscat

2. Connettiti al server WebSocket: Da terminale, lancia:

   wscat -c ws://localhost:9502

   Vedrai il prompt > se la connessione è stabilita.

3. Invia messaggi: Scrivi e invia un testo, poi premi invio:

   > Hello ServBay via wscat

   Il server risponderà, vedrai il testo (tipicamente con <):

   < Hello, you sent: Hello ServBay via wscat

   Nel frattempo anche il terminale dove gira websocket_server.php mostrerà i log relativi.

Per terminare la connessione wscat, premi Ctrl + C.

Note Importanti

• Conflitto di porte: Assicurati che le porte usate dal server Swoole (come 9501, 9502) non siano già in uso da altri processi. In caso di conflitto, il server non potrà avviarsi.
• Versione PHP: Al prompt dei comandi, verifica di usare la versione di PHP di ServBay con Swoole abilitato (puoi controllare con php -v). ServBay offre utilità per cambiare rapidamente la versione PHP della shell.
• Stato dell'estensione: Se il server non parte, ricontrolla di aver abilitato correttamente Swoole sulla versione PHP in uso in ServBay, e che ServBay o i servizi PHP siano stati riavviati per rendere effettive le modifiche.
• Gestione processi residenti: I server Swoole sono processi residenti in memoria. In produzione occorre affidarli a strumenti di gestione dei processi (come Supervisor, Systemd, pm2, ecc.) per garantire riavvii automatici e affidabilità. In locale su ServBay, gestirli a mano da terminale è di solito sufficiente.

Conclusioni

Con ServBay puoi abilitare e utilizzare facilmente l’estensione Swoole, sviluppando e testando applicazioni PHP ad alte prestazioni in locale, che si tratti di servizi HTTP tradizionali o moderne applicazioni real-time WebSocket. La potenza di Swoole, unita alla praticità dell’ambiente di sviluppo di ServBay, ti apre nuove prospettive nello sviluppo PHP, permettendoti di costruire applicazioni più efficienti e potenti. Prova ora le potenzialità di Swoole su ServBay!