Utilizar Swoole en ServBay para desarrollar aplicaciones PHP de alto rendimiento

ServBay es un entorno local de desarrollo web diseñado especialmente para desarrolladores. Viene con múltiples entornos de lenguajes, bases de datos y herramientas pre-integrados, con el objetivo de simplificar el flujo de trabajo en el desarrollo local. En este artículo nos centraremos en cómo potenciar aplicaciones PHP usando la extensión Swoole dentro de ServBay, para construir servicios de red de alto rendimiento.

¿Qué es Swoole?

Swoole es un motor de comunicación de red paralelo y de alto rendimiento para PHP, basado en corrutinas (coroutines). Está desarrollado completamente en C y provee capacidades de comunicación de red asíncrona, paralela y con corrutinas para PHP. Gracias a Swoole, los desarrolladores PHP pueden liberarse del modelo tradicional de petición-respuesta de servidores web como Apache/Nginx + PHP-FPM, y así manejar tareas de alta concurrencia de forma más eficiente, como construir servidores web en memoria, procesamiento de tareas asíncronas, servicios de comunicación en tiempo real (como WebSocket), entre otros.

Características principales de Swoole:

• Alto rendimiento: Implementado en C, ofrece soporte para I/O asíncrono y multiproceso/multihilo.
• Corrutinas: Proporciona corrutinas ligeras, permitiendo ejecutar código asíncrono de manera sincrónica, simplificando la programación asíncrona.
• Amplio soporte de protocolos: Soporta de forma nativa múltiples protocolos de red como TCP/UDP/HTTP/WebSocket.
• Fácil de usar: Dispone de una API sencilla, familiar para los desarrolladores PHP.
• Ejecución en memoria: Las aplicaciones pueden operar como procesos residentes, evitando la sobrecarga de inicialización en cada petición típica del PHP convencional.

Con Swoole, PHP deja de ser solo un lenguaje de scripting web y se convierte en una alternativa viable para aplicaciones de red de alto rendimiento más amplias.

Cómo habilitar Swoole en ServBay

Uno de los objetivos de diseño de ServBay es que los desarrolladores puedan gestionar y utilizar fácilmente diferentes extensiones PHP. Swoole, siendo una extensión clave para el desarrollo PHP moderno de alto rendimiento, ya viene pre-instalada en ServBay. Solo necesitas unos pocos pasos para activarla.

Requisitos previos:

• Tener ServBay instalado y funcionando.
• Asegurarse de que hay al menos una versión de PHP instalada en ServBay.

Pasos para habilitar Swoole:

1. Abre la interfaz de la aplicación ServBay.
2. Navega al apartado “Paquetes (Packages)” o al gestor de versiones de PHP. (Nota: dependiendo de la versión de ServBay, el nombre del acceso puede variar, pero usualmente se encuentra en la pantalla principal o en la configuración)
3. Selecciona la versión de PHP en la que deseas activar Swoole.
4. Busca la opción de la extensión Swoole y márcala para habilitarla. ServBay suele mostrar las extensiones precompiladas en forma de lista o interruptor.
5. Guarda los cambios y reinicia ServBay o el servicio PHP correspondiente según las instrucciones. ServBay se encargará de configurar automáticamente el entorno PHP para cargar la extensión Swoole.

Una vez completados estos pasos, ya puedes usar Swoole en la versión seleccionada de PHP. Puedes comprobarlo ejecutando el comando php -m en la terminal para verificar que swoole aparece en la lista de extensiones cargadas.

TIP

Por defecto, ServBay recomienda guardar tu sitio web y archivos de proyecto en el directorio /Applications/ServBay/www, lo que facilita la gestión y configuración de sitios en ServBay. En los ejemplos de este artículo seguiremos esta ruta recomendada.

Crear un servidor HTTP básico con Swoole

A continuación, crearemos un servidor HTTP sencillo con Swoole para demostrar cómo manejar peticiones web.

Paso 1: Crear el directorio del proyecto

Abre la terminal, crea y accede a un nuevo directorio de proyecto. Siguiendo la recomendación de ServBay, lo ubicamos en /Applications/ServBay/www:

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

Paso 2: Escribir el script del servidor

Dentro del directorio servbay-swoole-http, crea un archivo llamado server.php y añade el siguiente contenido:

<?php

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

// Crear una instancia del servidor HTTP de Swoole
// Escucha en todas las interfaces (0.0.0.0) en el puerto 9501
$server = new Server("0.0.0.0", 9501);

// Registrar el evento 'start'
// Se activa cuando el servidor inicia correctamente
$server->on("start", function (Server $server) {
    echo "Swoole HTTP server is started at http://0.0.0.0:9501\n";
    // Aquí puedes registrar el ID del proceso principal, de gestión, etc.
});

// Registrar el evento 'request'
// Se activa al recibir nuevas peticiones HTTP
$server->on("request", function (Request $request, Response $response) {
    // Establecer la cabecera de respuesta
    $response->header("Content-Type", "text/plain");

    // Lógica de manejo según la ruta o parámetros de la petición
    $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";
        // Se puede obtener más información de la petición a través del objeto $request
    }

    // Enviar el cuerpo de la respuesta y finalizar la petición
    $response->end($content);
});

// Iniciar el servidor
$server->start();

Este script crea un servidor HTTP con Swoole que escucha en el puerto 9501. Al recibir una petición, responde con el texto simple "Hello ServBay!". Si se accede a la ruta /info, devuelve información sobre la petición.

Paso 3: Ejecutar el servidor Swoole

Asegúrate de que la terminal esté ubicada en servbay-swoole-http. Usa la versión de PHP con Swoole habilitado en ServBay para ejecutar el script:

php server.php

Si todo está bien, verás el siguiente mensaje en la terminal:

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

Esto significa que el servidor HTTP de Swoole está ejecutándose en segundo plano y atendiendo el puerto 9501.

Paso 4: Acceder al servidor Swoole

Abre tu navegador web y visita:

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

Verás en la página los textos Hello ServBay! o información detallada de la petición según la ruta.

Para detener el servidor, vuelve a la ventana de terminal donde ejecutaste el script y pulsa Ctrl + C.

Manejar conexiones WebSocket con Swoole

Swoole soporta de manera nativa el protocolo WebSocket, lo que lo hace ideal para aplicaciones de comunicación en tiempo real como chats, servidores de juegos o notificaciones.

Paso 1: Crear el script del servidor WebSocket

En el directorio /Applications/ServBay/www/servbay-swoole-http (o si prefieres, crea un nuevo directorio como servbay-swoole-websocket), crea un archivo llamado websocket_server.php y agrega lo siguiente:

<?php

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

// Crear una instancia del servidor WebSocket de Swoole
// El servidor WebSocket hereda del servidor HTTP, por lo que también puede gestionar peticiones HTTP
$server = new Server("0.0.0.0", 9502); // Escucha en el puerto 9502

// Registrar el evento 'start', cuando el servidor inicia
$server->on("start", function (Server $server) {
    echo "Swoole WebSocket server is started at ws://0.0.0.0:9502\n";
});

// Registrar el evento 'open'
// Se activa cuando se establece una nueva conexión WebSocket
// El objeto $request contiene información del cliente, como $request->fd (descriptor de archivo)
$server->on("open", function (Server $server, Request $request) {
    echo "connection open: {$request->fd}\n";
    // Puedes enviar un mensaje de bienvenida al cliente
    $server->push($request->fd, "Welcome to ServBay WebSocket Demo!");
});

// Registrar el evento 'message'
// Se activa cuando el servidor recibe un mensaje WebSocket del cliente
// El objeto $frame contiene la información del mensaje, $frame->data es el contenido, $frame->fd el descriptor del cliente
$server->on("message", function (Server $server, Frame $frame) {
    echo "received message from {$frame->fd}: {$frame->data}\n";
    // Puedes difundir el mensaje a todos los clientes o solo responder al remitente
    // Por ejemplo, responder al remitente
    $server->push($frame->fd, "Hello, you sent: {$frame->data}");

    // Ejemplo de difusión (deberías mantener una lista de conexiones o iterar)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // No enviar al emisor
    //         $server->push($fd, "User {$frame->fd} says: {$frame->data}");
    //     }
    // }
});

// Registrar el evento 'close'
// Se activa cuando la conexión del cliente se cierra
$server->on("close", function ($ser, $fd) {
    echo "connection close: {$fd}\n";
});

// Iniciar el servidor
$server->start();

Este script crea un servidor WebSocket con Swoole, escuchando en el puerto 9502. Define callbacks para los eventos principales: start (inicio de servidor), open (nueva conexión), message (mensaje recibido), y close (desconexión). En el evento message, el servidor responde al remitente junto al contenido recibido.

Paso 2: Ejecutar el servidor WebSocket

Asegúrate de estar en la carpeta donde guardaste websocket_server.php. Usa la versión de PHP con Swoole habilitado en ServBay para ejecutar el script:

php websocket_server.php

Si todo es correcto, verás este mensaje en la terminal:

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

Esto indica que tu servidor WebSocket está activo y espera conexiones en el puerto 9502.

Paso 3: Conectar al servidor WebSocket

Tienes varias formas de probar tu servidor WebSocket.

Método A: Usar las herramientas de desarrollador del navegador

La mayoría de navegadores modernos tiene un panel “Red” (Network) o “Consola” (Console) en sus herramientas de desarrollador (usualmente con F12).

1. Abre una página web (por ejemplo, about:blank).

2. Abre las herramientas de desarrollador y cambia a la pestaña “Consola (Console)”.

3. Introduce el siguiente código JavaScript para conectarte:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("WebSocket connection opened:", event);
     ws.send("Hello from Browser!"); // Enviar mensaje tras conectar
   };
   
   ws.onmessage = function(event) {
     console.log("Message from server:", event.data); // Mensaje recibido
   };
   
   ws.onerror = function(event) {
     console.error("WebSocket error:", event); // Ocurre un error
   };
   
   ws.onclose = function(event) {
     console.log("WebSocket connection closed:", event); // Conexión cerrada
   };
   
   // Puedes enviar mensajes con ws.send("tu mensaje")
   // O cerrar la conexión con ws.close()

4. Ejecuta este código en la consola y observa los resultados. En la terminal donde corre websocket_server.php, también verás los logs correspondientes.

Método B: Usar la herramienta de línea de comandos wscat

wscat es un cliente WebSocket para la terminal, basado en Node.js.

1. Instala wscat: Si aún no tienes Node.js y npm, primero instálalos. Luego instala wscat globalmente:

   npm install -g wscat

2. Conéctate al servidor WebSocket: Ejecuta en la terminal:

   wscat -c ws://localhost:9502

   Al conectar, verás el prompt >.

3. Envía un mensaje: Escribe cualquier mensaje y pulsa enter:

   > Hello ServBay via wscat

   El servidor responderá y verás la respuesta (iniciada con <):

   < Hello, you sent: Hello ServBay via wscat

   Además, la terminal donde se ejecuta websocket_server.php mostrará los logs de la conexión y mensajes.

Para cerrar la conexión en wscat, presiona Ctrl + C.

Consideraciones importantes

• Conflicto de puertos: Asegúrate de que los puertos en los que escucha el servidor Swoole (ej. 9501, 9502) no estén en uso por otras aplicaciones. En caso de conflicto, el servidor no arrancará.
• Versión de PHP: A la hora de ejecutar los scripts en tu terminal, comprueba que estás usando la versión de PHP de ServBay con Swoole habilitado. Usa php -v para ver la versión actual. ServBay suele incluir una herramienta para cambiar fácilmente de versión en la consola.
• Estado de la extensión: Si el servidor no arranca, verifica que la extensión Swoole esté habilitada para la versión de PHP seleccionada en ServBay y que el servicio PHP correspondiente haya sido reiniciado.
• Gestión de procesos residentes: Los servidores Swoole son procesos en memoria. En producción, utiliza herramientas de gestión de procesos como Supervisor, Systemd, pm2 u otros para mantenerlos activos y reiniciarlos automáticamente en caso de fallo. En entornos de desarrollo local con ServBay, ejecutarlos manualmente suele ser suficiente.

Conclusión

Con ServBay, puedes habilitar y usar Swoole de forma sencilla para crear y probar aplicaciones PHP de alto rendimiento en un entorno local, tanto para servicios HTTP convencionales como para aplicaciones WebSocket en tiempo real. La potencia de Swoole, combinada con la comodidad del entorno de desarrollo de ServBay, abre nuevas posibilidades para los programadores PHP, permitiéndote construir aplicaciones más eficientes y robustas. ¡Empieza a experimentar con Swoole en ServBay ahora mismo!