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:
- 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.
- 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
Acceder al directorio raíz de sitios en ServBay:
macOS:
bashcd /Applications/ServBay/www
1Windows:
cmdcd C:\ServBay\www
1Crear carpeta para el proyecto: Monta una nueva carpeta para el app Slim.
bashmkdir servbay-slim-app
1Entrar al directorio del proyecto:
bashcd servbay-slim-app
1Instalar Slim con Composer: Ejecuta el siguiente comando para instalar Slim y su implementación PSR-7.
bashcomposer require slim/slim "^4.0" slim/psr7 -W
1Este comando descargará Slim y el paquete
slim/psr7
en la carpetavendor
y generará los archivoscomposer.json
ycomposer.lock
.
Inicializar la aplicación Slim
- 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 carpetapublic
y el archivo correspondiente:bashmkdir public touch public/index.php
1
2 - Editar el archivo de entrada: Abre
public/index.php
y agrega la siguiente base de código:phpEste ejemplo establece la estructura mínima de una aplicación Slim, define una ruta para el GET en el URL raíz (<?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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22/
) 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).
- Abre la interfaz de ServBay.
- Ve al módulo de Sitios Web (Websites).
- Haz clic para añadir un nuevo sitio.
- 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 enpublic
, por lo que el servidor debe apuntar ahí.- macOS:
- 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.
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.
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
bashcomposer require robmorgan/phinx
1 - macOS:
- Inicializa la configuración de Phinx:bashEsto generará
vendor/bin/phinx init
1phinx.yml
en la raíz del proyecto. Edítalo con tus datos de conexión, ejemplo:yamlpaths: 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- Dentro del directorio del proyecto, instala Phinx con Composer:
Crear archivo de migración: Usa Phinx para crear una migración nueva.
bashvendor/bin/phinx create CreateUsersTable
1Esto creará un nuevo archivo PHP en
db/migrations
. Edita el métodochange()
para definir la tablausers
:php<?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(); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28Ejecutar la migración: Desde la raíz ejecuta el comando para crear la tabla
users
.bashvendor/bin/phinx migrate
1Importante: 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.
Instalar illuminate/database: Corre en la raíz del proyecto:
- macOS:
/Applications/ServBay/www/servbay-slim-app
- Windows:
C:\ServBay\www\servbay-slim-app
bashcomposer require illuminate/database
1- macOS:
Configurar la conexión en
public/index.php
: Después derequire __DIR__ . '/../vendor/autoload.php';
y antes de crear la app ($app = AppFactory::create();
), agrega:php// ... 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 ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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
:
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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Acceso:
- Accede a
https://servbay-slim-test.local/mysql-add-user
para añadir un usuario al tablausers
. - 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
:
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 ...
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
Añade estas rutas antes de $app->run();
:
php
// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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
.
Instalar el cliente de Memcached: En la raíz:
- macOS:
/Applications/ServBay/www/servbay-slim-app
- Windows:
C:\ServBay\www\servbay-slim-app
bashcomposer require memcached/memcached
1- macOS:
Agregar rutas Memcached en
public/index.php
: Antes de$app->run();
, incluye:php// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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
.
Instalar el cliente Redis: En la raíz:
- macOS:
/Applications/ServBay/www/servbay-slim-app
- Windows:
C:\ServBay\www\servbay-slim-app
bashcomposer require predis/predis
1- macOS:
Agregar rutas Redis en
public/index.php
: Antes de$app->run();
:php// ... 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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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.