Crear y ejecutar un proyecto ThinkPHP 8 en ServBay

Este artículo te guiará sobre cómo usar ServBay—un potente entorno local de desarrollo web—para crear, configurar y ejecutar rápidamente un proyecto PHP basado en el framework ThinkPHP 8. ServBay ofrece un entorno PHP preconfigurado, servidores web (Caddy o Nginx) y diversas bases de datos, simplificando enormemente el proceso de desarrollo local de proyectos ThinkPHP.

¿Qué es ThinkPHP?

ThinkPHP es un framework de desarrollo PHP de código abierto, rápido y sencillo, originario de China y orientado a objetos. Sigue principios de desarrollo simples y eficientes, diseñado para proporcionar a los desarrolladores un conjunto de herramientas útiles para construir aplicaciones web modernas. Gracias a su facilidad de uso, funciones avanzadas (como un ORM potente, rutas flexibles, motor de plantillas integrado, soporte de caché y más), y una comunidad activa, ThinkPHP tiene amplia adopción entre desarrolladores PHP en China.

Principales características y ventajas de ThinkPHP

Sencillo y eficiente: Diseño minimalista, estructura clara del código, fácil de entender y mantener, y alta eficiencia de desarrollo.
Funcionalidad completa: Incluye componentes habituales de desarrollo web como arquitectura MVC, ORM, motor de plantillas, caché, gestión de sesiones, autenticación de permisos y tokens de formularios.
ORM potente: Ofrece un mapeo objeto-relacional robusto y fácil de usar, simplificando la gestión de bases de datos.
Enrutamiento flexible: Admite múltiples formas de definir rutas para satisfacer estructuras URL complejas.
Ecosistema amplio: Gran cantidad de librerías y plugins, junto con una comunidad de desarrolladores activa y recursos abundantes.
Actualización continua: Versiones que evolucionan rápidamente, siguiendo los avances de PHP y tendencias en desarrollo web.

ThinkPHP es adecuado para proyectos web de cualquier tamaño, desde pequeños hasta aplicaciones empresariales a gran escala.

Configurando un proyecto ThinkPHP 8 con ServBay

ServBay ofrece el entorno ideal para el desarrollo local de proyectos ThinkPHP 8, incluyendo:

Versiones de PHP preinstaladas (con extensiones comunes).
Servidor web integrado (Caddy o Nginx), fácil de configurar sitios web.
Servicios de base de datos integrados como MySQL, PostgreSQL, MongoDB, Redis y Memcached.
Gestor de dependencias Composer integrado.

Esta guía te mostrará cómo aprovechar estas capacidades para lanzar tu proyecto ThinkPHP 8 rápidamente.

Requisitos previos

Antes de comenzar, asegúrate de haber completado lo siguiente:

Descargar e instalar ServBay en macOS.
Tener ServBay en funcionamiento, con la versión de PHP requerida (ThinkPHP 8 requiere PHP 8.0 o posterior) y los servicios de bases de datos necesarios (por ejemplo, MySQL, PostgreSQL, Redis, Memcached) activados. Puedes revisar y activar estos servicios en la pestaña "Paquetes" del panel de control de ServBay.

Crear un proyecto ThinkPHP

ServBay recomienda organizar los archivos de tus sitios web locales en el directorio /Applications/ServBay/www, facilitando así la gestión de sitios.

Verifica que Composer esté instalado
ServBay ya incluye Composer por defecto, por lo general no necesitas instalar nada extra. Puedes comprobarlo ejecutando composer --version en la terminal de ServBay.
Crear el proyecto ThinkPHP con Composer
Abre la terminal en macOS y ejecuta lo siguiente desde el directorio raíz de sitios de ServBay para crear un nuevo proyecto ThinkPHP 8:
bash
```
cd /Applications/ServBay/www
composer create-project topthink/think servbay-thinkphp-app
```
1
2
Esto creará una carpeta llamada servbay-thinkphp-app dentro de /Applications/ServBay/www y descargará el núcleo y dependencias de ThinkPHP 8.
Ingresa al directorio del proyecto
Una vez creado el proyecto, accede al directorio:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
```
1

Inicializar la configuración del proyecto

Tras crear el proyecto, realiza algunos ajustes básicos necesarios.

Configura los datos de conexión a la base de datos

La configuración de base de datos de ThinkPHP suele estar en config/database.php. Según los servicios de base de datos que hayas iniciado en ServBay, modifica este archivo para ajustar los datos de conexión.

Ejemplo de configuración usando el servicio MySQL por defecto de ServBay:

php

<?php
// config/database.php

return [
    // Configuración de conexión de base de datos predeterminada
    'default'         => env('database.driver', 'mysql'),

    // Configuración de cada conexión de base de datos
    'connections'     => [
        'mysql' => [
            // Tipo de base de datos
            'type'     => 'mysql',
            // Dirección del servidor
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Nombre de la base de datos
            'database' => env('database.database', 'servbay_thinkphp_app'), // Se recomienda una base de datos independiente por proyecto
            // Nombre de usuario
            'username' => env('database.username', 'root'),
            // Contraseña
            'password' => env('database.password', 'password'), // Contraseña por defecto de ServBay, solo para entorno local
            // Puerto
            'hostport' => env('database.hostport', '3306'),
            // ... otras configuraciones ...
        ],
        // ... otras configuraciones de conexión ...
    ],
];

Aviso importante:

Cambia el valor de database por el nombre real de la base de datos creada para este proyecto (puedes crear una en phpMyAdmin o Adminer de ServBay, por ejemplo, llamada servbay_thinkphp_app).
La contraseña por defecto para el usuario root en ServBay es password. Esta contraseña es solo para entorno local; nunca la uses en producción. En servidores de producción, utiliza contraseñas fuertes y usuarios con los permisos mínimos necesarios.
Si usas un archivo .env para gestionar variables de entorno, asegúrate de que los valores ahí definidos prevalezcan sobre los de config/database.php.

Configurar el servidor web

El archivo de entrada de ThinkPHP es public/index.php y depende de reglas de reescritura (Rewrite) para gestionar rutas. Debido a que las reglas de enrutamiento son distintas y no acceden a archivos estáticos directamente, debemos usar las reglas Rewrite integradas de ServBay.

En el apartado de configuración de sitios de ServBay, selecciona ThinkPHP en el menú desplegable de reglas Rewrite y guarda los cambios.

Consulta la guía Agregar tu primer sitio web para detalles sobre la configuración en ServBay.

Agregar código de ejemplo

Para validar que tu configuración funciona y probar el enrutamiento básico de ThinkPHP, agrega una ruta y controlador sencillos.

Edita el archivo /Applications/ServBay/www/servbay-thinkphp-app/route/app.php de tu proyecto y añade el siguiente código para definir una ruta GET de ejemplo:

php

<?php
// route/app.php

use think\facade\Route;

// Definir la ruta servbay, accede a /servbay y ejecuta la función anónima
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... otras rutas ...

Acceder al sitio web

Después de completar los pasos anteriores, abre tu navegador web y ve a la URL correspondiente a tu dominio local configurado y la ruta de ejemplo:

https://thinkphp.servbay.demo/servbay

Si todo está correctamente configurado, deberías ver el mensaje Hello ServBay! en el navegador. Esto significa que tu proyecto ThinkPHP 8 corre exitosamente en ServBay y que las configuraciones de servidor web y PHP-FPM están funcionando.

Ejemplos con bases de datos NoSQL

ServBay incluye diversos servicios de bases de datos NoSQL como Memcached y Redis. ThinkPHP ofrece una capa de abstracción de caché que permite integrar fácilmente estos servicios NoSQL como drivers de caché.

Ejemplo con Memcached

Verifica la extensión de Memcached
ServBay ya trae la extensión Memcached preinstalada. Solo asegúrate de que el servicio Memcached está iniciado desde la pestaña "Paquetes" del panel de control.

Configura Memcached como sistema de caché

Edita el archivo config/cache.php y configura ThinkPHP para usar Memcached como driver de caché:

php

<?php
// config/cache.php

return [
    // Driver de caché por defecto
    'default' => env('cache.driver', 'memcached'),

    // Configuración de las conexiones de caché
    'stores'  => [
        'memcached' => [
            // Tipo de caché
            'type'       => 'memcached',
            // Lista de servidores
            'host'       => '127.0.0.1', // Dirección predeterminada de Memcached en ServBay
            'port'       => 11211, // Puerto predeterminado de Memcached en ServBay
            'persistent' => false,
            'expire'     => 0,
            'timeout'    => 0,
            'prefix'     => '',
        ],
        // ... otras configuraciones ...
    ],
];

Usar Memcached en el código

En tu controlador o callback de rutas utiliza el Facade Cache de ThinkPHP para operar con Memcached:

php

<?php
use think\facade\Cache;
use think\facade\Route;

Route::get('/memcached-example', function () {
    // Establecer caché válido por 600 segundos
    Cache::set('my_memcached_key', 'This value is from Memcached!', 600);

    // Obtener caché
    $value = Cache::get('my_memcached_key');

    return 'Value from Memcached: ' . $value;
});

Visita https://thinkphp.servbay.demo/memcached-example para probarlo.

Ejemplo con Redis

Verifica la extensión de Redis
ServBay incluye Redis y su extensión para PHP. Asegúrate de que el servicio Redis está activo desde la pestaña "Paquetes".

Configura Redis como sistema de caché

Edita config/cache.php y configura ThinkPHP para usar Redis:

php

<?php
// config/cache.php

return [
    // Driver de caché por defecto
    'default' => env('cache.driver', 'redis'),

    // Configuración de las conexiones de caché
    'stores'  => [
        'redis' => [
            // Tipo de caché
            'type'       => 'redis',
            // Dirección del servidor
            'host'       => env('cache.host', '127.0.0.1'), // Dirección predeterminada de Redis en ServBay
            // Puerto
            'port'       => env('cache.port', 6379), // Puerto predeterminado de Redis en ServBay
            // Contraseña (por defecto no tiene en ServBay)
            'password'   => env('cache.password', ''), // Por defecto sin contraseña
            'select'     => 0,
            'timeout'    => 0,
            'expire'     => 0,
            'persistent' => false,
            'prefix'     => '',
        ],
        // ... otras configuraciones ...
    ],
];

Nota: Por defecto, la instalación de Redis en ServBay no tiene contraseña. Si la asignas manualmente, recuerda actualizar el campo password aquí.

Usar Redis en el código

Emplea el Facade Cache de ThinkPHP en tu controlador o callback de rutas para operar con Redis:

php

<?php
use think\facade\Cache;
use think\facade\Route;

Route::get('/redis-example', function () {
    // Establecer caché de duración indefinida (o ajusta con el tercer parámetro)
    Cache::set('my_redis_key', 'Hello from Redis!');

    // Obtener valor de caché
    $value = Cache::get('my_redis_key');

    return 'Value from Redis: ' . $value;
});

Visita https://thinkphp.servbay.demo/redis-example para probarlo.

Ejemplos con bases de datos relacionales

ServBay integra bases de datos relacionales populares como MySQL y PostgreSQL. El ORM de ThinkPHP facilita la interacción con ellas.

Uso de la herramienta de migración de bases de datos en ThinkPHP

ThinkPHP emplea herramientas de migración para administrar cambios en la estructura de bases de datos, lo cual es útil para equipos y control de versiones.

Instala la extensión de migración
Desde la raíz de tu proyecto, instala la extensión de migración de bases de datos de ThinkPHP:
bash
```
cd /Applications/ServBay/www/servbay-thinkphp-app
composer require topthink/think-migration
```
1
2
Crea un archivo de migración
Usa la herramienta de línea de comandos de ThinkPHP para generar un nuevo archivo, por ejemplo, para crear una tabla users:
bash
```
php think migrate:create CreateUserTable
```
1
Esto genera un archivo PHP en el directorio database/migrations, cuyo nombre contiene una marca de tiempo y el nombre que especificaste (por ejemplo, 20231027100000_create_user_table.php).

Edita el archivo de migración

Abre el archivo generado en database/migrations y edita el método up() para definir la estructura de la tabla users:

php

<?php
// database/migrations/YYYYMMDDHHMMSS_create_user_table.php

use think\migration\Migrator;
use think\migration\db\Column;

class CreateUserTable extends Migrator
{
    /**
     * Change Method.
     *
     * Write your reversible migrations using this method.
     *
     * More information on writing migrations is available here:
     * http://docs.phinx.org/en/latest/migrations.html#the-change-method
     *
     * The following commands can be used in this method and Phinx will
     * automatically reverse them when rolling back:
     *
     * createTable
     * renameTable
     * addColumn
     * addCustomColumn
     * renameColumn
     * addIndex
     * addForeignKey
     * createDatabase
     * renameDatabase
     * dropTable
     * dropColumn
     * dropIndex
     * dropForeignKey
     */
    public function change()
    {
        // Crear la tabla usando createTable
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nombre del usuario'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Dirección de correo electrónico'])
              ->addIndex(['email'], ['unique' => true]) // Añadir índice único
              ->addTimestamps() // Agregar campos created_at y updated_at
              ->create(); // Ejecutar la creación
    }

    // Si no usas el método change, puedes definir up() y down() por separado
    /*
    public function up()
    {
        $table = $this->table('users');
        $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nombre del usuario'])
              ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Dirección de correo electrónico'])
              ->addIndex(['email'], ['unique' => true])
              ->addTimestamps()
              ->create();
    }

    public function down()
    {
        $this->dropTable('users');
    }
    */
}

Ejecuta la migración
Desde la terminal de ServBay, dentro del directorio raíz del proyecto, ejecuta el comando de migración para crear la tabla users:
bash
```
php think migrate:run
```
1
Si se ejecuta correctamente, verás la nueva tabla users en la base de datos.

Ejemplo con MySQL

Supón que has activado el servicio MySQL en ServBay y configurado la conexión MySQL en config/database.php (como vimos antes).

Configurar la conexión MySQL
Revisa la sección “Inicializar la configuración del proyecto” para ver un ejemplo de configuración de MySQL y asegúrate que los datos sean correctos.

Insertar datos de usuario desde código

Usa el Facade Db de ThinkPHP o modelo ORM para insertar datos. Aquí un ejemplo usando Db:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/mysql-add-user', function () {
    try {
        Db::table('users')->insert([
            'name' => 'ServBay Demo User',
            'email' => '[email protected]', // Email de ejemplo para la marca
            'created_at' => date('Y-m-d H:i:s'), // Marca de tiempo manual si addTimestamps() no lo hace automáticamente
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        return 'User added successfully!';
    } catch (\Exception $e) {
        return 'Error adding user: ' . $e->getMessage();
    }
});

Accede a https://thinkphp.servbay.demo/mysql-add-user para probar el ingreso de datos.

Leer datos de usuario desde código

Utiliza el Facade Db o modelo ORM para consultar los datos:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/mysql-users', function () {
    $users = Db::table('users')->select(); // Obtener todos los registros de usuarios
    return json($users); // Devolver resultados en formato JSON
});

Accede a https://thinkphp.servbay.demo/mysql-users para ver los datos de la tabla users.

Ejemplo con PostgreSQL

Supón que has iniciado el servicio PostgreSQL en ServBay y has configurado la conexión correspondiente en config/database.php.

Configurar la conexión PostgreSQL

En el archivo config/database.php, asegúrate de tener una configuración como la siguiente (ajústala según sea necesario):

php

<?php
// config/database.php (fragmento)

return [
    // ... otras configuraciones ...

    'connections'     => [
        // ... configuración MySQL ...

        'pgsql' => [
            // Tipo de base de datos
            'type'     => 'pgsql',
            // Dirección del servidor
            'hostname' => env('database.hostname', '127.0.0.1'),
            // Nombre de la base de datos
            'database' => env('database.database', 'servbay_thinkphp_app'), // Se recomienda una base de datos exclusiva por proyecto
            // Usuario
            'username' => env('database.username', 'root'),
            // Contraseña
            'password' => env('database.password', 'password'), // Contraseña por defecto de ServBay, solo para entornos locales
            // Puerto
            'hostport' => env('database.hostport', '5432'), // Puerto por defecto de PostgreSQL
            // ... otras configuraciones ...
        ],
        // ... otras conexiones ...
    ],
];

Aviso importante:

Igual que con MySQL, crea una base de datos PostgreSQL exclusiva para el proyecto y especifícala aquí.
La contraseña de usuario root en ServBay para PostgreSQL también es password. Solo debe usarse en desarrollo local.

Insertar datos de usuario con código

Usa el Facade Db de ThinkPHP o modelo ORM, especificando la conexión pgsql:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/pgsql-add-user', function () {
    try {
        Db::connect('pgsql')->table('users')->insert([ // Conexión pgsql
            'name' => 'ServBay PgSQL User',
            'email' => '[email protected]', // Email de ejemplo para la marca
            // El timestamp puede requerir setearse manualmente, según la migración y versión de ThinkPHP
            'created_at' => date('Y-m-d H:i:s'),
            'updated_at' => date('Y-m-d H:i:s'),
        ]);
        return 'PostgreSQL User added successfully!';
    } catch (\Exception $e) {
         return 'Error adding PostgreSQL user: ' . $e->getMessage();
    }
});

Accede a https://thinkphp.servbay.demo/pgsql-add-user para probar el ingreso.

Leer datos de usuario con código

Usa el Facade Db o modelo ORM, especificando la conexión pgsql para consultar usuarios:

php

<?php
use think\facade\Db;
use think\facade\Route;

Route::get('/pgsql-users', function () {
    $users = Db::connect('pgsql')->table('users')->select(); // Obtener datos usando conexión pgsql
    return json($users); // Respuesta en JSON
});

Accede a https://thinkphp.servbay.demo/pgsql-users para ver la información en la tabla users.

Conclusión

Siguiendo los pasos anteriores, has conseguido crear, configurar y ejecutar un proyecto ThinkPHP 8 usando el entorno local ServBay. Aprendiste a usar Composer integrado para crear el proyecto, configurar el servidor web Caddy con reglas de enrutamiento de ThinkPHP, y conectar tu aplicación con MySQL, PostgreSQL, Memcached y Redis suministrados por ServBay.

ServBay simplifica enormemente la configuración de entornos de desarrollo local para frameworks PHP como ThinkPHP, permitiéndote centrarte en la lógica de negocio. Ahora puedes continuar con el desarrollo de tu aplicación ThinkPHP y aprovechar todas las funciones y paquetes integrados que ofrece ServBay.

Crear y ejecutar un proyecto ThinkPHP 8 en ServBay ​

¿Qué es ThinkPHP? ​

Principales características y ventajas de ThinkPHP ​

Configurando un proyecto ThinkPHP 8 con ServBay ​

Requisitos previos ​

Crear un proyecto ThinkPHP ​

Inicializar la configuración del proyecto ​

Configurar el servidor web ​

Agregar código de ejemplo ​

Acceder al sitio web ​

Ejemplos con bases de datos NoSQL ​

Ejemplo con Memcached ​

Ejemplo con Redis ​

Ejemplos con bases de datos relacionales ​

Uso de la herramienta de migración de bases de datos en ThinkPHP ​

Ejemplo con MySQL ​

Ejemplo con PostgreSQL ​

Conclusión ​