Crear y ejecutar un proyecto PHPixie en macOS con ServBay

PHPixie es un framework PHP ligero y de alto rendimiento, diseñado para desarrollar aplicaciones web de manera rápida. Adopta el patrón de diseño HMVC (Hierarchical Model-View-Controller), ofreciendo una estructura de código limpia y eficiente. Gracias a su simplicidad, flexibilidad y velocidad, se ha convertido en la elección de muchos desarrolladores.

Principales características y ventajas de PHPixie

• Ligereza: El núcleo del sistema PHPixie es sumamente reducido, con solo los componentes esenciales para construir aplicaciones, lo que garantiza inicios y ejecuciones veloces.
• Alto rendimiento: Su arquitectura prioriza la eficiencia, permitiendo manejar solicitudes concurrentes de forma ágil. Es ideal para proyectos donde el rendimiento es crucial.
• Facilidad de aprendizaje: Dispone de una API clara y documentación extensa para que los desarrolladores puedan dominar rápidamente su funcionamiento.
• Flexibilidad: El framework está desacoplado, lo que permite integrar o sustituir librerías y componentes de terceros según las necesidades del proyecto.
• Comunidad activa: PHPixie cuenta con una comunidad entusiasta que genera multitud de extensiones y recursos de soporte.

PHPixie permite a los desarrolladores construir aplicaciones web de alta calidad y rendimiento de manera eficiente, adaptándose tanto a proyectos pequeños como a grandes implementaciones empresariales.

Crear y ejecutar un proyecto PHPixie usando ServBay

Esta guía te mostrará cómo usar el entorno de desarrollo web local proporcionado por ServBay para crear y poner en marcha un proyecto PHPixie. Usaremos el entorno PHP integrado, el gestor de dependencias Composer, y la función “Sitios Web” de ServBay para configurar el servidor web, facilitando así el acceso local y la integración con bases de datos y sistemas de caché.

Requisitos previos

• Tener instalado y en funcionamiento ServBay en macOS. ServBay integra PHP, Composer, varias bases de datos (MySQL, PostgreSQL, MongoDB, Redis, etc.) y el servidor web Caddy.
• Conocimientos básicos de terminal y línea de comandos.

Crear un proyecto PHPixie

Ruta recomendada para almacenar sitios web

Se recomienda organizar todos los proyectos web locales en el directorio /Applications/ServBay/www para una mejor gestión y control de permisos de acceso desde ServBay.

1. Verifica que Composer esté instalado: ServBay incluye Composer de fábrica, por lo que no es necesario instalarlo aparte. Abre una terminal y ejecuta composer --version para confirmarlo.
2. Crea el directorio del proyecto: En la raíz recomendada por ServBay, crea una nueva carpeta para tu proyecto PHPixie y accede a ella:

   cd /Applications/ServBay/www
   mkdir servbay-phpixie-app
   cd servbay-phpixie-app

3. Crea el proyecto PHPixie con Composer: Desde el directorio del proyecto, ejecuta el siguiente comando para descargar la plantilla:

   composer create-project phpixie/project .

   Composer descargará PHPixie y todas sus dependencias en el directorio actual.

Configuración del servidor web

Utiliza la función Sitios web de ServBay para configurar el servidor Caddy, permitiéndole apuntar y ejecutar correctamente tu proyecto PHPixie.

1. Abre la interfaz de la aplicación ServBay.

2. Ve a la sección Sitios web (Websites).

3. Haz clic en añadir nuevo sitio web.

4. Completa los parámetros de configuración:

   • Nombre: Por ejemplo, Mi Primer Sitio Dev PHPixie (es solo un identificador interno en ServBay).
   • Dominio: Por ejemplo, servbay-phpixie-test.local (dominio local para acceder al sitio).
   • Tipo de sitio web: Selecciona PHP.
   • Versión PHP: Elige la versión que desees, por ejemplo 8.3.
   • Directorio raíz (Document Root): Apunta al directorio web de tu proyecto: /Applications/ServBay/www/servbay-phpixie-app/web.

   ¿Por qué el directorio /web?

   El archivo principal de entrada de PHPixie es web/index.php. Por seguridad y buenas prácticas, la raíz del servidor web debe apuntar directamente al directorio web, evitando el acceso web directo a archivos sensibles (como configuraciones o la carpeta vendor).

5. Guarda la configuración. ServBay configurará automáticamente Caddy y actualizará el archivo hosts local (si es necesario) para que servbay-phpixie-test.local apunte a tu servidor ServBay.

Para pasos más detallados consulta Añadir tu primer sitio web.

Agregar código de ejemplo

Para comprobar que todo funciona y ver ejemplos de integración de base de datos y caché, vamos a añadir código de muestra al proyecto.

1. Crea un controlador de ejemplo: En el archivo src/App/HTTP/Controller/Home.php añade el siguiente contenido. Crea manualmente las carpetas si no existen.

   <?php
   
   namespace App\HTTP\Controller;
   
   use PHPixie\HTTP\Request;
   use PHPixie\Template;
   use PHPixie\Database\Query; // Importar la clase Query
   
   class Home extends \PHPixie\Controller
   {
       protected $template;
   
       public function __construct(Template $template)
       {
           $this->template = $template;
       }
   
       // Acción para la página de inicio
       public function action_index(Request $request)
       {
           // Renderiza la plantilla assets/templates/app/home.php
           return $this->template->render('app:home');
       }
   
       // Ejemplo de acción con Memcached
       public function action_memcached(Request $request)
       {
           $cache = $this->components->cache();
           $cache->set('key', '¡Hola Memcached desde ServBay!', 60); // Almacenar datos por 60 segundos
           $value = $cache->get('key'); // Recuperar datos
           return $this->response()->string($value); // Devolver como texto
       }
   
       // Ejemplo de acción con Redis
       public function action_redis(Request $request)
       {
           $redis = $this->components->redis();
           $redis->set('key', '¡Hola Redis desde ServBay!'); // Almacenar datos
           $value = $redis->get('key'); // Recuperar datos
           return $this->response()->string($value); // Devolver como texto
       }
   
       // Ejemplo de agregar usuario a MySQL/PostgreSQL
       public function action_add_user(Request $request)
       {
           // Usa el componente de base de datos para el query builder
           $query = $this->components->database()->query();
           // Inserta un nuevo registro en la tabla 'users'
           $query->insert('users')->data([
               'name' => 'Usuario de demostración ServBay',
               'email' => 'demo-' . uniqid() . '@servbay.test', // Usar email único
           ])->execute(); // Ejecutar inserción
   
           return $this->response()->string('Usuario agregado exitosamente.'); // Mensaje de éxito
       }
   
       // Ejemplo de listar usuarios desde MySQL/PostgreSQL
       public function action_list_users(Request $request)
       {
           // Usa el componente de base de datos para el query builder
           $query = $this->components->database()->query();
           // Consulta todos los usuarios en la tabla 'users'
           $users = $query->select('*')->from('users')->execute()->fetchAll(); // Ejecutar consulta y obtener resultados
   
           return $this->response()->json($users); // Responder con la lista en formato JSON
       }
   }

2. Crea una plantilla de ejemplo: En assets/templates/app/home.php agrega el siguiente contenido. Crea las carpetas necesarias si no existen.

   <!doctype html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>Welcome to PHPixie on ServBay</title>
       <style>
           body { font-family: sans-serif; line-height: 1.6; margin: 20px; }
           h1 { color: #333; }
           p { margin-bottom: 15px; }
           code { background-color: #f4f4f4; padding: 2px 5px; border-radius: 4px; }
           ul { list-style: none; padding: 0; }
           li { margin-bottom: 10px; }
           li a { text-decoration: none; color: #007bff; }
           li a:hover { text-decoration: underline; }
       </style>
   </head>
   <body>
       <h1>Welcome to PHPixie on ServBay</h1>
       <p>Esta página es generada dinámicamente por tu aplicación PHPixie ejecutándose en ServBay.</p>
   
       <h2>Enlaces de funcionalidades ejemplo:</h2>
       <ul>
           <li><a href="/home/memcached">Probar Memcached</a></li>
           <li><a href="/home/redis">Probar Redis</a></li>
           <li><a href="/home/add_user">Agregar usuario a la base de datos</a></li>
           <li><a href="/home/list_users">Listar usuarios en la base de datos</a></li>
       </ul>
   
       <p>Asegúrate de haber completado la configuración de la base de datos y caché necesaria.</p>
   
   </body>
   </html>

Acceso al sitio básico

Tras configurar el sitio en ServBay y añadir el código de ejemplo, puedes acceder al dominio configurado en tu navegador:

• Abre el navegador y visita https://servbay-phpixie-test.local.
• Deberías ver una página con "Welcome to PHPixie on ServBay" y enlaces a funcionalidades de ejemplo.

Si tienes problemas para acceder verifica:

• Que ServBay esté en ejecución.
• Que la configuración del sitio en ServBay sea correcta, especialmente dominio, tipo y directorio raíz.
• Que tu archivo hosts local resuelva bien servbay-phpixie-test.local (ServBay normalmente lo gestiona automáticamente).
• Que la versión PHP esté habilitada en ServBay.

Ejemplo de integración con base de datos y caché

PHPixie soporta múltiples bases de datos y sistemas de caché de manera nativa. ServBay incluye paquetes de MySQL, PostgreSQL, Redis, Memcached, permitiendo integraciones sencillas.

Importante: Antes de realizar operaciones con la base de datos, asegúrate de que el servicio correspondiente (por ejemplo MySQL o PostgreSQL) esté en marcha en ServBay, y que hayas creado una base de datos para el proyecto. Por ejemplo, en los ejemplos se utiliza el nombre de base de datos servbay_phpixie_app. Puedes utilizar herramientas como Sequel Ace, Postico, TablePlus o clientes por línea de comandos. El usuario por defecto suele ser root y la contraseña password (confírmalo según tu configuración de ServBay).

Configuración de la conexión a base de datos

Según el tipo que utilices (MySQL o PostgreSQL), edita el archivo assets/config/database.php en la raíz del proyecto. Normalmente, ServBay utiliza la dirección 127.0.0.1.

Ejemplo de configuración para MySQL (assets/config/database.php):

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // Modifica el string de conexión según tu base de datos y configuración de ServBay
        'connection' => 'mysql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Usuario por defecto en ServBay
        'password'  => 'password', // Contraseña por defecto (ajusta si es distinto)
        'options'   => []
    ]
];

Ejemplo de configuración para PostgreSQL (assets/config/database.php):

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // Modifica el string de conexión según tu base de datos y configuración de ServBay
        'connection' => 'pgsql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Usuario por defecto en ServBay
        'password'  => 'password', // Contraseña por defecto (ajusta si es distinto)
        'options'   => []
    ]
];

Crear la tabla de la base (con migraciones)

PHPixie dispone de herramienta CLI para gestionar migraciones, facilitando el control de versiones del esquema de la base de datos.

1. Abre una terminal: Cambia al directorio raíz de tu proyecto PHPixie:

   cd /Applications/ServBay/www/servbay-phpixie-app

2. Crea un archivo de migración: Genera una migración con la CLI de PHPixie para crear la tabla users:

   php pixie generate:migration create_users_table

   Esto generará un archivo PHP nuevo en assets/migrations con un timestamp en el nombre.
3. Edita el archivo de migración: Abre el archivo recién generado (p.ej. YYYY_MM_DD_HHMMSS_create_users_table.php) y define los métodos up() y down() para la estructura de la tabla:

   <?php
   
   use PHPixie\Database\Migration;
   use PHPixie\Database\Schema\Table;
   
   class CreateUsersTable extends Migration
   {
       public function up()
       {
           // Crea la tabla 'users' usando el schema builder
           $this->schema->create('users', function(Table $table) {
               $table->increments('id'); // Clave primaria autoincremental
               $table->string('name'); // Columna para el nombre
               $table->string('email')->unique(); // Columna email, único
               $table->timestamps(); // Columnas de timestamps created_at y updated_at
           });
       }
   
       public function down()
       {
           // Elimina la tabla 'users'
           $this->schema->drop('users');
       }
   }

4. Ejecuta la migración: En la terminal, estando en la raíz del proyecto, ejecuta:

   php pixie migrate

   Si todo sale bien, verás un mensaje de éxito en la terminal. Puedes verificar en tu base de datos servbay_phpixie_app que la tabla users ha sido creada.

Uso de bases de datos relacionales (MySQL/PostgreSQL)

Como vimos en el controlador de ejemplo src/App/HTTP/Controller/Home.php, los métodos action_add_user y action_list_users muestran cómo usar el componente de base de datos para interactuar con MySQL o PostgreSQL.

• Agregar usuario: Accede a https://servbay-phpixie-test.local/home/add_user para insertar un nuevo usuario.
• Listar usuarios: Accede a https://servbay-phpixie-test.local/home/list_users para obtener una lista (en JSON) de los usuarios registrados.

Configuración y uso de bases de datos NoSQL (Memcached/Redis)

ServBay instala Memcached y Redis junto con sus extensiones PHP. Solo necesitas configurar PHPixie para usarlos.

Configuración Memcached (assets/config/cache.php):

Edita o crea assets/config/cache.php y añade:

<?php

return [
    'default' => [
        'driver' => 'memcached',
        'servers' => [
            [
                'host'   => '127.0.0.1', // Dirección predeterminada Memcached ServBay
                'port'   => 11211, // Puerto por defecto
                'weight' => 100,
            ],
        ],
    ],
];

Configuración Redis (assets/config/redis.php):

Edita o crea assets/config/redis.php y añade:

<?php

return [
    'default' => [
        'hostname' => '127.0.0.1', // Dirección predeterminada Redis ServBay
        'port'     => 6379, // Puerto por defecto
        'timeout'  => 0,
        'database' => 0, // Índice de la base de Redis
    ],
];

Usar Memcached/Redis:

En el controlador de ejemplo src/App/HTTP/Controller/Home.php ya incluimos los métodos action_memcached y action_redis para demostrar el uso del componente de caché de PHPixie (que puede emplear Memcached o Redis según la configuración).

• Probar Memcached: Accede a https://servbay-phpixie-test.local/home/memcached para guardar y recuperar un valor de Memcached.
• Probar Redis: Accede a https://servbay-phpixie-test.local/home/redis para guardar y recuperar un valor de Redis.

Asegúrate de que los servicios Memcached y Redis estén activos en ServBay.

Resumen

Siguiendo estos pasos has aprendido cómo crear, configurar y ejecutar un proyecto PHPixie de forma local en macOS usando ServBay. Ahora sabes cómo crear un proyecto con Composer, configurar el servidor web mediante la función Sitios Web de ServBay, integrar bases de datos y sistemas de caché, y comprobar el funcionamiento de todas estas integraciones.

El entorno integrado que ofrece ServBay simplifica al máximo la puesta en marcha del desarrollo PHP, permitiéndote concentrarte plenamente en tu código. ¡Esperamos que esta guía te ayude a empezar rápidamente con PHPixie y a crear tu próximo proyecto web!