Crear y ejecutar un proyecto FuelPHP en el entorno local ServBay
¿Qué es FuelPHP?
FuelPHP es un framework PHP flexible y modular, diseñado para crear aplicaciones web modernas. Sigue el patrón de diseño Modelo-Vista-Controlador Jerárquico (HMVC - Hierarchical Model-View-Controller), proporcionando funciones y herramientas potentes que ayudan a los desarrolladores a construir aplicaciones web de alta calidad de manera rápida y eficiente. FuelPHP destaca por su extraordinaria flexibilidad, alto rendimiento y facilidad de ampliación, lo que lo convierte en una de las elecciones principales para la comunidad PHP.
Características y ventajas principales de FuelPHP
- Arquitectura HMVC: Soporta el patrón de diseño MVC jerárquico que favorece la organización del código, la reutilización y el desarrollo modular, lo cual resulta ideal para proyectos grandes o complejos.
- Alto rendimiento: FuelPHP está diseñado para optimizar el uso de recursos y la velocidad; es reconocido por su eficiencia y respuesta rápida ante solicitudes simultáneas.
- Fácil de ampliar: El framework ofrece un mecanismo robusto de extensibilidad, permitiendo integrar fácilmente librerías externas o añadir funcionalidades personalizadas según los requisitos de cada proyecto.
- Seguridad: Incluye medidas de seguridad integradas como validación automática de entradas, filtrado de salidas (prevención XSS), protección CSRF, prevención de inyecciones SQL, entre otras, para facilitar el desarrollo de aplicaciones seguras.
- Gran comunidad de soporte: FuelPHP cuenta con una comunidad activa de desarrolladores, proporcionando ayuda oportuna y recursos de terceros para facilitar el trabajo.
Estas características permiten a los desarrolladores construir aplicaciones web de alto rendimiento, seguras y fáciles de mantener, adaptables tanto para proyectos pequeños como empresariales.
Instalar el entorno de desarrollo FuelPHP usando ServBay
ServBay es un entorno local de desarrollo web pensado para desarrolladores, preinstalado con PHP, Caddy/Nginx/Apache, MySQL/PostgreSQL/MongoDB, Redis y otros servicios esenciales. Usando ServBay puedes crear el entorno necesario para proyectos FuelPHP sin instalaciones y configuraciones manuales complicadas.
Esta guía explica con detalle cómo utilizar el entorno PHP de ServBay, el servidor web (Caddy), la base de datos, y los servicios de caché para crear y ejecutar un proyecto FuelPHP. Utilizaremos la función de Sitios web de ServBay para configurar el servidor web y permitir el acceso y la prueba rápida del proyecto.
Requisitos previos
Antes de comenzar, asegúrate de cumplir con lo siguiente:
- ServBay está instalado y ejecutándose correctamente en macOS.
- El entorno PHP de ServBay está habilitado (por defecto lo está).
- Los servicios de base de datos (por ejemplo, MySQL) y caché (por ejemplo, Redis, Memcached) que planeas utilizar están activos y funcionando en ServBay.
- ServBay ya incluye Composer, no necesitas instalarlo aparte.
Crear un proyecto FuelPHP
Ruta recomendada para proyectos
ServBay recomienda almacenar los proyectos web en la ruta /Applications/ServBay/www
, facilitando su gestión y configuración. Esta guía utiliza ese directorio como ejemplo.
Ir al directorio raíz de sitios web
Abre la terminal y navega a la carpeta recomendada por ServBay:
bashcd /Applications/ServBay/www
1Crear la carpeta del proyecto
Crea un nuevo directorio para el proyecto FuelPHP y entra en él:
bashmkdir servbay-fuelphp-app cd servbay-fuelphp-app
1
2Crear el proyecto FuelPHP con Composer
En el directorio del proyecto, ejecuta Composer para descargar e inicializar el framework FuelPHP. El punto (.) indica que se instalará en el directorio actual:
bashcomposer create-project fuel/fuel .
1Composer descargará automáticamente FuelPHP y sus dependencias en la carpeta
servbay-fuelphp-app
.
Configuración del servidor web (usando la función Sitio web de ServBay)
Para acceder al proyecto FuelPHP desde el navegador, debes configurar un host virtual mediante la función Sitios web de ServBay.
- Abre la interfaz principal de ServBay.
- Haz clic en el menú lateral Sitios web.
- Pulsa el botón Agregar sitio web en la esquina superior derecha.
- En la ventana de configuración, completa la información siguiente:
- Nombre: Asigna un nombre descriptivo, por ejemplo
Mi primer sitio FuelPHP Dev
. - Dominio: Elige un dominio para desarrollo local, por ejemplo
servbay-fuelphp-test.local
. ServBay lo resolverá automáticamente en local. - Tipo de sitio: Selecciona
PHP
. - Versión PHP: Elige la versión de PHP deseada, por ejemplo
8.3
. - Directorio raíz del sitio: Indica el directorio de entrada del proyecto FuelPHP. El archivo público es
public/index.php
, así que la raíz debe apuntar a la subcarpetapublic
:/Applications/ServBay/www/servbay-fuelphp-app/public
.
- Nombre: Asigna un nombre descriptivo, por ejemplo
- Haz clic en Agregar para guardar la configuración.
ServBay actualizará la configuración de Caddy y recargará los servicios automáticamente para que el nuevo dominio esté activo.
Para más detalles sobre cómo agregar un sitio web, consulta la documentación de ServBay: Agregar el primer sitio web.
Configuración de servicios de FuelPHP
Los proyectos FuelPHP suelen requerir la configuración de conexión con la base de datos, caché y otros servicios.
Configuración de la base de datos
La configuración de la base de datos de FuelPHP se encuentra en el archivo fuel/app/config/development/db.php
. Edítalo para ajustar los datos de conexión. Supongamos que usas el servicio MySQL por defecto de ServBay:
php
<?php
/**
* Configuración de la base de datos para desarrollo. Se unen con la configuración global.
*/
return [
'default' => [
'connection' => [
'dsn' => 'mysql:host=localhost;dbname=fuel_dev', // Asegúrate de que la base de datos fuel_dev existe
'username' => 'root', // Usuario por defecto de MySQL en ServBay
'password' => 'root', // Contraseña por defecto (solo para desarrollo local)
],
'identifier' => '`', // MySQL requiere comillas invertidas como identificador
],
];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
Notas:
- Debes crear manualmente una base de datos llamada
fuel_dev
usando herramientas como phpMyAdmin o Adminer en ServBay. El usuario por defecto de MySQL esroot
con contraseñaroot
(sólo recomendado en entornos de desarrollo). 'identifier' => '
'` es obligatorio para MySQL, garantizando la referencia correcta de tablas y campos.
Configuración de caché (Memcached y Redis)
FuelPHP soporta distintos drivers de caché. Configúralos en fuel/app/config/cache.php
. Asegúrate de que los servicios Memcached y/o Redis estén activos en ServBay.
Configuración de Memcached (fuel/app/config/cache.php
):
Si planeas usar Memcached como caché por defecto:
php
<?php
return [
'driver' => 'memcached', // Driver por defecto: memcached
'memcached' => [
'cache_id' => 'fuel', // ID de caché
'servers' => [
'default' => [
'host' => '127.0.0.1', // Dirección por defecto de Memcached
'port' => 11211, // Puerto por defecto Memcached
'weight' => 100,
],
],
'compression' => false, // Activar o desactivar compresión
],
// ... otras configuraciones de caché
];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Las versiones PHP de ServBay suelen incluir la extensión Memcached.
Configuración de Redis (fuel/app/config/redis.php
):
Para usar Redis, configura la conexión en el archivo redis.php
:
php
<?php
return [
'default' => [
'hostname' => '127.0.0.1', // Dirección por defecto de Redis
'port' => 6379, // Puerto por defecto Redis
'database' => 0, // Índice de la base de datos Redis
],
// Puedes añadir varias conexiones si lo necesitas
];
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
Las versiones de PHP proporcionadas por ServBay suelen incluir la extensión Redis.
Ejemplo de servicios base de datos y caché
Para mostrar cómo FuelPHP interactúa con la base de datos y los servicios de caché, añadiremos código de muestra.
Preparar la tabla de base de datos (usando migraciones FuelPHP)
FuelPHP incluye la herramienta Oil para gestionar migraciones, lo que permite controlar la estructura de la base de datos por versiones.
Crear el archivo de migración
En la raíz del proyecto (
servbay-fuelphp-app
), crea una nueva migración para la estructura de la tablausers
:bashphp oil generate migration create_users_table
1Esto generará un archivo de migración en
fuel/app/migrations
con un nombre y timestamp único.Editar el archivo de migración
Abre el nuevo archivo (
fuel/app/migrations/xxxxxxxxxxxx_create_users_table.php
) y edita el métodoup()
para definir la estructura de la tabla. El métododown()
será el rollback:php<?php namespace Fuel\Migrations; use Fuel\Core\DBUtil; class Create_users_table { public function up() { // Crear tabla users DBUtil::create_table('users', [ 'id' => ['type' => 'int', 'constraint' => 11, 'auto_increment' => true], 'name' => ['type' => 'varchar', 'constraint' => 100], 'email' => ['type' => 'varchar', 'constraint' => 100, 'unique' => true], ], ['id'], true, 'InnoDB', 'utf8mb4_unicode_ci'); // Definir clave primaria, índice y configuración de motor y charset } public function down() { // Eliminar tabla users (rollback) DBUtil::drop_table('users'); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Ejecutar la migración
En la raíz del proyecto (
servbay-fuelphp-app
), ejecuta la migración con Oil para crear la tabla en la base de datos:bashphp oil refine migrate
1Si todo sale bien, la tabla
users
se creará en la base de datosfuel_dev
.
Añadir código de controlador de ejemplo
Edita el archivo fuel/app/classes/controller/welcome.php
para crear métodos que demuestren la interacción con base de datos y caché:
php
<?php
use Fuel\Core\Controller;
use Fuel\Core\Response;
use Fuel\Core\Cache;
use Fuel\Core\DB; // Importa DB facade
use Fuel\Core\Redis; // Importa Redis facade
class Controller_Welcome extends Controller
{
// Acción para la página de inicio
public function action_index()
{
return Response::forge('Hello ServBay!');
}
// Ejemplo de Memcached
public function action_memcached()
{
// Intentar obtener datos del caché
$value = Cache::get('servbay_memcached_key');
if ($value === false) {
// Si no existen, guardar en caché
$value = 'Hello Memcached from ServBay!';
Cache::set('servbay_memcached_key', $value, 60); // Guarda por 60 segundos
$value .= ' (from cache)';
} else {
$value .= ' (cached)';
}
return Response::forge($value);
}
// Ejemplo de Redis
public function action_redis()
{
// Obtener instancia de Redis (conexión por defecto)
$redis = \Redis_Db::instance(); // Para FuelPHP 1.x usar Redis_Db::instance()
// Si tienes múltiples conexiones, usa \Redis_Db::instance('connection_name')
// Guardar dato en Redis
$redis->set('servbay_redis_key', 'Hello Redis from ServBay!');
// Recuperar dato de Redis
$value = $redis->get('servbay_redis_key');
return Response::forge($value);
}
// Ejemplo de escritura en MySQL
public function action_mysql_add()
{
try {
// Insertar registro en la tabla users
$result = DB::insert('users')->set([
'name' => 'ServBay Demo User ' . time(), // Garantiza unicidad usando timestamp
'email' => 'demo_user_' . time() . '@servbay.test',
])->execute(); // execute() devuelve un array con el nuevo ID
return Response::forge('User added with ID: ' . $result[0]);
} catch (\Database_Exception $e) {
// Capturar errores de base de datos (p.ej. email duplicado)
return Response::forge('Error adding user: ' . $e->getMessage(), 500);
}
}
// Ejemplo de lectura en MySQL
public function action_mysql()
{
// Consultar todos los registros de users
$users = DB::select('id', 'name', 'email')->from('users')->execute()->as_array();
// Devolver la lista en formato JSON
return Response::forge(json_encode($users, JSON_PRETTY_PRINT));
}
}
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
Notas:
- Para usar
DB
yRedis
necesitas incluir las respectivas facades (use Fuel\Core\DB;
,use Fuel\Core\Redis;
). - Se utiliza el prefijo
servbay_
en las claves de caché para evitar colisiones. - El ejemplo de escritura en MySQL utiliza timestamp y manejo de errores para mayor robustez.
- FuelPHP 1.x requiere el método
\Redis_Db::instance()
para instanciar Redis.
Configuración de rutas
Para poder acceder mediante URLs a las acciones agregadas en el controlador, necesitas editar el archivo fuel/app/config/routes.php
. Aunque FuelPHP ya configura acceso por defecto al controlador Controller_Welcome
, es recomendable especificar rutas para las nuevas acciones memcached
, redis
, mysql_add
, mysql
.
Edita o añade las siguientes rutas en fuel/app/config/routes.php
:
php
<?php
return array(
'_root_' => 'welcome/index', // Ruta por defecto a la acción index de welcome
'_404_' => 'welcome/404', // Página de error 404
// Configuración de rutas para las nuevas acciones de ejemplo
'memcached' => 'welcome/memcached',
'redis' => 'welcome/redis',
'mysql_add' => 'welcome/mysql_add',
'mysql' => 'welcome/mysql',
// ... otras rutas
);
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
Acceso y pruebas del sitio web
Ahora puedes probar tu proyecto FuelPHP y los servicios configurados accediendo al dominio especificado en ServBay, por ejemplo https://servbay-fuelphp-test.local
.
- Página principal:
https://servbay-fuelphp-test.local
- Resultado esperado:
Hello ServBay!
- Resultado esperado:
- Prueba Memcached:
https://servbay-fuelphp-test.local/memcached
- En la primera visita:
Hello Memcached from ServBay! (from cache)
(si el caché funciona) - En visitas siguientes:
Hello Memcached from ServBay! (cached)
(si el caché sigue válido)
- En la primera visita:
- Prueba Redis:
https://servbay-fuelphp-test.local/redis
- Resultado esperado:
Hello Redis from ServBay!
(si Redis está activo)
- Resultado esperado:
- Agregar usuario (MySQL):
https://servbay-fuelphp-test.local/mysql_add
- Resultado esperado:
User added with ID: [nuevo ID]
(si MySQL está activo y la base de datos y tabla existen)
- Resultado esperado:
- Leer usuarios (MySQL):
https://servbay-fuelphp-test.local/mysql
- Resultado esperado: Un array JSON con los registros de la tabla
users
(si MySQL está activo y hay datos)
- Resultado esperado: Un array JSON con los registros de la tabla
Sobre HTTPS: ServBay configura automáticamente certificados SSL para los sitios locales, mediante ServBay User CA o ServBay Public CA. Si el navegador indica que el certificado no es confiable, asegúrate de confiar el CA de ServBay en tu sistema.
Consideraciones
- Asegúrate de que los servicios PHP (versión usada), Caddy (o Nginx/Apache), MySQL (si usas base de datos), Redis (si usas Redis), Memcached (si usas Memcached), etc. estén activos en el panel principal de ServBay.
- Recuerda crear manualmente la base de datos
fuel_dev
con los gestores de base de datos de ServBay (o indicar otra existente endb.php
). El comandooil refine migrate
crea tablas, pero no la base de datos. - El archivo público de entrada de FuelPHP es
public/index.php
; por lo tanto, en ServBay, el directorio raíz del sitio debe apuntar obligatoriamente a la subcarpetapublic
.
Resumen
ServBay permite crear rápidamente un entorno completo de desarrollo local para proyectos FuelPHP en macOS. Esta guía explica cómo crear un proyecto FuelPHP, configurar la función Sitio web de ServBay, conectar servicios de base de datos y caché, y validar el funcionamiento con código de ejemplo. Gracias a los servicios pre-integrados y la configuración simplificada de ServBay, podrás acelerar significativamente tu trabajo de desarrollo.
¡Esperamos que esta guía te ayude a dar tus primeros pasos desarrollando con FuelPHP en ServBay!