Crear y ejecutar un proyecto Webman en ServBay

¿Qué es Webman?

Webman es un framework web asíncrono de alto rendimiento basado en Workerman, especialmente diseñado para construir aplicaciones web de alta concurrencia y alto rendimiento. A diferencia de los frameworks tradicionales de PHP basados en bloqueo síncrono, Webman adopta un modelo de I/O asíncrono y dirigido por eventos, permitiéndole destacar en la gestión de grandes volúmenes de peticiones simultáneas. Webman proporciona una API sencilla y flexible, facilitando la creación de aplicaciones en tiempo real, servicios API, microservicios y más.

Principales características y ventajas de Webman

• Alto rendimiento: Basado en Workerman, utiliza I/O asíncrono y dirigido por eventos, capaz de manejar innumerables conexiones concurrentes. Su rendimiento supera con creces el de los frameworks síncronos tradicionales.
• Fácil de usar: Ofrece una API clara e intuitiva y un conjunto de características completas que permiten a los desarrolladores comenzar rápidamente y construir aplicaciones ágilmente.
• Soporte multiprotocolo: Soporta de forma nativa HTTP, WebSocket y otros protocolos de capa de aplicación comunes, facilitando la creación de distintos tipos de servicios.
• Expansión flexible: Se puede extender fácilmente mediante paquetes de Composer, plugins y middleware.
• Bajo consumo de recursos: Comparado con el modelo tradicional de servidor web + PHP-FPM, Webman actúa como una aplicación residente en memoria, reduciendo el consumo de recursos.
• Gran soporte comunitario: Una comunidad activa de desarrolladores y abundante documentación.

Webman ayuda a los desarrolladores a crear rápidas aplicaciones y servicios web de alto rendimiento y alta disponibilidad, especialmente adecuados para escenarios de alta concurrencia y baja latencia.

Crear y ejecutar un proyecto simple de Webman con ServBay

Esta guía explica en detalle cómo crear y ejecutar un proyecto web simple con Webman en el entorno de desarrollo local de ServBay. Mostraremos cómo instalar Webman, escribir rutas y controladores básicos, e integrar los servicios de bases de datos (MySQL, PostgreSQL) y caché (Redis, Memcached) que ofrece ServBay.

TIP

ServBay recomienda a los desarrolladores ubicar todos los proyectos web locales en el directorio /Applications/ServBay/www para una gestión centralizada, como la configuración de sitios locales (anteriormente llamados “hosts”).

Requisitos previos

Antes de comenzar, asegúrate de tener lo siguiente preparado:

1. Instalar ServBay: Ya tienes ServBay instalado correctamente en macOS. ServBay ofrece un entorno completo de desarrollo local que incluye PHP, Composer, MySQL, PostgreSQL, Redis, Memcached y todos los paquetes necesarios para este tutorial.
2. Habilitar los paquetes necesarios: Desde el panel de control de ServBay, asegúrate de que los siguientes paquetes estén instalados y en funcionamiento:
   • La versión de PHP que elijas (se recomienda una versión reciente, como PHP 8.x)
   • Composer (ya incluido en ServBay)
   • MySQL
   • PostgreSQL
   • Redis
   • Memcached
   • Asegúrate de que la versión de PHP seleccionada tenga habilitadas las extensiones necesarias como memcached, redis, pdo_mysql, pdo_pgsql, etc. ServBay suele activarlas por defecto, pero puedes verificar en la configuración de PHP de ServBay.
3. Acceso a la terminal: Estar familiarizado con el uso de la app Terminal de macOS.

Instalar Webman

1. Verifica que Composer esté disponible

   ServBay viene con Composer preinstalado y configurado para usarse directamente desde la terminal. Puedes comprobarlo ejecutando:

   composer --version

   Si ves la información de la versión correctamente, Composer está listo para usarse.

2. Accede al directorio de sitios web de ServBay

   Abre la terminal y navega al directorio raíz recomendado para sitios web en ServBay:

   cd /Applications/ServBay/www

3. Crea un proyecto Webman con Composer

   Usa el comando create-project de Composer para instalar el framework Webman en el directorio que elijas. En este ejemplo, lo llamamos servbay-webman-app:

   composer create-project workerman/webman servbay-webman-app

   Composer descargará Webman y sus dependencias principales dentro del directorio servbay-webman-app.

4. Accede al directorio del proyecto

   Una vez finalizada la instalación, entra en el nuevo directorio del proyecto:

   cd servbay-webman-app

5. Instala los componentes necesarios

   Para mostrar el uso de base de datos y caché, instalaremos algunos paquetes adicionales de Composer. Webman suele utilizar illuminate/database (el componente de base de datos de Laravel), illuminate/redis y otros. El parámetro -W (--with-dependencies) asegura que se resuelvan las dependencias y la compatibilidad.

   composer require -W illuminate/database illuminate/redis illuminate/pagination illuminate/events symfony/var-dumper

   Este comando instala el ORM para bases de datos, el cliente de Redis, componentes de paginación, despacho de eventos y la herramienta de depuración VarDumper.

Crear la base de datos y la tabla

Para que los ejemplos funcionen, necesitamos crear la base de datos correspondiente y la tabla users tanto en MySQL como en PostgreSQL de ServBay. La contraseña predeterminada del usuario root es password.

Puedes usar las herramientas de gestión incluidas en ServBay (como phpMyAdmin o pgAdmin, accesibles desde el panel de control de ServBay) o la línea de comandos para ejecutar los siguientes SQL.

1. Crear la base de datos webman_app

   • MySQL:

     CREATE DATABASE IF NOT EXISTS webman_app CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

   • PostgreSQL:

     CREATE DATABASE webman_app;

2. Crear la tabla users dentro de la base de datos webman_app

   • MySQL:

     USE webman_app;
     CREATE TABLE users (
         id INT AUTO_INCREMENT PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

   • PostgreSQL:

     \c webman_app; -- Conéctate a la nueva base de datos
     CREATE TABLE users (
         id SERIAL PRIMARY KEY,
         name VARCHAR(255) NOT NULL,
         email VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );

Escribir el código del proyecto web

A continuación, añadiremos el código necesario para definir las rutas, crear los controladores y la lógica para interactuar con la base de datos y los sistemas de caché.

1. Configura las rutas

   Edita el archivo config/route.php en la raíz del proyecto, agregando el siguiente código para definir las rutas necesarias:

   <?php
   
   use Webman\Route;
   use app\controller\IndexController;
   use app\controller\CacheController;
   use app\controller\DatabaseController;
   
   // Define la ruta raíz, mapeando al método index de IndexController
   Route::any('/', [IndexController::class, 'index']);
   
   // Define rutas relacionadas con la caché
   Route::any('/memcached', [CacheController::class, 'memcached']);
   Route::any('/redis', [CacheController::class, 'redis']);
   
   // Define rutas para la base de datos
   Route::any('/mysql-add', [DatabaseController::class, 'mysqlAdd']);
   Route::any('/mysql', [DatabaseController::class, 'mysqlGet']);
   Route::any('/pgsql-add', [DatabaseController::class, 'pgsqlAdd']);
   Route::any('/pgsql', [DatabaseController::class, 'pgsqlGet']);
   
   // Puedes agregar más rutas aquí...

2. Crea los archivos de controladores

   Dentro del directorio app/controller, crea los archivos IndexController.php, CacheController.php y DatabaseController.php y añade el siguiente código para cada uno.

   • app/controller/IndexController.php: Maneja peticiones a la ruta raíz.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response; // Importar la clase Response
     
     class IndexController
     {
         /**
          * Método de ejemplo para manejar la ruta raíz
          * @param Request $request Objeto de la petición actual
          * @return Response Devuelve una respuesta
          */
         public function index(Request $request): Response // Especificar el tipo de retorno
         {
             // Devuelve una respuesta de texto sencilla
             return response('¡Hola ServBay & Webman!'); // Mensaje de bienvenida actualizado
         }
     }

   • app/controller/CacheController.php: Demuestra el uso de Memcached y Redis.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use Memcached; // Importar la clase Memcached
     use support\Redis; // Importar el facade Redis de Webman
     
     class CacheController
     {
         /**
          * Ejemplo de uso de Memcached
          * @param Request $request
          * @return Response
          */
         public function memcached(Request $request): Response
         {
             // Conectar al servidor Memcached, por defecto en 127.0.0.1:11211 en ServBay
             $memcached = new Memcached();
             $memcached->addServer('127.0.0.1', 11211);
     
             // Establece un ítem de caché válido por 60 segundos
             $success = $memcached->set('servbay_key', '¡Hola Memcached desde ServBay!', 60); // Clave y valor actualizados
             if (!$success) {
                  return response('No se pudo guardar la clave en Memcached', 500);
             }
     
             // Obtener el valor cacheado
             $value = $memcached->get('servbay_key'); // Clave actualizada
     
             // Devuelve el valor encontrado o un mensaje si expiró/no existe
             return response($value ?: 'Clave de Memcached no encontrada o expirada'); // Mensaje actualizado
         }
     
         /**
          * Ejemplo de uso de Redis
          * @param Request $request
          * @return Response
          */
         public function redis(Request $request): Response
         {
             // Usa el facade Redis de Webman para guardar un valor en caché
             Redis::set('servbay_redis_key', '¡Hola Redis desde ServBay!'); // Clave y valor actualizados
     
             // Recupera el valor cacheado de Redis
             $value = Redis::get('servbay_redis_key'); // Clave actualizada
     
             // Devuelve el valor encontrado o un mensaje si no existe
             return response($value ?: 'Clave de Redis no encontrada'); // Mensaje actualizado
         }
     }

   • app/controller/DatabaseController.php: Demuestra operaciones de base de datos con MySQL y PostgreSQL.

     <?php
     
     namespace app\controller;
     
     use support\Request;
     use support\Response;
     use support\Db; // Importar el facade Db de Webman
     
     class DatabaseController
     {
         /**
          * Agrega un usuario a la base de datos MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlAdd(Request $request): Response
         {
             try {
                 // Conecta a MySQL e inserta el usuario
                 Db::connection('mysql')->table('users')->insert([
                     'name' => 'Usuario MySQL de ServBay Webman', // Datos de ejemplo actualizados
                     'email' => 'mysql_demo@servbay.test', // Correo de ejemplo actualizado
                     'created_at' => date('Y-m-d H:i:s') // Se añade created_at
                 ]);
                 return response('Usuario agregado a MySQL'); // Mensaje actualizado
             } catch (\Exception $e) {
                 return response('Error al agregar usuario en MySQL: ' . $e->getMessage(), 500); // Manejo de errores mejorado
             }
         }
     
         /**
          * Obtiene la lista de usuarios de la base de datos MySQL
          * @param Request $request
          * @return Response
          */
         public function mysqlGet(Request $request): Response
         {
             try {
                 // Recupera todos los usuarios de la base de datos MySQL
                 $users = Db::connection('mysql')->table('users')->get();
                 // Devuelve la lista formateada en JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Especificar Content-Type
             } catch (\Exception $e) {
                  return response('Error al obtener usuarios de MySQL: ' . $e->getMessage(), 500); // Manejo de errores mejorado
             }
         }
     
         /**
          * Agrega un usuario a la base de datos PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlAdd(Request $request): Response
         {
              try {
                 // Conecta a PostgreSQL e inserta el usuario
                 Db::connection('pgsql')->table('users')->insert([
                     'name' => 'Usuario PgSQL de ServBay Webman', // Datos de ejemplo actualizados
                     'email' => 'pgsql_demo@servbay.test', // Correo de ejemplo actualizado
                     'created_at' => date('Y-m-d H:i:s') // Se añade created_at
                 ]);
                 return response('Usuario agregado a PostgreSQL'); // Mensaje actualizado
              } catch (\Exception $e) {
                 return response('Error al agregar usuario en PostgreSQL: ' . $e->getMessage(), 500); // Manejo de errores mejorado
              }
         }
     
         /**
          * Obtiene la lista de usuarios de la base de datos PostgreSQL
          * @param Request $request
          * @return Response
          */
         public function pgsqlGet(Request $request): Response
         {
              try {
                 // Recupera todos los usuarios de la base de datos PostgreSQL
                 $users = Db::connection('pgsql')->table('users')->get();
                 // Devuelve la lista formateada en JSON
                 return response(json_encode($users), 200, ['Content-Type' => 'application/json']); // Especificar Content-Type
              } catch (\Exception $e) {
                 return response('Error al obtener usuarios de PostgreSQL: ' . $e->getMessage(), 500); // Manejo de errores mejorado
              }
         }
     }

3. Configura la conexión a la base de datos

   Edita el archivo config/database.php en la raíz del proyecto configurando la conexión a MySQL y PostgreSQL. El host predeterminado es 127.0.0.1, los puertos son 3306 (MySQL) y 5432 (PostgreSQL), y la contraseña del usuario root es password.

   <?php
   /**
    * Configuración de base de datos
    */
   return [
       // Conexión por defecto
       'default' => 'mysql',
   
       // Lista de conexiones
       'connections' => [
           'mysql' => [
               'driver'    => 'mysql',
               // Host y puerto MySQL por defecto en ServBay
               'host'      => '127.0.0.1',
               'port'      => 3306,
               // Nombre de la base de datos creada antes
               'database'  => 'webman_app',
               // Usuario por defecto de ServBay MySQL
               'username'  => 'root',
               // Contraseña predeterminada de ServBay MySQL
               'password'  => 'password',
               'charset'   => 'utf8mb4',
               'collation' => 'utf8mb4_unicode_ci',
               'prefix'    => '',
               'strict'    => true,
               'engine'    => null,
           ],
           'pgsql' => [
               'driver'   => 'pgsql',
               // Host y puerto PostgreSQL por defecto en ServBay
               'host'     => '127.0.0.1',
               'port'     => 5432,
                // Nombre de la base de datos creada antes
               'database' => 'webman_app',
                // Usuario por defecto de ServBay PostgreSQL
               'username' => 'root',
                // Contraseña predeterminada de ServBay PostgreSQL
               'password' => 'password',
               'charset'  => 'utf8',
               'prefix'   => '',
               'schema'   => 'public',
               'sslmode'  => 'prefer', // O require, verify-ca, verify-full
           ],
           // Puedes agregar más conexiones aquí...
       ],
   ];

   Aviso importante: En un entorno de producción, asegúrate de cambiar la contraseña predeterminada y evita guardar información sensible en el código fuente.

Ejecutar el proyecto Webman

Generalmente, un proyecto Webman se inicia mediante el script start.php, el cual arranca los procesos de Workerman. Esto difiere de la manera tradicional con Nginx/Apache + PHP-FPM; Webman es una aplicación asíncrona residente en memoria.

En el directorio raíz del proyecto (/Applications/ServBay/www/servbay-webman-app), ejecuta el siguiente comando para iniciar Webman:

php start.php start

Tras ejecutar el comando, deberías ver el mensaje de inicio de Webman, que por defecto escuchará peticiones HTTP en 127.0.0.1:8787.

• Nota: El comando php que utilices es el que proporciona el entorno de ServBay. ServBay ajusta automáticamente el PATH de tu terminal para que uses la versión de PHP instalada en ServBay.
• Para ejecutar Webman en segundo plano, añade el parámetro -d: php start.php start -d.
• Para detener el servicio de Webman, ejecuta: php start.php stop.
• Para reiniciar Webman, ejecuta: php start.php restart.
• Para recargar suavemente (sin interrumpir las conexiones actuales): php start.php reload.

Probar el proyecto

Una vez que Webman esté corriendo y escuchando en 127.0.0.1:8787, puedes acceder a las siguientes URLs desde tu navegador para probar cada funcionalidad:

• http://localhost:8787/: Verás la salida ¡Hola ServBay & Webman!.
• http://localhost:8787/memcached: Debería mostrar ¡Hola Memcached desde ServBay!. Esto indica que la integración con Memcached vía Webman funciona.
• http://localhost:8787/redis: Debería mostrar ¡Hola Redis desde ServBay!. Éxito en la conexión y uso de Redis.
• http://localhost:8787/mysql-add: Verás el mensaje Usuario agregado a MySQL. Se insertará un registro en la tabla users de la base creada anteriormente en MySQL.
• http://localhost:8787/mysql: Mostrará en formato JSON la lista de usuarios de la tabla users de MySQL.
• http://localhost:8787/pgsql-add: El mensaje Usuario agregado a PostgreSQL confirmará la inserción en la tabla respectiva de PostgreSQL.
• http://localhost:8787/pgsql: Mostrará la lista de usuarios en formato JSON desde PostgreSQL.

Si encuentras algún problema al acceder a estas URL, revisa la salida en la terminal de Webman para mensajes de error y asegúrate de que los servicios MySQL, PostgreSQL, Redis y Memcached están en marcha, así como que las extensiones PHP necesarias están activadas.

Preguntas frecuentes (FAQ)

• P: ¿No encuentra el comando php start.php start?
  • R: Asegúrate de haber ejecutado cd para situarte en el directorio del proyecto servbay-webman-app en la terminal. Verifica que la PHP de ServBay esté correctamente en el PATH (ServBay suele configurarlo automáticamente).
• P: ¿Al acceder a localhost:8787 aparece error de conexión?
  • R: Verifica mensajes de error en la terminal al ejecutar php start.php start. Asegúrate de que el puerto 8787 no esté ocupado. Si lo está, puedes cambiar el puerto en el archivo de configuración de Webman (por ejemplo, en config/server.php).
• P: ¿Error de conexión a la base de datos?
  • R: Comprueba que los servicios de MySQL y PostgreSQL de ServBay estén activos. Revisa config/database.php (host, puerto, nombre de base, usuario y contraseña) y asegúrate de que coincidan con la configuración de ServBay (por defecto usuario root, contraseña password) y de que has creado la base y la tabla users.
• P: ¿Error de conexión a Memcached o Redis?
  • R: Revisa si los servicios de Memcached y Redis de ServBay están en marcha. Verifica las direcciones y puertos en app/controller/CacheController.php (por defecto 127.0.0.1:11211 y 127.0.0.1:6379). Asegúrate de tener habilitadas las extensiones memcached y redis en PHP.

Resumen

Siguiendo estos pasos, has creado, configurado y ejecutado con éxito un proyecto básico de Webman en el entorno de desarrollo local de ServBay. Aprendiste a aprovechar los servicios integrados de ServBay para montar fácilmente el entorno de desarrollo de Webman, así como la integración de bases de datos y caché. Las capacidades de alto rendimiento de Webman, combinadas con la conveniencia de ServBay, ofrecen una potente plataforma para el desarrollo de aplicaciones PHP asíncronas. Esperamos que esta guía te ayude a sacar el máximo partido a ServBay y Webman para construir excelentes aplicaciones web.