Crear y ejecutar un proyecto PHPixie en macOS con ServBay

PHPixie es un framework PHP ligero y de alto rendimiento, diseñado para el desarrollo rápido de aplicaciones web. Adopta el patrón de diseño HMVC (Hierarchical Model-View-Controller), ofreciendo una estructura de código limpia y eficiente. PHPixie es apreciado por muchos desarrolladores gracias a su sencillez, flexibilidad y desempeño sobresaliente.

Principales características y ventajas de PHPixie

Ligero: El núcleo de PHPixie es muy compacto y solo incluye los componentes esenciales para construir aplicaciones, lo que permite arranques y ejecuciones veloces.
Alto rendimiento: El framework está diseñado para la eficiencia y puede gestionar solicitudes concurrentes, ideal para aplicaciones con altas exigencias de rendimiento.
Facilidad de aprendizaje: Proporciona una API clara y documentación completa, facilitando que los desarrolladores dominen su uso rápidamente.
Flexibilidad: Su estructura está poco acoplada, permitiendo elegir e integrar bibliotecas y componentes de terceros según las necesidades del proyecto.
Comunidad activa: PHPixie cuenta con una comunidad entusiasta que ofrece muchos recursos y extensiones adicionales de terceros.

PHPixie ayuda a los desarrolladores a construir aplicaciones web de alto rendimiento y calidad de manera eficiente, adaptándose desde proyectos pequeños hasta aplicaciones empresariales de gran escala.

Crear y ejecutar un proyecto PHPixie con ServBay

Este artículo te guía paso a paso para crear y ejecutar un proyecto PHPixie usando el entorno de desarrollo local integrado en ServBay. Utilizaremos la integración de PHP, el gestor de dependencias Composer y la función de “Sitios Web” para configurar el servidor Caddy, además de mostrar cómo acceder localmente al proyecto y hacerlo funcionar con bases de datos y sistemas de caché.

Requisitos previos

Tener ServBay instalado y funcionando en macOS. ServBay incluye PHP, Composer, diferentes bases de datos (MySQL, PostgreSQL, MongoDB, Redis, etc.) y el servidor web Caddy.
Conocer los comandos básicos de terminal.

Crear un proyecto PHPixie

Ruta recomendada para sitios web

ServBay recomienda que todos tus proyectos web locales se almacenen en el directorio /Applications/ServBay/www para una fácil gestión y control de permisos de acceso.

Verificar que Composer está instalado: ServBay viene incluido con Composer, no necesitas instalarlo aparte. Abre la terminal y ejecuta composer --version para comprobarlo.
Crear el directorio del proyecto: En el directorio raíz recomendado por ServBay, crea una carpeta nueva para tu proyecto PHPixie y accede a ella:
bash
```
cd /Applications/ServBay/www
mkdir servbay-phpixie-app
cd servbay-phpixie-app
```
1
2
3
Crear el proyecto PHPixie con Composer: Ejecuta el siguiente comando dentro del directorio de tu proyecto para obtener la plantilla de PHPixie:
bash
```
composer create-project phpixie/project .
```
1
Composer descargará PHPixie y todas sus dependencias en este directorio.

Configurar el servidor web

Utiliza la función de Sitios Web de ServBay para configurar el servidor web Caddy y dirigirlo correctamente al proyecto PHPixie.

Abre la interfaz de ServBay.
Navega al listado Sitios Web (Websites).
Haz clic en “Agregar nuevo sitio”.
Completa la información de configuración:
- Nombre: Por ejemplo Mi primer sitio PHPixie Dev (identificador interno de ServBay).
- Dominio: Por ejemplo servbay-phpixie-test.local (será el dominio local que usarás en tu navegador).
- Tipo de sitio: Selecciona PHP.
- Versión de PHP: Elige la que prefieras, por ejemplo 8.3.
- Directorio raíz (Document Root): Apunta al directorio web dentro de tu proyecto: /Applications/ServBay/www/servbay-phpixie-app/web.
¿Por qué el directorio /web?
El archivo de entrada del proyecto PHPixie es web/index.php. Para mayor seguridad y buenas prácticas, el servidor web debe apuntar directamente al directorio web que contiene este archivo, evitando el acceso directo por web a archivos sensibles (como configuraciones o el directorio vendor).
Guarda la configuración. ServBay ajustará automáticamente Caddy y actualizará tu archivo hosts local (si fuera necesario), haciendo que servbay-phpixie-test.local apunte a tu servidor ServBay local.

Para más detalles, consulta Agregar tu primer sitio web.

Añadir código de ejemplo

Para verificar el funcionamiento del proyecto y demostrar la integración con la base de datos y la caché, vamos a agregar algo de código de ejemplo al proyecto.

Crear un controlador de ejemplo: Agrega el siguiente código en src/App/HTTP/Controller/Home.php. Si la carpeta o el archivo no existen, créalos manualmente.

php

<?php

namespace App\HTTP\Controller;

use PHPixie\HTTP\Request;
use PHPixie\Template;
use PHPixie\Database\Query; // Importar clase Query

class Home extends \PHPixie\Controller
{
    protected $template;

    public function __construct(Template $template)
    {
        $this->template = $template;
    }

    // Action principal para la página de inicio
    public function action_index(Request $request)
    {
        // Renderizar la plantilla assets/templates/app/home.php
        return $this->template->render('app:home');
    }

    // Ejemplo de uso de Memcached
    public function action_memcached(Request $request)
    {
        $cache = $this->components->cache();
        $cache->set('key', '¡Hola Memcached desde ServBay!', 60); // Guardar datos con vencimiento de 60 segundos
        $value = $cache->get('key'); // Obtener datos
        return $this->response()->string($value); // Respuesta de tipo string
    }

    // Ejemplo de uso de Redis
    public function action_redis(Request $request)
    {
        $redis = $this->components->redis();
        $redis->set('key', '¡Hola Redis desde ServBay!'); // Guardar datos
        $value = $redis->get('key'); // Obtener datos
        return $this->response()->string($value); // Respuesta de tipo string
    }

    // Ejemplo para agregar usuario a MySQL/PostgreSQL
    public function action_add_user(Request $request)
    {
        // Utilizar el componente de base de datos para obtener el query builder
        $query = $this->components->database()->query();
        // Insertar nuevo usuario en la tabla 'users'
        $query->insert('users')->data([
            'name' => 'Usuario Demo ServBay',
            'email' => 'demo-' . uniqid() . '@servbay.test', // Email único
        ])->execute(); // Ejecutar la inserción

        return $this->response()->string('Usuario agregado correctamente.'); // Mensaje de éxito
    }

    // Ejemplo para listar usuarios desde MySQL/PostgreSQL
    public function action_list_users(Request $request)
    {
        // Utilizar el componente de base de datos para obtener el query builder
        $query = $this->components->database()->query();
        // Consultar todos los usuarios en la tabla 'users'
        $users = $query->select('*')->from('users')->execute()->fetchAll(); // Ejecutar consulta y obtener resultados

        return $this->response()->json($users); // Respuesta en formato JSON
    }
}

Crear plantilla de ejemplo: Agrega el siguiente código en assets/templates/app/home.php. Si el archivo o carpeta no existen, créalos manualmente.

php

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Bienvenido a PHPixie en 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>Bienvenido a PHPixie en ServBay</h1>
    <p>Esta página se genera dinámicamente por tu aplicación PHPixie que se ejecuta en ServBay.</p>

    <h2>Enlaces de funciones de 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 un usuario a la base de datos</a></li>
        <li><a href="/home/list_users">Listar usuarios de la base de datos</a></li>
    </ul>

    <p>Asegúrate de haber completado los pasos de configuración de la base de datos y la caché.</p>

</body>
</html>

Acceder al sitio básico

Después de configurar el sitio en ServBay y añadir el código de ejemplo, ya puedes acceder al dominio local configurado desde tu navegador:

Abre el navegador y visita https://servbay-phpixie-test.local.
Deberías ver una página que dice "Bienvenido a PHPixie en ServBay" y los enlaces de funciones de ejemplo.

Si no puedes acceder:

Verifica que ServBay está funcionando.
Comprueba que la configuración del sitio en ServBay es correcta, especialmente el dominio, el tipo de sitio y el directorio raíz.
Confirma que el archivo hosts local resuelve correctamente servbay-phpixie-test.local (ServBay normalmente gestiona esto automáticamente).
Verifica que la versión de PHP está activa en ServBay.

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

PHPixie incluye soporte integrado para múltiples bases de datos y sistemas de caché. ServBay proporciona servicios como MySQL, PostgreSQL, Redis, Memcached, para que puedas integrarlos fácilmente a tu proyecto PHPixie.

Nota importante: Antes de realizar operaciones sobre la base de datos, asegúrate de haber arrancado el servicio correspondiente en ServBay (MySQL o PostgreSQL) y haber creado la base de datos para tu proyecto. En el ejemplo usamos servbay_phpixie_app como nombre de base de datos. Puedes usar herramientas de gestión de bases de datos proporcionadas por ServBay (como Sequel Ace, Postico, TablePlus) o un cliente de línea de comandos para crear la base de datos. El usuario por defecto suele ser root y la contraseña password (confirma estos datos según tu configuración en ServBay).

Configurar la conexión a base de datos

Edita el archivo assets/config/database.php en la raíz del proyecto, adaptándolo según el tipo de base de datos elegida (MySQL o PostgreSQL). El servidor por defecto en ServBay es 127.0.0.1.

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

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // La cadena de conexión se ajusta según el tipo de base de datos y la 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 según tu configuración)
        'options'   => []
    ]
];

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

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // La cadena de conexión se ajusta según el tipo de base de datos y la 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 según tu configuración)
        'options'   => []
    ]
];

Crear una tabla de base de datos (migraciones)

PHPixie ofrece herramientas de línea de comandos para gestionar migraciones de bases de datos, permitiendo el control por versiones de la estructura.

Abre la terminal: Navega al directorio raíz del proyecto PHPixie:
bash
```
cd /Applications/ServBay/www/servbay-phpixie-app
```
1
Crea un archivo de migración: Ejecuta la CLI de PHPixie para generar una migración que cree la tabla users:
bash
```
php pixie generate:migration create_users_table
```
1
Esto creará un nuevo archivo PHP en assets/migrations con un nombre que incluye la fecha y hora.

Edita el archivo de migración: Abre el nuevo archivo creado (por ejemplo YYYY_MM_DD_HHMMSS_create_users_table.php) y edita los métodos up() y down() para definir la estructura de la tabla users:

php

<?php

use PHPixie\Database\Migration;
use PHPixie\Database\Schema\Table;

class CreateUsersTable extends Migration
{
    public function up()
    {
        // Crear la tabla 'users' con el schema builder
        $this->schema->create('users', function(Table $table) {
            $table->increments('id'); // Clave primaria autoincremental
            $table->string('name'); // Columna de nombre
            $table->string('email')->unique(); // Columna de email, única
            $table->timestamps(); // Columnas created_at y updated_at
        });
    }

    public function down()
    {
        // Eliminar la tabla 'users' con el schema builder
        $this->schema->drop('users');
    }
}

Ejecuta la migración: Desde la terminal ubicada en la raíz del proyecto, ejecuta el comando para crear la tabla:
bash
```
php pixie migrate
```
1
Si todo va bien, verás un mensaje de éxito en la terminal. Puedes verificar con tu herramienta de gestión de bases de datos que la tabla users fue creada en servbay_phpixie_app.

Usar bases de datos relacionales (MySQL/PostgreSQL)

En el controlador de ejemplo (src/App/HTTP/Controller/Home.php) ya agregamos los métodos action_add_user y action_list_users, mostrando cómo interactuar con MySQL o PostgreSQL usando el componente de base de datos de PHPixie.

Agregar usuario: Visita https://servbay-phpixie-test.local/home/add_user para insertar un nuevo registro de usuario en la tabla users.
Listar usuarios: Visita https://servbay-phpixie-test.local/home/list_users para consultar todos los usuarios de la tabla y obtenerlos en formato JSON.

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

ServBay incluye las aplicaciones Memcached y Redis junto con las extensiones PHP necesarias. Solo necesitas configurar PHPixie para usarlas.

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

Edita o crea el archivo assets/config/cache.php y añade la configuración de Memcached:

php

<?php

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

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

Edita o crea el archivo assets/config/redis.php para añadir la configuración de Redis:

php

<?php

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

Uso de Memcached/Redis:

El controlador de ejemplo (src/App/HTTP/Controller/Home.php) ya incluye los métodos action_memcached y action_redis para mostrar cómo usar el componente de caché de PHPixie (que debajo utiliza Memcached o Redis según la configuración).

Probar Memcached: Accede a https://servbay-phpixie-test.local/home/memcached para escribir una clave en Memcached y leer el valor para mostrarlo.
Probar Redis: Accede a https://servbay-phpixie-test.local/home/redis para escribir una clave en Redis y leer el valor para mostrarlo.

Asegúrate de que Memcached y Redis estén ejecutándose en ServBay.

Resumen

Siguiendo estos pasos, habrás creado, configurado y ejecutado con éxito un proyecto PHPixie en tu entorno local de macOS utilizando ServBay. Aprendiste cómo crear el proyecto con Composer, configurar el servidor web con la función de Sitios Web, integrar y configurar bases de datos y sistemas de caché, y cómo validar el funcionamiento de cada uno.

El entorno integrado de ServBay simplifica enormemente la configuración del entorno de desarrollo PHP, permitiéndote concentrarte en el código. ¡Esperamos que esta guía te ayude a arrancar de manera rápida con PHPixie para construir tu próximo proyecto web!

Crear y ejecutar un proyecto PHPixie en macOS con ServBay ​

Principales características y ventajas de PHPixie ​

Crear y ejecutar un proyecto PHPixie con ServBay ​

Requisitos previos ​

Crear un proyecto PHPixie ​

Configurar el servidor web ​

Añadir código de ejemplo ​

Acceder al sitio básico ​

Ejemplos de integración con base de datos y caché ​

Configurar la conexión a base de datos ​

Crear una tabla de base de datos (migraciones) ​

Usar bases de datos relacionales (MySQL/PostgreSQL) ​

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

Resumen ​