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:
bash
```
cd /Applications/ServBay/www
```
1
Crear la carpeta del proyecto
Crea un nuevo directorio para el proyecto FuelPHP y entra en él:
bash
```
mkdir servbay-fuelphp-app
cd servbay-fuelphp-app
```
1
2
Crear 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:
bash
```
composer create-project fuel/fuel .
```
1
Composer 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 subcarpeta public: /Applications/ServBay/www/servbay-fuelphp-app/public.
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
    ],
];

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 es root con contraseña root (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é
];

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
];

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 tabla users:
bash
```
php oil generate migration create_users_table
```
1
Esto 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étodo up() para definir la estructura de la tabla. El método down() 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');
    }
}

Ejecutar 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:
bash
```
php oil refine migrate
```
1
Si todo sale bien, la tabla users se creará en la base de datos fuel_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));
    }
}

Notas:

Para usar DB y Redis 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
);

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!
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)
Prueba Redis: https://servbay-fuelphp-test.local/redis
- Resultado esperado: Hello Redis from ServBay! (si Redis está activo)
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)
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)

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 en db.php). El comando oil 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 subcarpeta public.

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!

Crear y ejecutar un proyecto FuelPHP en el entorno local ServBay ​

¿Qué es FuelPHP? ​

Características y ventajas principales de FuelPHP ​

Instalar el entorno de desarrollo FuelPHP usando ServBay ​

Requisitos previos ​

Crear un proyecto FuelPHP ​

Configuración del servidor web (usando la función Sitio web de ServBay) ​

Configuración de servicios de FuelPHP ​

Configuración de la base de datos ​

Configuración de caché (Memcached y Redis) ​

Ejemplo de servicios base de datos y caché ​

Preparar la tabla de base de datos (usando migraciones FuelPHP) ​

Añadir código de controlador de ejemplo ​

Configuración de rutas ​

Acceso y pruebas del sitio web ​

Consideraciones ​

Resumen ​