Crear y ejecutar un proyecto ThinkPHP 8 en ServBay

Este artículo te guiará en el proceso de crear, configurar y ejecutar rápidamente un proyecto PHP basado en el framework ThinkPHP 8 usando ServBay, un potente entorno local de desarrollo web. ServBay proporciona un entorno PHP preconfigurado, servidores web (Caddy o Nginx) y múltiples bases de datos, lo que simplifica enormemente la puesta en marcha local de proyectos ThinkPHP.

¿Qué es ThinkPHP?

ThinkPHP es un framework PHP de código abierto, rápido y sencillo, orientado a objetos, originario de China. Sigue los principios de desarrollo limpio y eficiente, con el objetivo de ofrecer a los desarrolladores un conjunto de herramientas prácticas para construir aplicaciones web modernas. Gracias a su facilidad de uso, funcionalidad rica (como ORM potente, rutas flexibles, motor de plantillas integrado y soporte de caché), y a una comunidad activa, ThinkPHP está ampliamente adoptado en el desarrollo PHP en China.

Principales características y ventajas de ThinkPHP

• Sencillez y eficiencia: Diseño limpio, estructura de código clara, fácil de entender y mantener, alta productividad.
• Funcionalidades completas: Incluye los componentes esenciales para el desarrollo web, como estructura MVC, ORM, motor de plantillas, caché, gestión de sesiones, autenticación, tokens de formulario, etc.
• ORM potente: Ofrece mapeo objeto-relacional robusto y fácil de usar, simplificando el acceso a la base de datos.
• Rutas flexibles: Permite definir rutas de múltiples formas, adaptándose a estructuras de URL complejas.
• Ecosistema amplio: Dispone de multitud de librerías y plugins, así como una gran y activa comunidad de desarrolladores.
• Actualizaciones constantes: El framework evoluciona rápidamente, manteniéndose alineado con las tendencias de PHP y el desarrollo web.

ThinkPHP se adapta tanto a proyectos pequeños como a aplicaciones empresariales de gran escala.

Configuración de un proyecto ThinkPHP 8 en ServBay

ServBay ofrece el entorno ideal para desarrollar proyectos ThinkPHP 8 localmente, incluyendo:

• PHP en varias versiones y extensiones preinstaladas.
• Servidores web integrados (Caddy o Nginx) para facilitar la configuración de sitios.
• Bases de datos integradas como MySQL, PostgreSQL, MongoDB, Redis y Memcached.
• Composer como gestor de dependencias incluido.

Esta guía aprovechará todas estas funciones para que crees tu proyecto ThinkPHP 8 de forma sencilla.

Requisitos previos

Antes de comenzar, asegúrate de tener lo siguiente:

1. Descargado e instalado ServBay en macOS o Windows.
2. ServBay en funcionamiento, con la versión de PHP requerida (ThinkPHP 8 necesita PHP 8.0 o superior) y los servicios de bases de datos necesarios (MySQL, PostgreSQL, Redis, Memcached, etc.) activos. Puedes verificar y encender estos servicios desde la pestaña “Paquetes” en el panel de control de ServBay.

Crear un proyecto ThinkPHP

Se recomienda almacenar todos los archivos de tus sitios locales en el directorio /Applications/ServBay/www, para permitir una mejor gestión por parte de ServBay.

1. Verifica que Composer esté instalado

   ServBay instala Composer automáticamente, por lo que no se requiere instalación adicional. Confirma la instalación ejecutando el comando composer --version en la terminal de ServBay.

2. Crea el proyecto ThinkPHP usando Composer

   Abre la terminal en macOS y ejecuta el siguiente comando para crear un nuevo proyecto ThinkPHP 8 en el directorio raíz de sitios de ServBay:

   cd /Applications/ServBay/www
   composer create-project topthink/think servbay-thinkphp-app

   Esto generará una carpeta servbay-thinkphp-app en /Applications/ServBay/www y descargará los archivos núcleo y dependencias de ThinkPHP 8.

3. Accede al directorio del proyecto

   Cuando la creación termine, entra a la carpeta del proyecto:

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

Inicializar la configuración del proyecto

Una vez creado el proyecto, realiza unas configuraciones básicas.

1. Configura la conexión a la base de datos

   La configuración de la base de datos de ThinkPHP suele estar en config/database.php. Edítala según la base de datos que tienes activa en ServBay.

   Por ejemplo, para la configuración de MySQL por defecto en ServBay:

   <?php
   // config/database.php
   
   return [
       // Configuración de conexión de base de datos predeterminada
       'default'         => env('database.driver', 'mysql'),
   
       // Configuración de todas las conexiones a 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 crear una base de datos exclusiva para el proyecto
               // Usuario
               'username' => env('database.username', 'root'),
               // Contraseña
               'password' => env('database.password', 'password'), // Contraseña por defecto en ServBay, ¡solo para desarrollo local!
               // Puerto
               'hostport' => env('database.hostport', '3306'),
               // ... Otras configuraciones ...
           ],
           // ... Otras conexiones ...
       ],
   ];

   Nota importante:

   • Cambia el valor de database por el nombre real de la base de datos creada para este proyecto (puedes hacerlo desde phpMyAdmin o Adminer de ServBay).
   • La contraseña por defecto del usuario root en ServBay es password. Usa esta contraseña solo en ambientes de desarrollo local, ¡nunca en producción! En producción, emplea contraseñas seguras y usuarios con permisos mínimos necesarios.
   • Si utilizas el archivo .env para variables de entorno, asegúrate de que sus configuraciones prevalezcan sobre los valores por defecto de config/database.php.

Configurar el servidor web

El archivo de entrada de ThinkPHP es public/index.php, y depende de reglas de Rewrite para el manejo de rutas. Dado que ThinkPHP utiliza rutas diferentes a las de archivos estáticos, debes emplear la regla de Rewrite incluida en ServBay.

Selecciona ThinkPHP en el menú desplegable de reglas de Rewrite en la pantalla de configuración del sitio, y guarda los cambios.

Para configuración detallada de sitios web en ServBay, consulta Añadir tu primer sitio web.

Agregar código de ejemplo

Para comprobar que la configuración es correcta y entender el routing básico en ThinkPHP, añade una ruta y controlador sencillo.

Edita el archivo /Applications/ServBay/www/servbay-thinkphp-app/route/app.php y define la siguiente ruta para solicitudes GET:

<?php
// route/app.php

use think\facade\Route;

// Define una ruta 'servbay'; al acceder a /servbay se ejecuta esta función anónima
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... Otras rutas ...

Acceder al sitio web

Tras completar los pasos, abre el navegador y visita el dominio local y URL de la ruta de ejemplo:

https://thinkphp.servbay.demo/servbay

Si todo está correctamente configurado, verás el mensaje Hello ServBay! en el navegador. Esto confirma que el proyecto ThinkPHP 8 está funcionando en el entorno ServBay y tanto el servidor web como PHP-FPM están correctos.

Ejemplo con bases de datos NoSQL

ServBay incluye varias bases de datos NoSQL como Memcached y Redis. ThinkPHP ofrece una capa de abstracción para caché que permite usarlas fácilmente como driver de almacenamiento en caché.

Ejemplo con Memcached

1. Instala la extensión Memcached

   ServBay ya tiene la extensión Memcached en sus paquetes PHP. Solo verifica que el servicio Memcached esté activo en la pestaña “Paquetes” del panel de ServBay.

2. Configura Memcached como caché

   Edita el archivo config/cache.php y configura ThinkPHP para usar Memcached:

   <?php
   // config/cache.php
   
   return [
       // Driver de caché predeterminado
       'default' => env('cache.driver', 'memcached'),
   
       // Configuración de conexiones de caché
       'stores'  => [
           'memcached' => [
               // Tipo de caché
               'type'       => 'memcached',
               // Lista de servidores
               'host'       => '127.0.0.1', // Dirección por defecto de Memcached en ServBay
               'port'       => 11211, // Puerto por defecto
               'persistent' => false,
               'expire'     => 0,
               'timeout'    => 0,
               'prefix'     => '',
           ],
           // ... Otras configuraciones ...
       ],
   ];

3. Usar Memcached en el código

   En tus controladores o callbacks de rutas, usa la fachada Cache de ThinkPHP:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/memcached-example', function () {
       // Guarda en caché por 600 segundos
       Cache::set('my_memcached_key', 'This value is from Memcached!', 600);
   
       // Recupera el valor de la caché
       $value = Cache::get('my_memcached_key');
   
       return 'Value from Memcached: ' . $value;
   });

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

Ejemplo con Redis

1. Instala la extensión Redis

   ServBay también incluye Redis en sus paquetes. Solo verifica que el servicio esté funcionando en la pestaña “Paquetes”.

2. Configura Redis como caché

   Edita config/cache.php para configurar ThinkPHP con Redis:

   <?php
   // config/cache.php
   
   return [
       // Driver de caché predeterminado
       'default' => env('cache.driver', 'redis'),
   
       // Configuración de conexiones de caché
       'stores'  => [
           'redis' => [
               // Tipo de caché
               'type'       => 'redis',
               // Dirección del servidor
               'host'       => env('cache.host', '127.0.0.1'), // Dirección por defecto en ServBay
               // Puerto
               'port'       => env('cache.port', 6379), // Puerto por defecto
               // Contraseña (por defecto no hay)
               'password'   => env('cache.password', ''), // ServBay no establece contraseña por defecto
               'select'     => 0,
               'timeout'    => 0,
               'expire'     => 0,
               'persistent' => false,
               'prefix'     => '',
           ],
           // ... Otras configuraciones ...
       ],
   ];

   Atención: Redis en ServBay no tiene contraseña por defecto; si la configuras manualmente, actualiza el campo password en la configuración.

3. Usar Redis en el código

   En tu controlador o callback de ruta:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/redis-example', function () {
       // Guarda en caché (permanente o define expiración)
       Cache::set('my_redis_key', 'Hello from Redis!');
   
       // Recupera de la caché
       $value = Cache::get('my_redis_key');
   
       return 'Value from Redis: ' . $value;
   });

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

Ejemplo con bases de datos relacionales

ServBay integra bases de datos populares como MySQL y PostgreSQL. Puedes acceder fácilmente con el ORM de ThinkPHP.

Usar migraciones de base de datos en ThinkPHP

ThinkPHP usa herramientas de migración para la estructura de la base de datos, facilitando el trabajo en equipo y el control de versiones.

1. Instala la herramienta de migraciones

   Desde el directorio raíz de tu proyecto, instala la extensión de migración de ThinkPHP:

   cd /Applications/ServBay/www/servbay-thinkphp-app
   composer require topthink/think-migration

2. Crea un archivo de migración

   Usa la herramienta CLI de ThinkPHP para crear una migración nueva, por ejemplo, para la tabla users:

   php think migrate:create CreateUserTable

   Esto crea un archivo PHP en database/migrations con nombre y timestamp, como 20231027100000_create_user_table.php.

3. Edita el archivo de migración

   Modifica el método up() para definir la estructura de la tabla users:

   <?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()
       {
           // Usa createTable para crear una tabla
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nombre del usuario'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Dirección de correo'])
                 ->addIndex(['email'], ['unique' => true]) // Índice único
                 ->addTimestamps() // Campos created_at y updated_at
                 ->create(); // Ejecuta la creación
       }
   
       // Si no usas change, puedes definir up() y down()
       /*
       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'])
                 ->addIndex(['email'], ['unique' => true])
                 ->addTimestamps()
                 ->create();
       }
   
       public function down()
       {
           $this->dropTable('users');
       }
       */
   }

4. Ejecuta la migración

   Asegúrate de estar en el directorio raíz del proyecto y corre:

   php think migrate:run

   Si se ejecuta correctamente, encontrarás la tabla users en la base de datos.

Ejemplo con MySQL

Supón que MySQL está activo en ServBay y configuraste la conexión en config/database.php como antes.

1. Configura la conexión MySQL

   Consulta la sección “Inicializar configuración del proyecto” para verificar la configuración en config/database.php.

2. Escribe datos de usuario en el código

   Usa la fachada Db o el modelo ORM de ThinkPHP para insertar datos. Ejemplo con Db:

   <?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' => 'demo@servbay.demo', // Email de ejemplo para la marca
               'created_at' => date('Y-m-d H:i:s'), // Si addTimestamps() no lo rellena automáticamente
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'User added successfully!';
       } catch (\Exception $e) {
           return 'Error adding user: ' . $e->getMessage();
       }
   });

   Prueba insertando datos desde https://thinkphp.servbay.demo/mysql-add-user.

3. Consulta datos de usuario en el código

   Usa la fachada Db o el modelo para consultar:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-users', function () {
       $users = Db::table('users')->select(); // Recupera todos los usuarios
       return json($users); // Devuelve el resultado en formato JSON
   });

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

Ejemplo con PostgreSQL

Supón que PostgreSQL está activo y la conexión configurada en config/database.php.

1. Configura la conexión PostgreSQL

   En config/database.php, incluye la conexión de PostgreSQL, por ejemplo:

   <?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 crear una base de datos exclusiva para el proyecto
               // Usuario
               'username' => env('database.username', 'root'),
               // Contraseña
               'password' => env('database.password', 'password'), // Contraseña por defecto en ServBay, ¡solo para desarrollo local!
               // Puerto
               'hostport' => env('database.hostport', '5432'), // Puerto por defecto en PostgreSQL
               // ... Otras configuraciones ...
           ],
           // ... Otras conexiones ...
       ],
   ];

   Nota importante:

   • Como con MySQL, crea una base de datos separada para tu proyecto en PostgreSQL y referencia su nombre en la configuración.
   • La contraseña por defecto del usuario root en ServBay para PostgreSQL es también password. Utilízala solo para desarrollo local.

2. Introduce datos de usuario en el código

   Usa Db y especifica la conexión pgsql:

   <?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' => 'pgsql-demo@servbay.demo', // Email de ejemplo para la marca
               // Los campos de fecha/hora pueden requerir relleno manual según definición y versión
               '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();
       }
   });

   Prueba la inserción desde https://thinkphp.servbay.demo/pgsql-add-user.

3. Consulta datos en la base de PostgreSQL

   Usa la fachada Db y la conexión pgsql:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-users', function () {
       $users = Db::connect('pgsql')->table('users')->select(); // Consulta con conexión pgsql
       return json($users); // Devuelve los datos en formato JSON
   });

   Consulta la tabla desde https://thinkphp.servbay.demo/pgsql-users.

Conclusión

Siguiendo estos pasos, ya sabes cómo crear, configurar y ejecutar un proyecto ThinkPHP 8 usando el entorno de desarrollo local ServBay. Aprendiste a usar Composer para crear el proyecto, configurar el servidor web Caddy para procesar las rutas de ThinkPHP, y conectar tu aplicación con los servicios de base de datos MySQL, PostgreSQL, Memcached y Redis proporcionados por ServBay.

ServBay simplifica en gran medida la creación de entornos de desarrollo local para frameworks PHP como ThinkPHP, permitiéndote centrarte en el desarrollo de tu aplicación. Ahora puedes seguir construyendo tu proyecto ThinkPHP, aprovechando todos los paquetes y herramientas que ServBay te ofrece.