Crear y ejecutar un proyecto Slim en ServBay

Esta guía te mostrará cómo crear, configurar y ejecutar rápidamente un proyecto basado en Slim Framework para PHP dentro del potente entorno local de desarrollo web ServBay. ServBay ofrece PHP preintegrado, servidores web (Caddy/Nginx/Apache) y múltiples paquetes de bases de datos, convirtiéndolo en la plataforma ideal para el desarrollo con Slim.

¿Qué es Slim?

Slim es un microframework PHP ligero, diseñado para construir aplicaciones web y APIs rápidas y funcionales. Proporciona funcionalidades clave como enrutamiento, manejo de peticiones y respuestas, siendo una base perfecta para proyectos que requieren desarrollo y despliegue ágil, o bien como cimiento para aplicaciones más complejas.

Principales características y ventajas de Slim

• Ligero: El núcleo de Slim es increíblemente pequeño, ocupando pocos recursos y con rápido tiempo de inicio; ideal para aplicaciones pequeñas/medianas o microservicios.
• Flexible: Pensado para ser modular, permite integrar fácilmente componentes o librerías externas (motores de plantillas, ORM, bibliotecas de autenticación, etc.), otorgando la flexibilidad de elegir las herramientas que mejor se adapten a tu proyecto.
• Fácil de usar: Su API limpio y documentación clara permiten a cualquier desarrollador entender sus conceptos clave y comenzar a trabajar al instante.
• Enrutamiento potente: Compatible con diversos métodos HTTP (GET, POST, PUT, DELETE, etc.) y configuraciones complejas de rutas, incluyendo agrupación, middlewares y parámetros.
• Soporte para middlewares: El sistema de middlewares de Slim permite intervenir antes de que la petición llegue a la lógica de la aplicación o antes de enviar la respuesta, facilitando tareas como autenticación, logging, gestión de CORS, entre otras.

Slim es ideal para desarrollar API RESTful, prototipos rápidos y gestionar módulos o funcionalidades independientes.

Crear y ejecutar un proyecto Slim usando ServBay

Esta guía utiliza el entorno preconfigurado con PHP de ServBay y su función de Sitios web para levantar el servidor, facilitando el acceso al proyecto Slim con mínima configuración.

Prerrequisitos

Antes de comenzar, asegúrate de tener:

1. ServBay instalado y en ejecución: Confirma que ServBay esté correctamente instalado en macOS y que la aplicación esté funcionando.
2. Composer integrado: ServBay incluye Composer por defecto, por lo que no necesitas instalarlo aparte.

Crear un proyecto Slim

ServBay recomienda organizar todos los proyectos web bajo el directorio /Applications/ServBay/www, para un mejor manejo y configuración de los mismos.

1. Accede al directorio raíz de los sitios web en ServBay:

   cd /Applications/ServBay/www

2. Crea el directorio del proyecto: Genera una nueva carpeta para tu proyecto Slim.

   mkdir servbay-slim-app

3. Entra en el directorio de tu proyecto:

   cd servbay-slim-app

4. Instala Slim con Composer: Utiliza Composer dentro del directorio del proyecto para instalar Slim y su implementación PSR-7.

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

   Este comando descargará el framework Slim y la librería slim/psr7 dentro del directorio vendor y generará los archivos composer.json y composer.lock.

Inicializar la aplicación Slim

1. Crea el archivo de entrada: Los proyectos en Slim suelen tener un único archivo de entrada (por ejemplo, public/index.php) para manejar todas las peticiones. Crea la carpeta public en la raíz del proyecto y dentro de ella, el archivo index.php.

   mkdir public
   touch public/index.php

2. Edita el archivo de entrada: Abre public/index.php y añade el siguiente código básico para una app Slim:

   <?php
   // Cargar el autoload de Composer
   require __DIR__ . '/../vendor/autoload.php';
   
   // Importar las interfaces necesarias de PSR-7 y la factoría de Slim
   use Psr\Http\Message\ResponseInterface as Response;
   use Psr\Http\Message\ServerRequestInterface as Request;
   use Slim\Factory\AppFactory;
   
   // Crear la instancia de la aplicación Slim
   $app = AppFactory::create();
   
   // Añadir una ruta básica: manejar 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 aplicación Slim
   $app->run();

   Este ejemplo configura una aplicación Slim mínima que define una ruta para solicitudes GET en la URL raíz (/), devolviendo en respuesta el texto "Hello ServBay!".

Configurar el sitio en ServBay

Para acceder a tu proyecto Slim desde el navegador, debes configurar un Sitio web en ServBay (llamado "Host" en versiones anteriores).

1. Abre la interfaz de la aplicación ServBay.
2. Ve al módulo de Sitios web.
3. Haz clic en agregar un nuevo sitio.
4. Completa la configuración según el proyecto:
   • Nombre: My First Slim Dev Site (o cualquier nombre de tu preferencia)
   • Dominio: servbay-slim-test.local (recomendado usar .local o .test para desarrollo)
   • Tipo de sitio web: PHP
   • Versión de PHP: Selecciona la versión deseada, por ejemplo, 8.3.
   • Directorio raíz: Haz clic en explorar y selecciona la carpeta public de tu proyecto: /Applications/ServBay/www/servbay-slim-app/public. Slim ubica su archivo de entrada index.php en este directorio, así que el servidor debe apuntar aquí.
5. Guarda la configuración. ServBay se encargará de actualizar y cargar automáticamente la configuración del servidor web.

Para pasos detallados, consulta Agregar tu primer sitio web.

Acceder a tu sitio Slim

Una vez terminado, abre tu navegador y visita el dominio configurado: https://servbay-slim-test.local.

Si todo está correcto, deberías ver en pantalla el texto Hello ServBay!, evidenciando que el proyecto Slim se ejecuta exitosamente bajo el servidor de ServBay.

Ejemplo de integración con bases de datos

Slim no incluye un ORM ni capa de abstracción de base de datos, pero permite integrarlos fácilmente. A continuación, mostraremos cómo conectar MySQL y PostgreSQL usando Eloquent ORM de Laravel (vía illuminate/database), además de ejemplos con Memcached y Redis.

Prerrequisito: Crear la base de datos y ejecutar migraciones

Antes de integrar la base de datos, crea primero la base de datos correspondiente en ServBay y configura las tablas necesarias para tu aplicación.

1. Crear la base de datos:
   • Abre la interfaz de ServBay y accede al paquete de bases de datos elegido (como MySQL o PostgreSQL).
   • Usa una herramienta de gestión proporcionada por ServBay (por ejemplo, phpMyAdmin para MySQL/MariaDB, pgAdmin para PostgreSQL) o el cliente de línea de comandos para crear una nueva base de datos, por ejemplo, servbay_slim_app.
   • La contraseña por defecto del usuario root suele ser password, puedes verla o cambiarla desde la interfaz de ServBay.
2. Instalar y configurar Phinx (herramienta de migraciones): Phinx permite controlar la versión del esquema de tu base de datos.
   • Instala Phinx en /Applications/ServBay/www/servbay-slim-app:

     composer require robmorgan/phinx

   • Inicializa el archivo de configuración:

     vendor/bin/phinx init

     Esto crea un archivo phinx.yml en la raíz del proyecto. Edita este archivo para configurar los datos de conexión:

     paths:
         migrations: '%%PHINX_CONFIG_DIR%%/db/migrations'
         seeds: '%%PHINX_CONFIG_DIR%%/db/seeds'
     
     environments:
         default_migration_table: phinxlog
         default_environment: development
     
         development:
             adapter: mysql # o pgsql
             host: 127.0.0.1
             name: servbay_slim_app # nombre de la base de datos creada
             user: root
             pass: password # tu contraseña de base de datos
             port: 3306 # por defecto para MySQL, PostgreSQL usualmente 5432
             charset: utf8mb4
             collation: utf8mb4_unicode_ci
     
     version_order: creation

3. Crear un archivo de migración: Con el comando Phinx:

   vendor/bin/phinx create CreateUsersTable

   Esto genera un 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
   {
       /**
        * Método Change.
        *
        * Escribe tus migraciones reversibles aquí.
        *
        * Más información sobre migraciones:
        * https://book.cakephp.org/phinx/0/en/migrations.html#the-change-method
        *
        * Recuerda llamar a "create()" o "update()" y NO a "save()" al trabajar con la clase Table.
        */
       public function change(): void
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string')
                 ->addColumn('email', 'string', ['unique' => true])
                 ->addTimestamps() // Añade campos created_at y updated_at
                 ->create();
       }
   }

4. Ejecutar la migración: Desde la raíz del proyecto, ejecuta:

   vendor/bin/phinx migrate

   Importante: Antes de ejecutar los ejemplos de integración de base de datos, asegúrate de haber completado la creación de base de datos y migración.

Usando el componente illuminate/database

Utilizaremos el componente de base de datos de Laravel (illuminate/database) como ORM y generador de consultas.

1. Instalar illuminate/database: En /Applications/ServBay/www/servbay-slim-app, ejecuta:

   composer require illuminate/database

2. Inicializar la conexión en public/index.php: Añade después de require __DIR__ . '/../vendor/autoload.php'; y antes de crear la instancia Slim $app = AppFactory::create(); lo siguiente:

   // ... otros require y use ...
   
   use Illuminate\Database\Capsule\Manager as Capsule; // Importar Capsule
   
   // Inicializar Eloquent ORM
   $capsule = new Capsule;
   
   // Añadir configuración de la conexión (ajusta driver y parámetros según la base de datos)
   $capsule->addConnection([
       'driver' => 'mysql', // o 'pgsql'
       'host' => '127.0.0.1',
       'database' => 'servbay_slim_app', // nombre de la base de datos
       'username' => 'root', // usuario de base de datos
       'password' => 'password', // contraseña
       'charset' => 'utf8mb4',
       'collation' => 'utf8mb4_unicode_ci',
       'prefix' => '',
       // PostgreSQL requiere el parámetro schema
       // 'schema' => 'public',
   ]);
   
   // Hacer disponible globalmente
   $capsule->setAsGlobal();
   
   // Iniciar Eloquent
   $capsule->bootEloquent();
   
   // ... crear la instancia de Slim ($app = AppFactory::create();) ...

Ejemplo con MySQL

Supón que ya has iniciado el paquete MySQL en ServBay, creado la base de datos servbay_slim_app, y ejecutado Phinx para crear la tabla users.

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

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

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

// Ruta para añadir 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', // Garantiza que el email sea único
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('Usuario añadido a MySQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error al añadir usuario: ' . $e->getMessage());
        $response = $response->withStatus(500); // Devuelve un 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()); // Salida en formato JSON
        $response = $response->withHeader('Content-Type', 'application/json'); // Ajusta Content-Type
    } catch (\Exception $e) {
         $response->getBody()->write('Error al obtener usuarios: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

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

Cómo acceder:

• Entra en https://servbay-slim-test.local/mysql-add-user para insertar un nuevo usuario en la tabla users.
• Visita https://servbay-slim-test.local/mysql-get-users para obtener y mostrar en JSON todos los usuarios de la tabla.

Ejemplo con PostgreSQL

Supón que ya has iniciado el paquete PostgreSQL en ServBay, creado la base servbay_slim_app, y ejecutado Phinx (asegúrate que adapter sea pgsql y port: 5432 en la configuración).

Edita la configuración de conexión en public/index.php, cambiando driver a pgsql y añadiendo schema:

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

Añade antes de $app->run(); lo siguiente:

// ... inicialización previa y ruta '/' ...
// ... rutas para MySQL si existen ...

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

// Ruta para añadir usuario en PostgreSQL
$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',
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        $response->getBody()->write('Usuario añadido a PostgreSQL');
    } catch (\Exception $e) {
        $response->getBody()->write('Error al añadir usuario: ' . $e->getMessage());
        $response = $response->withStatus(500);
    }
    return $response;
});

// Ruta para obtener usuarios en PostgreSQL
$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 obtener usuarios: ' . $e->getMessage());
         $response = $response->withStatus(500);
    }
    return $response;
});

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

Cómo acceder:

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

Ejemplo con Memcached

ServBay incluye el paquete Memcached y la extensión PHP ext-memcached. Solo necesitas instalar una librería cliente PHP como memcached/memcached.

1. Instala el cliente: En /Applications/ServBay/www/servbay-slim-app:

   composer require memcached/memcached

2. Añade una ruta para Memcached antes de $app->run();:

   // ... inicialización previa y rutas de base de datos ...
   
   // Ruta de ejemplo con Memcached
   $app->get('/memcached-example', function (Request $request, Response $response, $args) {
       // Crear instancia del cliente Memcached
       $memcached = new Memcached();
       // Añadir el servidor (por defecto en ServBay: 127.0.0.1:11211)
       $memcached->addServer('127.0.0.1', 11211);
   
       $cacheKey = 'my_servbay_cache_key';
       // Intentar obtener datos de la cache
       $cachedData = $memcached->get($cacheKey);
   
       if ($cachedData === false) {
           // Si no hay datos, generar y almacenar en caché
           $cachedData = 'Hello Memcached from ServBay! This was not cached.';
           // Almacenar en caché, TTL de 60 segundos
           $memcached->set($cacheKey, $cachedData, 60);
           $response->getBody()->write($cachedData);
       } else {
           // Si hay datos, servir desde la caché
           $response->getBody()->write('Hello Memcached from ServBay! This was served from cache.');
       }
   
       return $response;
   });
   
   // ... $app->run();

Cómo acceder: Accede a https://servbay-slim-test.local/memcached-example. En la primera visita verás "This was not cached.", y en las siguientes (hasta que expire) "This was served from cache.".

Ejemplo con Redis

ServBay ofrece Redis y la extensión PHP ext-redis. Para interactuar con Redis simplemente instala la librería cliente predis/predis.

1. Instala el cliente: En /Applications/ServBay/www/servbay-slim-app:

   composer require predis/predis

2. Crea una ruta para Redis antes de $app->run();:

   // ... inicialización previa, rutas de base de datos y Memcached ...
   
   use Predis\Client as RedisClient; // Importar Predis
   
   // Ruta de ejemplo con Redis
   $app->get('/redis-example', function (Request $request, Response $response, $args) {
       try {
           // Crear el cliente (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 obtener datos de la cache
           $cachedData = $redis->get($cacheKey);
   
           if ($cachedData === null) {
               // Si no existe el dato, lo genera y almacena en caché
               $cachedData = 'Hello Redis from ServBay! This was not cached.';
               // Guardar en caché, 60 segundos de expiración
               $redis->setex($cacheKey, 60, $cachedData); // SETEX clave segundos valor
               $response->getBody()->write($cachedData);
           } else {
               // Si existe, servir desde la caché
               $response->getBody()->write('Hello Redis from ServBay! This was served from cache.');
           }
       } catch (\Exception $e) {
           // Manejar errores de conexión u operaciones
           $response->getBody()->write('Error al conectar o trabajar con Redis: ' . $e->getMessage());
           $response = $response->withStatus(500);
       }
       return $response;
   });
   
   // ... $app->run();

Cómo acceder: Accede a https://servbay-slim-test.local/redis-example. La primera vez mostrará "This was not cached." y en las siguientes (antes de expirar) "This was served from cache.".

Resumen

Siguiendo estas indicaciones, has creado con éxito un proyecto con Slim Framework en el entorno local de ServBay, configurando la función de Sitios web para alojarlo y acceder a él fácilmente. Además, aprendiste cómo integrar diferentes paquetes de ServBay (como MySQL, PostgreSQL, Memcached y Redis) y las extensiones apropiadas de PHP para añadir persistencia de datos y almacenamiento en caché a tu aplicación Slim. ServBay facilita la creación y gestión del entorno local, permitiéndote centrarte en desarrollar tu aplicación.