Crear y ejecutar un proyecto Slim en ServBay

Este artículo te muestra paso a paso cómo crear, configurar y poner en marcha un proyecto con Slim Framework PHP usando ServBay, un potente entorno de desarrollo web local. ServBay incorpora paquetes integrados de PHP, servidores web (Caddy/Nginx/Apache) y diversas bases de datos, lo que lo convierte en una plataforma ideal para proyectos con Slim.

¿Qué es Slim?

Slim es un microframework PHP de bajo peso diseñado para construir aplicaciones web y APIs sencillas pero muy funcionales de manera rápida. Ofrece funcionalidades esenciales como enrutamiento y manejo de peticiones y respuestas, siendo perfecto tanto para desarrollos rápidos y despliegues como para servir de base de aplicaciones más complejas.

Principales características y ventajas de Slim

• Ligereza: El núcleo de Slim es minimalista, consume pocos recursos y arranca con rapidez, ideal para apps pequeñas y medianas o microservicios.
• Flexibilidad: Su arquitectura permite integrar cualquier componente externo o librería (como motores de plantillas, ORM, sistemas de autenticación, etc.), facilitando la personalización total según los requisitos del proyecto.
• Facilidad de uso: Gracias a su API clara y documentación sencilla, los desarrolladores pueden entender sus conceptos y empezar rápidamente.
• Enrutamiento potente: Ofrece soporte para múltiples métodos HTTP (GET, POST, PUT, DELETE, etc.), reglas de enrutamiento avanzadas, agrupación de rutas, middlewares y captura de parametros.
• Soporte de middlewares: Permite ejecutar tareas en peticiones y respuestas antes o después de la lógica principal, como autenticación, logs, CORS, entre otras.

Slim es una excelente elección para construir APIs RESTful, prototipos rápidos y módulos funcionales independientes.

Crear y ejecutar un proyecto Slim en ServBay

En esta guía aprovecharemos el entorno PHP preconfigurado de ServBay y la función de Sitios Web para configurar el servidor y acceder fácilmente a tu proyecto Slim.

Requisitos previos

Antes de empezar, asegúrate de lo siguiente:

1. Instalación y ejecución de ServBay: Verifica que ServBay está instalado correctamente en tu sistema macOS o Windows y que la aplicación está en funcionamiento.
2. Composer integrado en ServBay: Composer ya viene incluido en ServBay, no necesitas instalarlo aparte.

Crear el proyecto Slim

Se recomienda guardar todos los proyectos web en las siguientes rutas para facilitar la administración y configuración desde ServBay:

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

1. Acceder al directorio raíz de sitios en ServBay:

   macOS:

   cd /Applications/ServBay/www

   Windows:

   cd C:\ServBay\www

2. Crear carpeta para el proyecto: Monta una nueva carpeta para el app Slim.

   mkdir servbay-slim-app

3. Entrar al directorio del proyecto:

   cd servbay-slim-app

4. Instalar Slim con Composer: Ejecuta el siguiente comando para instalar Slim y su implementación PSR-7.

   composer require slim/slim "^4.0" slim/psr7 -W

   Este comando descargará Slim y el paquete slim/psr7 en la carpeta vendor y generará los archivos composer.json y composer.lock.

Inicializar la aplicación Slim

1. Crear el archivo de entrada: Un proyecto Slim suele tener un único archivo de entrada (public/index.php) para atender todas las peticiones. Crea la carpeta public y el archivo correspondiente:

   mkdir public
   touch public/index.php

2. Editar el archivo de entrada: Abre public/index.php y agrega la siguiente base de código:

   <?php
   // Cargar el autoloader de Composer
   require __DIR__ . '/../vendor/autoload.php';
   
   // Importar interfaces PSR-7 y la factoría principal de Slim
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Crear una instancia de la aplicación Slim
   $app = AppFactory::create();
   
   // Añadir una ruta básica: gestiona peticiones GET a la raíz '/'
   $app->get('/', function (Request $request, Response $response, $args) {
       // Escribir contenido en el cuerpo de la respuesta
       $response->getBody()->write("Hello ServBay!");
       // Devolver el objeto de respuesta
       return $response;
   });
   
   // Ejecutar la app Slim
   $app->run();

   Este ejemplo establece la estructura mínima de una aplicación Slim, define una ruta para el GET en el URL raíz (/) y devuelve "Hello ServBay!" como respuesta.

Configurar el sitio web en ServBay

Para acceder al proyecto Slim desde el navegador, debes configurar un Sitio Web en ServBay (denominado “Host” en versiones antiguas).

1. Abre la interfaz de ServBay.
2. Ve al módulo de Sitios Web (Websites).
3. Haz clic para añadir un nuevo sitio.
4. Completa la configuración según tu proyecto:

   • Nombre (Name): My First Slim Dev Site (o cualquier nombre que prefieras)

   • Dominio (Domain): servbay-slim-test.local (recomendado usar .local o .test para desarrollo local)

   • Tipo de sitio (Website Type): PHP

   • Versión de PHP (PHP Version): Elige la versión que necesites, por ejemplo 8.3.

   • Raíz del documento (Document Root): Selecciona la carpeta public de tu proyecto:

     • macOS: /Applications/ServBay/www/servbay-slim-app/public
     • Windows: C:\ServBay\www\servbay-slim-app\public

     Esto es esencial porque el archivo de entrada index.php de Slim se encuentra en public, por lo que el servidor debe apuntar ahí.

5. Guarda la configuración. ServBay actualizará automáticamente el servidor web y aplicará los cambios.

Para más detalles sobre la configuración de sitios en ServBay, consulta Agregar tu primer sitio web.

Acceder a tu sitio Slim

Una vez configurado, abre el navegador y accede al dominio que elegiste: https://servbay-slim-test.local.

Si todo está correcto, verás el mensaje Hello ServBay! en la página, señal de que tu proyecto Slim está funcionando con ServBay como servidor web.

Ejemplo de integración con bases de datos

Slim no incluye una capa de abstracción de base de datos por defecto, pero se integra fácilmente con librerías PHP de bases de datos. Aquí mostraremos cómo conectar MySQL y PostgreSQL usando el ORM Eloquent de Laravel (componente illuminate/database), además de ejemplos para Memcached y Redis.

Requisito previo: crear la base de datos y correr migraciones

Antes de integrar la base de datos, necesitas crearla en ServBay y definir las tablas necesarias para tu app.

1. Crear base de datos:

   • Accede a la interfaz de ServBay y ubica el paquete de base de datos que prefieras (MySQL o PostgreSQL).
   • Usa las herramientas incluidas (phpMyAdmin para MySQL/MariaDB, pgAdmin para PostgreSQL) o el terminal para crear una nueva base de datos, por ejemplo llamada servbay_slim_app.
   • Por defecto, la contraseña del usuario root es password, puedes consultarla y modificarla en la interfaz de ServBay.

2. Instalar y configurar Phinx (herramienta de migraciones): Phinx es una herramienta popular de migración de bases de datos para PHP que facilita el control de versiones de la estructura de datos.

   • Dentro del directorio del proyecto, instala Phinx con Composer:
     • macOS: /Applications/ServBay/www/servbay-slim-app
     • Windows: C:\ServBay\www\servbay-slim-app

     composer require robmorgan/phinx

   • Inicializa la configuración de Phinx:

     vendor/bin/phinx init

     Esto generará phinx.yml en la raíz del proyecto. Edítalo con tus datos de conexión, ejemplo:

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development # O el nombre de tu entorno
     
         development: # Ajusta según tipo de base de datos
             adapter: mysql # o pgsql
             host: 127.0.0.1
             name: servbay_slim_app # Tu BD
             user: root
             pass: password # Tu clave
             port: 3306 # MySQL, PostgreSQL usa 5432
             charset: utf8mb4 # Recomendado MySQL
             collation: utf8mb4_unicode_ci # Recomendado MySQL
     
     version_order: creation

3. Crear archivo de migración: Usa Phinx para crear una migración nueva.

   vendor/bin/phinx create CreateUsersTable

   Esto creará un nuevo archivo PHP en db/migrations. Edita el método change() para definir la tabla users:

   <?php
   
   declare(strict_types=1);
   
   use Phinx\Migration\AbstractMigration;
   
   final class CreateUsersTable extends AbstractMigration
   {
       /**
        * Change Method.
        *
        * Write your reversible migrations using this method.
        *
        * More information on writing migrations is available here:
        * https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
        *
        * Remember to call "create()" or "update()" and NOT "save()" when working
        * with the Table class.
        */
       public function change(): void
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string')
                 ->addColumn('email', 'string', ['unique' => true])
                 ->addTimestamps() // Agrega campos created_at y updated_at
                 ->create();
       }
   }

4. Ejecutar la migración: Desde la raíz ejecuta el comando para crear la tabla users.

   vendor/bin/phinx migrate

   Importante: Realiza estos pasos antes de probar los ejemplos con base de datos.

Usando el componente illuminate/database

Utilizaremos el paquete de Laravel (illuminate/database) como ORM y constructor de consultas SQL.

1. Instalar illuminate/database: Corre en la raíz del proyecto:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require illuminate/database

2. Configurar la conexión en public/index.php: Después de require __DIR__ . '/../vendor/autoload.php'; y antes de crear la app ($app = AppFactory::create();), agrega:

   // ... otras declaraciones require y use ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // Importar Capsule
   
   // Inicializar Eloquent ORM
   $capsule = new Capsule;
   
   // Configuración de la conexión (ajusta driver y parámetros según tu base)
   $capsule->addConnection([
       'driver' => 'mysql', // o 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app', // nombre de tu BD
       'username' => 'root', // usuario BD
       'password' => 'password', // clave BD
       'charset' => 'utf8mb4', // MySQL
       'collation' => 'utf8mb4_unicode_ci', // MySQL
       'prefix' => '',
       // Para PostgreSQL añade:
       // 'schema' => 'public',
   ]);
   
   // Hacerlo global
   $capsule->setAsGlobal();
   
   // Arrancar Eloquent
   $capsule->bootEloquent();
   
   // ... crear instancia Slim ...

Ejemplo MySQL

Imaginando que tienes el paquete MySQL iniciado en ServBay, has creado la BD servbay_slim_app y ejecutado la migración de la tabla users.

Añade las siguientes rutas antes de $app->run(); en public/index.php:

// ... inicialización y ruta '/' ...

use Illuminate\Database\Capsule\Manager as Capsule; // Asegúrate de importar

// Ruta para agregar usuario
$app->get('/mysql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay Demo User',
            'email' => 'servbay-demo-' . time() . '@servbay.test', // Email único usando time()
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('Usuario agregado a MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error al agregar usuario: ' . $e->getMessage());
        $response = $response->withStatus(500); // Código de error
    }
    return $response;
});

// Ruta para obtener usuarios
$app->get('/mysql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson()); // Resultado como JSON
        $response = $response->withHeader('Content-Type', 'application/json'); // Encabezado JSON
    } catch (\Exception $e) {
         $response->getBody()->write('Error al consultar usuarios: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Acceso:

• Accede a https://servbay-slim-test.local/mysql-add-user para añadir un usuario al tabla users.
• Dirígete a https://servbay-slim-test.local/mysql-get-users para listar todos los usuarios en formato JSON.

Ejemplo PostgreSQL

Si tienes el paquete PostgreSQL activo en ServBay, la base servbay_slim_app creada y la migración ejecutada (asegúrate de que el config de Phinx use adapter: pgsql y puerto 5432).

Modifica la config de conexión en public/index.php:

$capsule->addConnection([
    'driver' => 'pgsql', // Cambia a pgsql
    'host' => '127.0.0.1',
    'database' => 'servbay_slim_app',
    'username' => 'root',
    'password' => 'password',
    'charset' => 'utf8', // PostgreSQL suele usarse utf8
    'prefix' => '',
    'schema' => 'public', // Especifica el schema
]);
// ... el resto de la inicialización Eloquent sin cambios ...

Añade estas rutas antes de $app->run();:

// ... inicialización y ruta '/' ...
// ... rutas MySQL si lo deseas ...

use Illuminate\Database\Capsule\Manager as Capsule; // Asegúrate de importar

// Ruta para agregar usuario
$app->get('/pgsql-add-user', function (Request $request, Response $response, $args) {
    try {
        Capsule::table('users')->insert([
            'name' => 'ServBay PG Demo User',
            'email' => 'servbay-pg-demo-' . time() . '@servbay.test', // Email único
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('Usuario agregado a PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error al agregar usuario: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Ruta para obtener usuarios
$app->get('/pgsql-get-users', function (Request $request, Response $response, $args) {
    try {
        $users = Capsule::table('users')->get();
        $response->getBody()->write($users->toJson());
        $response = $response->withHeader('Content-Type', 'application/json');
    } catch (\Exception $e) {
         $response->getBody()->write('Error al consultar usuarios: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

// ... $app->run();

Acceso:

• Visita https://servbay-slim-test.local/pgsql-add-user para añadir un usuario a PostgreSQL.
• Accede a https://servbay-slim-test.local/pgsql-get-users para obtener todos los usuarios en JSON.

Ejemplo Memcached

ServBay incluye el paquete Memcached y la extensión ext-memcached para PHP. Solo necesitas instalar el cliente PHP para usarlo, en este ejemplo empleamos memcached/memcached.

1. Instalar el cliente de Memcached: En la raíz:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require memcached/memcached

2. Agregar rutas Memcached en public/index.php: Antes de $app->run();, incluye:

   // ... inicialización y rutas de BD ...
   
   // Ruta de ejemplo con Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Instanciar cliente
       $memcached = new Memcached();
       // Agregar servidor (por defecto en ServBay, 127.0.0.1:11211)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Intentar leer del caché
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Si no existe, generar y guardar en caché
           $cachedData = '¡Hola Memcached desde ServBay! Esto no estaba cacheado.';
           // Guardar datos 60 segundos
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // Si existe, usar datos de caché
           $response->getBody()->write('¡Hola Memcached desde ServBay! Esto fue servido desde caché.');
       }
   
       return $response;
   });
   
   // ... $app->run();

Acceso: Ve a https://servbay-slim-test.local/memcached-example. La primera visita muestra "Esto no estaba cacheado", las siguientes (antes de expirar el caché) "Esto fue servido desde caché".

Ejemplo Redis

ServBay incluye el paquete Redis y la extensión ext-redis para PHP. Solo necesitas instalar el cliente PHP; aquí usamos predis/predis.

1. Instalar el cliente Redis: En la raíz:

   • macOS: /Applications/ServBay/www/servbay-slim-app
   • Windows: C:\ServBay\www\servbay-slim-app

   composer require predis/predis

2. Agregar rutas Redis en public/index.php: Antes de $app->run();:

   // ... inicialización y rutas de BD ...
   // ... rutas Memcached si las usas ...
   
   use Predis\Client as RedisClient; // Importar Predis
   
   // Ruta de ejemplo con Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Instanciar cliente Redis (por defecto en ServBay, 127.0.0.1:6379)
           $redis = new RedisClient([
               'scheme' => 'tcp',
               'host' => '127.0.0.1',
               'port' => 6379,
           ]);
   
           $cacheKey = 'my_servbay_redis_cache_key';
           // Intentar leer del caché
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Si no existe, generar y guardar en caché
               $cachedData = '¡Hola Redis desde ServBay! Esto no estaba cacheado.';
               // Guardar datos 60 segundos
               $redis->setex($cacheKey, 60, $cachedData); // SETEX key segundos valor
               $response->getBody()->write($cachedData);
           } else {
               // Si existe, usar datos cacheados
               $response->getBody()->write('¡Hola Redis desde ServBay! Esto fue servido desde caché.');
           }
       } catch (\Exception $e) {
           // Captura excepciones de conexión u operación
           $response->getBody()->write('Error al conectar o operar con Redis: ' . $e->getMessage());
           $response = $response->withStatus(500);
       }
   
       return $response;
   });
   
   // ... $app->run();

Acceso: Ingresa a https://servbay-slim-test.local/redis-example. La primera visita muestra "Esto no estaba cacheado", las siguientes (antes de expirar el caché) muestran "Esto fue servido desde caché".

Resumen

Siguiendo estos pasos, habrás creado un proyecto con Slim Framework en tu entorno ServBay y configurado la función de Sitios Web para alojarlo y acceder desde el navegador. Además, aprendiste a integrar diversos paquetes y extensiones de ServBay (MySQL, PostgreSQL, Memcached, Redis) en tu app Slim para gestionar bases de datos y caché de forma sencilla. ServBay simplifica la instalación y administración del entorno local, permitiéndote centrarte en el desarrollo de tu aplicación.