Usar Swoole en ServBay para crear aplicaciones PHP de alto rendimiento

ServBay es un entorno de desarrollo web local diseñado especialmente para desarrolladores. Incluye múltiples lenguajes, bases de datos y herramientas preinstaladas para simplificar tu flujo de trabajo local. En este artículo, aprenderás cómo aprovechar la extensión Swoole en ServBay para potenciar tus aplicaciones PHP y crear servicios de red de alto rendimiento.

¿Qué es Swoole?

Swoole es un motor de comunicación de red basado en corrutinas y diseñado para PHP, capaz de ejecutar tareas en paralelo y con alto rendimiento. Está escrito en C puro y dota a PHP de capacidades asincrónicas, paralelas y basadas en corrutinas para la comunicación en red. Gracias a Swoole, los desarrolladores PHP pueden superar las restricciones del modelo tradicional de petición-respuesta de servidores web como Apache/Nginx + PHP-FPM, y manejar tareas altamente concurrentes de forma eficiente, como servidores web residentes en memoria, procesamiento de tareas asíncronas o servicios de comunicación en tiempo real como WebSocket.

Características clave de Swoole:

• Alto rendimiento: Implementación en C a bajo nivel, con soporte para I/O asíncrono, multiprocesos y multihilos.
• Corrutinas: Corrutinas ligeras que permiten la ejecución asíncrona usando código síncrono; simplifica la programación asíncrona.
• Soporte de protocolos variado: Compatibilidad nativa con TCP, UDP, HTTP, WebSocket y más.
• Facilidad de uso: API sencilla que sigue las convenciones habituales de PHP.
• Proceso residente en memoria: Las aplicaciones se ejecutan como procesos persistentes, evitando la sobrecarga de inicialización en cada petición típica de PHP.

Con Swoole, PHP deja de ser simplemente un lenguaje para desarrollo web y pasa a ser apto para aplicaciones de red modernas y de alto rendimiento.

Activar Swoole en ServBay

Uno de los objetivos de diseño de ServBay es facilitar la gestión y activación de extensiones PHP para los desarrolladores. Como extensión esencial para el desarrollo de alto rendimiento moderno en PHP, Swoole ya viene preinstalado en ServBay. Solo necesitas unos pocos pasos para activarlo.

Requisitos previos:

• ServBay debe estar instalado y en ejecución.
• Verifica que tienes al menos una versión de PHP instalada en ServBay.

Pasos para activar Swoole:

1. Abre la interfaz de la aplicación ServBay.
2. Navega a "Paquetes (Packages)" o al panel de gestión de versiones de PHP. (Nota: el nombre puede variar según la versión de ServBay, suele estar en la pantalla principal o en la configuración).
3. Selecciona la versión de PHP donde deseas activar Swoole.
4. Encuentra la opción de la extensión Swoole y márcala como habilitada. ServBay suele mostrar las extensiones compiladas en forma de lista o interruptores.
5. Guarda los cambios y reinicia ServBay o el servicio PHP correspondiente según las indicaciones. ServBay configurará automáticamente el entorno para cargar Swoole.

Después de estos pasos, podrás usar Swoole en la versión de PHP seleccionada. Compruébalo ejecutando php -m en la terminal para confirmar que swoole aparece en la lista de extensiones cargadas.

TIP

ServBay recomienda guardar tus archivos de proyectos y sitios web en los siguientes directorios, lo que facilita la gestión y configuración:

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

En los ejemplos de este artículo seguiremos esa estructura de rutas.

Crear un servidor HTTP básico con Swoole

A continuación, vamos a crear un servidor HTTP simple usando Swoole para procesar solicitudes web.

Paso 1: Crear el directorio del proyecto

Abre la terminal y crea un nuevo directorio para tu proyecto en la ruta recomendada por 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

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
// Escuchar el puerto 9501 en todas las interfaces de red (0.0.0.0)
$server = new Server("0.0.0.0", 9501);

// Registrar el callback para el evento 'start'
// Se dispara cuando el servidor inicia exitosamente
$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, el ID del proceso de gestión, etc.
});

// Registrar el callback para el evento 'request'
// Se dispara al recibir una nueva solicitud HTTP
$server->on("request", function (Request $request, Response $response) {
    // Establecer la cabecera de la respuesta
    $response->header("Content-Type", "text/plain");

    // Lógica según la ruta o los parámetros de la solicitud
    $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 solicitud a través del objeto $request
    }

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

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

Este script crea un servidor HTTP con Swoole en el puerto 9501. Cuando recibe una solicitud, responde con el texto "Hello ServBay!". Si visitas la ruta /info, te devolverá información de la solicitud.

Paso 3: Ejecutar el servidor Swoole

Verifica que estás en el directorio servbay-swoole-http en el terminal. Ejecuta el script usando la versión de PHP de ServBay con Swoole habilitado:

php server.php

Si todo está correcto, verás esta salida en la terminal:

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

Esto indica que el servidor HTTP de Swoole está funcionando y escuchando en el puerto 9501.

Paso 4: Acceder al servidor Swoole

Abre tu navegador web y visita:

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

Verás la respuesta "Hello ServBay!" o el texto con la información de la solicitud, según la ruta.

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

Usar Swoole para manejar conexiones WebSocket

Swoole ofrece soporte nativo para el protocolo WebSocket, ideal para aplicaciones de comunicación en tiempo real como chats, servidores de juegos o envío de datos instantáneos.

Paso 1: Escribir el script del servidor WebSocket

En tu directorio de proyecto (por ejemplo, servbay-swoole-http o crea uno nuevo, como servbay-swoole-websocket), crea un archivo llamado websocket_server.php y añade el siguiente contenido:

Ruta del directorio de proyecto:

• 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;

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

// Registrar el evento 'start', se dispara 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 dispara cuando se establece una nueva conexión WebSocket
// El objeto $request contiene la información de la conexión, como $request->fd que es el descriptor del cliente
$server->on("open", function (Server $server, Request $request) {
    echo "connection open: {$request->fd}\n";
    // Se puede enviar un mensaje de bienvenida al cliente
    $server->push($request->fd, "Welcome to ServBay WebSocket Demo!");
});

// Registrar el evento 'message'
// Se dispara cuando el servidor recibe un mensaje WebSocket del cliente
// El objeto $frame contiene la información, como $frame->data para el contenido y $frame->fd para el descriptor del cliente
$server->on("message", function (Server $server, Frame $frame) {
    echo "received message from {$frame->fd}: {$frame->data}\n";
    // Enviar la respuesta al cliente que envió el mensaje, o hacer broadcast
    // Por ejemplo, responder solo al emisor
    $server->push($frame->fd, "Hello, you sent: {$frame->data}");

    // Ejemplo de broadcast (requiere mantener una lista de conexiones o recorrerlas)
    // foreach ($server->connections as $fd) {
    //     if ($fd != $frame->fd) { // No enviar al propio emisor
    //         $server->push($fd, "User {$frame->fd} says: {$frame->data}");
    //     }
    // }
});

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

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

Este script crea un servidor WebSocket con Swoole en el puerto 9502. Define callbacks para eventos clave: start (inicio del servidor), open (nueva conexión), message (recepción de mensaje), y close (cierre de conexión). En el evento message, el servidor responde al emisor con el contenido que se recibió.

Paso 2: Ejecutar el servidor WebSocket

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

php websocket_server.php

Si todo va bien, la terminal mostrará:

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

El servidor WebSocket Swoole ya está escuchando en el puerto 9502.

Paso 3: Conectar al servidor WebSocket

Puedes probar tu servidor WebSocket de varias maneras.

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

La mayoría de los navegadores modernos tienen paneles de "Red (Network)" o "Consola (Console)" accesibles con F12, que permiten probar conexiones WebSocket.

1. Abre una página sencilla (ejemplo: about:blank).

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

3. Escribe el siguiente código JavaScript para iniciar la conexión:

   var ws = new WebSocket("ws://localhost:9502");
   
   ws.onopen = function(event) {
     console.log("WebSocket connection opened:", event);
     ws.send("Hello from Browser!"); // Envía un mensaje al establecer la conexión
   };
   
   ws.onmessage = function(event) {
     console.log("Message from server:", event.data); // Mensaje recibido del servidor
   };
   
   ws.onerror = function(event) {
     console.error("WebSocket error:", event); // Se produjo un error
   };
   
   ws.onclose = function(event) {
     console.log("WebSocket connection closed:", event); // La conexión se ha cerrado
   };
   
   // Puedes enviar mensajes con ws.send("tu mensaje") en cualquier momento
   // Y cerrar la conexión con ws.close()

4. Ejecuta el código en la consola y observa el resultado. También verás registros en la terminal donde corre websocket_server.php.

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

wscat es un cliente WebSocket simple basado en Node.js.

1. Instalar wscat: Si no tienes Node.js y npm instalados, hazlo primero. Después, instala wscat globalmente:

   npm install -g wscat

2. Conectar al servidor WebSocket: Ejecuta en la terminal:

   wscat -c ws://localhost:9502

   Si la conexión es exitosa, aparecerá el prompt >.

3. Enviar mensajes: Escribe el mensaje y pulsa enter:

   > Hello ServBay via wscat

   El servidor responderá, y verás el mensaje (usualmente comienza con <):

   < Hello, you sent: Hello ServBay via wscat

   Además, la terminal del servidor mostrará el registro correspondiente.

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

Consideraciones importantes

• Conflicto de puertos: Verifica que los puertos elegidos (9501, 9502) no estén ocupados por otros servicios en tu sistema. Si hay conflictos, Swoole no podrá iniciar.
• Versión de PHP: Asegúrate de usar la versión de PHP con Swoole habilitado que configuraste en ServBay al ejecutar scripts en la terminal. Compruébalo con php -v o usa las herramientas de ServBay para cambiar la versión.
• Estado de la extensión: Si el servidor falla al iniciar, asegúrate de que la extensión Swoole está correctamente habilitada para la versión de PHP que usas en ServBay, y de que has reiniciado ServBay o el servicio PHP.
• Gestión de procesos residentes: Los servidores Swoole operan como procesos residentes en memoria. En producción, es recomendable usar herramientas como Supervisor, Systemd, pm2, etc. para mantener el proceso activo frente a posibles caídas. Para desarrollo local con ServBay, ejecutarlos manualmente desde la terminal suele ser suficiente.

Conclusión

ServBay facilita la habilitación y el uso de la extensión Swoole, permitiéndote desarrollar y probar aplicaciones PHP de alto rendimiento en tu entorno local. Da igual si se trata de servicios HTTP tradicionales o aplicaciones de comunicación en tiempo real con WebSocket: la potencia de Swoole, sumada a la comodidad de ServBay, abre un mundo de posibilidades para desarrolladores PHP, ayudándote a construir aplicaciones más rápidas y robustas. ¡Prueba Swoole en ServBay hoy mismo!